jsonapionify 0.0.1.pre → 0.9.0

data/lib/jsonapionify/api/resource/definitions/sorting.rb

@@ -1,84 +1,97 @@
+require 'set'
+
 module JSONAPIonify::Api
   module Resource::Definitions::Sorting
+    using JSONAPIonify::DeepSortCollection
 
-    class SortField
-
-      attr_reader :name, :order
-
-      def initialize(name)
-        if name.to_s.start_with? '-'
-          @name  = name.to_s[1..-1].to_sym
-          @order = :desc
-        else
-          @name  = name
-          @order = :asc
-        end
-      end
-
-    end
+    def self.extended(klass)
+      klass.class_eval do
+        inherited_hash_attribute :sorting_strategies
+        delegate :sort_fields_from_sort_string, to: :class
 
-    STRATEGIES         = {
-      active_record: proc { |collection, fields|
-        order_hash = fields.each_with_object({}) do |field, hash|
-          hash[field.name] = field.order
-        end
-        collection.order order_hash
-      },
-      enumerable:    proc { |collection, fields|
-        fields.reverse.reduce(collection) do |o, field|
-          result = o.sort_by(&field.name)
-          case field.order
-          when :asc
-            result
-          when :desc
-            result.reverse
+        # Define Contexts
+        context :sorted_collection do |context|
+          _, block = sorting_strategies.to_a.reverse.to_h.find do |mod, _|
+            Object.const_defined?(mod, false) && context.collection.class <= Object.const_get(mod, false)
           end
+          context.reset(:sort_params)
+          instance_exec(context.collection, context.sort_params, context, &block)
         end
-      }
-    }
-    STRATEGIES[:array] = STRATEGIES[:enumerable]
-    DEFAULT            = STRATEGIES[:enumerable]
-
-    def self.extended(klass)
-      klass.class_eval do
 
         context(:sort_params, readonly: true) do |context|
-          should_error = false
-          fields       = context.params['sort'].to_s.split(',')
-          fields.each_with_object([]) do |field, array|
-            field, resource = field.split('.').map(&:to_sym).reverse
-            if self.class <= self.class.api.resource(resource || self.class.type)
-              if self.class.field_valid? field
-                array << SortField.new(field)
-              else
+          sort_fields_from_sort_string(context.params['sort']).tap do |fields|
+            should_error = false
+            fields.each do |field|
+              unless self.class.field_valid?(field.name) || field.name == id_attribute
                 should_error = true
+                type = self.class.type
                 error :sort_parameter_invalid do
-                  detail "resource `#{self.class.type}` does not have field: #{field}"
+                  detail "resource `#{type}` does not have field: #{field.name}"
                 end
+                next
               end
             end
-          end.tap do
-            raise error_exception if should_error
+            raise Errors::RequestError if should_error
           end
         end
+
+        define_sorting_strategy('Object') do |collection|
+          collection
+        end
+
+        define_sorting_strategy('Enumerable') do |collection, fields|
+          collection.to_a.deep_sort(fields.to_hash)
+        end
+
+        define_sorting_strategy('ActiveRecord::Relation') do |collection, fields|
+          collection.reorder(fields.to_hash).order(self.class.id_attribute)
+        end
+
+        # Configure the default sort
+        default_sort 'id'
+
       end
     end
 
-    def sorting(strategy = nil, &block)
-      param :sort
-      context :sorted_collection do |context|
-        unless (actual_block = block)
-          actual_strategy = strategy || self.class.default_strategy
-          actual_block    = actual_strategy ? STRATEGIES[actual_strategy] : DEFAULT
+    def define_sorting_strategy(mod, &block)
+      sorting_strategies[mod.to_s] = block
+    end
+
+    def default_sort(options)
+      string =
+        case options
+        when Hash, Array
+          options.map do |k, v|
+            v.to_s.downcase == 'asc' ? "-#{k}" : k.to_s
+          end.join(',')
+        else
+          options.to_s
         end
-        Object.new.instance_exec(context.collection, context.sort_params, &actual_block)
+      param :sort, default: string, sticky: true
+    end
+
+    def sort_attrs_from_sort(sort_string)
+      sort_attrs = sort_string.split(',').map do |a|
+        a == 'id' ? id_attribute.to_s : a.to_s
       end
+      sort_attrs.uniq
     end
 
-    private
+    def sort_fields_from_sort_string(sort_string)
+      field_specs = sort_string.to_s.split(',')
+      field_specs.each_with_object(SortFieldSet.new) do |field_spec, array|
+        field_name, resource = field_spec.split('.').map(&:to_sym).reverse
+
+        # Skip unless this resource
+        next unless self <= self.api.resource(resource || type)
 
-    def default_sort
-      api.resource_definitions.keys.each_with_object({}) { |type, h| h[type] = [] }
+        # Assign Sort Fields
+        field = SortField.new(field_name)
+        field = SortField.new(id_attribute.to_s) if field.id?
+        array << field
+      end.tap do |field_set|
+        field_set << SortField.new(id_attribute.to_s)
+      end
     end
 
   end

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

@@ -4,7 +4,6 @@ module JSONAPIonify::Api
 
     included do
       include ActiveSupport::Rescuable
-      context(:error_exception) { Class.new(StandardError) }
       context(:errors, readonly: true) do
         ErrorsObject.new
       end
@@ -50,7 +49,7 @@ module JSONAPIonify::Api
 
     def error_now(name, *args, &block)
       error(name, *args, &block)
-      raise error_exception
+      raise Errors::RequestError
     end
 
     def set_errors(collection)
@@ -71,6 +70,7 @@ module JSONAPIonify::Api
 
     def rescued_response(exception)
       rescue_with_handler(exception) || begin
+        run_callbacks(:exception, exception)
         errors.evaluate(
           error_block:   lookup_error(:internal_server_error),
           runtime_block: proc {

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

@@ -1,4 +1,10 @@
 module JSONAPIonify::Api
   module Resource::Includer
+    extend ActiveSupport::Concern
+
+    included do
+      param :include
+    end
+
   end
 end

data/lib/jsonapionify/api/resource.rb

@@ -11,25 +11,36 @@ module JSONAPIonify::Api
     extend ClassMethods
 
     include ErrorHandling
+    include Includer
     include Builders
     include Defaults
 
     def self.inherited(subclass)
       super(subclass)
       subclass.class_eval do
-        context(:api, readonly: true) { api }
+        context(:api, readonly: true) { self.class.api }
         context(:resource, readonly: true) { self }
       end
     end
 
-    def self.example_instance(id=1)
+    def self.example_id_generator(&block)
+      define_singleton_method :generate_id, &block
+    end
+
+    def self.example_instance(index=1)
+      id = generate_id(index)
       OpenStruct.new.tap do |instance|
         instance.send "#{id_attribute}=", (id).to_s
         attributes.select(&:read?).each do |attribute|
-          instance.send "#{attribute.name}=", attribute.example
+          instance.send "#{attribute.name}=", attribute.example(id, index)
         end
       end
     end
 
+    example_id_generator { |val| val }
+
+    def action_name
+    end
+
   end
 end

data/lib/jsonapionify/api/response.rb

@@ -36,8 +36,8 @@ module JSONAPIonify::Api
         body = instance_exec(context, &response.response_block)
         Rack::Response.new.tap do |rack_response|
           rack_response.status = response.status
-          response_headers.each { |k, v| rack_response.headers[k] = v }
-          rack_response.headers['content-type'] = response.accept unless response.accept == '*/*'
+          response_headers.each { |k, v| rack_response.headers[k.split('-').map(&:capitalize).join('-')] = v }
+          rack_response.headers['Content-Type'] = response.accept unless response.accept == '*/*'
           rack_response.write(body) unless body.nil?
         end.finish
       end

data/lib/jsonapionify/api/server/mock_response.rb

@@ -5,8 +5,8 @@ module JSONAPIonify::Api
     attr_reader :status, :headers, :body
 
     def initialize(status, headers, body)
-      @status = status
-      @body   = body.is_a?(Rack::BodyProxy) ? body.body : body
+      @status  = status
+      @body    = body.is_a?(Rack::BodyProxy) ? body.body : body
       @headers = Rack::Utils::HeaderHash.new headers
     end
 

data/lib/jsonapionify/api/server/request.rb

@@ -10,13 +10,13 @@ module JSONAPIonify::Api
     end
 
     def headers
-      Rack::Utils::HeaderHash.new(
-        env.select do |name, _|
-          name.start_with?('HTTP_') && !%w{HTTP_VERSION}.include?(name)
-        end.each_with_object({}) do |(name, value), hash|
-          hash[name[5..-1].gsub('_', '-')] = value
-        end
-      )
+      env_headers                 = env.select do |name, _|
+        name.start_with?('HTTP_') && !%w{HTTP_VERSION}.include?(name)
+      end.each_with_object({}) do |(name, value), hash|
+        hash[name[5..-1].gsub('_', '-').downcase] = value
+      end
+      env_headers['content-type'] = content_type
+      Rack::Utils::HeaderHash.new(env_headers)
     end
 
     def http_string
@@ -44,6 +44,10 @@ module JSONAPIonify::Api
       body.rewind
     end
 
+    def content_type
+      super.try(:split, ';').try(:first)
+    end
+
     def accept
       accepts = (headers['accept'] || '*/*').split(',')
       accepts.to_a.sort_by! do |accept|

data/lib/jsonapionify/api/server.rb

@@ -33,7 +33,7 @@ module JSONAPIonify::Api
       def response
         @resource ? resource.process(request) : api_index
       rescue Errors::ResourceNotFound
-        Resource::Http.process(:not_found, request)
+        api.http_error(:not_found, request)
       end
 
       private

data/lib/jsonapionify/api/sort_field.rb

@@ -0,0 +1,59 @@
+module JSONAPIonify::Api
+  class SortField
+    delegate :to_s, :inspect, to: :to_hash
+    attr_reader :name, :order
+
+    def initialize(name)
+      @str = name.to_s
+      if name.to_s.start_with? '-'
+        @name  = name.to_s[1..-1].to_sym
+        @order = :desc
+      else
+        @name  = name.to_sym
+        @order = :asc
+      end
+      freeze
+    end
+
+    def ==(other)
+      other.class == self.class &&
+        other.name == self.name
+    end
+
+    def ===(other)
+      other.class == self.class &&
+        other.name == self.name
+    end
+
+    def id?
+      name == :id
+    end
+
+    def contains_operator
+      case @order
+      when :asc
+        :>=
+      when :desc
+        :<=
+      end
+    end
+
+    def outside_operator
+      case @order
+      when :asc
+        :>
+      when :desc
+        :<
+      end
+    end
+
+    def to_s
+      @str
+    end
+
+    def to_hash
+      { name => order }
+    end
+
+  end
+end

data/lib/jsonapionify/api/sort_field_set.rb

@@ -0,0 +1,36 @@
+module JSONAPIonify::Api
+  class SortFieldSet
+    include Enumerable
+    delegate :[], :length, :to_s, :inspect, :each, to: :@list
+
+    def initialize
+      @list = []
+      freeze
+    end
+
+    def to_hash
+      map(&:to_hash).reduce(:merge)
+    end
+
+    def reverse
+      self.class.new.tap do |set|
+        each do |field|
+          name =
+            case field.order
+            when :asc
+              "-#{field.name}"
+            when :desc
+              "#{field.name}"
+            end
+          set << SortField.new(name)
+        end
+      end
+    end
+
+    def <<(field)
+      raise TypeError unless field.is_a? SortField
+      @list << field unless @list.include? field
+    end
+
+  end
+end

data/lib/jsonapionify/callbacks.rb

@@ -13,16 +13,16 @@ module JSONAPIonify
             after:  "__#{name}_after_callback_chain"
           }
           define_method chains[:main] do |*args, &block|
+            block ||= proc {}
             if send(chains[:before], *args) != false
               value = instance_exec(*args, &block)
               value if send(chains[:after], *args) != false
             end
-          end
+          end unless method_defined? chains[:main]
 
           # Define before and after chains
           %i{after before}.each do |timing|
-            define_method chains[timing] do |*|
-            end
+            define_method chains[timing] { |*| } unless method_defined? chains[timing]
 
             define_singleton_method "#{timing}_#{name}" do |sym = nil, &outer_block|
               outer_block = (outer_block || sym).to_proc

data/lib/jsonapionify/continuation.rb

@@ -1,3 +1,4 @@
+require 'unstrict_proc'
 module JSONAPIonify
   class Continuation
     using UnstrictProc

data/lib/jsonapionify/deep_sort_collection.rb

@@ -0,0 +1,22 @@
+module JSONAPIonify
+  module DeepSortCollection
+    refine Array do
+      def deep_sort(hash)
+        keys   = hash.to_a
+        sorter = lambda do |iterator, depth = 0|
+          key_name, order = keys[depth]
+          if key_name
+            sorted = iterator.sort_by(&key_name)
+            sorted.reverse! if order == :desc
+            sorted.group_by(&key_name).values.map do |value|
+              sorter.call(value, depth + 1)
+            end.reduce(:+) || []
+          else
+            iterator
+          end
+        end
+        sorter.call(self)
+      end
+    end
+  end
+end