haveapi 0.20.0 → 0.21.1

data/lib/haveapi/hooks.rb

@@ -77,7 +77,7 @@ module HaveAPI
   #   p MyClass.call_hooks(:myhook, args: [1, 2, 3], initial: {counter: 0})
   #   => {:counter=>5}
   module Hooks
-    INSTANCE_VARIABLE = '@_haveapi_hooks'
+    INSTANCE_VARIABLE = '@_haveapi_hooks'.freeze
 
     # Register a hook defined by `klass` with `name`.
     # @param klass [Class]  an instance of Class, that is class name, not it's instance
@@ -116,7 +116,7 @@ module HaveAPI
         instance.instance_variable_set(INSTANCE_VARIABLE, hooks)
       end
 
-      hooks[name] ||= {listeners: []}
+      hooks[name] ||= { listeners: [] }
       hooks[name][:listeners] << block
     end
 
@@ -143,36 +143,37 @@ module HaveAPI
     # @param initial [Hash] initial return value
     # @param instance [Boolean] call instance hooks or not; nil means auto-detect
     def self.call_for(
-        klass,
-        name,
-        where = nil,
-        args: [],
-        kwargs: {},
-        initial: {},
-        instance: nil
+      klass,
+      name,
+      where = nil,
+      args: [],
+      kwargs: {},
+      initial: {},
+      instance: nil
     )
       classified = hook_classify(klass)
 
-      if (instance.nil? && !classified.is_a?(Class)) || instance
-        all_hooks = klass.instance_variable_get(INSTANCE_VARIABLE)
+      all_hooks = if (instance.nil? && !classified.is_a?(Class)) || instance
+                    klass.instance_variable_get(INSTANCE_VARIABLE)
 
-      else
-        all_hooks = @hooks[classified]
-      end
+                  else
+                    @hooks[classified]
+                  end
 
       catch(:stop) do
         return initial unless all_hooks
         return initial unless all_hooks[name]
+
         hooks = all_hooks[name][:listeners]
         return initial unless hooks
 
         hooks.each do |hook|
-          if where
-            ret = where.instance_exec(initial, *args, **kwargs, &hook)
+          ret = if where
+                  where.instance_exec(initial, *args, **kwargs, &hook)
 
-          else
-            ret = hook.call(initial, *args, **kwargs)
-          end
+                else
+                  hook.call(initial, *args, **kwargs)
+                end
 
           initial.update(ret) if ret
         end
@@ -195,60 +196,60 @@ module HaveAPI
     module ClassMethods
       # Register a hook named `name`.
       def has_hook(name, opts = {})
-        Hooks.register_hook(self.to_s, name, opts)
+        Hooks.register_hook(to_s, name, opts)
       end
 
       # Connect `block` to registered hook with `name`.
-      def connect_hook(name, &block)
-        Hooks.connect_hook(self.to_s, name, &block)
+      def connect_hook(name, &)
+        Hooks.connect_hook(to_s, name, &)
       end
 
       # Call all hooks for `name`. see {Hooks.call_for}.
-      def call_hooks(*args, **kwargs)
-        Hooks.call_for(self.to_s, *args, **kwargs)
+      def call_hooks(*, **)
+        Hooks.call_for(to_s, *, **)
       end
     end
 
     module InstanceMethods
       # Call all instance and class hooks.
-      def call_hooks_for(*args, **kwargs)
-        ret = call_instance_hooks_for(*args, **kwargs)
+      def call_hooks_for(*, **kwargs)
+        ret = call_instance_hooks_for(*, **kwargs)
 
         kwargs[:initial] = ret
-        call_class_hooks_for(*args, **kwargs)
+        call_class_hooks_for(*, **kwargs)
       end
 
       # Call only instance hooks.
       def call_instance_hooks_for(name, where = nil, args: [], kwargs: {}, initial: {})
-        Hooks.call_for(self, name, where, args: args, kwargs: kwargs, initial: initial)
+        Hooks.call_for(self, name, where, args:, kwargs:, initial:)
       end
 
       # Call only class hooks.
-      def call_class_hooks_for(name, where  = nil, args: [], kwargs: {}, initial: {})
-        Hooks.call_for(self.class, name, where, args: args, kwargs: kwargs, initial: initial)
+      def call_class_hooks_for(name, where = nil, args: [], kwargs: {}, initial: {})
+        Hooks.call_for(self.class, name, where, args:, kwargs:, initial:)
       end
 
       # Call hooks for different `klass`.
-      def call_hooks_as_for(klass, *args, **kwargs)
-        ret = call_instance_hooks_as_for(klass, *args, **kwargs)
+      def call_hooks_as_for(klass, *, **kwargs)
+        ret = call_instance_hooks_as_for(klass, *, **kwargs)
 
         kwargs[:initial] = ret
-        call_class_hooks_as_for(klass.class, *args, **kwargs)
+        call_class_hooks_as_for(klass.class, *, **kwargs)
       end
 
       # Call only instance hooks for different `klass`.
-      def call_instance_hooks_as_for(klass, *args, **kwargs)
-        Hooks.call_for(klass, *args, **kwargs)
+      def call_instance_hooks_as_for(klass, *, **)
+        Hooks.call_for(klass, *, **)
       end
 
       # Call only class hooks for different `klass`.
-      def call_class_hooks_as_for(klass, *args, **kwargs)
-        Hooks.call_for(klass, *args, **kwargs)
+      def call_class_hooks_as_for(klass, *, **)
+        Hooks.call_for(klass, *, **)
       end
 
       # Connect instance level hook `name` to `block`.
-      def connect_hook(name, &block)
-        Hooks.connect_instance_hook(self, name, &block)
+      def connect_hook(name, &)
+        Hooks.connect_instance_hook(self, name, &)
       end
     end
 

data/lib/haveapi/metadata.rb

@@ -6,7 +6,7 @@ module HaveAPI
 
     def self.describe
       {
-        namespace: namespace
+        namespace:
       }
     end
 

data/lib/haveapi/model_adapter.rb

@@ -14,38 +14,37 @@ module HaveAPI
       # Every model adapter must register itself using this method.
       def register
         ModelAdapter.adapters ||= []
-        ModelAdapter.adapters << Kernel.const_get(self.to_s)
+        ModelAdapter.adapters << Kernel.const_get(to_s)
       end
 
       # Returns an adapter suitable for `layout` and `obj`.
       # Adapters are iterated over and the first to return true to handle?()
       # is returned.
       def for(layout, obj)
-        return ModelAdapters::Hash if !obj || %i(hash hash_list).include?(layout)
-        adapter = @adapters.detect { |adapter| adapter.handle?(layout, obj) }
+        return ModelAdapters::Hash if !obj || %i[hash hash_list].include?(layout)
+
+        adapter = @adapters.detect { |a| a.handle?(layout, obj) }
         adapter || ModelAdapters::Hash
       end
 
       # Shortcut to Input::clean.
-      def input_clean(*args)
-        self::Input.clean(*args)
+      def input_clean(*)
+        self::Input.clean(*)
       end
 
       # Shortcut to get an instance of Input model adapter.
-      def input(*args)
-        self::Input.new(*args)
+      def input(*)
+        self::Input.new(*)
       end
 
       # Shortcut to get an instance of Output model adapter.
-      def output(*args)
-        self::Output.new(*args)
+      def output(*)
+        self::Output.new(*)
       end
 
       # Override this method to load validators from `model`
       # to `params`.
-      def load_validators(model, params)
-
-      end
+      def load_validators(model, params); end
 
       # Called when mounting the API. Model adapters may use this method
       # to add custom meta parameters to `action`. `direction` is one of
@@ -63,9 +62,7 @@ module HaveAPI
     # Subclass this class in your adapter and reimplement
     # necessary methods.
     class Input
-      def self.used_by(action)
-
-      end
+      def self.used_by(action); end
 
       def initialize(input)
         @input = input
@@ -83,17 +80,13 @@ module HaveAPI
       end
 
       # Return model instance from a raw input resource parameter.
-      def self.clean(model, raw, extra)
-
-      end
+      def self.clean(model, raw, extra); end
     end
 
     # Subclass this class in your adapter and reimplement
     # necessary methods.
     class Output
-      def self.used_by(action)
-
-      end
+      def self.used_by(action); end
 
       def initialize(context, obj)
         @context = context
@@ -102,14 +95,10 @@ module HaveAPI
 
       # Return true if input parameters contain parameter
       # with `name`.
-      def has_param?(name)
-
-      end
+      def has_param?(name); end
 
       # Return a parameter in an appropriate format to be sent to a client.
-      def [](name)
-
-      end
+      def [](name); end
 
       def meta
         {}

data/lib/haveapi/model_adapters/active_record.rb

@@ -6,7 +6,7 @@ module HaveAPI::ModelAdapters
     register
 
     def self.handle?(layout, klass)
-      klass < ::ActiveRecord::Base && %i(object object_list).include?(layout)
+      klass < ::ActiveRecord::Base && %i[object object_list].include?(layout)
     end
 
     def self.load_validators(model, params)
@@ -34,10 +34,10 @@ module HaveAPI::ModelAdapters
           # it well, it is not necessary to fix.
           args.concat(ar_default_includes).uniq
 
-          if !args.empty?
-            q.includes(*args)
-          else
+          if args.empty?
             q
+          else
+            q.includes(*args)
           end
         end
 
@@ -45,6 +45,7 @@ module HaveAPI::ModelAdapters
         # in an array of symbols and hashes.
         def ar_parse_includes(raw)
           return @ar_parsed_includes if @ar_parsed_includes
+
           @ar_parsed_includes = ar_inner_includes(raw).select do |inc|
             # Drop associations that are not registered in the AR:
             #   The API resource may have associations that are not based on
@@ -70,7 +71,7 @@ module HaveAPI::ModelAdapters
             if assoc.index('__')
               tmp = {}
               parts = assoc.split('__')
-              tmp[parts.first.to_sym] = ar_inner_includes([parts[1..-1].join('__')])
+              tmp[parts.first.to_sym] = ar_inner_includes([parts[1..].join('__')])
 
               args << tmp
             else
@@ -115,39 +116,37 @@ module HaveAPI::ModelAdapters
         action.meta(:object) do
           output do
             custom :path_params, label: 'URL parameters',
-                   desc: 'An array of parameters needed to resolve URL to this object'
+                                 desc: 'An array of parameters needed to resolve URL to this object'
             bool :resolved, label: 'Resolved', desc: 'True if the association is resolved'
           end
         end
 
-        if %i(object object_list).include?(action.input.layout)
-          clean = Proc.new do |raw|
-            if raw.is_a?(String)
-              raw.strip.split(',')
-            elsif raw.is_a?(Array)
-              raw
-            else
-              nil
-            end
-          end
+        return unless %i[object object_list].include?(action.input.layout)
 
-          desc = <<END
-A list of names of associated resources separated by a comma.
-Nested associations are declared with '__' between resource names.
-For example, 'user,node' will resolve the two associations.
-To resolve further associations of node, use e.g. 'user,node__location',
-to go even deeper, use e.g. 'user,node__location__environment'.
-END
-
-          action.meta(:global) do
-            input do
-              custom :includes, label: 'Included associations',
-                     desc: desc, &clean
-            end
+        clean = proc do |raw|
+          if raw.is_a?(String)
+            raw.strip.split(',')
+          elsif raw.is_a?(Array)
+            raw
           end
+        end
 
-          action.send(:include, Action::InstanceMethods)
+        desc = <<~END
+          A list of names of associated resources separated by a comma.
+          Nested associations are declared with '__' between resource names.
+          For example, 'user,node' will resolve the two associations.
+          To resolve further associations of node, use e.g. 'user,node__location',
+          to go even deeper, use e.g. 'user,node__location__environment'.
+        END
+
+        action.meta(:global) do
+          input do
+            custom :includes, label: 'Included associations',
+                              desc:, &clean
+          end
         end
+
+        action.send(:include, Action::InstanceMethods)
       end
 
       def has_param?(name)
@@ -169,14 +168,14 @@ END
       def meta
         res = @context.action.resource
 
-        if @context.action.name.demodulize == 'Index' \
+        params = if @context.action.name.demodulize == 'Index' \
            && !@context.action.resolve \
            && res.const_defined?(:Show)
-          params = res::Show.resolve_path_params(@object)
+                   res::Show.resolve_path_params(@object)
 
-        else
-          params = @context.action.resolve_path_params(@object)
-        end
+                 else
+                   @context.action.resolve_path_params(@object)
+                 end
 
         {
           path_params: params.is_a?(Array) ? params : [params],
@@ -185,6 +184,7 @@ END
       end
 
       protected
+
       # Return representation of an associated resource `param`
       # with its instance in `val`.
       #
@@ -223,7 +223,7 @@ END
           @context.action_instance = push_ins
           @context.action = push_cls
 
-          fail "#{res_show.to_s} resolve failed" unless ret[0]
+          raise "#{res_show} resolve failed" unless ret[0]
 
           ret[1][res_show.output.namespace].update({
               _meta: ret[1][:_meta].update(resolved: true)
@@ -234,8 +234,8 @@ END
             param.value_id => val.send(res_output[param.value_id].db_name),
             param.value_label => val.send(res_output[param.value_label].db_name),
             _meta: {
-              :path_params => args.is_a?(Array) ? args : [args],
-              :resolved => false
+              path_params: args.is_a?(Array) ? args : [args],
+              resolved: false
             }
           }
         end
@@ -244,49 +244,39 @@ END
       # Should an association with `name` be resolved?
       def includes_include?(name)
         includes = @context.action_instance.meta[:includes]
-        return unless includes
+        return false unless includes
 
         name = name.to_sym
 
         if @context.action_instance.flags[:inner_assoc]
           # This action is called as an association of parent resource.
           # Meta includes are already parsed and can be accessed directly.
-          includes.each do |v|
-            if v.is_a?(::Hash)
-              return true if v.has_key?(name)
-            else
-              return true if v == name
-            end
-          end
-
-          false
-
         else
           # This action is the one that was called by the user.
           # Meta includes contains an array of strings as was sent
           # by the user. The parsed includes must be fetched from
           # the action itself.
           includes = @context.action_instance.ar_parse_includes([])
+        end
 
-          includes.each do |v|
-            if v.is_a?(::Hash)
-              return true if v.has_key?(name)
-            else
-              return true if v == name
-            end
+        includes.each do |v|
+          if v.is_a?(::Hash)
+            return true if v.has_key?(name)
+          elsif v == name
+            return true
           end
-
-          false
         end
+
+        false
       end
 
       # Create an array of includes that is passed to child association.
       def includes_pass_on_to(assoc)
         parsed = if @context.action_instance.flags[:inner_assoc]
-          @context.action_instance.meta[:includes]
-        else
-          @context.action_instance.ar_parse_includes([])
-        end
+                   @context.action_instance.meta[:includes]
+                 else
+                   @context.action_instance.ar_parse_includes([])
+                 end
 
         ret = []
 
@@ -324,7 +314,7 @@ END
 
       handle ::ActiveModel::Validations::ExclusionValidator do |v|
         opts = {
-          values: v.options[:in].map { |v| v }
+          values: v.options[:in]
         }
         opts[:message] = v.options[:message] if v.options[:message]
 
@@ -342,7 +332,7 @@ END
 
       handle ::ActiveModel::Validations::InclusionValidator do |v|
         opts = {
-          values: v.options[:in].map { |v| v }
+          values: v.options[:in]
         }
         opts[:message] = v.options[:message] if v.options[:message]
 
@@ -402,13 +392,13 @@ END
 
       def translate(v)
         self.class.handlers.each do |klass, translator|
-          if v.is_a?(klass)
-            v.attributes.each do |attr|
-              @attr = attr
-              instance_exec(v, &translator)
-            end
-            break
+          next unless v.is_a?(klass)
+
+          v.attributes.each do |attr|
+            @attr = attr
+            instance_exec(v, &translator)
           end
+          break
         end
       end
     end

data/lib/haveapi/output_formatter.rb

@@ -1,6 +1,5 @@
 module HaveAPI
   module OutputFormatters
-
   end
 
   class OutputFormatter
@@ -29,7 +28,7 @@ module HaveAPI
         end
       end
 
-      @formatter.nil? ? false : true
+      !@formatter.nil?
     end
 
     def format(status, response, message = nil, errors = nil, version: true)
@@ -45,14 +44,15 @@ module HaveAPI
     end
 
     protected
-    def header(status, response, message = nil, errors = nil, version)
+
+    def header(status, response, message = nil, errors = nil, version = nil)
       ret = {}
       ret[:version] = HaveAPI::PROTOCOL_VERSION if version
       ret.update({
-        status: status,
-        response: response,
-        message: message,
-        errors: errors
+        status:,
+        response:,
+        message:,
+        errors:
       })
       ret
     end

data/lib/haveapi/output_formatters/base.rb

@@ -7,7 +7,7 @@ module HaveAPI::OutputFormatters
         @types ||= []
         @types += args
 
-        HaveAPI::OutputFormatter.register(Kernel.const_get(self.to_s)) unless @registered
+        HaveAPI::OutputFormatter.register(Kernel.const_get(to_s)) unless @registered
         @registered = true
       end
 
@@ -22,8 +22,6 @@ module HaveAPI::OutputFormatters
       self.class.types.first
     end
 
-    def format(response)
-
-    end
+    def format(response); end
   end
 end

data/lib/haveapi/parameters/resource.rb

@@ -4,8 +4,8 @@ module HaveAPI::Parameters
                 :choices, :value_params
 
     def initialize(resource, name: nil, label: nil, desc: nil,
-        choices: nil, value_id: :id, value_label: :label, required: nil,
-        db_name: nil, fetch: nil)
+                   choices: nil, value_id: :id, value_label: :label, required: nil,
+                   db_name: nil, fetch: nil)
       @resource = resource
       @resource_path = build_resource_path(resource)
       @name = name || resource.resource_name.underscore.to_sym
@@ -17,7 +17,7 @@ module HaveAPI::Parameters
       @required = required
       @db_name = db_name
       @extra = {
-          fetch: fetch
+          fetch:
       }
     end
 
@@ -65,7 +65,7 @@ module HaveAPI::Parameters
         value: context.action_prepare && {
           path: val_path,
           method: val_method,
-          help: "#{val_path}?method=#{val_method}",
+          help: "#{val_path}?method=#{val_method}"
         },
         choices: {
           path: choices_path,
@@ -76,13 +76,13 @@ module HaveAPI::Parameters
     end
 
     def validate_build_output
-      %i(value_id value_label).each do |name|
+      %i[value_id value_label].each do |name|
         v = instance_variable_get("@#{name}")
 
         [show_action, show_index].each do |klass|
           next unless klass.instance_variable_get('@output')[v].nil?
 
-          fail "association to '#{@resource}': value_label '#{v}' is not an output parameter of '#{klass}'"
+          raise "association to '#{@resource}': value_label '#{v}' is not an output parameter of '#{klass}'"
         end
       end
     end
@@ -106,6 +106,7 @@ module HaveAPI::Parameters
     end
 
     private
+
     def build_resource_path(r)
       path = []
       top_module = Kernel
@@ -115,7 +116,6 @@ module HaveAPI::Parameters
 
         begin
           top_module.obj_type
-
         rescue NoMethodError
           next
         end

data/lib/haveapi/parameters/typed.rb

@@ -2,7 +2,7 @@ require 'date'
 
 module HaveAPI::Parameters
   class Typed
-    ATTRIBUTES = %i(label desc type db_name default fill clean protected load_validators)
+    ATTRIBUTES = %i[label desc type db_name default fill clean protected load_validators].freeze
 
     attr_reader :name, :label, :desc, :type, :default
 
@@ -14,14 +14,14 @@ module HaveAPI::Parameters
       @label = myargs.delete(:label) || name.to_s.capitalize
       @layout = :custom
 
-      (ATTRIBUTES - %i(label)).each do |attr|
+      (ATTRIBUTES - %i[label]).each do |attr|
         instance_variable_set("@#{attr}", myargs.delete(attr))
       end
 
       @type ||= String
 
       @validators = HaveAPI::ValidatorChain.new(myargs) unless myargs.empty?
-      fail "unused arguments #{myargs}" unless myargs.empty?
+      raise "unused arguments #{myargs}" unless myargs.empty?
     end
 
     def db_name
@@ -52,7 +52,7 @@ module HaveAPI::Parameters
         type: @type ? @type.to_s : String.to_s,
         validators: @validators ? @validators.describe : {},
         default: @default,
-        protected: @protected || false,
+        protected: @protected || false
       }
     end
 
@@ -75,7 +75,7 @@ module HaveAPI::Parameters
     def clean(raw)
       return instance_exec(raw, &@clean) if @clean
 
-      val = if raw.nil?
+      if raw.nil?
         @default
 
       elsif @type.nil?
@@ -93,16 +93,13 @@ module HaveAPI::Parameters
       elsif @type == ::Datetime
         begin
           DateTime.iso8601(raw).to_time
-
         rescue ArgumentError
-          raise HaveAPI::ValidationError.new("not in ISO 8601 format '#{raw}'")
+          raise HaveAPI::ValidationError, "not in ISO 8601 format '#{raw}'"
         end
 
       else
         raw
       end
-
-      val
     end
 
     def validate(v, params)