jsonapi_swagger_helpers 0.1.5 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b9b3f968a4f5d28cdde96e82960634eb620f152
-  data.tar.gz: a1a488145afdab452e203eca3301f02fb9c03e04
+  metadata.gz: 9a9dd06a7c8afca90ba9b3b340598a61ee7473d4
+  data.tar.gz: a4e56e637f81f4da21a6e784c9a4d2dae0b85953
 SHA512:
-  metadata.gz: 85b70ab34c7a2e0dcdb0aab4aea2d9d62cdcd598772f5eb186837a9e3ab79d169024de4721fa0b4893b14e30472ec544d2e7ede0620225f88628a28703448a58
-  data.tar.gz: 0b33c9e6fad54818f4fcf28a8bea33692d6a51a204f11e6caa2b6b5238133ce9d3f91ccfb946d023a4d50c505afed588f44f4ed1b4d4e269b60d83474e71d171
+  metadata.gz: 002f847d7f43fa3433932b72fab3e1efba37aafa120d2ba7332b9df78c9792a7e9075d5e30a6f56592d69c49a8ab5a213a03ad55463cce5db5040720d2896fd1
+  data.tar.gz: edc488adacd76b2281ad138410e37e3150fb380b889550ec171f8e0e90207e5dd917c81fb94f40335189d790f7a50f648f9865d517a68969e0f29841699e54de

data/.gitignore

@@ -7,3 +7,5 @@
 /pkg/
 /spec/reports/
 /tmp/
+swagger.json
+npm-debug.log

data/jsonapi_swagger_helpers.gemspec

@@ -19,6 +19,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency 'swagger-blocks', '~> 1.3'
+  # TODO: above 0.4.2
+  spec.add_dependency 'jsonapi_spec_helpers', ['< 1']
 
   spec.add_development_dependency "bundler", "~> 1.12"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/jsonapi_swagger_helpers/configuration.rb

@@ -0,0 +1,10 @@
+class JsonapiSwaggerHelpers::Configuration
+  def type_mapping
+    @type_mapping ||= {
+      string: [String],
+      integer: [Integer, Bignum],
+      float: [Float],
+      boolean: [TrueClass, FalseClass]
+    }
+  end
+end

data/lib/jsonapi_swagger_helpers/create_action.rb

@@ -0,0 +1,27 @@
+class JsonapiSwaggerHelpers::CreateAction
+  include JsonapiSwaggerHelpers::Writeable
+
+  def action_name
+    :create
+  end
+
+  def generate
+    _self = self
+
+    define_schema
+    @node.operation :post do
+      key :description, _self.description
+      key :operationId, _self.operation_id
+      key :tags, _self.all_tags
+
+      parameter do
+        key :name, :payload
+        key :in, :body
+
+        schema do
+          key :'$ref', :"#{_self.strong_resource.name}_create"
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_swagger_helpers/destroy_action.rb

@@ -0,0 +1,19 @@
+class JsonapiSwaggerHelpers::DestroyAction
+  include JsonapiSwaggerHelpers::Writeable
+
+  def action_name
+    :destroy
+  end
+
+  def generate
+    _self = self
+
+    @node.operation :delete do
+      key :description, _self.description
+      key :operationId, _self.operation_id
+      key :tags, _self.tags
+
+      _self.util.id_in_url(self)
+    end
+  end
+end

data/lib/jsonapi_swagger_helpers/docs_controller_mixin.rb

@@ -1,13 +1,32 @@
 module JsonapiSwaggerHelpers
   module DocsControllerMixin
     def self.included(klass)
+      # Save our controller so we can execute Swagger::Blocks code against it
+      JsonapiSwaggerHelpers.docs_controller = klass
+
+      # Add glue code
       klass.send(:include, Swagger::Blocks)
-      klass.extend(ResourceMixin)
+      klass.extend(ResourceMixin) # jsonapi_resource DSL
+      klass.extend(ClassMethods) # for predefining payloads
+
+      # Predefine swagger definitions for later reference
+      #   * spec payloads define outputs
+      #   * strong resources define inputs
+      klass.register_payload_definitions!
+    end
+
+    module ClassMethods
+      def register_payload_definitions!
+        JsonapiSpecHelpers.load_payloads!
+        JsonapiSpecHelpers::Payload.registry.each_pair do |payload_name, payload|
+          JsonapiSwaggerHelpers::PayloadDefinition.new(payload).generate
+        end
+      end
     end
 
+    # Give Swagger::Blocks what it wants
     def index
-      klasses = [self.class, JsonapiSwaggerHelpers::StrongResourceMixin::Schemas]
-      render json: Swagger::Blocks.build_root_json(klasses)
+      render json: Swagger::Blocks.build_root_json([self.class])
     end
   end
 end

data/lib/jsonapi_swagger_helpers/index_action.rb

@@ -0,0 +1,45 @@
+class JsonapiSwaggerHelpers::IndexAction
+  include JsonapiSwaggerHelpers::Readable
+
+  def action_name
+    :index
+  end
+
+  def generate
+    _self = self
+
+    @node.operation :get do
+      key :description, _self.full_description
+      key :operationId, _self.operation_id
+      key :tags, _self.all_tags
+
+      _self.util.jsonapi_sorting(self)
+      _self.util.jsonapi_pagination(self)
+
+      _self.util.each_filter(_self.resource) do |filter_label|
+        _self.util.jsonapi_filter(self, filter_label)
+      end
+
+      _self.each_stat do |stat_name, calculations|
+        _self.util.jsonapi_stat(self, stat_name, calculations)
+      end
+
+      _self.util.jsonapi_fields(self, _self.jsonapi_type)
+
+      if _self.has_extra_fields?
+        _self.util.jsonapi_extra_fields(self, _self.resource)
+      end
+
+      if _self.has_sideloads?
+        _self.util.jsonapi_includes(self)
+
+        _self.each_association do |association_name, association_resource|
+          _self.util.each_filter(association_resource, association_name) do |filter_label|
+            _self.util.jsonapi_filter(self, filter_label)
+            _self.util.jsonapi_fields(self, association_resource.config[:type])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_swagger_helpers/payload_definition.rb

@@ -0,0 +1,57 @@
+class JsonapiSwaggerHelpers::PayloadDefinition
+  attr_reader :payload
+
+  # Given a spec payload like:
+  #
+  # key(:name, String)
+  #
+  # Return the corresponding swagger type, ie :string
+  # If a key has multiple types, we'll pick the first swagger type that matches:
+  #
+  # key(:total, [String, Integer]) => :string
+  def self.swagger_type_for(payload_name, attribute, type)
+    types = Array(type)
+    return :string if types.empty?
+
+    type_mapping.each_pair do |swagger_type, klasses|
+      if types.any? { |t| klasses.include?(t) }
+        return swagger_type
+      end
+    end
+
+    raise JsonapiSwaggerHelpers::Errors::TypeNotFound
+      .new(payload_name, attribute)
+  end
+
+  def self.type_mapping
+    JsonapiSwaggerHelpers.config.type_mapping
+  end
+
+  def initialize(payload)
+    @payload = payload
+  end
+
+  def context
+    JsonapiSwaggerHelpers.docs_controller
+  end
+
+  def jsonapi_type
+    payload.type
+  end
+
+  def generate
+    _self = self
+
+    context.send(:swagger_schema, payload.name) do
+      payload = _self.payload
+
+      payload.keys.each_pair do |attribute, config|
+        property attribute do
+          type = _self.class.swagger_type_for(payload.name, attribute, config[:type])
+          key :type, type
+          key :description, config[:description]
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_swagger_helpers/readable.rb

@@ -0,0 +1,83 @@
+module JsonapiSwaggerHelpers::Readable
+  def self.included(klass)
+    klass.class_eval do
+      attr_reader :node,
+        :controller,
+        :resource,
+        :description,
+        :tags
+    end
+  end
+
+  def initialize(node, controller, description: nil, tags: [])
+    @node = node
+    @controller = controller
+    @resource = controller._jsonapi_compliable
+    @description = description || default_description
+    @tags = tags
+  end
+
+  def default_description
+    "#{action_name.capitalize} Action"
+  end
+
+  def operation_id
+    "#{controller.name.gsub('::', '-')}-#{action_name}"
+  end
+
+  def util
+    JsonapiSwaggerHelpers::Util
+  end
+
+  def include_directive
+    util.include_directive_for(controller, action_name)
+  end
+
+  def has_sideloads?
+    include_directive.keys.length > 0
+  end
+
+  def has_extra_fields?
+    resource.config[:extra_fields].keys.length > 1
+  end
+
+  def full_description
+    "#{description}<br /><br />#{util.sideload_label(include_directive)}"
+  end
+
+  def all_tags
+    tags + payload_tags
+  end
+
+  def payload_tags
+    util.payload_tags_for(resource, include_directive.to_hash)
+  end
+
+  def operation_id
+    "#{controller.name.gsub('::', '-')}-#{action_name}"
+  end
+
+  def each_stat
+    resource.config[:stats].each_pair do |stat_name, opts|
+      calculations = opts.calculations.keys - [:keys]
+      calculations = calculations.join(', ')
+
+      yield stat_name, calculations
+    end
+  end
+
+  def each_association
+    resource_map = util.all_resources(resource, include_directive)
+    resource_map.each_pair do |association_name, association_resource|
+      yield association_name, association_resource
+    end
+  end
+
+  def jsonapi_type
+    resource.config[:type]
+  end
+
+  def generate
+    raise 'override me'
+  end
+end

data/lib/jsonapi_swagger_helpers/resource_mixin.rb

@@ -1,76 +1,58 @@
 module JsonapiSwaggerHelpers
   module ResourceMixin
 
-    def jsonapi_resource(base_path, tags: [], descriptions: {}, only: [], except: [])
-      actions   = [:index, :show, :create, :update, :destroy]
-
-      unless only.empty?
-        actions.select! { |a| only.include?(a) }
-      end
-
-      unless except.empty?
-        actions.reject! { |a| except.include?(a) }
-      end
+    def jsonapi_resource(base_path,
+                         tags: [],
+                         descriptions: {},
+                         only: [],
+                         except: [])
+      actions = [:index, :show, :create, :update, :destroy]
+      actions.select! { |a| only.include?(a) } unless only.empty?
+      actions.reject! { |a| except.include?(a) } unless except.empty?
 
       prefix     = @swagger_root_node.data[:basePath]
       full_path  = [prefix, base_path].join('/').gsub('//', '/')
-      controller = controller_for(full_path)
+      controller = JsonapiSwaggerHelpers::Util.controller_for(full_path)
 
+      ctx = self
       if [:create, :index].any? { |a| actions.include?(a) }
         swagger_path base_path do
-          if actions.include?(:index)
-            operation :get do
-              key :tags, tags
-              key :description, descriptions[:index]
-              jsonapi_index(controller)
-            end
+          if actions.include?(:index) && controller.action_methods.include?('index')
+            index_action = JsonapiSwaggerHelpers::IndexAction.new \
+              self, controller, tags: tags, description: descriptions[:index]
+            index_action.generate
           end
 
-          if actions.include?(:create)
-            operation :post do
-              key :tags, tags
-              key :description, descriptions[:create]
-              strong_resource(controller, :create)
-            end
+          if actions.include?(:create) && controller.action_methods.include?('create')
+            create_action = JsonapiSwaggerHelpers::CreateAction.new \
+              self, controller, tags: tags, description: descriptions[:create]
+            create_action.generate
           end
         end
       end
 
       if [:show, :update, :destroy].any? { |a| actions.include?(a) }
+        ctx = self
         swagger_path "#{base_path}/{id}" do
-          if actions.include?(:show)
-            operation :get do
-              key :tags, tags
-              key :description, descriptions[:show]
-              jsonapi_show(controller)
-            end
+          if actions.include?(:show) && controller.action_methods.include?('show')
+            show_action = JsonapiSwaggerHelpers::ShowAction.new \
+              self, controller, tags: tags, description: descriptions[:show]
+            show_action.generate
           end
 
-          if actions.include?(:update)
-            operation :put do
-              key :tags, tags
-              key :description, descriptions[:update]
-              id_in_url
-              strong_resource(controller, :update)
-            end
+          if actions.include?(:update) && controller.action_methods.include?('update')
+            update_action = JsonapiSwaggerHelpers::UpdateAction.new \
+              self, controller, tags: tags, description: descriptions[:update]
+            update_action.generate
           end
 
-          if actions.include?(:destroy)
-            operation :delete do
-              key :tags, tags
-              key :description, descriptions[:destroy]
-              id_in_url
-            end
+          if actions.include?(:destroy) && controller.action_methods.include?('destroy')
+            destroy_action = JsonapiSwaggerHelpers::DestroyAction.new \
+              self, controller, tags: tags, description: descriptions[:destroy]
+            destroy_action.generate
           end
         end
       end
     end
-
-    def controller_for(path)
-      path = path.sub('{id}', '1')
-      route = Rails.application.routes.recognize_path(path)
-      "#{route[:controller]}_controller".classify.constantize
-    end
-
   end
 end

data/lib/jsonapi_swagger_helpers/show_action.rb

@@ -0,0 +1,43 @@
+class JsonapiSwaggerHelpers::ShowAction
+  include JsonapiSwaggerHelpers::Readable
+
+  def action_name
+    :show
+  end
+
+  def generate
+    _self = self
+
+    @node.operation :get do
+      key :description, _self.full_description
+      key :operationId, _self.operation_id
+      key :tags, _self.all_tags
+
+      _self.util.id_in_url(self)
+      _self.util.jsonapi_fields(self, _self.jsonapi_type)
+
+      if _self.has_extra_fields?
+        _self.util.jsonapi_extra_fields(self, _self.resource)
+      end
+
+      _self.each_stat do |stat_name, calculations|
+        _self.util.jsonapi_stat(self, stat_name, calculations)
+      end
+
+      if _self.has_sideloads?
+        _self.util.jsonapi_includes(self)
+
+        _self.each_association do |association_name, association_resource|
+          _self.util.each_filter(association_resource, association_name) do |filter_label|
+            _self.util.jsonapi_filter(self, filter_label)
+            _self.util.jsonapi_fields(self, association_resource.config[:type])
+
+            if association_resource.config[:extra_fields].keys.length > 0
+              _self.util.jsonapi_extra_fields(self, association_resource)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_swagger_helpers/update_action.rb

@@ -0,0 +1,29 @@
+class JsonapiSwaggerHelpers::UpdateAction
+  include JsonapiSwaggerHelpers::Writeable
+
+  def action_name
+    :update
+  end
+
+  def generate
+    _self = self
+
+    define_schema
+    @node.operation :put do
+      key :description, _self.description
+      key :operationId, _self.operation_id
+      key :tags, _self.all_tags
+
+      _self.util.id_in_url(self)
+
+      parameter do
+        key :name, :payload
+        key :in, :body
+
+        schema do
+          key :'$ref', :"#{_self.strong_resource.name}_update"
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi_swagger_helpers/util.rb

@@ -0,0 +1,165 @@
+module JsonapiSwaggerHelpers::Util
+  def self.controller_for(path)
+    path = path.sub('{id}', '1')
+    route = Rails.application.routes.recognize_path(path)
+    "#{route[:controller]}_controller".classify.constantize
+  end
+
+  def self.sideload_label(include_directive)
+    sideloads = include_directive.to_string.split(",").sort.join(",<br/>")
+
+    <<-HTML
+<label>
+  Possible sideloads:
+  <span class="possible-sideloads">#{sideloads}</span>
+</label>
+    HTML
+  end
+
+  def self.each_filter(resource, association_name = nil)
+    resource.config[:filters].each_pair do |filter_name, opts|
+      if association_name
+        yield "filter[#{association_name}][#{filter_name}]"
+      else
+        yield "filter[#{filter_name}]"
+      end
+    end
+  end
+
+  def self.all_resources(resource, include_directive, memo = {})
+    resource.sideloading.sideloads.each_pair do |name, sideload|
+      next if memo[name] || !include_directive.key?(name)
+
+      memo[name] = sideload.resource.class
+      all_resources(sideload.resource.class, include_directive[name], memo)
+    end
+    memo
+  end
+
+  def self.include_directive_for(controller, action)
+    resource_class = controller._jsonapi_compliable
+    includes       = resource_class.sideloading.to_hash[:base]
+    whitelist      = resource_class.config[:sideload_whitelist]
+
+    if whitelist && whitelist[action]
+      includes = JsonapiCompliable::Util::IncludeParams
+        .scrub(includes, whitelist[action])
+    end
+
+    JSONAPI::IncludeDirective.new(includes)
+  end
+
+  def self.payloads_for(resource, include_hash)
+    [].tap do |payloads|
+      payloads << JsonapiSpecHelpers::Payload.by_type(resource.config[:type])
+
+      include_hash.each_pair do |name, nested|
+        sideload = resource.sideloading.sideloads[name]
+
+        if sideload.polymorphic?
+          sideload.polymorphic_groups.each_pair do |type, sl|
+            payloads << payloads_for(sl.resource_class, nested)
+          end
+        else
+          sideload_resource = sideload.resource_class
+          payloads << payloads_for(sideload_resource, nested)
+        end
+      end
+    end.flatten.uniq(&:name)
+  end
+
+  def self.payload_tags_for(resource, include_hash)
+    payloads_for(resource, include_hash).map { |p| "payload-#{p.name}" }
+  end
+
+  def self.jsonapi_filter(node, label)
+    node.parameter do
+      key :description, '<a href="http://jsonapi.org/format/#fetching-filtering">JSONAPI Filter</a>'
+      key :name, label
+      key :in, :query
+      key :type, :string
+      key :required, false
+    end
+  end
+
+  def self.jsonapi_sorting(node)
+    node.parameter do
+      key :description, '<a href="http://jsonapi.org/format/#fetching-sorting">JSONAPI Sorting</a>'
+      key :name, :sort
+      key :in, :query
+      key :type, :string
+      key :required, false
+    end
+  end
+
+  def self.jsonapi_pagination(node)
+    node.parameter do
+      key :description, '<a href="http://jsonapi.org/format/#fetching-pagination">JSONAPI Page Size</a>'
+      key :name, "page[size]"
+      key :in, :query
+      key :type, :string
+      key :required, false
+    end
+
+    node.parameter do
+      key :description, '<a href="http://jsonapi.org/format/#fetching-pagination">JSONAPI Page Number</a>'
+      key :name, "page[number]"
+      key :in, :query
+      key :type, :string
+      key :required, false
+    end
+  end
+
+  def self.jsonapi_stat(node, name, calculations)
+    node.parameter do
+      key :name, "stats[#{name}]"
+      key :description, "<a href=\"https://jsonapi-suite.github.io/jsonapi_suite/how-to-return-statistics\">JSONAPI Stats</a><br /><b>Possible Calculations:</b> #{calculations}"
+      key :in, :query
+      key :type, :string
+      key :required, false
+    end
+  end
+
+  def self.jsonapi_includes(node)
+    node.parameter do
+      key :description, '<a href="http://jsonapi.org/format/#fetching-includes">JSONAPI Includes</a>'
+      key :name, :include
+      key :in, :query
+      key :type, :string
+      key :required, false
+    end
+  end
+
+  def self.jsonapi_fields(node, jsonapi_type)
+    node.parameter do
+      key :description, '<a href="http://jsonapi.org/format/#fetching-sparse-fieldsets">JSONAPI Sparse Fieldset</a>'
+      key :name, "fields[#{jsonapi_type}]"
+      key :in, :query
+      key :type, :string
+      key :required, false
+    end
+  end
+
+  def self.jsonapi_extra_fields(node, resource)
+    jsonapi_type = resource.config[:type]
+
+    extra_field_names = resource.config[:extra_fields].keys.join(',')
+    node.parameter do
+      key :description, "<a href=\"https://jsonapi-suite.github.io/jsonapi_suite/how-to-conditionally-render-fields\">JSONAPI Extra Fields</a><br /><b>Possible Fields:</b> #{extra_field_names}"
+      key :name, "extra_fields[#{jsonapi_type}]"
+      key :in, :query
+      key :type, :string
+      key :required, false
+    end
+  end
+
+  def self.id_in_url(node)
+    node.parameter do
+      key :name, :id
+      key :in, :path
+      key :type, :string
+      key :required, true
+      key :description, 'record id'
+    end
+  end
+end

data/lib/jsonapi_swagger_helpers/version.rb

@@ -1,3 +1,3 @@
 module JsonapiSwaggerHelpers
-  VERSION = "0.1.5"
+  VERSION = "0.3.0"
 end

data/lib/jsonapi_swagger_helpers/writeable.rb

@@ -0,0 +1,89 @@
+module JsonapiSwaggerHelpers::Writeable
+  def self.included(klass)
+    klass.class_eval do
+      attr_reader :node,
+        :controller,
+        :resource,
+        :description,
+        :tags
+    end
+  end
+
+  def initialize(node, controller, description: nil, tags: [])
+    @node = node
+    @controller = controller
+    @resource = controller._jsonapi_compliable
+    @description = description || default_description
+    @tags = tags
+  end
+
+  def util
+    JsonapiSwaggerHelpers::Util
+  end
+
+  def action_name
+    raise 'override me'
+  end
+
+  def default_description
+    "#{action_name.to_s.capitalize} Action"
+  end
+
+  def operation_id
+    "#{controller.name.gsub('::', '-')}-#{action_name}"
+  end
+
+  def all_tags
+    tags + payload_tags
+  end
+
+  def payload_tags
+    tags = [:"payload-#{strong_resource.name}_#{action_name}"]
+
+    strong_resource.relations.each_pair do |relation_name, relation_config|
+      tags << :"payload-#{strong_resource.name}_#{relation_name}_#{action_name}"
+    end
+
+    tags
+  end
+
+  def context
+    JsonapiSwaggerHelpers.docs_controller
+  end
+
+  def strong_resource
+    controller._strong_resources[action_name]
+  end
+
+  def define_schema
+    _self = self
+    context.send(:swagger_schema, :"#{strong_resource.name}_#{action_name}") do
+      _self.strong_resource.attributes.each_pair do |attribute, config|
+        property attribute do
+          key :type, config[:type] # TODO - swagger type?
+        end
+      end
+    end
+
+    _self.strong_resource.relations.each_pair do |relation_name, relation_config|
+      context.send(:swagger_schema, :"#{strong_resource.name}_#{relation_name}_#{action_name}") do
+        relation_config[:resource].attributes.each_pair do |attribute, config|
+          property attribute do
+            key :type, config[:type] # TODO - swagger type?
+          end
+        end
+      end
+    end
+  end
+
+  def generate
+    _self = self
+
+    define_schema
+    @node.operation :post do
+      key :description, _self.description
+      key :operationId, _self.operation_id
+      key :tags, _self.all_tags
+    end
+  end
+end

data/lib/jsonapi_swagger_helpers.rb

@@ -1,13 +1,26 @@
 require 'swagger/blocks'
-require "jsonapi_swagger_helpers/version"
-require "jsonapi_swagger_helpers/schema_helpers"
-require "jsonapi_swagger_helpers/strong_resource_mixin"
+require "jsonapi_spec_helpers"
+require "jsonapi_swagger_helpers/configuration"
+require "jsonapi_swagger_helpers/payload_definition"
+require "jsonapi_swagger_helpers/util"
+require "jsonapi_swagger_helpers/readable"
+require "jsonapi_swagger_helpers/writeable"
+require "jsonapi_swagger_helpers/index_action"
+require "jsonapi_swagger_helpers/show_action"
+require "jsonapi_swagger_helpers/create_action"
+require "jsonapi_swagger_helpers/update_action"
+require "jsonapi_swagger_helpers/destroy_action"
+
 require "jsonapi_swagger_helpers/resource_mixin"
 require "jsonapi_swagger_helpers/docs_controller_mixin"
 
 module JsonapiSwaggerHelpers
-  def self.prepended(klass)
-    klass.send(:include, StrongResourceMixin)
+  def self.configure
+    yield config
+  end
+
+  def self.config
+    @config ||= Configuration.new
   end
 
   def self.docs_controller
@@ -17,125 +30,6 @@ module JsonapiSwaggerHelpers
   def self.docs_controller=(controller)
     @docs_controller = controller
   end
-
-  def jsonapi_link
-    "<br/><p><a href='http://jsonapi.org'>JSONAPI-compliant</a> endpoint.</p><br />"
-  end
-
-  def validation_messages(messages)
-    string = "<p><b>Validations:</b><ul>"
-    messages.each do |message|
-      string << "<li>#{message}</li>"
-    end
-    string << "</ul></p>"
-  end
-
-  def jsonapi_index(controller)
-    jsonapi_includes(controller, :index)
-    jsonapi_filters(controller)
-    jsonapi_stats(controller)
-    jsonapi_pagination
-    jsonapi_sorting
-  end
-
-  def jsonapi_show(controller)
-    id_in_url
-    jsonapi_includes(controller, :show)
-  end
-
-  def id_in_url
-    parameter do
-      key :name, :id
-      key :in, :path
-      key :type, :string
-      key :required, true
-      key :description, 'record id'
-    end
-  end
-
-  def jsonapi_filters(controller)
-    filter_names = []
-    controller._jsonapi_compliable.filters.each_pair do |name, opts|
-      filter_names << name
-    end
-
-    filter_names.each do |filter_name|
-      parameter do
-        key :name, "filter[#{filter_name}]"
-        key :in, :query
-        key :type, :string
-        key :required, false
-        key :description, "<a href='http://jsonapi.org/format/#fetching-filtering'>JSONAPI filter</a>"
-
-        items do
-          key :model, :string
-        end
-      end
-    end
-  end
-
-  def jsonapi_stats(controller)
-    controller._jsonapi_compliable.stats.each_pair do |stat_name, opts|
-      calculations = opts.calculations.keys - [:keys]
-      calculations = calculations.join('<br/>')
-      parameter do
-        key :name, "stats[#{stat_name}]"
-        key :in, :query
-        key :type, :string
-        key :required, false
-        key :description, "<a href='http://jsonapi.org/format/#document-meta'>JSONAPI meta data</a><br/> #{calculations}"
-
-        items do
-          key :model, :string
-        end
-      end
-    end
-  end
-
-  def jsonapi_pagination
-    parameter do
-      key :name, "page[size]"
-      key :in, :query
-      key :type, :string
-      key :required, false
-      key :description, "<a href='http://jsonapi.org/format/#fetching-pagination'>JSONAPI page size</a>"
-    end
-
-    parameter do
-      key :name, "page[number]"
-      key :in, :query
-      key :type, :string
-      key :required, false
-      key :description, "<a href='http://jsonapi.org/format/#fetching-pagination'>JSONAPI page number</a>"
-    end
-  end
-
-  def jsonapi_sorting
-    parameter do
-      key :name, :sort
-      key :in, :query
-      key :type, :string
-      key :required, false
-      key :description, "<a href='http://jsonapi.org/format/#fetching-sorting'>JSONAPI sort</a>"
-    end
-  end
-
-  def jsonapi_includes(controller, action)
-    includes = controller._jsonapi_compliable.sideloads[:whitelist]
-
-    if includes && includes[action]
-      directive = includes[action]
-      includes  = directive.to_string.split(",").sort.join(",<br/>")
-
-      parameter do
-        key :name, :include
-        key :in, :query
-        key :type, :string
-        key :required, false
-        key :description, "<a href='http://jsonapi.org/format/#fetching-includes'>JSONAPI includes</a>: <br/> #{includes}"
-      end
-    end
-  end
 end
 
 Swagger::Blocks::OperationNode.prepend(JsonapiSwaggerHelpers)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi_swagger_helpers
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Lee Richmond
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-01-26 00:00:00.000000000 Z
+date: 2017-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: swagger-blocks
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: jsonapi_spec_helpers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -84,11 +98,19 @@ files:
 - bin/setup
 - jsonapi_swagger_helpers.gemspec
 - lib/jsonapi_swagger_helpers.rb
+- lib/jsonapi_swagger_helpers/configuration.rb
+- lib/jsonapi_swagger_helpers/create_action.rb
+- lib/jsonapi_swagger_helpers/destroy_action.rb
 - lib/jsonapi_swagger_helpers/docs_controller_mixin.rb
+- lib/jsonapi_swagger_helpers/index_action.rb
+- lib/jsonapi_swagger_helpers/payload_definition.rb
+- lib/jsonapi_swagger_helpers/readable.rb
 - lib/jsonapi_swagger_helpers/resource_mixin.rb
-- lib/jsonapi_swagger_helpers/schema_helpers.rb
-- lib/jsonapi_swagger_helpers/strong_resource_mixin.rb
+- lib/jsonapi_swagger_helpers/show_action.rb
+- lib/jsonapi_swagger_helpers/update_action.rb
+- lib/jsonapi_swagger_helpers/util.rb
 - lib/jsonapi_swagger_helpers/version.rb
+- lib/jsonapi_swagger_helpers/writeable.rb
 homepage: 
 licenses:
 - MIT
@@ -109,7 +131,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: Swagger helpers for jsonapi.org-compatible APIs

data/lib/jsonapi_swagger_helpers/schema_helpers.rb

@@ -1,78 +0,0 @@
-module JsonapiSwaggerHelpers
-  class SchemaHelpers
-    def self.attributes_schema
-      lambda do |attributes|
-        property :attributes do
-          key :type, :object
-
-          attributes.each_pair do |name, attr_type|
-            property name do
-              key :name, name
-              key :type, attr_type
-            end
-          end
-        end
-      end
-    end
-
-    def self.relationships_schema
-      lambda do |relationships|
-        property :relationships do
-          key :type, :object
-
-          relationships.each_pair do |relation_name, opts|
-            property relation_name do
-              property :data do
-                if opts[:array]
-                  key :type, :array
-                  items do
-                    if opts[:id]
-                      property :id do
-                        key :type, :string
-                      end
-                    end
-
-                    property :type do
-                      key :type, :string
-                      key :required, true
-                      key :enum, [opts[:jsonapi_type]]
-                    end
-
-                    if opts[:attributes]
-                      instance_exec(opts[:attributes], &SchemaHelpers.attributes_schema)
-                    end
-
-                    if opts[:relationships]
-                      instance_exec(opts[:relationships], &SchemaHelpers.relationships_schema)
-                    end
-                  end
-                else
-                  if opts[:id]
-                    property :id do
-                      key :type, :string
-                    end
-                  end
-
-                  property :type do
-                    key :type, :string
-                    key :required, true
-                    key :enum, [opts[:jsonapi_type]]
-                  end
-
-                  if opts[:attributes]
-                    instance_exec(opts[:attributes], &SchemaHelpers.attributes_schema)
-                  end
-
-                  if opts[:relationships]
-                    instance_exec(opts[:relationships], &SchemaHelpers.relationships_schema)
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-
-  end
-end

data/lib/jsonapi_swagger_helpers/strong_resource_mixin.rb

@@ -1,120 +0,0 @@
-module JsonapiSwaggerHelpers
-  module StrongResourceMixin
-
-    class Schemas
-      include Swagger::Blocks
-
-      def self.schema(name, &blk)
-        swagger_schema(name, &blk)
-      end
-    end
-
-    def strong_resource(controller, action)
-      update   = action == :update
-      resource = controller._strong_resources[action]
-      opts     = { jsonapi_type: resource.jsonapi_type }
-
-      if (attributes = strong_resource_attributes(resource, update)).present?
-        opts[:attributes] = attributes
-      end
-
-      if (relationships = strong_resource_relationships(resource, update)).present?
-        opts[:relationships] = relationships
-      end
-
-      jsonapi_payload(SecureRandom.uuid.to_sym, opts)
-    end
-
-    def strong_resource_attributes(resource, is_update = false)
-      attributes = {}
-      resource.attributes.each_pair do |name, opts|
-        type = StrongResources.config.strong_params[opts[:type]][:swagger]
-        attributes[name] = type
-
-        if is_update
-          if resource.destroy?
-            attributes[:_destroy] = :boolean
-          end
-
-          if resource.delete?
-            attributes[:_delete] = :boolean
-          end
-        end
-      end
-
-      attributes = attributes.slice(*resource.only) if !!resource.only
-      attributes = attributes.except(*resource.except) if !!resource.except
-      attributes
-    end
-
-    def strong_resource_relationships(resource, is_update = false)
-      {}.tap do |relations|
-        resource.relations.each_pair do |relation_name, opts|
-          resource = opts[:resource]
-
-          payload = {
-            jsonapi_type: resource.jsonapi_type,
-            id: true,
-            array: resource.has_many?
-          }
-
-          if (attributes = strong_resource_attributes(resource, is_update)).present?
-            payload[:attributes] = attributes
-          end
-
-          if (relationships = strong_resource_relationships(resource, is_update)).present?
-            payload[:relationships] = relationships
-          end
-
-          relations[relation_name] = payload
-        end
-      end
-    end
-
-    def jsonapi_payload(schema_name, payload)
-      jsonapi_input_schema(schema_name, payload)
-
-      parameter do
-        key :name, :payload
-        key :in, :body
-
-        schema do
-          key :'$ref', schema_name
-        end
-      end
-    end
-
-    def jsonapi_input_schema(schema_name,
-                                id: false,
-                                jsonapi_type:,
-                                attributes: nil,
-                                relationships: nil)
-      Schemas.schema(schema_name) do
-        property :data do
-          key :type, :object
-
-          property :type do
-            key :type, :string
-            key :required, true
-            key :enum, [jsonapi_type]
-          end
-
-          if id
-            property :id do
-              key :type, :string
-            end
-          end
-
-          if attributes
-            instance_exec(attributes, &SchemaHelpers.attributes_schema)
-          end
-
-          if relationships
-            instance_exec(relationships, &SchemaHelpers.relationships_schema)
-          end
-        end
-      end
-    end
-
-  end
-end