Initial commit.

Author: beauby

.gitignore

@@ -0,0 +1,36 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+sudo: false
+before_install:
+  - bundle update
+rvm:
+  - 2.1
+  - 2.2
+  - 2.3.0
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head

Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

README.md

@@ -0,0 +1,96 @@
+# jsonapi-renderer
+Ruby gem for rendering [JSON API](http://jsonapi.org) documents.
+
+## Status
+
+[![Gem Version](https://badge.fury.io/rb/jsonapi-renderer.svg)](https://badge.fury.io/rb/jsonapi-renderer)
+[![Build Status](https://secure.travis-ci.org/jsonapi-rb/renderer.svg?branch=master)](http://travis-ci.org/jsonapi-rb/renderer?branch=master)
+
+## Installation
+```ruby
+# In Gemfile
+gem 'jsonapi-renderer'
+```
+then
+```
+$ bundle
+```
+or manually via
+```
+$ gem install jsonapi-renderer
+```
+
+## Usage
+
+First, require the gem:
+```ruby
+require 'jsonapi/renderer'
+```
+
+### Rendering resources
+
+A resource here is any class that implements the following interface:
+```ruby
+class ResourceInterface
+  # Returns the type of the resource.
+  # @return [String]
+  def jsonapi_type; end
+
+  # Returns the id of the resource.
+  # @return [String]
+  def jsonapi_id; end
+
+  # Returns a hash containing, for each included relationship, the resource(s)
+  # to be included from that one.
+  # @param [Array<Symbol>] included_relationships The keys of the relationships
+  #   to be included.
+  # @return [Hash{Symbol => #ResourceInterface, Array<#ResourceInterface>}]
+  def jsonapi_related(included_relationships); end
+
+  # Returns a JSON API-compliant representation of the resource as a hash.
+  # @param [Hash] options
+  #   @option [Array<Symbol>, Nil] fields The requested fields, or nil.
+  #   @option [Array<Symbol>, Nil] included The requested included
+  #     relationships, or nil.
+  # @return [Hash]
+  def as_jsonapi(options = {}); end
+```
+
+#### Rendering a single resource
+```ruby
+JSONAPI.render(resource,
+               include: include_string,
+               fields: fields_hash,
+               meta: meta_hash,
+               links: links_hash)
+```
+
+This returns a JSON API compliant hash representing the described document.
+
+#### Rendering a collection of resources
+```ruby
+JSONAPI.render(resources,
+               include: include_string,
+               fields: fields_hash,
+               meta: meta_hash,
+               links: links_hash)
+```
+
+This returns a JSON API compliant hash representing the described document.
+
+### Rendering errors
+
+```ruby
+JSONAPI.render_errors(errors,
+                      meta: meta_hash,
+                      links: links_hash)
+```
+
+where `errors` is an array of objects implementing the `as_jsonapi` method, that
+returns a JSON API-compliant representation of the error.
+
+This returns a JSON API compliant hash representing the described document.
+
+## License
+
+jsonapi-renderer is released under the [MIT License](http://www.opensource.org/licenses/MIT).

Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = Dir.glob('spec/**/*_spec.rb')
+end
+
+task default: :test
+task test: :spec

VERSION

@@ -0,0 +1 @@
+0.1.1.beta2

jsonapi-renderer.gemspec

@@ -0,0 +1,15 @@
+version = File.read(File.expand_path('../VERSION', __FILE__)).strip
+
+Gem::Specification.new do |spec|
+  spec.name          = 'jsonapi-renderer'
+  spec.version       = version
+  spec.author        = 'Lucas Hosseini'
+  spec.email         = '[email protected]'
+  spec.summary       = 'Render JSONAPI documents.'
+  spec.description   = 'Efficiently render JSON API documents.'
+  spec.homepage      = 'https://github.com/jsonapi-rb/renderer'
+  spec.license       = 'MIT'
+
+  spec.files         = Dir['README.md', 'lib/**/*']
+  spec.require_path  = 'lib'
+end

lib/jsonapi/include_directive.rb

@@ -0,0 +1,72 @@
+require 'jsonapi/include_directive/parser'
+
+module JSONAPI
+  # Represent a recursive set of include directives
+  # (c.f. http://jsonapi.org/format/#fetching-includes)
+  #
+  # Addition to the spec: two wildcards, namely '*' and '**'.
+  # The former stands for any one level of relationship, and the latter stands
+  # for any number of levels of relationships.
+  # @example 'posts.*' # => Include related posts, and all the included posts'
+  #   related resources.
+  # @example 'posts.**' # => Include related posts, and all the included
+  #   posts' related resources, and their related resources, recursively.
+  class IncludeDirective
+    # @param include_args (see Parser.parse_include_args)
+    def initialize(include_args, options = {})
+      include_hash = Parser.parse_include_args(include_args)
+      @hash = include_hash.each_with_object({}) do |(key, value), hash|
+        hash[key] = self.class.new(value, options)
+      end
+      @options = options
+    end
+
+    # @param key [Symbol, String]
+    def key?(key)
+      @hash.key?(key.to_sym) ||
+        (@options[:allow_wildcard] && (@hash.key?(:*) || @hash.key?(:**)))
+    end
+
+    # @return [Array<Symbol>]
+    def keys
+      @hash.keys
+    end
+
+    # @param key [Symbol, String]
+    # @return [IncludeDirective, nil]
+    def [](key)
+      case
+      when @hash.key?(key.to_sym)
+        @hash[key.to_sym]
+      when @options[:allow_wildcard] && @hash.key?(:**)
+        self.class.new({ :** => {} }, @options)
+      when @options[:allow_wildcard] && @hash.key?(:*)
+        @hash[:*]
+      end
+    end
+
+    # @return [Hash{Symbol => Hash}]
+    def to_hash
+      @hash.each_with_object({}) do |(key, value), hash|
+        hash[key] = value.to_hash
+      end
+    end
+
+    # @return [String]
+    def to_string
+      string_array = @hash.map do |(key, value)|
+        string_value = value.to_string
+        if string_value == ''
+          key.to_s
+        else
+          string_value
+            .split(',')
+            .map { |x| key.to_s + '.' + x }
+            .join(',')
+        end
+      end
+
+      string_array.join(',')
+    end
+  end
+end

lib/jsonapi/include_directive/parser.rb

@@ -0,0 +1,65 @@
+module JSONAPI
+  class IncludeDirective
+    # Utilities to create an IncludeDirective hash from various types of
+    # inputs.
+    module Parser
+      module_function
+
+      # @api private
+      def parse_include_args(include_args)
+        case include_args
+        when Symbol
+          { include_args => {} }
+        when Hash
+          parse_hash(include_args)
+        when Array
+          parse_array(include_args)
+        when String
+          parse_string(include_args)
+        else
+          {}
+        end
+      end
+
+      # @api private
+      def parse_string(include_string)
+        include_string.split(',')
+          .each_with_object({}) do |path, hash|
+            deep_merge!(hash, parse_path_string(path))
+        end
+      end
+
+      # @api private
+      def parse_path_string(include_path)
+        include_path.split('.')
+          .reverse
+          .reduce({}) { |a, e| { e.to_sym => a } }
+      end
+
+      # @api private
+      def parse_hash(include_hash)
+        include_hash.each_with_object({}) do |(key, value), hash|
+          hash[key.to_sym] = parse_include_args(value)
+        end
+      end
+
+      # @api private
+      def parse_array(include_array)
+        include_array.each_with_object({}) do |x, hash|
+          deep_merge!(hash, parse_include_args(x))
+        end
+      end
+
+      # @api private
+      def deep_merge!(src, ext)
+        ext.each do |k, v|
+          if src[k].is_a?(Hash) && v.is_a?(Hash)
+            deep_merge!(src[k], v)
+          else
+            src[k] = v
+          end
+        end
+      end
+    end
+  end
+end