jsonapi 0.1.1.beta2 → 0.1.1.beta6

data/lib/jsonapi/document.rb

@@ -1,126 +0,0 @@
-module JSONAPI
-  # c.f. http://jsonapi.org/format/#document-top-level
-  class Document
-    attr_reader :data, :meta, :errors, :json_api, :links, :included
-
-    def initialize(document_hash, options = {})
-      @hash = document_hash
-      @options = options
-      @data_defined = document_hash.key?('data')
-      @data = parse_data(document_hash['data']) if @data_defined
-      @meta_defined = document_hash.key?('meta')
-      @meta = parse_meta(document_hash['meta']) if @meta_defined
-      @errors_defined = document_hash.key?('errors')
-      @errors = parse_errors(document_hash['errors']) if @errors_defined
-      @jsonapi_defined = document_hash.key?('jsonapi')
-      @jsonapi = JsonApi.new(document_hash['jsonapi'], @options) if
-        @jsonapi_defined
-      @links_hash = document_hash['links'] || {}
-      @links = Links.new(@links_hash, @options)
-      @included_defined = document_hash.key?('included')
-      @included = parse_included(document_hash['included']) if
-        @included_defined
-
-      validate!
-    end
-
-    def to_hash
-      @hash
-    end
-
-    def collection?
-      @data.is_a?(Array)
-    end
-
-    private
-
-    def validate!
-      case
-      when !@data_defined && !@meta_defined && !@errors_defined
-        fail InvalidDocument,
-             "a document MUST contain at least one of 'data', 'meta', or" \
-             " or 'errors' at top-level"
-      when @data_defined && @errors_defined
-        fail InvalidDocument,
-             "'data' and 'errors' MUST NOT coexist in the same document"
-      when !@data_defined && @included_defined
-        fail InvalidDocument, "'included' MUST NOT be present unless 'data' is"
-      when @options[:verify_duplicates] && duplicates?
-        fail InvalidDocument,
-             "resources MUST NOT appear both in 'data' and 'included'"
-      when @options[:verify_linkage] && !full_linkage?
-        fail InvalidDocument,
-             "resources in 'included' MUST respect full-linkage"
-      end
-    end
-
-    def duplicates?
-      resources = Set.new
-
-      (Array(data) + Array(included)).each do |resource|
-        return true unless resources.add?([resource.type, resource.id])
-      end
-
-      false
-    end
-
-    def full_linkage?
-      return true unless @included
-
-      reachable = Set.new
-      # NOTE(lucas): Does Array() already dup?
-      queue = Array(data).dup
-      included_resources = Hash[included.map { |r| [[r.type, r.id], r] }]
-      queue.each { |resource| reachable << [resource.type, resource.id] }
-
-      traverse = lambda do |rel|
-        ri = [rel.type, rel.id]
-        return unless included_resources[ri]
-        return unless reachable.add?(ri)
-        queue << included_resources[ri]
-      end
-
-      until queue.empty?
-        resource = queue.pop
-        resource.relationships.each do |_, rel|
-          Array(rel.data).map(&traverse)
-        end
-      end
-
-      included_resources.keys.all? { |ri| reachable.include?(ri) }
-    end
-
-    def parse_data(data_hash)
-      collection = data_hash.is_a?(Array)
-      if collection
-        data_hash.map { |h| Resource.new(h, @options.merge(id_optional: true)) }
-      elsif data_hash.nil?
-        nil
-      else
-        Resource.new(data_hash, @options.merge(id_optional: true))
-      end
-    end
-
-    def parse_meta(meta_hash)
-      fail InvalidDocument, "the value of 'meta' MUST be an object" unless
-        meta_hash.is_a?(Hash)
-      meta_hash
-    end
-
-    def parse_included(included_hash)
-      fail InvalidDocument,
-           "the value of 'included' MUST be an array of resource objects" unless
-        included_hash.is_a?(Array)
-
-      included_hash.map { |h| Resource.new(h, @options) }
-    end
-
-    def parse_errors(errors_hash)
-      fail InvalidDocument,
-           "the value of 'errors' MUST be an array of error objects" unless
-        errors_hash.is_a?(Array)
-
-      errors_hash.map { |h| Error.new(h, @options) }
-    end
-  end
-end

data/lib/jsonapi/error.rb

@@ -1,27 +0,0 @@
-module JSONAPI
-  # c.f. http://jsonapi.org/format/#error-objects
-  class Error
-    attr_reader :id, :links, :status, :code, :title, :detail, :source, :meta
-
-    def initialize(error_hash, options = {})
-      fail InvalidDocument,
-           "the value of 'errors' MUST be an array of error objects" unless
-        error_hash.is_a?(Hash)
-
-      @hash = error_hash
-      @id = error_hash['id'] if error_hash.key?('id')
-      links_hash = error_hash['links'] || {}
-      @links = Links.new(links_hash, options)
-      @status = error_hash['status'] if error_hash.key?('status')
-      @code = error_hash['code'] if error_hash.key?('code')
-      @title = error_hash['title'] if error_hash.key?('title')
-      @detail = error_hash['detail'] if error_hash.key?('detail')
-      @source = error_hash['source'] if error_hash.key?('source')
-      @meta = error_hash['meta'] if error_hash.key?('meta')
-    end
-
-    def to_hash
-      @hash
-    end
-  end
-end

data/lib/jsonapi/exceptions.rb

@@ -1,4 +0,0 @@
-module JSONAPI
-  class InvalidDocument < StandardError
-  end
-end

data/lib/jsonapi/include_directive.rb

@@ -1,67 +0,0 @@
-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.include_hash_from_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
-
-    # @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

data/lib/jsonapi/include_directive/parser.rb

@@ -1,66 +0,0 @@
-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(',')
-          .map(&:strip)
-          .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

data/lib/jsonapi/jsonapi.rb

@@ -1,19 +0,0 @@
-module JSONAPI
-  # c.f. http://jsonapi.org/format/#document-jsonapi-object
-  class JsonApi
-    attr_reader :version, :meta
-
-    def initialize(jsonapi_hash, options = {})
-      fail InvalidDocument, "the value of 'jsonapi' MUST be an object" unless
-        jsonapi_hash.is_a?(Hash)
-
-      @hash = jsonapi_hash
-      @version = jsonapi_hash['version'] if jsonapi_hash.key?('meta')
-      @meta = jsonapi_hash['meta'] if jsonapi_hash.key?('meta')
-    end
-
-    def to_hash
-      @hash
-    end
-  end
-end

data/lib/jsonapi/link.rb

@@ -1,41 +0,0 @@
-module JSONAPI
-  # c.f. http://jsonapi.org/format/#document-links
-  class Link
-    attr_reader :value, :href, :meta
-
-    def initialize(link_hash, options = {})
-      @hash = link_hash
-
-      validate!(link_hash)
-      @value = link_hash
-      return unless link_hash.is_a?(Hash)
-
-      @href = link_hash['href']
-      @meta = link_hash['meta']
-    end
-
-    def to_hash
-      @hash
-    end
-
-    private
-
-    def validate!(link_hash)
-      case
-      when !link_hash.is_a?(String) && !link_hash.is_a?(Hash)
-        fail InvalidDocument,
-             "a 'link' object MUST be either a string or an object"
-      when link_hash.is_a?(Hash) && (!link_hash.key?('href') ||
-                                     !link_hash['href'].is_a?(String))
-        fail InvalidDocument,
-             "a 'link' object MUST be either a string or an object containing" \
-             " an 'href' string"
-      when link_hash.is_a?(Hash) && (!link_hash.key?('meta') ||
-                                     !link_hash['meta'].is_a?(Hash))
-        fail InvalidDocument,
-             "a 'link' object MUST be either a string or an object containing" \
-             " an 'meta' object"
-      end
-    end
-  end
-end

data/lib/jsonapi/links.rb

@@ -1,34 +0,0 @@
-module JSONAPI
-  # c.f. http://jsonapi.org/format/#document-links
-  class Links
-    def initialize(links_hash, options = {})
-      fail InvalidDocument, "the value of 'links' MUST be an object" unless
-        links_hash.is_a?(Hash)
-
-      @hash = links_hash
-      @links = {}
-      links_hash.each do |link_name, link_val|
-        @links[link_name.to_s] = Link.new(link_val, options)
-        define_singleton_method(link_name) do
-          @links[link_name.to_s]
-        end
-      end
-    end
-
-    def to_hash
-      @hash
-    end
-
-    def defined?(link_name)
-      @links.key?(link_name.to_s)
-    end
-
-    def [](link_name)
-      @links[link_name.to_s]
-    end
-
-    def keys
-      @links.keys
-    end
-  end
-end

data/lib/jsonapi/parse.rb

@@ -1,18 +0,0 @@
-require 'json'
-
-module JSONAPI
-  module_function
-
-  # Parse a JSON API document.
-  #
-  # @param document [Hash, String] the JSON API document.
-  # @param options [Hash] options
-  # @option options [Boolean] :id_optional (false) whether the resource
-  #   objects in the primary data must have an id
-  # @return [JSON::API::Document]
-  def parse(document, options = {})
-    hash = document.is_a?(Hash) ? document : JSON.parse(document)
-
-    Document.new(hash, options)
-  end
-end

data/lib/jsonapi/relationship.rb

@@ -1,57 +0,0 @@
-module JSONAPI
-  # c.f. http://jsonapi.org/format/#document-resource-object-relationships
-  class Relationship
-    attr_reader :data, :links, :meta
-
-    def initialize(relationship_hash, options = {})
-      @hash = relationship_hash
-      @options = options
-      @links_defined = relationship_hash.key?('links')
-      @data_defined = relationship_hash.key?('data')
-      @meta_defined = relationship_hash.key?('meta')
-      links_hash = relationship_hash['links'] || {}
-      @links = Links.new(links_hash, @options)
-      @data = parse_linkage(relationship_hash['data']) if
-        @data_defined
-      @meta = relationship_hash['meta'] if @meta_defined
-
-      validate!
-    end
-
-    def to_hash
-      @hash
-    end
-
-    def collection?
-      @data.is_a?(Array)
-    end
-
-    private
-
-    def validate!
-      case
-      when !@links_defined && !@data_defined && !@meta_defined
-        fail InvalidDocument,
-             "a relationship object MUST contain at least one of 'links'," \
-             " 'data', or 'meta'"
-      when @links_defined &&
-           !@links.defined?(:self) &&
-           !@links.defined?(:related)
-        fail InvalidDocument,
-             "the 'links' object of a relationship object MUST contain at" \
-             " least one of 'self' or 'related'"
-      end
-    end
-
-    def parse_linkage(linkage_hash)
-      collection = linkage_hash.is_a?(Array)
-      if collection
-        linkage_hash.map { |h| ResourceIdentifier.new(h, @options) }
-      elsif linkage_hash.nil?
-        nil
-      else
-        ResourceIdentifier.new(linkage_hash, @options)
-      end
-    end
-  end
-end