jsonapionify 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,15 @@
 ---
-SHA1:
-  metadata.gz: 515e9924931d33894090d68b518e2fe0e1509ab4
-  data.tar.gz: eb62428441716cfc4012d90f3b3af2bb6013e158
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NGNlYzQxYWRmZDlmZWJhODFiNDEwY2E3ZmZkNmRlNzA0YzhjODU1Zg==
+  data.tar.gz: !binary |-
+    ZGY4YjVhMWZiZGY0NmM5YWNiZGRjOGUxY2ViMmRlZTNkNTA3YjhhNw==
 SHA512:
-  metadata.gz: eea64da6a6862c3a985fd63c8a2458fdf7c162777ca0f5116e8d20f81982fe1aafbc3023c02c4cac89b1003fe85e70e219476f53c2ebe999c8fe096c7c1ed59a
-  data.tar.gz: c84cd475c778481ad492c7ed220b3195315e23ff8f7a1223721ce74004792273f06340b1f3738132bfc3dcd69ad715784cdd4141f43a3d65f2f68fef87eb9a8a
+  metadata.gz: !binary |-
+    ODE5ZWI5MjkxNjhhYzRjYzcwNWJlN2U1MTRlZjM4MjFiMDVlN2FhMzA3NDhh
+    YTc4Zjg1MzY0ZjQ3Zjg2YmUyZDdmZjQyM2ZlYzY4YmRjZjA4OTBmZjA5NDZm
+    YTRiZTAwOTgzNGFkYjY0YWYyZGMwNmEwZmE4YjM4OGY3NzgyY2Y=
+  data.tar.gz: !binary |-
+    YjIxZmE5M2Y4YTVkYWIzOTg1MmVlNjhhMmU5ODU5MzY4YTQ1ZmZkMDM3OTVl
+    MGZmZGJhM2ViYTEyYjZkZTg0YjY4OTA5ZmIyZGE2OGUyNTg5ODk3Mjk0OTJm
+    OWU3YmNmMTllMmFkYThmYmRjNDUyNGRjZTNlMDVhMzM0YWJiNjg=

data/.rubocop.yml

@@ -2,6 +2,7 @@
 # This is used to easily disable Style/* checks
 AllCops:
   DisabledByDefault: true
+  TargetRubyVersion: 2.3
 
 ################## STYLE #################################
 

data/.ruby-version

@@ -1 +1 @@
-2.3.0
+2.3.1

data/.travis.yml

@@ -6,3 +6,11 @@ cache: bundler
 addons:
   code_climate:
     repo_token: 8954c3078fac0b34ca184e61ca41e6b1dda3d820d5a0f3f18101d00bd86cdb1b
+deploy:
+  provider: rubygems
+  api_key:
+    secure: e6pDIHcdw8vgoHQxMOyQ1AalytHueDIF4F0AaGPnLujcwQBh1WzNHpBC3ck2V9Wsk4eFZ/UaEsNvYGiZgmhPKuDC728dUAEF3Ww12a3F3/8Qgp8oiKlGQM+K7YncZesWi4/1d0R9iNTNsypuX2RuF7cUP0rMt4/RpP3AU7th6BfjYbAyR29vNxcWY51W4tYUVqQXljg32OPel05j/I9KU/KcgB0VheYPr2sb9+jzFJaU5h+bKwi/esJiC5eBXUr+JkUhl+TLiuY8lvEzmzQB9WY2WvjjMiDbsMMR642fp6a3vt4sEMj7BxcQ6+QpAyetH5xeQNsXIWiTxEroyw/F1zlBaWYNi0ees4wGCU4bi/1iN4hZ2/BN0gsn7N5ZXf8+uWILUYHjG+CT/qPvn69YbOPgW/Ap1HtZTXK5Ais5RUUJxZnAVYfKLxGLHGEg/7sEk/oCGiKlpmfnIK7wvgWU19T19Ki50wuUPAl1dZecwGHL3iK9Q7v5GcuDgIzNgseGZQHr99WzcTken9NSQd/pO1Qwli7yX3id/lmuN3qsYiEJn0DkgTRJ9Ccf9fgk32ehWt3asw1X9eXgp0Ai57LAtbCZaz+OeSFhydrBqCQ8zVe1gGAhBBr1keKyptevMyqkRmJ1z4UIxEgwIAWbvW+5e+xCDREGa5lMtQyvgcG7OwU=
+  gem: jsonapionify
+  on:
+    tags: true
+    repo: brandfolder/jsonapionify

data/README.md

@@ -29,8 +29,91 @@ And then execute:
 
 ## Usage
 
-Refer to the [wiki](https://github.com/brandfolder/jsonapionify/wiki) for detailed
-information on how to use the framework.
+### Context: Read First
+
+Before we get started with defining an API, you should understand a pattern used heavily throughout JSONAPIonify. This pattern is called a context. A context is a definition of data that is memoized and passed around a request. You may see context used as follows:
+
+```ruby
+before :create do |context|
+  puts context.request.request_method
+end
+```
+
+Contexts can also call other contexts within their definitions:
+
+```ruby
+context :request_method do |context|
+  context.request.request_method
+end
+```
+
+JSONApionify already ships with a set of predefined contexts.
+
+### Create an API
+
+Api Definitions are the basis of JSONApi's DSL. They encompass resources that are available and can be run as standalone rack apps or be mounted within a rails app.
+
+```
+class MyCompanyApi < JSONAPIonify::Base
+
+  # Write a description for your API.
+  description <<~markdown
+  A description of your API, that will be available at the top of the documentation.
+  markdown
+  
+  # Add some rack middleware
+  use Rack::SSL::Enforcer
+  
+  # Handle Authorization
+
+end
+```
+
+### Predefined Contexts
+
+#### request_body
+The raw body of the request
+
+#### request_object
+The JSON parsed into a JSONApionify Structure Object. Keys can be accessed as symbols.
+
+#### id
+The id present in the request path, if present.
+
+#### request_id
+The id of the requested resource, within the data attribute of the request object.
+
+#### request_attributes
+The parsed attributes from the request object. Accessing this context, will also validate the data/structure.
+
+#### request_relationships
+The parsed relationships from the request object. Accessing this context, will also validate the data/structure.
+
+#### request_instance
+The instance of the object found from the request's data/type and data/id attibutes. This is determined from the resource's defined scope.
+
+#### request_resource
+The resource's scope determined from the request's data/type attribute.
+
+#### request_data
+The data attribute in the top level object of the request
+
+#### authentication
+An object containing the authentication data.
+
+#### links
+The links object that will be present in the response.
+
+#### meta
+The meta object that will be present in the response.
+
+#### response_object
+The jsonapi object that will be used for the response.
+
+#### response_collection
+The response for the collection.
+
+
 
 ## Development
 
@@ -42,7 +125,6 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/brandfolder/jsonapionify. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
 
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -17,6 +17,20 @@ task :missing_specs do
   end
 end
 
+desc 'Open a console with jsonapionify'
+task :console do
+  require 'jsonapionify'
+  Pry.start
+end
+
+task :benchmark do
+  require 'jsonapionify'
+  toplevel = nil
+  puts parse: Benchmark.realtime { toplevel = JSONAPIonify.parse(File.read('spec/fixtures/sample.json')) }
+  puts validate: Benchmark.realtime { toplevel.validate }
+  puts generate: Benchmark.realtime { toplevel.to_json(validate: false) }
+end
+
 desc 'Remove empty specs'
 task :prune_specs do
   empty_specs = Dir.glob("./spec/**/*_spec.rb").select do |f|

data/jsonapionify.gemspec

@@ -31,6 +31,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'possessive'
   spec.add_dependency 'unstrict_proc'
   spec.add_dependency 'enumerable_observer'
+  spec.add_dependency 'concurrent-ruby', '~> 1.0.1'
+  spec.add_dependency 'concurrent-ruby-ext'
+  spec.add_dependency 'mime-types'
 
   spec.add_development_dependency 'pry'
   spec.add_development_dependency 'rocco'

data/lib/jsonapionify/api/action.rb

@@ -1,7 +1,10 @@
+require 'unstrict_proc'
+
 module JSONAPIonify::Api
   class Action
-    attr_reader :name, :request_block, :content_type, :responses, :prepend,
-                :path, :request_method, :only_associated
+    attr_reader :name, :block, :content_type, :responses, :prepend,
+                :path, :request_method, :only_associated, :cacheable,
+                :callbacks
 
     def self.dummy(&block)
       new(nil, nil, &block)
@@ -13,17 +16,25 @@ module JSONAPIonify::Api
       end
     end
 
-    def initialize(name, request_method, path = nil, require_body = nil, example_type = :resource, content_type: nil, prepend: nil, only_associated: false, &block)
+    def initialize(name, request_method, path = nil,
+                   example_input: nil,
+                   content_type: nil,
+                   prepend: nil,
+                   only_associated: false,
+                   cacheable: false,
+                   callbacks: true,
+                   &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
+      @example_input   = example_input
       @content_type    = content_type || 'application/vnd.api+json'
-      @request_block   = block || proc {}
+      @block           = block || proc {}
       @responses       = []
+      @cacheable       = cacheable
+      @callbacks       = callbacks
     end
 
     def initialize_copy(new_instance)
@@ -45,8 +56,15 @@ module JSONAPIonify::Api
     end
 
     def path_regex(base, name, include_path)
-      raw_reqexp = build_path(base, name, include_path).gsub(':id', '(?<id>[^\/]+)')
-      Regexp.new('^' + raw_reqexp + '$')
+      raw_reqexp =
+        build_path(
+          base, name, include_path
+        ).gsub(
+          ':id', '(?<id>[^\/]+)'
+        ).gsub(
+          '/*', '/?[^\/]*'
+        )
+      Regexp.new('^' + raw_reqexp + '(\.[A-Za-z_-]+)?$')
     end
 
     def ==(other)
@@ -70,20 +88,43 @@ module JSONAPIonify::Api
       )
     end
 
+    def example_input(resource)
+      request = Server::Request.env_for('http://example.org', request_method)
+      context = ContextDelegate::Mock.new(
+        request: request, resource: resource.new, _is_example_: true, includes: []
+      )
+      case @example_input
+      when :resource
+        {
+          'data' => resource.build_resource(
+            context,
+            resource.example_instance_for_action(name, context),
+            relationships: false,
+            links:         false,
+            fields:        resource.fields_for_action(name, context)
+          ).as_json
+        }.to_json
+      when :resource_identifier
+        {
+          'data' => resource.build_resource_identifier(
+            resource.example_instance_for_action(name, context)
+          ).as_json
+        }.to_json
+      when Proc
+        @example_input.call
+      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' && !%w{GET DELETE}.include?(request_method)
-        request                   = Server::Request.env_for(url, request_method, opts)
-        response                  = Server::MockResponse.new(*sample_request(resource, request))
+        opts                 = {}
+        opts['CONTENT_TYPE'] = content_type if @example_input
+        opts['HTTP_ACCEPT']  = response.accept
+        if content_type == 'application/vnd.api+json' && @example_input
+          opts[:input] = example_input(resource)
+        end
+        request  = Server::Request.env_for(url, request_method, opts)
+        response = Server::MockResponse.new(*sample_request(resource, request))
 
         OpenStruct.new(
           request:  request.http_string,
@@ -106,116 +147,38 @@ module JSONAPIonify::Api
         supports_content_type?(request)
     end
 
-    def response(status: nil, accept: nil, &block)
-      new_response = Response.new(self, status: status, accept: accept, &block)
+    def response(**options, &block)
+      new_response = Response.new(self, **options, &block)
       @responses.delete new_response
-      @responses << new_response
+      @responses.push 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
+    def sample_context(resource)
+      resource.context_definitions.dup.tap do |defs|
+        collection_context          = proc do |context|
+          3.times.map { resource.example_instance_for_action(action.name, context) }
         end
-
-        # Render the response
-        response_definition =
-          action.responses.find { |response| response.accept? request } ||
-            error_now(:not_acceptable)
-        response_definition.call(self, context)
+        defs[:_is_example_]         = Context.new(readonly: true) { true }
+        defs[:collection]           = Context.new(&collection_context)
+        defs[:paginated_collection] = Context.new { |context| context.collection }
+        defs[:instance]             = Context.new(readonly: true) { |context| context.collection.first }
+        defs[:owner_context]        = Context.new(readonly: true) { ContextDelegate::Mock.new } if defs.has_key? :owner_context
       end
     end
 
-    def call(resource, request)
-      action        = dup
-      cache_options = {}
-      resource.new.instance_eval do
-        # Bootstrap the Action
-        context = ContextDelegate.new(request, self, self.class.context_definitions)
-
-        # Define Singletons
-        define_singleton_method :cache do |key, **options|
-          raise Errors::DoubleCacheError, "Cache was already called for this action" if @called
-          @called = true
-          cache_options.merge! options
-
-          # Build the cache key, and obscure it.
-          context.meta[:cache_key] =
-            cache_options[:key] =
-              Base64.urlsafe_encode64(
-                {
-                  dsl:    JSONAPIonify.digest,
-                  api:    self.class.api.signature,
-                  path:   request.path,
-                  accept: request.accept,
-                  params: context.params,
-                  key:    key,
-                }.to_json
-              )
-          # If the cache exists, then fail to cache miss
-          if self.class.cache_store.exist?(cache_options[:key])
-            raise Errors::CacheHit, cache_options[:key]
-          end
-        end if request.get?
-
-        define_singleton_method :action_name do
-          action.name
-        end
-
-        define_singleton_method :errors do
-          context.errors
-        end
-
-        define_singleton_method :response_headers do
-          context.response_headers
-        end
+    def sample_request(resource, request)
+      call(resource, request, context_definitions: sample_context(resource), callbacks: false)
+    end
 
-        begin
-          # Run Callbacks
-          [:request, action.name].each do |callback|
-            case run_callbacks(callback, context) { errors.present? }
-            when true # Boolean true means errors
-              raise Errors::RequestError
-            when nil # nil means no result, callback failed
-              error_now :internal_server_error
-            end if action.name
-          end
-
-          # Start the request
-          instance_exec(context, &action.request_block)
-          fail Errors::RequestError 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? && cache_options.present?
-          end
-        rescue Errors::RequestError
-          error_response
-        rescue Errors::CacheHit
-          self.class.cache_store.read cache_options[:key]
-        rescue Exception => exception
-          rescued_response exception
-        end
-      end
+    def call(resource, request, callbacks: self.callbacks, **opts)
+      resource.new(
+        request:   request,
+        callbacks: callbacks,
+        cacheable: cacheable,
+        action:    self,
+        **opts
+      ).call
     end
   end
 end

data/lib/jsonapionify/api/attribute.rb

@@ -3,20 +3,34 @@ require 'unstrict_proc'
 module JSONAPIonify::Api
   class Attribute
     using UnstrictProc
-    attr_reader :name, :type, :description, :read, :write, :required
+    attr_reader :name, :type, :description, :read, :write, :required, :block
 
-    def initialize(name, type, description, read: true, write: true, required: false, example: nil)
-      raise ArgumentError, 'required attributes must be writable' if required && !write
+    def initialize(
+      name,
+      type,
+      description,
+      read: true,
+      write: true,
+      required: false,
+      example: nil,
+      &block
+    )
       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
+
+      @name              = name.to_sym
+      @type              = type&.freeze
+      @description       = description&.freeze
+      @example           = example&.freeze
+      @read              = read&.freeze
+      @write             = write&.freeze
+      @required          = required&.freeze
+      @block             = block&.freeze
+      @writeable_actions = write
+      @readable_actions  = read
+
+      freeze
     end
 
     def ==(other)
@@ -24,19 +38,82 @@ module JSONAPIonify::Api
         self.name == other.name
     end
 
-    def options_json
-      {
-        name:     name,
-        required: required
-      }
+    def supports_read_for_action?(action_name, context)
+      case (setting = @readable_actions)
+      when TrueClass, FalseClass
+        setting
+      when Hash
+        !!JSONAPIonify::Continuation.new(setting).check(action_name, context) { true }
+      when Array
+        setting.map(&:to_sym).include? action_name
+      when Symbol, String
+        setting.to_sym === action_name
+      else
+        false
+      end
+    end
+
+    def supports_write_for_action?(action_name, context)
+      action = context.resource.class.actions.find { |a| a.name == action_name }
+      return false unless %{POST PUT PATCH}.include? action.request_method
+      case (setting = @writeable_actions)
+      when TrueClass, FalseClass
+        setting
+      when Hash
+        !!JSONAPIonify::Continuation.new(setting).check(action_name, context) { true }
+      when Array
+        setting.map(&:to_sym).include? action_name
+      when Symbol, String
+        setting.to_sym === action_name
+      else
+        false
+      end
+    end
+
+    def resolve(instance, context, example_id: nil)
+      if context.respond_to?(:_is_example_) && context._is_example_ == true
+        return example(example_id)
+      end
+      block = self.block || proc { |attr, i| i.send attr }
+      type.dump block.unstrict.call(self.name, instance, context)
+    rescue JSONAPIonify::Types::DumpError => ex
+      error_block =
+        context.resource.class.error_definitions[:attribute_type_error]
+      context.errors.evaluate(
+        name,
+        error_block:   error_block,
+        backtrace:     ex.backtrace,
+        runtime_block: proc {
+          detail ex.message
+        }
+      )
+    rescue JSONAPIonify::Types::NotNullError => ex
+      error_block =
+        context.resource.class.error_definitions[:attribute_cannot_be_null]
+      context.errors.evaluate(
+        name,
+        error_block:   error_block,
+        backtrace:     ex.backtrace,
+        runtime_block: proc {}
+      )
+      nil
     end
 
-    def required?
-      !!@required
+    def required_for_action?(action_name, context)
+      supports_write_for_action?(action_name, context) &&
+        (required === true || Array.wrap(required).include?(action_name))
     end
 
-    def optional?
-      !required?
+    def options_json_for_action(action_name, context)
+      {
+        name:        @name,
+        type:        @type.to_s,
+        description: JSONAPIonify::Documentation.onelinify_markdown(description),
+        example:     example(context.resource.class.generate_id)
+      }.tap do |opts|
+        opts[:not_null] = true if @type.not_null?
+        opts[:required] = true if required_for_action?(action_name, context)
+      end
     end
 
     def read?
@@ -62,7 +139,7 @@ module JSONAPIonify::Api
       OpenStruct.new(
         name:        name,
         type:        type.name,
-        required:    required?,
+        required:    Array.wrap(required).join(', '),
         description: JSONAPIonify::Documentation.render_markdown(description),
         allow:       allow
       )

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

@@ -21,7 +21,8 @@ module JSONAPIonify::Api
     end
 
     def load_resources
-      return unless load_path || resources_loaded?
+      return if !load_path || resources_loaded?
+      superclass.load_resources if superclass.respond_to? :load_resources
       @documentation_output = nil
       @last_signature       = resource_signature
       $".delete_if { |s| s.start_with? load_path }
@@ -34,8 +35,8 @@ module JSONAPIonify::Api
       @last_signature == resource_signature
     end
 
-    def http_error(action, request)
-      Action.error(action).call(resource_class, request)
+    def http_error(error, request, &block)
+      Action.error(error, &block).call(resource_class, request)
     end
 
     def root_url(request)
@@ -46,7 +47,7 @@ module JSONAPIonify::Api
     end
 
     def process_index(request)
-      headers                    = ContextDelegate.new(request, resource_class.new, resource_class.context_definitions).response_headers
+      headers                    = resource_class.new(request: request).exec { |c| c.response_headers }
       obj                        = JSONAPIonify.new_object
       obj[:meta]                 = { resources: {} }
       obj[:links]                = { self: request.url }

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

@@ -4,11 +4,27 @@ module JSONAPIonify::Api
     def self.extended(klass)
       klass.class_eval do
         class << self
-          delegate :context, :response_header, :helper, :rescue_from, :error,
-                   :enable_pagination, :before, :param, :request_header,
-                   :define_pagination_strategy, :define_sorting_strategy,
-                   :sticky_params, :authentication, :on_exception,
+          delegate :context,
+                   :response_header,
+                   :helper,
+                   :rescue_from,
+                   :register_exception,
+                   :error,
+                   :enable_pagination,
+                   :before,
+                   :param,
+                   :request_header,
+                   :define_pagination_strategy,
+                   :define_sorting_strategy,
+                   :sticky_params,
+                   :authentication,
+                   :on_exception,
                    :example_id_generator,
+                   :after,
+                   :builder,
+                   :types,
+                   :attribute,
+
                    to: :resource_class
         end
       end

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

@@ -26,9 +26,9 @@ module JSONAPIonify::Api
     end
 
     def documentation_output(request)
-      #cache_store.fetch(resource_signature) do
-      JSONAPIonify::Documentation.new(documentation_object(request)).result
-      #end
+      cache_store.fetch(resource_signature) do
+        JSONAPIonify::Documentation.new(documentation_object(request)).result
+      end
     end
 
     def resources_in_order

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

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