jsonapionify 0.0.1.pre

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

@@ -0,0 +1,85 @@
+module JSONAPIonify::Api
+  module Resource::Definitions::Sorting
+
+    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
+
+    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
+          end
+        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
+                should_error = true
+                error :sort_parameter_invalid do
+                  detail "resource `#{self.class.type}` does not have field: #{field}"
+                end
+              end
+            end
+          end.tap do
+            raise error_exception if should_error
+          end
+        end
+      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
+        end
+        Object.new.instance_exec(context.collection, context.sort_params, &actual_block)
+      end
+    end
+
+    private
+
+    def default_sort
+      api.resource_definitions.keys.each_with_object({}) { |type, h| h[type] = [] }
+    end
+
+  end
+end

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

@@ -0,0 +1,14 @@
+module JSONAPIonify::Api
+  module Resource::Definitions
+    extend JSONAPIonify::Autoload
+    autoload_all
+
+    def self.extended(klass)
+      klass.extend Contexts
+      constants(false).each do |const|
+        mod = const_get(const, false)
+        klass.extend mod unless klass.singleton_class < mod
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+module JSONAPIonify::Api
+  module Resource::ErrorHandling
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveSupport::Rescuable
+      context(:error_exception) { Class.new(StandardError) }
+      context(:errors, readonly: true) do
+        ErrorsObject.new
+      end
+    end
+
+    module ClassMethods
+
+      def error(name, &block)
+        self.error_definitions = self.error_definitions.merge name.to_sym => block
+      end
+
+      def rescue_from(*klasses, error:, &block)
+        super(*klasses) do |exception|
+          errors.evaluate(
+            error_block:   lookup_error(error),
+            runtime_block: block || proc {},
+            backtrace:     exception.backtrace
+          )
+        end
+      end
+
+      def error_definitions=(hash)
+        @error_definitions = hash
+      end
+
+      def error_definitions
+        @error_definitions ||= {}
+        if superclass.respond_to?(:error_definitions)
+          superclass.error_definitions.merge(@error_definitions)
+        else
+          @error_definitions
+        end
+      end
+    end
+
+    def error(name, *args, &block)
+      errors.evaluate(
+        *args,
+        error_block:   lookup_error(name),
+        runtime_block: block
+      )
+    end
+
+    def error_now(name, *args, &block)
+      error(name, *args, &block)
+      raise error_exception
+    end
+
+    def set_errors(collection)
+      errors.set collection
+    end
+
+    def error_meta
+      errors.meta
+    end
+
+    private
+
+    def lookup_error(name)
+      self.class.error_definitions[name].tap do |error|
+        raise ArgumentError, "Error does not exist: #{name}" unless error
+      end
+    end
+
+    def rescued_response(exception)
+      rescue_with_handler(exception) || begin
+        errors.evaluate(
+          error_block:   lookup_error(:internal_server_error),
+          runtime_block: proc {
+            unless ENV['RACK_ENV'] == 'production'
+              detail exception.message
+              meta[:error_class] = exception.class.name
+            end
+          },
+          backtrace:     exception.backtrace
+        )
+      end
+    ensure
+      return error_response
+    end
+
+    def error_response
+      Rack::Response.new.tap do |response|
+        error_collection = errors.collection
+        status_codes     = error_collection.map { |error| error[:status] }.compact.uniq.sort
+        response.status  =
+          if status_codes.length == 1
+            status_codes[0].to_i
+          elsif status_codes.blank?
+            500
+          else
+            (status_codes.last[0] + "00").to_i
+          end
+        response_headers.each { |k, v| response.headers[k] = v }
+        response.headers['content-type'] = 'application/vnd.api+json'
+        response.write(errors.top_level.to_json)
+      end.finish
+    end
+
+  end
+end

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

@@ -0,0 +1,11 @@
+module JSONAPIonify::Api
+  class Resource::Http < Resource
+
+    Rack::Utils::SYMBOL_TO_STATUS_CODE.each do |symbol, code|
+      define_action(symbol).response status: code do
+        error_now symbol
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,4 @@
+module JSONAPIonify::Api
+  module Resource::Includer
+  end
+end

data/lib/jsonapionify/api/resource.rb

@@ -0,0 +1,35 @@
+require 'active_support/rescuable'
+require 'rack/response'
+require 'active_support/json'
+
+module JSONAPIonify::Api
+  class Resource
+    extend JSONAPIonify::Autoload
+    autoload_all
+
+    extend Definitions
+    extend ClassMethods
+
+    include ErrorHandling
+    include Builders
+    include Defaults
+
+    def self.inherited(subclass)
+      super(subclass)
+      subclass.class_eval do
+        context(:api, readonly: true) { api }
+        context(:resource, readonly: true) { self }
+      end
+    end
+
+    def self.example_instance(id=1)
+      OpenStruct.new.tap do |instance|
+        instance.send "#{id_attribute}=", (id).to_s
+        attributes.select(&:read?).each do |attribute|
+          instance.send "#{attribute.name}=", attribute.example
+        end
+      end
+    end
+
+  end
+end

data/lib/jsonapionify/api/response.rb

@@ -0,0 +1,47 @@
+module JSONAPIonify::Api
+  class Response
+    attr_reader :action, :accept, :response_block, :status
+
+    def initialize(action, accept: nil, status: nil, &block)
+      @action         = action
+      @response_block = block || proc {}
+      @accept         = accept || 'application/vnd.api+json'
+      @status         = status || 200
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        %i{@accept}.all? do |ivar|
+          instance_variable_get(ivar) == other.instance_variable_get(ivar)
+        end
+    end
+
+    def accept?(request)
+      request.accept.any? do |accept|
+        @accept == accept || accept == '*/*' || self.accept == '*/*'
+      end
+    end
+
+    def documentation_object
+      OpenStruct.new(
+        accept:       accept,
+        content_type: accept,
+        status:       status
+      )
+    end
+
+    def call(instance, context)
+      response = self
+      instance.instance_eval do
+        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 == '*/*'
+          rack_response.write(body) unless body.nil?
+        end.finish
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'rack/utils'
+
+module JSONAPIonify::Api
+  class Server::MockResponse
+    attr_reader :status, :headers, :body
+
+    def initialize(status, headers, body)
+      @status = status
+      @body   = body.is_a?(Rack::BodyProxy) ? body.body : body
+      @headers = Rack::Utils::HeaderHash.new headers
+    end
+
+    def body
+      return nil unless @body.present?
+      JSON.pretty_generate(Oj.load(@body.join("\n")))
+    rescue Oj::ParseError
+      @body
+    end
+
+    def http_string
+      # HTTP/1.1 200 OK
+      # Date: Fri, 31 Dec 1999 23:59:59 GMT
+      # Content-Type: text/html
+      # Content-Length: 1354
+      #
+      # <body>
+      [].tap do |lines|
+        lines << "HTTP/1.1 #{status} #{Rack::Utils::HTTP_STATUS_CODES[status]}"
+        headers.each do |k, v|
+          lines << "#{k.split('-').map(&:capitalize).join('-')}: #{v}"
+        end
+        lines << ''
+        lines << body if body.present?
+      end.join("\n")
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+require 'rack/request'
+require 'rack/utils'
+require 'rack/mock'
+
+module JSONAPIonify::Api
+  class Server::Request < Rack::Request
+    def self.env_for(url, method, options = {})
+      options[:method] = method
+      new Rack::MockRequest.env_for(url, options)
+    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
+      )
+    end
+
+    def http_string
+      # GET /path/file.html HTTP/1.0
+      # From: someuser@jmarshall.com
+      # User-Agent: HTTPTool/1.0
+      # [blank line here]
+      [].tap do |lines|
+        lines << "#{request_method} #{fullpath} HTTP/1.1"
+        headers.each do |k, v|
+          lines << "#{k.split('-').map(&:capitalize).join('-')}: #{v}"
+        end
+        lines << ''
+        lines << pretty_body if has_body?
+      end.join("\n")
+    end
+
+    def pretty_body
+      return '' unless has_body?
+      value = body.read
+      JSON.pretty_generate(Oj.load(value))
+    rescue Oj::ParseError
+      value
+    ensure
+      body.rewind
+    end
+
+    def accept
+      accepts = (headers['accept'] || '*/*').split(',')
+      accepts.to_a.sort_by! do |accept|
+        _, *media_type_params = accept.split(';')
+        rqf                   = media_type_params.find { |mtp| mtp.start_with? 'q=' }
+        -(rqf ? rqf[2..-1].to_f : 1.0)
+      end.map do |accept|
+        mime, *media_type_params = accept.split(';')
+        media_type_params.reject! { |mtp| mtp.start_with? 'q=' }
+        [mime, *media_type_params].join(';')
+      end
+    end
+
+    def authorizations
+      parts = headers['authorization'].to_s.split(' ')
+      parts.length == 2 ? Rack::Utils::HeaderHash.new([parts].to_h) : {}
+    end
+
+    def has_body?
+      body.read(1).present?
+    ensure
+      body.rewind
+    end
+
+    def root_url
+      URI.parse(url).tap do |uri|
+        uri.query = nil
+        uri.path.chomp! path_info
+      end.to_s
+    end
+  end
+end

data/lib/jsonapionify/api/server.rb

@@ -0,0 +1,50 @@
+require 'delegate'
+require 'active_support/core_ext/object/blank'
+
+module JSONAPIonify::Api
+  class Server
+    extend JSONAPIonify::Autoload
+    autoload_all
+
+    attr_reader :api
+
+    def initialize(api)
+      @api = api
+    end
+
+    def call(env)
+      Processor.new(env, api).response
+    end
+
+    class Processor
+      attr_reader :request, :id, :more, :api
+
+      def initialize(env, api)
+        @api     = api
+        @request = Request.new(env)
+        request.path_info.split('/').tap(&:shift).tap do |parts|
+          @resource, @id, @relationship, @relationship_name, *@more = parts
+          request.env['jsonapionify.resource_name']                 = @resource if @resource
+          request.env['jsonapionify.resource']                      = resource if @resource
+          request.env['jsonapionify.id']                            = @id if @id
+        end
+      end
+
+      def response
+        @resource ? resource.process(request) : api_index
+      rescue Errors::ResourceNotFound
+        Resource::Http.process(:not_found, request)
+      end
+
+      private
+
+      def api_index
+        api.process_index(request)
+      end
+
+      def resource
+        api.resource(@resource)
+      end
+    end
+  end
+end

data/lib/jsonapionify/api/test_helper.rb

@@ -0,0 +1,52 @@
+require 'rack/test'
+require 'active_support/concern'
+
+module JSONAPIonify
+  module Api::TestHelper
+    extend ActiveSupport::Concern
+    include Rack::Test::Methods
+
+    module ClassMethods
+      def set_api(api)
+        define_method(:app) do
+          api
+        end
+      end
+    end
+
+    def set_headers
+      @set_headers ||= Rack::Utils::HeaderHash.new
+    end
+
+    def json(hash)
+      Oj.dump hash.deep_stringify_keys
+    end
+
+    def last_response_json
+      Oj.load last_response.body
+    end
+
+    def header(name, value)
+      set_headers[name] = value
+      super
+    end
+
+    def content_type(value)
+      header('content-type', value)
+    end
+
+    def accept(*values)
+      header('accept', values.join(','))
+    end
+
+    def delete(*args, &block)
+      header('content-type', set_headers['content-type'].to_s)
+      super
+    end
+
+    def authorization(type, value)
+      header 'Authorization', [type, value].join(' ')
+    end
+
+  end
+end

data/lib/jsonapionify/api.rb

@@ -0,0 +1,9 @@
+module JSONAPIonify::Api
+  extend JSONAPIonify::Autoload
+  autoload_all
+
+  module Actions
+    extend JSONAPIonify::Autoload
+    autoload_all 'api/actions'
+  end
+end

data/lib/jsonapionify/autoload.rb

@@ -0,0 +1,52 @@
+require 'active_support/inflections'
+
+module JSONAPIonify
+  module Autoload
+    def self.eager_load!
+      load_tracker = {}
+      while unloaded.present?
+        unloaded.each do |mod, consts|
+          consts.each do |const|
+            tracker = [mod.name, const].join('::')
+            begin
+              mod.const_get(const, false)
+            rescue NameError => e
+              load_tracker[tracker] = load_tracker[tracker].to_i + 1
+              if !e.message.include?('uninitialized constant') || load_tracker[tracker] > 50
+                raise e
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def self.unloaded
+      modules = ObjectSpace.each_object.select do |o|
+        o.is_a?(Module)
+      end
+      modules.each_with_object({}) do |mod, hash|
+        autoloadable_constants = mod.constants.each_with_object([]) do |const, ary|
+          if mod.autoload?(const) && mod.autoload?(const).include?(__dir__)
+            ary << const
+          end
+        end
+        if autoloadable_constants.present?
+          hash[mod] = autoloadable_constants
+        end
+      end
+    end
+
+    def autoload_all(dir=nil)
+      file     = caller[0].split(/\:\d/)[0]
+      base_dir = File.expand_path File.dirname(file)
+      dir      ||= name.split('::').last.underscore
+      Dir.glob("#{base_dir}/#{dir}/*.rb").each do |file|
+        basename   = File.basename file, File.extname(file)
+        fullpath   = File.expand_path file
+        const_name = basename.camelize.to_sym
+        autoload const_name, fullpath
+      end
+    end
+  end
+end

data/lib/jsonapionify/callbacks.rb

@@ -0,0 +1,49 @@
+require 'active_support/concern'
+
+module JSONAPIonify
+  module Callbacks
+    extend ActiveSupport::Concern
+    included do
+
+      def self.define_callbacks(*names)
+        names.each do |name|
+          chains = {
+            main:   "__#{name}_callback_chain",
+            before: "__#{name}_before_callback_chain",
+            after:  "__#{name}_after_callback_chain"
+          }
+          define_method chains[:main] do |*args, &block|
+            if send(chains[:before], *args) != false
+              value = instance_exec(*args, &block)
+              value if send(chains[:after], *args) != false
+            end
+          end
+
+          # Define before and after chains
+          %i{after before}.each do |timing|
+            define_method chains[timing] do |*|
+            end
+
+            define_singleton_method "#{timing}_#{name}" do |sym = nil, &outer_block|
+              outer_block = (outer_block || sym).to_proc
+              prev_chain  = instance_method(chains[timing])
+              define_method chains[timing] do |*args, &block|
+                if prev_chain.bind(self).call(*args, &block) != false
+                  instance_exec(*args, &outer_block)
+                end
+              end
+            end
+          end
+
+          private *chains.values
+
+        end
+      end
+    end
+
+    def run_callbacks(name, *args, &block)
+      send("__#{name}_callback_chain", *args, &block)
+    end
+
+  end
+end

data/lib/jsonapionify/character_range.rb

@@ -0,0 +1,41 @@
+module JSONAPIonify
+  class CharacterRange
+    include Enumerable
+
+    class << self
+      def [](*args)
+        new(*args)
+      end
+    end
+
+    def initialize(start_char, end_char)
+      if [start_char, end_char].any? { |c| c.length > 1 }
+        raise ArgumentError, 'must be single characters'
+      end
+      @start_char = start_char
+      @end_char   = end_char
+    end
+
+    def each
+      range.each do |ord|
+        begin
+          char = ord.chr(Encoding::UTF_8)
+          yield char
+        rescue RangeError
+          next
+        end
+      end
+    end
+
+    def to_a
+      each.to_a
+    end
+
+    private
+
+    def range
+      (@start_char.ord)..(@end_char.ord)
+    end
+
+  end
+end