jsonapionify 0.0.1.pre

data/lib/jsonapionify/api/param_options.rb

@@ -0,0 +1,46 @@
+module JSONAPIonify::Api
+  class ParamOptions
+
+    def self.hash_to_keypaths(hash)
+      mapper = lambda do |hash, ary|
+        hash.each_with_object(ary) do |(k, v), a|
+          a << (map = [k.to_sym])
+          mapper[v, map] if v.is_a?(Hash)
+        end
+      end
+      mapper[hash, []].map(&:flatten)
+    end
+
+    def self.keypath_to_string(*paths)
+      first_path, *rest = paths
+      "#{first_path}#{rest.map { |path| "[#{path}]" }.join}"
+    end
+
+    def self.invalid_parameters(hash, keypaths)
+      invalid_key_paths = hash_to_keypaths(hash) - keypaths
+      invalid_key_paths.map do |paths|
+        keypath_to_string(*paths)
+      end
+    end
+
+    def self.missing_parameters(hash, keypaths)
+      missing_key_paths = keypaths - hash_to_keypaths(hash)
+      missing_key_paths.map do |paths|
+        keypath_to_string(*paths)
+      end
+    end
+
+    attr_reader :keypath, :actions, :required
+
+    def initialize(*keys, actions: nil, required: false)
+      @keypath  = keys
+      @actions  = Array.wrap(actions)
+      @required = required
+    end
+
+    def string
+      self.class.keypath_to_string(*@keypath)
+    end
+
+  end
+end

data/lib/jsonapionify/api/relationship/blocks.rb

@@ -0,0 +1,41 @@
+module JSONAPIonify::Api
+  module Relationship::Blocks
+
+    def self.extended(klass)
+      klass.class_eval do
+        prepend_class
+        append_class
+      end
+    end
+
+    def prepend_class(&block)
+      block ||= proc {}
+      if method_defined? :class_prepends
+        previous_prepends = instance_method(:class_prepends)
+        define_method :class_prepends do
+          (previous_prepends.bind(self).call + [block]).freeze
+        end
+      else
+        prepends = [block].freeze
+        define_method :class_prepends do
+          prepends
+        end
+      end
+    end
+
+    def append_class(&block)
+      block ||= proc {}
+      if method_defined? :class_appends
+        previous_appends = instance_method(:class_appends)
+        define_method :class_appends do
+          (previous_appends.bind(self).call + [block]).freeze
+        end
+      else
+        appends = [block].freeze
+        define_method :class_appends do
+          appends
+        end
+      end
+    end
+  end
+end

data/lib/jsonapionify/api/relationship/many.rb

@@ -0,0 +1,61 @@
+module JSONAPIonify::Api
+  class Relationship::Many < Relationship
+
+    prepend_class do
+      rel = self.rel
+      remove_action :read
+      class << self
+        undef_method :read
+      end
+
+      define_singleton_method(:show) do |**options, &block|
+        options[:prepend] = 'relationships'
+        define_action(:show, 'GET', **options, &block).response status: 200 do |context|
+          context.response_object[:data] = build_identifier_collection(context.collection)
+          context.meta[:total_count]     = context.collection.count
+          context.response_object.to_json
+        end
+      end
+
+      define_singleton_method(:replace) do |**options, &block|
+        options[:prepend] = 'relationships'
+        define_action(:replace, 'PATCH', '', true, :resource_identifier, **options, &block).response status: 200 do |context|
+          context.owner_context.reset(:instance)
+          context.reset(:collection)
+          context.response_object[:data] = build_identifier_collection(context.collection)
+          context.meta[:total_count]     = context.collection.count
+          context.response_object.to_json
+        end
+      end
+
+      define_singleton_method(:add) do |**options, &block|
+        options[:prepend] = 'relationships'
+        define_action(:add, 'POST', '', true, :resource_identifier, **options, &block).response status: 200 do |context|
+          context.owner_context.reset(:instance)
+          context.reset(:collection)
+          context.response_object[:data] = build_identifier_collection(context.collection)
+          context.meta[:total_count]     = context.collection.count
+          context.response_object.to_json
+        end
+      end
+
+      define_singleton_method(:remove) do |**options, &block|
+        options[:prepend] = 'relationships'
+        define_action(:remove, 'DELETE', '', true, :resource_identifier, **options, &block).response status: 200 do |context|
+          context.owner_context.reset(:instance)
+          context.reset(:collection)
+          context.response_object[:data] = build_identifier_collection(context.collection)
+          context.meta[:total_count]     = context.collection.count
+          context.response_object.to_json
+        end
+      end
+
+      context :scope do |context|
+        context.owner_context.instance.send(rel.name)
+      end
+
+      show
+      replace { error_now :forbidden }
+    end
+  end
+end

data/lib/jsonapionify/api/relationship/one.rb

@@ -0,0 +1,36 @@
+module JSONAPIonify::Api
+  class Relationship::One < Relationship
+
+    prepend_class do
+      rel = self.rel
+      remove_action :list, :create
+      class << self
+        undef_method :list, :create
+      end
+
+      define_singleton_method(:show) do |**options, &block|
+        options[:prepend] = 'relationships'
+        define_action(:show, 'GET', '', nil, :resource_identifier, **options, &block).response status: 200 do |context|
+          context.response_object[:data] = build_resource_identifier(context.instance)
+          context.response_object.to_json
+        end
+      end
+
+        define_singleton_method(:replace) do |**options, &block|
+          options[:prepend] = 'relationships'
+          define_action(:replace, 'PATCH', '', nil, :resource_identifier, **options, &block).response status: 200 do |context|
+            context.owner_context.reset(:instance)
+            context.reset(:instance)
+            context.response_object[:data] = build_resource_identifier(context.instance)
+            context.response_object.to_json
+          end
+        end
+
+      context :instance do |context|
+        context.owner_context.instance.send(rel.name)
+      end
+
+      show
+    end
+  end
+end

data/lib/jsonapionify/api/relationship.rb

@@ -0,0 +1,89 @@
+module JSONAPIonify::Api
+  class Relationship
+    extend JSONAPIonify::Autoload
+    autoload_all
+
+    extend Blocks
+
+    prepend_class do
+      remove_action :delete, :update
+      class << self
+        undef_method :delete, :update
+      end
+    end
+
+    append_class do
+
+      def self.supports_path?
+        false
+      end
+
+      def self.relationship(name)
+        rel.resource.relationship(name)
+      end
+
+      owner_context_proc = Proc.new do |request|
+        ContextDelegate.new(request, rel.owner.new, rel.owner.context_definitions)
+      end
+
+      context(:owner_context) do |context|
+        owner_context_proc.call(context.request)
+      end
+
+      context(:id) do
+        nil
+      end
+
+      define_singleton_method :base_path do
+        "/#{rel.owner.type}/:id"
+      end
+
+      define_singleton_method :path_name do
+        rel.name.to_s
+      end
+
+      define_singleton_method(:build_links) do |base_url|
+        JSONAPIonify::Structure::Maps::RelationshipLinks.new(
+          self:    File.join(base_url, 'relationships', rel.name.to_s),
+          related: File.join(base_url, rel.name.to_s)
+        )
+      end
+    end
+
+    attr_reader :owner, :class_proc, :name
+
+    def initialize(owner, name, resource: nil, &block)
+      @class_proc = block || proc {}
+      @owner      = owner
+      @name       = name
+      @resource   = resource || name
+    end
+
+    def documentation_object(base_url)
+      OpenStruct.new(
+        name: name,
+        actions: resource_class.actions.map { |a| a.documentation_object resource_class, base_url, name.to_s, false }
+      )
+    end
+
+    def resource_class
+      @resource_class ||= begin
+        rel = self
+        Class.new(resource) do
+          define_singleton_method(:rel) do
+            rel
+          end
+
+          rel.class_prepends.each { |prepend| class_eval &prepend }
+          class_eval(&rel.class_proc)
+          rel.class_appends.each { |append| class_eval &append }
+        end
+      end
+    end
+
+    def resource
+      owner.api.resource(@resource)
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/builders.rb

@@ -0,0 +1,81 @@
+module JSONAPIonify::Api
+  module Resource::Builders
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def build_resource(request, instance, fields: api.fields, relationships: true, links: true)
+        return nil unless instance
+        resource_url = build_url(request, instance)
+        id           = build_id(instance)
+        JSONAPIonify::Structure::Objects::Resource.new.tap do |resource|
+          resource[:id]            = id
+          resource[:type]          = type
+          resource[:attributes]    = fields[type.to_sym].each_with_object(JSONAPIonify::Structure::Objects::Attributes.new) do |member, attributes|
+            attributes[member.to_sym] = instance.public_send(member)
+          end
+          resource[:links]         = JSONAPIonify::Structure::Objects::Links.new(
+            self: resource_url
+          ) if links
+          resource[:relationships] = relationship_definitions.each_with_object(JSONAPIonify::Structure::Maps::Relationships.new) do |rel, hash|
+            hash[rel.name] = build_relationship(request, instance, rel.name)
+          end if relationships
+        end
+      end
+
+      def build_resource_identifier(instance)
+        JSONAPIonify::Structure::Objects::ResourceIdentifier.new(
+          id:   build_id(instance),
+          type: type.to_s
+        )
+      end
+
+      def build_collection(request, collection, fields: api.fields, relationships: false)
+        collection.each_with_object(JSONAPIonify::Structure::Collections::Resources.new) do |instance, resources|
+          resources << build_resource(request, instance, fields: fields, relationships: relationships)
+        end
+      end
+
+      def build_identifier_collection(collection)
+        collection.each_with_object(JSONAPIonify::Structure::Collections::ResourceIdentifiers.new) do |instance, resource_identifiers|
+          resource_identifiers << build_resource_identifier(instance)
+        end
+      end
+
+      def build_relationship(request, instance, name, links: true, data: false)
+        resource_url = build_url(request, instance)
+        relationship = self.relationship(name)
+        JSONAPIonify::Structure::Objects::Relationship.new.tap do |rel|
+          rel[:links] = relationship.build_links(resource_url) if links
+          if data
+            rel[:data] =
+              if relationship < Resource::RelationshipToMany
+                instance.send(name).map do |child|
+                  relationship.build_resource_identifier(child)
+                end
+              elsif relationship < Resource::RelationshipToOne
+                value = instance.send(name)
+                relationship.build_resource_identifier value if value
+              end
+          end
+        end
+      end
+
+      def build_url(request, instance = nil)
+        if instance
+          File.join(request.root_url, type, build_id(instance))
+        else
+          File.join(request.root_url, type)
+        end
+      end
+
+      def build_id(instance)
+        instance.send(id_attribute).to_s
+      end
+    end
+
+    included do
+      delegate *(ClassMethods.instance_methods - JSONAPIonify::Api::Resource::Builders.instance_methods), to: :class
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/class_methods.rb

@@ -0,0 +1,82 @@
+require 'active_support/rescuable'
+
+module JSONAPIonify::Api
+  module Resource::ClassMethods
+
+    def self.extended(klass)
+      klass.include ActiveSupport::Rescuable
+    end
+
+    def description(description)
+      @description = description
+    end
+
+    def set_api(api)
+      self.tap do
+        define_singleton_method :api do
+          api
+        end
+      end
+    end
+
+    def set_type(type)
+      type = type.to_s
+      self.tap do
+        define_singleton_method :type do
+          type
+        end
+      end
+    end
+
+    def type
+      nil
+    end
+
+    def api
+      nil
+    end
+
+    def get_url(base)
+      File.join base, type.to_s
+    end
+
+    def actions_in_order
+      indexes = %i{list create read update delete add replace remove}
+      actions.sort_by { |action| indexes.index(action.name) || indexes.length }
+    end
+
+    def documentation_object(base_url)
+      url = File.join(base_url, type)
+      OpenStruct.new(
+        name:          type,
+        description:   JSONAPIonify::Documentation.render_markdown(@description || ''),
+        relationships: relationships.map { |r| r.documentation_object url },
+        attributes:    attributes.map(&:documentation_object),
+        actions:       actions_in_order.map { |a| a.documentation_object self, base_url, type, true }
+      )
+    end
+
+    def cache(store, *args)
+      self.cache_store = ActiveSupport::Cache.lookup_store(store, *args)
+    end
+
+    def cache_store=(store)
+      @cache_store = store
+    end
+
+    def cache_store
+      @cache_store ||= api.cache_store
+    end
+
+    def default_strategy
+      if defined?(ActiveRecord) && current_scope.is_a?(Class) && current_scope < ActiveRecord::Base
+        :active_record
+      elsif Enumerable === current_scope || (current_scope.is_a?(Class) && current_scope < Enumerable)
+        :enumerable
+      end
+    rescue NotImplementedError
+      nil
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/defaults/actions.rb

@@ -0,0 +1,11 @@
+module JSONAPIonify::Api
+  module Resource::Defaults::Actions
+    extend ActiveSupport::Concern
+
+    included do
+      before(:create) { |context| context.instance = context.new_instance }
+      list
+      read
+    end
+  end
+end

data/lib/jsonapionify/api/resource/defaults/errors.rb

@@ -0,0 +1,99 @@
+require 'oj'
+
+module JSONAPIonify::Api
+  module Resource::Defaults::Errors
+    extend ActiveSupport::Concern
+
+    included do
+      rescue_from JSONAPIonify::Structure::ValidationError, error: :jsonapi_validation_error
+      rescue_from Oj::ParseError, error: :json_parse_error
+
+      Rack::Utils::SYMBOL_TO_STATUS_CODE.each do |symbol, code|
+        message = Rack::Utils::HTTP_STATUS_CODES[code]
+        error symbol do
+          title message
+          status code.to_s
+        end
+      end
+
+      error :data_missing do
+        pointer ''
+        title 'Missing Member'
+        detail 'missing data member'
+        status '422'
+      end
+
+      error :json_parse_error do
+        title 'Parse Error'
+        detail 'Could not parse JSON object'
+        status '422'
+      end
+
+      error :field_not_permitted do |type, field|
+        parameter "fields[#{type}]"
+        title 'Invalid Field'
+        detail "type: `#{type}`, does not have field: `#{field}`"
+        status '400'
+      end
+
+      error :attribute_not_permitted do |attribute|
+        pointer "data/attributes/#{attribute}"
+        title 'Attribute not permitted'
+        detail "Attribute not permitted: #{attribute}"
+      end
+
+      error :attributes_missing do
+        pointer 'data'
+        title 'Missing Member'
+        detail 'missing attributes member'
+        status '422'
+      end
+
+      error :include_parameter_invalid do
+        parameter 'sort'
+        title 'Sort parameter is invalid'
+        status '400'
+      end
+
+      error :parameters_missing do |parameters|
+        title 'Missing required parameters'
+        detail "missing: #{parameters.to_sentence}"
+        status '400'
+      end
+
+      error :parameter_not_permitted do |param|
+        parameter param
+        title 'Parameter Not Permitted'
+        detail "parameter not permitted: #{param}"
+        status '400'
+      end
+
+      error :headers_missing do |headers|
+        title 'Missing required headers'
+        detail "missing: #{headers.to_sentence}"
+        status '400'
+      end
+
+      error :header_not_permitted do |header|
+        title 'Header Not Permitted'
+        detail "header not permitted: #{header}"
+        status '400'
+      end
+
+      error :sort_parameter_invalid do
+        parameter 'sort'
+        title 'Sort parameter is invalid'
+        status '400'
+      end
+
+      error :request_object_invalid do |context, request_object|
+        context.errors.set request_object.errors.as_collection
+      end
+
+      error :resource_invalid do
+        title 'Invalid Resource'
+        status '404'
+      end
+    end
+  end
+end

data/lib/jsonapionify/api/resource/defaults/request_contexts.rb

@@ -0,0 +1,96 @@
+module JSONAPIonify::Api
+  module Resource::Defaults::RequestContexts
+    extend ActiveSupport::Concern
+
+    included do
+      context(:request_body, readonly: true) do |context|
+        context.request.body.read
+      end
+
+      context(:request_object, readonly: true) do |context|
+        JSONAPIonify.parse(context.request_body).as(:client).tap do |input|
+          error_now(:request_object_invalid, context, input) unless input.validate
+        end
+      end
+
+      context(:id, readonly: true) do |context|
+        context.request.env['jsonapionify.id']
+      end
+
+      context(:request_attributes, readonly: true) do |context|
+        request_object     = context.request_object
+        request_attributes = context.request_data.fetch(:attributes) do
+          error_now :attributes_missing
+        end
+        request_attributes.tap do |attributes|
+          writable_attributes = context.request_resource.attributes.select(&:write?)
+          required_attributes = writable_attributes.select(&:required?).map(&:name)
+          optional_attributes = writable_attributes.select(&:optional?).map(&:name)
+          if (extra_attributes = attributes.keys - (optional_attributes + required_attributes)).present?
+            extra_attributes.each { |attr| error :attribute_not_permitted, attr }
+            raise error_exception
+          end
+          request_object.validate
+          error_now(:request_object_invalid, context, request_object) if request_object.errors.present?
+        end.to_hash
+      end
+
+      context(:request_instances, readonly: true) do |context|
+        should_error = false
+        data         = context.request_data
+        instances    = data.map.each_with_index do |item, i|
+          begin
+            find_instance item, pointer: "data/#{i}"
+          rescue error_exception
+            should_error = true
+          end
+        end
+        raise error_exception if should_error
+        instances
+      end
+
+      context(:request_instance, readonly: true) do |context|
+        find_instance(context.request_data, pointer: 'data')
+      end
+
+      context(:request_resource, readonly: true) do |context|
+        item = context.request_data
+        find_resource item, pointer: 'data'
+      end
+
+      context(:request_data) do |context|
+        context.request_object.fetch(:data) {
+          error_now(:data_missing)
+        }
+      end
+    end
+
+    def find_instance(item, pointer:)
+      should_error = false
+      resource     = find_resource(item, pointer: pointer)
+      unless (instance = resource.find_instance item[:id])
+        should_error = true
+        error :resource_invalid do
+          self.pointer pointer
+          self.detail "could not find resource: `#{item[:type]}` with id: #{item[:id]}"
+        end
+      end
+      raise error_exception if should_error
+      instance
+    end
+
+    def find_resource(item, pointer:)
+      should_error = false
+      unless (resource = self.class.api.resource item[:type])
+        should_error = true
+        error :resource_invalid do
+          self.pointer pointer
+          self.detail "could not find resource: `#{item[:type]}`"
+        end
+      end
+      raise error_exception if should_error
+      resource
+    end
+
+  end
+end

data/lib/jsonapionify/api/resource/defaults/response_contexts.rb

@@ -0,0 +1,31 @@
+module JSONAPIonify::Api
+  module Resource::Defaults::ResponseContexts
+    extend ActiveSupport::Concern
+
+    included do
+
+      # Response Objects
+      context(:links, readonly: true) do |context|
+        context.response_object[:links]
+      end
+
+      context(:meta, readonly: true) do |context|
+        JSONAPIonify::Structure::Helpers::MetaDelegate.new context.response_object
+      end
+
+      context(:response_object) do |context|
+        JSONAPIonify.parse(links: { self: context.request.url })
+      end
+
+      context(:response_collection) do |context|
+        collections = %i{
+            paginated_collection
+            sorted_collection
+            collection
+          }
+        context.public_send collections.find { |c| context.respond_to? c }
+      end
+
+    end
+  end
+end

data/lib/jsonapionify/api/resource/defaults.rb

@@ -0,0 +1,10 @@
+module JSONAPIonify::Api
+  module Resource::Defaults
+    extend JSONAPIonify::Autoload
+    autoload_all
+
+    def self.included(klass)
+      constants(false).each { |const| klass.include const_get const, false }
+    end
+  end
+end