rails_api_documentation 0.2.3 → 0.3.0

data/lib/rails_api_doc/controller/response/factory.rb

@@ -6,12 +6,30 @@ class RailsApiDoc::Controller::Response::Factory
   class << self
 
     # TODO: add more options later depending on app settings
+    # TODO: rename to :load_repo
     def repo
-      ::RailsApiDoc::Controller::Response::Rabl.new(controllers)
+      attributes = RailsApiDoc::Controller::Response::Repository.new(repository.repo)
+
+      attributes = merge_attributes_from_model attributes
+
+      attributes
     end
 
     def controllers
-      RailsApiDoc::Controller::Request::Repository.registered_controllers
+      RailsApiDoc::Controller::Request::Factory.registered_controllers
+    end
+
+    private
+
+    def repository
+      @repo ||= ::RailsApiDoc::Controller::Response::Rabl.new(controllers)
+    end
+
+    #
+    # do not mutate attributes
+    #
+    def merge_attributes_from_model(attributes)
+      RailsApiDoc::Model::AttributeMerger.new(attributes).call(api_type: 'response')
     end
 
   end

data/lib/rails_api_doc/controller/response/headers.rb

@@ -1,27 +1,16 @@
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
 # :nodoc:
 module RailsApiDoc::Controller::Response::Headers
 
-  RESPONSE_HEADERS = {
-    'Parameter' => {
-      value: -> (row_name, row_values) { row_name },
-      fill_type: :input,
-      param: :name
-    },
-    'Value' => {
-      value: -> (row_name, row_values) {
-        title = row_values.attr.to_s
-        title += '(NESTED)' if row_values.nested?
-        title
-      }
-    },
-    'Desc' => {
-      value: -> (row_name, row_values) {
-        'TODO: description' # if row_values[:desc]
-      },
-      fill_type: :input,
-      param: :desc
-    }
-  }
+  include RailsApiDoc::Controller::Headers
+
+  RESPONSE_HEADERS = [
+    NAME_HEADER,
+    TYPE_HEADER,
+    VALUE_HEADER,
+    DESC_HEADER
+  ].reduce(&:merge).freeze
 
   def headers
     RESPONSE_HEADERS

data/lib/rails_api_doc/controller/response/param.rb

@@ -1,13 +1,50 @@
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
 # :nodoc:
 module RailsApiDoc
   module Controller
     module Response
-      class Param < Struct.new(:name, :attr, :nested, :model, :desc)
+
+      #
+      # name - attribute key returned in json response
+      # attr - actual attribute usage attribute
+      # nested - attribute nesting if present
+      # model - attribute model if nested and has model
+      # desc - description for attribute
+      # type - attribute type if set
+      # id - param id in DB for lookup on display
+      #
+      class Param < RailsApiDoc::Controller::Param
+
+        define_accessors *VALID_RESPONSE_KEYS
+
+        def initialize(name, attr, nested, model = nil, desc = nil, type = nil, id = nil, action_type = nil, is_new: false)
+          @name = name
+          @store = {
+            name: name,
+            attr: attr,
+            nested: nested,
+            model: model,
+            desc: desc,
+            type: type,
+            action_type: action_type,
+            id: id
+          }.compact
+
+          @is_new = is_new
+          @new = []
+        end
 
         def nested?
           !nested.nil?
         end
 
+        def display_value
+          title = attr.to_s
+          title += '(NESTED)' if nested?
+          title
+        end
+
       end
     end
   end

data/lib/rails_api_doc/controller/response/rabl.rb

@@ -7,48 +7,37 @@ module RailsApiDoc::Controller::Response
   # :nodoc:
   class Rabl
 
-    include RailsApiDoc::Controller::Response::Headers
-
     class << self
 
       attr_accessor :renderer
 
     end
 
-    attr_reader :map
+    attr_reader :repo
 
     # pass all controllers registered for api doc
     # TODO: add setting for displaying all from start
     def initialize(controllers)
       @controllers = controllers
-      @routes = Rails.application.routes.set.anchored_routes.reject { |r| r.defaults[:internal] }
-      @map = construct_controller_template_map
-    end
 
-    def load_template(ctrl, action)
-      RablCompiler.new("#{ctrl.controller_path}/#{action}").compile_source
-    end
+      @routes = Rails.application.routes.set.anchored_routes.reject { |r| r.defaults[:internal] }
 
-    def action_route(ctrl, action)
-      action_route = @map[ctrl][:routes].detect { |r| r.defaults[:action] == action }
-      return unless action_route
-      method = action_route.instance_variable_get(:@request_method_match)&.first&.name&.split('::')&.last
-      route = action_route.path.spec.to_s
-      [method, route].compact.join(' ')
+      @repo = construct_controller_template_map
     end
 
-    private
-
     def construct_controller_template_map
-      @controllers.each_with_object({}) do |ctrl, map|
-        map[ctrl] = ctrl_actions(ctrl)
+      @controllers.each_with_object({}) do |ctrl, repo|
+        repo[ctrl] = ctrl_actions(ctrl)
       end
     end
 
+    private
+
     def ctrl_actions(ctrl)
       routes = @routes.select do |route|
         route.defaults[:controller].in?([ctrl.controller_path, ctrl.controller_name])
       end
+
       actions = routes.map { |r| r.defaults[:action] }
       {
         routes: routes,

data/lib/rails_api_doc/controller/response/rabl_compiler.rb

@@ -23,9 +23,7 @@ module RailsApiDoc::Controller::Response
     # end
 
     def add(n)
-      if n[:attr] && n[:name] != n[:attr]
-        n[:name] = "#{n[:name]}(#{n[:attr]})"
-      end
+      n[:name] = "#{n[:name]}(#{n[:attr]})" if n[:attr] && n[:name] != n[:attr]
 
       @nodes[n[:name]] = RailsApiDoc::Controller::Response::Param.new(n[:name], n[:attr], n[:nested])
     end
@@ -159,8 +157,8 @@ module RailsApiDoc::Controller::Response
     #   merge { |item| partial("specific/#{item.to_s}", object: item) }
     #
     # def merge
-      # return unless block_given?
-      # yield
+    # return unless block_given?
+    # yield
     # end
 
     #
@@ -181,13 +179,13 @@ module RailsApiDoc::Controller::Response
     # end
     #
     # def condition(*)
-      # return unless block_given?
-      # template = sub_compile(nil, true) { yield }
-      # @attributes.extends template
+    # return unless block_given?
+    # template = sub_compile(nil, true) { yield }
+    # @attributes.extends template
     # end
     #
     def method_missing(name, *attrs)
-      return p("#{name} is not implemented in railsApiDoc") if name.in?(['merge', 'condtiion'])
+      return p("#{name} is not implemented in railsApiDoc") if name.in?(%w(merge condtiion))
       super
     end
 

data/lib/rails_api_doc/controller/response/repository.rb

@@ -0,0 +1,38 @@
+# :nodoc:
+class RailsApiDoc::Controller::Response::Repository
+
+  include RailsApiDoc::Controller::Repo
+  include RailsApiDoc::Controller::Response::Headers
+
+  def initialize(repo)
+    @repo = repo.clone.transform_values { |v| v.deep_dup }
+  end
+
+  def load_template(ctrl, action)
+    RailsApiDoc::Controller::Response::RablCompiler.new("#{ctrl.controller_path}/#{action}").compile_source
+  end
+
+  def action_route(ctrl, action)
+    return unless action_route = action_route_for(ctrl, action)
+
+    {
+      method: method(action_route),
+      url: url(action_route)
+    }
+  end
+
+  private
+
+  def method(route)
+    route.instance_variable_get(:@request_method_match)&.first&.name&.split('::')&.last
+  end
+
+  def url(a_route)
+    a_route.path.spec.to_s.gsub(/(\(.*\))/, '')
+  end
+
+  def action_route_for(ctrl, action)
+    @repo[ctrl][:routes].detect { |r| r.defaults[:action] == action }
+  end
+
+end

data/lib/rails_api_doc/model/attribute_merger.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+# author: Vadim Shaveiko <@vshaveyko>
+# :nodoc:
+class RailsApiDoc::Model::AttributeMerger
+
+  MODEL = RailsApiDoc::ApiDatum
+  MERGABLE_FIELDS = [:type, :desc, :action_type].freeze
+
+  #
+  # do not mutate attributes
+  #
+  # please - impossible
+  #
+  def initialize(attributes)
+    @attrs = attributes
+  end
+
+  def call(api_type:)
+    @api_type = api_type
+
+    api_params = MODEL.where(api_type: api_type).all.each do |param|
+      _add_nested_param(param)
+    end
+
+    @attrs
+  end
+
+  private
+
+  def _add_nested_param(param)
+    # nesting should be present for parameter to appear
+    return if param.nesting.blank?
+
+    attrs, nesting, name = _parse_settings(param)
+
+    return unless name
+
+    ctrl_param = _find_param(nesting, name, attrs)
+
+    ctrl_param.param = param
+    # _merge_data_to_param(ctrl_param, param)
+  end
+
+  def _parse_settings(param)
+    ctrl = param.nesting[0].constantize
+    nesting = param.nesting[1..-1]
+    name = param.name&.to_sym
+    attrs = @attrs[ctrl]
+
+    #
+    # making exception
+    # until request parameters are not split by actions
+    #
+    attrs = attrs[param.api_action] if @api_type == 'response'
+
+    [attrs, nesting, name]
+  end
+
+  def _merge_data_to_param(ctrl_param, param)
+    MERGABLE_FIELDS.each do |field|
+      next if ctrl_param_value = ctrl_param.public_send(field) # do not override data set in api ctrl
+
+      param_value = param.public_send(field)
+      next if param_value.blank?
+
+      ctrl_param.public_send("#{field}=", param_value)
+      ctrl_param.add_updated_field(field)
+    end
+
+    _merge_special(ctrl_param, param)
+  end
+
+  def _merge_special(ctrl_param, param)
+    return if param.special.blank?
+
+    if ctrl_param.enum? && ctrl_param.enum.blank?
+      ctrl_param.enum = _parse_enum(param.special)
+      ctrl_param.add_updated_field('enum')
+    elsif ctrl_param.nested? && ctrl_param.model.blank?
+      ctrl_param.model = special.capitalize
+      ctrl_param.add_updated_field('model')
+    end
+  end
+
+  def _find_param(nesting, name, attrs)
+    nesting.each do |model|
+      nested_attrs = attrs.each_value.detect { |v| v.nested? && v.model == model }
+
+      attrs = nested_attrs ? nested_attrs : _define_nesting_level(attrs, name, model)
+    end
+
+    if attrs[name]
+      attrs[name]
+    else
+      attrs[name] = _init_param_for_api_type(name)
+    end
+  end
+
+  def _define_nesting_level(attrs, name, model)
+    attr = _init_param_for_api_type(name, type: :object, model: model, nested: {})
+
+    attrs[name] = attr
+  end
+
+  #
+  # common attrs:
+  # 1. name
+  # 2. type
+  # 3. desc
+  # 4. model
+  # 5. id
+  # 6. nested
+  #
+  # request attrs:
+  # 1. enum
+  # 2. value
+  # 3. required
+  #
+  # response attrs:
+  # 1. attr
+  #
+  def _init_param_for_api_type(name, options)
+    if @api_type == 'request'
+      RailsApiDoc::Controller::Request::Param.new(name, options, is_new: true)
+    elsif @api_type == 'response'
+      RailsApiDoc::Controller::Response::Param.new(name, name, options[:nested], options[:model], '', options[:type], is_new: true)
+    end
+  end
+
+end

data/lib/rails_api_doc/model/attribute_parser.rb

@@ -5,16 +5,20 @@ class RailsApiDoc::Model::AttributeParser
 
   # TODO : Change to I18n. Added on: 08.10.16. Added by: <@vshaveyko>
   WRONG_NAME_ERROR_STRING = 'Name should consist only of letters\ciphers\underscores'
+  WRONG_TYPE_ERROR_STRING = 'Wrong type saved'
 
   class << self
 
     def parse_attributes(params)
-      type = :enum if params[:enum].present?
-
       {
         name: parse_name(params[:name]),
-        type: type || parse_type(params[:type]),
-        enum: parse_enum(params[:enum])
+        type: parse_type(params[:type]),
+        desc: params[:desc],
+        special: parse_special(params[:type], params[:special]),
+        action_type: params[:action],
+        nesting: params[:nesting],
+        api_type: params[:api_type],
+        id: params[:id]
       }.compact
     end
 
@@ -46,9 +50,23 @@ class RailsApiDoc::Model::AttributeParser
       end
     end
 
+    def parse_special(type, special)
+      return unless special.present? && type
+
+      if type == :enum
+        parse_enum(special) # parse as enum array value
+      elsif RailsApiDoc::NESTED_TYPES.include?(type.to_sym)
+        special.capitalize # parse as model name
+      end
+    end
+
     def parse_type(type)
       return if type.blank?
-      type.constantize
+
+      type = type.to_sym
+      raise NameError, WRONG_TYPE_ERROR_STRING unless type.in?(RailsApiDoc::ACCEPTED_TYPES)
+
+      type
     end
 
   end

data/lib/rails_api_doc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 # author: Vadim Shaveiko <@vshaveyko>
 module RailsApiDoc
-  VERSION = '0.2.3'
+  VERSION = '0.3.0'
 end