jsonapionify 0.0.1.pre

data/lib/jsonapionify/api/action.rb

@@ -0,0 +1,211 @@
+module JSONAPIonify::Api
+  class Action
+    attr_reader :name, :request_block, :content_type, :responses, :prepend,
+                :path, :request_method, :only_associated
+
+    def self.stub(&block)
+      new(nil, nil, &block)
+    end
+
+    def initialize(name, request_method, path = nil, require_body = nil, example_type = :resource, content_type: nil, prepend: nil, only_associated: false, &block)
+      @request_method  = request_method
+      @require_body    = require_body.nil? ? %w{POST PUT PATCH}.include?(@request_method) : require_body
+      @path            = path || ''
+      @prepend         = prepend
+      @only_associated = only_associated
+      @name            = name
+      @example_type    = example_type
+      @content_type    = content_type || 'application/vnd.api+json'
+      @request_block   = block || proc {}
+      @responses       = []
+    end
+
+    def initialize_copy(new_instance)
+      super
+      %i{@responses}.each do |ivar|
+        value = instance_variable_get(ivar)
+        new_instance.instance_variable_set(
+          ivar, value.frozen? ? value : value.dup
+        )
+      end
+    end
+
+    def build_path(base, name, include_path)
+      File.join(*[base].tap do |parts|
+        parts << prepend if prepend
+        parts << name
+        parts << path if path.present? && include_path
+      end)
+    end
+
+    def path_regex(base, name, include_path)
+      raw_reqexp = build_path(base, name, include_path).gsub(':id', '(?<id>[^\/]+)')
+      Regexp.new('^' + raw_reqexp + '$')
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        %i{@request_method @path @content_type @prepend}.all? do |ivar|
+          instance_variable_get(ivar) == other.instance_variable_get(ivar)
+        end
+    end
+
+    def supports_path?(request, base, name, include_path)
+      request.path_info.match(path_regex(base, name, include_path))
+    end
+
+    def documentation_object(resource, base, name, include_path)
+      @documentation_object ||= begin
+        url = build_path(base, name, include_path)
+        OpenStruct.new(
+          name:            self.name.to_s,
+          sample_requests: example_requests(resource, url)
+        )
+      end
+    end
+
+
+    def example_requests(resource, url)
+      responses.map do |response|
+        opts                      = {}
+        opts['HTTP_CONTENT_TYPE'] = content_type if @require_body
+        opts['HTTP_ACCEPT']       = response.accept
+        request                   = Server::Request.env_for(url, request_method, opts)
+        opts[:input]              = case @example_type
+                                    when :resource
+                                      { 'data' => resource.build_resource(request, resource.example_instance, relationships: false, links: false).as_json }.to_json
+                                    when :resource_identifier
+                                      { 'data' => resource.build_resource_identifier(resource.example_instance).as_json }.to_json
+                                    end if @content_type == 'application/vnd.api+json'
+        request                   = Server::Request.env_for(url, request_method, opts)
+        response                  = Server::MockResponse.new(*sample_request(resource, request))
+
+        OpenStruct.new(
+          request:  request.http_string,
+          response: response.http_string
+        )
+      end
+    end
+
+    def supports_content_type?(request)
+      @content_type == request.content_type ||
+        (request.content_type.nil? && !request.has_body?)
+    end
+
+    def supports_request_method?(request)
+      request.request_method == @request_method
+    end
+
+    def supports?(request, base, name, include_path)
+      supports_path?(request, base, name, include_path) &&
+        supports_request_method?(request) &&
+        supports_content_type?(request)
+    end
+
+    def response(status: nil, accept: nil, &block)
+      new_response = Response.new(self, status: status, accept: accept, &block)
+      @responses.delete new_response
+      @responses << new_response
+      self
+    end
+
+    def sample_request(resource, request)
+      action = dup
+      resource.new.instance_eval do
+        sample_context                        = self.class.context_definitions.dup
+        sample_context[:collection]           =
+          Context.new proc { 3.times.map.each_with_index { |i| resource.example_instance(i + 1) } }, true
+        sample_context[:paginated_collection] = Context.new proc { |context| context.collection }
+        sample_context[:instance]             = Context.new proc { |context| context.collection.first }
+        if sample_context.has_key? :owner_context
+          sample_context[:owner_context] = Context.new proc { ContextDelegate::Mock.new }, true
+        end
+
+        # Bootstrap the Action
+        context = ContextDelegate.new(request, self, sample_context)
+
+        define_singleton_method :response_headers do
+          context.response_headers
+        end
+
+        # Render the response
+        response_definition =
+          action.responses.find { |response| response.accept? request } ||
+            error_now(:not_acceptable)
+        response_definition.call(self, context)
+      end
+    end
+
+    def call(resource, request)
+      action              = dup
+      cache_hit_exception = Class.new StandardError
+      cache_options       = {}
+      resource.new.instance_eval do
+        # Bootstrap the Action
+        callbacks = resource.callbacks_for(action.name).new
+        context   = ContextDelegate.new(request, self, self.class.context_definitions)
+
+        define_singleton_method :action_name do
+          action.name
+        end
+
+        define_singleton_method :cache do |key, **options|
+          cache_options.merge! options
+          cache_options[:key] = [*{
+            api:          [self.class.api.name, self.class.api.resource_signature].join('@'),
+            resource:     self.class.type,
+            content_type: request.content_type || '*',
+            accept:       request.accept.join(','),
+            params:       context.params.to_param
+          }.map { |kv| kv.join(':') }, key].join('|')
+          raise cache_hit_exception, cache_options[:key] if self.class.cache_store.exist?(cache_options[:key])
+        end if request.get?
+
+        # Define Shared Singletons
+        [self, callbacks].each do |target|
+          target.define_singleton_method :errors do
+            context.errors
+          end
+
+          define_singleton_method :response_headers do
+            context.response_headers
+          end
+
+          target.define_singleton_method :error_exception do
+            context.error_exception
+          end
+        end
+
+        begin
+          # Run Callbacks
+          case callbacks.run_callbacks(:request, context) { errors.present? }
+          when true # Boolean true means errors
+            raise error_exception
+          when nil # nil means no result, callback failed
+            error_now :internal_server_error
+          end
+
+          # Start the request
+          instance_exec(context, &action.request_block)
+          fail error_exception if errors.present?
+          response_definition =
+            action.responses.find { |response| response.accept? request } ||
+              error_now(:not_acceptable)
+          response_definition.call(self, context).tap do |status, headers, body|
+            self.class.cache_store.write(
+              cache_options[:key],
+              [status, headers, body.body],
+              **cache_options.except(:key)
+            ) if request.get?
+          end
+        rescue error_exception
+          error_response
+        rescue cache_hit_exception
+          self.class.cache_store.read cache_options[:key]
+        rescue Exception => exception
+          rescued_response exception
+        end
+      end
+    end
+  end
+end

data/lib/jsonapionify/api/attribute.rb

@@ -0,0 +1,67 @@
+module JSONAPIonify::Api
+  class Attribute
+    attr_reader :name, :type, :description, :read, :write, :required
+
+    def initialize(name, type, description, read: true, write: true, required: false, example: nil)
+      unless type.is_a? JSONAPIonify::Types::BaseType
+        raise TypeError, "#{type} is not a valid JSON type"
+      end
+      @name        = name
+      @type        = type
+      @description = description
+      @example     = example
+      @read        = read
+      @write       = write
+      @required    = write ? required : false
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        self.name == other.name
+    end
+
+    def required?
+      !!@required
+    end
+
+    def optional?
+      !required?
+    end
+
+    def read?
+      !!@read
+    end
+
+    def write?
+      !!@write
+    end
+
+    def example
+      case @example
+      when Proc
+        type.dump @example.call
+      when nil
+        type.dump type.sample(name)
+      else
+        type.dump @example
+      end
+    end
+
+    def documentation_object
+      OpenStruct.new(
+        name:        name,
+        type:        type.name,
+        required:    required?,
+        description: JSONAPIonify::Documentation.render_markdown(description),
+        allow:       allow
+      )
+    end
+
+    def allow
+      Array.new.tap do |ary|
+        ary << 'read' if read?
+        ary << 'write' if write?
+      end
+    end
+  end
+end

data/lib/jsonapionify/api/base/app_builder.rb

@@ -0,0 +1,33 @@
+module JSONAPIonify::Api
+  module Base::AppBuilder
+
+    def call(env)
+      app.call(env)
+    end
+
+    private
+
+    def app
+      api = self
+      Rack::Builder.new do
+        use Rack::ShowExceptions
+        use Rack::CommonLogger
+        use Base::Reloader unless ENV['RACK_ENV'] == 'production'
+        map "/docs" do
+          run ->(env) {
+            request    = JSONAPIonify::Api::Server::Request.new env
+            if request.path_info.present?
+              return [301, { 'location' => request.path.chomp(request.path_info) }, []]
+            end
+            response   = Rack::Response.new
+            response.write api.documentation_output(request)
+            response.finish
+          }
+        end
+        map "/" do
+          run JSONAPIonify::Api::Server.new(api)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'active_support/core_ext/class/attribute'
+
+module JSONAPIonify::Api
+  module Base::ClassMethods
+
+    def self.extended(klass)
+      klass.class_attribute :load_path
+    end
+
+    def resource_files
+      Dir.glob File.join(load_path, '**/*.rb')
+    end
+
+    def resource_signature
+      Digest::SHA2.hexdigest resource_files.map { |file| File.read file }.join
+    end
+
+    def load_resources
+      return unless load_path
+      if @last_signature != resource_signature
+        @documentation_output = nil
+        @last_signature       = resource_signature
+        $".delete_if { |s| s.start_with? load_path }
+        resource_files.each do |file|
+          require file
+        end
+      end
+    end
+
+    def resource_class
+      const_get(:ResourceBase, false)
+    end
+
+    def documentation_order(resources_in_order)
+      @documentation_order = resources_in_order
+    end
+
+    def process_index(request)
+      headers                    = ContextDelegate.new(request, resource_class.new, resource_class.context_definitions).response_headers
+      obj                        = JSONAPIonify.new_object
+      obj[:meta]                 = { resources: {} }
+      obj[:links]                = { self: request.root_url }
+      obj[:meta][:documentation] = File.join(request.root_url, 'docs')
+      obj[:meta][:resources]     = resources.each_with_object({}) do |resource, hash|
+        hash[resource.type] = resource.get_url(request.root_url)
+      end
+      Rack::Response.new.tap do |response|
+        response.status = 200
+        headers.each { |k, v| response[k] = v }
+        response['content-type'] = 'application/vnd.api+json'
+        response.write obj.to_json
+      end.finish
+    end
+
+    def fields
+      resources.each_with_object({}) do |resource, fields|
+        fields[resource.type.to_sym] = resource.fields
+      end
+    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 ||= JSONAPIonify.cache_store
+    end
+  end
+end

data/lib/jsonapionify/api/base/delegation.rb

@@ -0,0 +1,15 @@
+module JSONAPIonify::Api
+  module Base::Delegation
+
+    def self.extended(klass)
+      klass.class_eval do
+        class << self
+          delegate :context, :response_header, :helper, :rescue_from, :error,
+                   :pagination, :before, :param, :request_header, :sorting,
+                   to: :resource_class
+        end
+      end
+    end
+
+  end
+end

data/lib/jsonapionify/api/base/doc_helper.rb

@@ -0,0 +1,47 @@
+module JSONAPIonify::Api
+  module Base::DocHelper
+
+    def self.extended(klass)
+      klass.class_eval do
+        extend JSONAPIonify::InheritedAttributes
+        inherited_array_attribute :links
+      end
+    end
+
+    def link(href)
+      links << href
+    end
+
+    def title(title)
+      @title = title
+    end
+
+    def description(description)
+      @description = description
+    end
+
+    def documentation_output(request)
+      @documentation_output ||= JSONAPIonify::Documentation.new(documentation_object(request)).result
+    end
+
+    def resources_in_order
+      indexes = @documentation_order || []
+      resources.sort_by { |resource| indexes.index(resource.name) || indexes.length }
+    end
+
+    def documentation_object(request)
+      base_url = URI.parse(request.url).tap do |uri|
+        uri.query = nil
+        uri.path.chomp! request.path_info
+        uri.path.chomp! '/docs'
+      end.to_s
+      OpenStruct.new(
+        links:       links,
+        title:       @title || self.name,
+        base_url:    base_url,
+        description: JSONAPIonify::Documentation.render_markdown(@description || ''),
+        resources:   resources_in_order.map { |r| r.documentation_object base_url }
+      )
+    end
+  end
+end

data/lib/jsonapionify/api/base/reloader.rb

@@ -0,0 +1,10 @@
+module JSONAPIonify::Api
+  class Base::Reloader < Struct.new :app
+
+    def call(env)
+      Base.descendants.each(&:load_resources)
+      app.call(env)
+    end
+
+  end
+end

data/lib/jsonapionify/api/base/resource_definitions.rb

@@ -0,0 +1,39 @@
+module JSONAPIonify::Api
+  module Base::ResourceDefinitions
+
+    def self.extended(klass)
+      klass.class_eval do
+        extend JSONAPIonify::InheritedAttributes
+        inherited_hash_attribute :resource_definitions
+      end
+    end
+
+    def resource(type)
+      raise ArgumentError, 'type required' if type.nil?
+      type       = type.to_sym
+      const_name = type.to_s.camelcase
+      return const_get(const_name, false) if const_defined?(const_name, false)
+      raise Errors::ResourceNotFound, "Resource not defined: #{type}" unless resource_defined?(type)
+      klass = Class.new(resource_class, &resource_definitions[type]).set_type(type)
+      param(:fields, type)
+      const_set const_name, klass
+    end
+
+    def resource_defined?(name)
+      !!resource_definitions[name]
+    end
+
+    def resources
+      resource_definitions.map do |name, _|
+        resource(name)
+      end
+    end
+
+    def define_resource(name, &block)
+      const_name = name.to_s.camelcase
+      remove_const(const_name) if const_defined? const_name
+      resource_definitions[name.to_sym] = block
+    end
+
+  end
+end

data/lib/jsonapionify/api/base.rb

@@ -0,0 +1,25 @@
+require 'active_support/descendants_tracker'
+require 'active_support/core_ext/module/delegation'
+
+module JSONAPIonify::Api
+  class Base
+    extend JSONAPIonify::Autoload
+    autoload_all
+    extend AppBuilder
+    extend DocHelper
+    extend ClassMethods
+    extend Delegation
+    extend ResourceDefinitions
+
+    def self.inherited(subclass)
+      super(subclass)
+      file           = caller.reject { |f| f.start_with? JSONAPIonify.path }[0].split(/\:\d/)[0]
+      dir            = File.expand_path File.dirname(file)
+      basename       = File.basename(file, File.extname(file))
+      self.load_path = File.join(dir, basename)
+      subclass.const_set(:ResourceBase, Class.new(Resource).set_api(subclass))
+      load_resources
+    end
+
+  end
+end

data/lib/jsonapionify/api/context.rb

@@ -0,0 +1,14 @@
+module JSONAPIonify::Api
+  class Context < Struct.new :block, :readonly
+
+    def call(instance, delegate)
+      block = self.block || proc {}
+      instance.instance_exec(delegate, &block)
+    end
+
+    def readonly?
+      !!readonly
+    end
+
+  end
+end

data/lib/jsonapionify/api/context_delegate.rb

@@ -0,0 +1,42 @@
+module JSONAPIonify::Api
+  class ContextDelegate
+    class Mock
+      def method_missing(*args, &block)
+        self
+      end
+    end
+
+    def initialize(request, instance, definitions)
+      memo     = {}
+      delegate = self
+      @definitions = definitions
+
+      define_singleton_method :request do
+        request
+      end
+
+      %i{initialize_dup initialize_clone}.each do |method|
+        define_singleton_method method do |copy|
+          memo.each do |k, v|
+            copy.public_send "#{k}=", v
+          end
+        end
+      end
+
+      define_singleton_method(:reset) do |key|
+        memo.delete(key)
+      end
+
+      definitions.each do |name, context|
+        define_singleton_method name do
+          memo[name] ||= context.call(instance, delegate)
+        end
+
+        define_singleton_method "#{name}=" do |value|
+          memo[name] = value
+        end unless context.readonly?
+      end
+    end
+
+  end
+end

data/lib/jsonapionify/api/errors.rb

@@ -0,0 +1,6 @@
+module JSONAPIonify::Api
+  module Errors
+    ResourceNotFound     = Class.new StandardError
+    RelationshipNotFound = Class.new StandardError
+  end
+end

data/lib/jsonapionify/api/errors_object.rb

@@ -0,0 +1,66 @@
+require 'active_support/core_ext/module/delegation'
+
+module JSONAPIonify
+  module Api
+    class ErrorsObject
+
+      delegate :present?, to: :collection
+
+      class Evaluator
+        Structure::Objects::Error.permitted_keys.each do |key|
+          define_method(key) do |value|
+            @error[key] = value
+          end
+        end
+
+        def initialize(error)
+          @error = error
+          freeze
+        end
+
+        def meta
+          JSONAPIonify::Structure::Helpers::MetaDelegate.new @error
+        end
+
+        def pointer(value)
+          @error[:source]           ||= {}
+          @error[:source][:pointer] = value
+        end
+
+        def parameter(value)
+          @error[:source]             ||= {}
+          @error[:source][:parameter] = value
+        end
+      end
+
+      def evaluate(*args, error_block:, runtime_block:, backtrace: nil)
+        backtrace ||= caller
+        error     = Structure::Objects::Error.new
+        evaluator = Evaluator.new(error)
+        collection << error
+        [runtime_block, error_block].each do |block|
+          evaluator.instance_exec(*args, &block) if block
+        end
+        unless ENV['RACK_ENV'] == 'production'
+          error[:meta]   ||= {}
+          error[:meta][:backtrace] = backtrace
+        end
+      end
+
+      def top_level
+        JSONAPIonify.new_object.tap do |obj|
+          obj[:errors] = collection
+        end
+      end
+
+      def collection
+        @collection ||= Structure::Collections::Errors.new
+      end
+
+      def set(collection)
+        @collection = collection
+      end
+
+    end
+  end
+end

data/lib/jsonapionify/api/header_options.rb

@@ -0,0 +1,13 @@
+module JSONAPIonify::Api
+  class HeaderOptions
+
+    attr_reader :name, :actions, :required
+
+    def initialize(name, actions: nil, required: false)
+      @name     = name
+      @actions  = Array.wrap(actions)
+      @required = required
+    end
+
+  end
+end