service_operation 1.0.0

data/lib/service_operation/params.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/SafeNavigation
+require 'service_operation/params/types'
+
+module ServiceOperation
+  # Params depends on {Hooks}
+  module Params
+    autoload :Attribute, 'service_operation/params/attribute'
+    autoload :DSL, 'service_operation/params/dsl'
+
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :include, InstanceMethods
+    end
+
+    # ClassMethods
+    module ClassMethods
+      # @example
+      #   params do
+      #     param1, :integer, coerce: true
+      #   end
+      def params(&block)
+        @params ||= superclass && superclass.respond_to?(:params) ? superclass.params.dup : []
+
+        if block_given?
+          @params += Params::DSL.run(&block)
+          define_params_hooks
+        end
+
+        @params = @params.reverse.uniq(&:name).reverse
+        @params
+      end
+
+      alias input params
+
+      # @example
+      #   returns do
+      #     result, [:string]
+      #     log_data, [:string], optional: true
+      #   end
+      def returns(&block)
+        @returns ||= superclass && superclass.respond_to?(:returns) ? superclass.returns.dup : []
+
+        @returns += Params::DSL.run(&block) if block_given?
+
+        @returns = @returns.reverse.uniq(&:name).reverse
+        @returns
+      end
+
+      def attributes
+        (returns + params).uniq(&:name) # returns first to preserve log: option
+      end
+
+      # should only be called by Instance after all attributes have been defined
+      def attribute_names
+        @attribute_names ||= attributes.map(&:name)
+      end
+
+      alias output returns
+
+      def remove_params(*args)
+        params.delete_if { |a| args.include?(a.name) }
+      end
+
+      private
+
+      def define_params_hooks
+        return if @defined_params_hooks
+
+        before :validate_params
+        after :validate_returns
+        @defined_params_hooks = true
+      end
+    end
+
+    # InstanceMethods
+    module InstanceMethods
+      private
+
+      # coerces param and adds an error if it fails to validate type
+      def validate_params
+        validate_attributes(self.class.params, coerce: true)
+      end
+
+      def validate_returns
+        validate_attributes(self.class.returns)
+      end
+
+      def validate_attributes(attributes, coerce: false)
+        attributes.each do |attr|
+          value = attr.optional ? context[attr.name] : send(attr.name)
+
+          context[attr.name] = value = attr.from(value, self.class) if coerce
+
+          if error = attr.error(value)
+            errors.add(attr.name, error)
+          end
+        end
+
+        context.fail!(errors: errors) if errors.any?
+      end
+
+      #
+      # Method Missing to delegate to params/context
+      #
+
+      # delegate to context if calling an explicit param
+      def method_missing(method_name, *args, &block)
+        method_name_without_q = method_name.to_s.delete('?').to_sym
+        if attribute_exists?(method_name_without_q)
+          context.send(method_name_without_q, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        attribute_exists?(method_name) || super
+      end
+
+      def attribute_exists?(method_name)
+        self.class.attribute_names.include?(method_name)
+      end
+    end
+  end
+end
+
+# rubocop:enable Style/SafeNavigation

data/lib/service_operation/params/attribute.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require 'service_operation/params'
+
+module ServiceOperation
+  KEYWORDS = [
+    :base, :errors, :error_code, :status_code
+  ].freeze
+
+  module Params
+    #
+    # Represents a single attribute of a value class
+    #
+    class Attribute
+      OPTIONS = [:name, :validator, :coercer, :default, :log, :optional].freeze
+
+      # Types of validation classes that can be expanded
+      EXPANDABLE_VALIDATORS = %w[Array Symbol String].freeze
+
+      # Typical coercions from web/string parameters
+      PARAM_COERCIONS = {
+        date: ->(d) { d.is_a?(String) ? Date.parse(d) : d },
+        integer: ->(o) { o && o != '' ? o.to_i : nil },
+        string: ->(o) { o && o != '' ? o.to_s : nil }
+      }.freeze
+
+      COERCIONS = {
+        'Integer' => PARAM_COERCIONS[:integer],
+        'String' => PARAM_COERCIONS[:string],
+        'EnumerableOf(Integer)' => ->(o) { Array(o).map(&:to_i) },
+        'EnumerableOf(String)' => ->(o) { Array(o).map(&:to_s) },
+
+        json_api_page: lambda do |o|
+          h = Hash(o)
+          h[:size] = h[:size].to_i if h && h[:size].present?
+          h
+        end
+      }.freeze
+
+      #
+      # Class Methods
+      #
+
+      class << self
+        def define(*args)
+          options = extract_options(args)
+          name, validator = args
+          validator ||= Anything
+
+          raise "#{name.inspect} is a keyword" if KEYWORDS.include?(name)
+
+          if EXPANDABLE_VALIDATORS.include?(validator.class.name)
+            validator = expand_validator(validator)
+            options[:coerce] = COERCIONS[validator.name] || true if options[:coerce].nil?
+          end
+
+          # options[:coerce] = COERCIONS[validator.name] || options[:coerce]
+          options[:coercer] = options.delete(:coerce)
+
+          new options.merge(name: name, validator: validator)
+        end
+
+        private
+
+        # activesupport/lib/active_support/inflector/methods.rb
+        # rubocop:disable all
+        def camelize(string, uppercase_first_letter = true)
+          if uppercase_first_letter
+            string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+          else
+            string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
+          end
+          string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+        end
+        # rubocop:enable all
+
+        def expand_validator(validator)
+          case validator
+          when Array
+            EnumerableOf.new(*validator.map { |v| expand_validator(v) })
+          when Symbol, String
+            validator = 'bool' if validator.to_s == 'boolean'
+            Params.const_get camelize(validator.to_s)
+          else
+            validator
+          end
+        end
+
+        def extract_options(args)
+          args.last.is_a?(Hash) ? args.pop : {}
+        end
+      end
+
+      #
+      # Instance Methods
+      #
+
+      attr_reader :name, :validator, :coercer, :default, :log, :optional, :options
+
+      def initialize(options = {})
+        @name = options[:name].to_sym
+        @validator  = options[:validator]
+        @coercer    = options[:coercer]
+        @default    = options[:default]
+        @log        = options.fetch(:log) { true }
+        @optional   = options.fetch(:optional) { false }
+        @options    = options.reject { |k, _v| OPTIONS.include?(k) }
+
+        freeze
+      end
+
+      def ==(other)
+        name == other.name
+      end
+
+      def from(raw_value, klass = nil)
+        raw_value = (default.respond_to?(:call) ? default.call : default) if raw_value.nil?
+        coerce(raw_value, klass)
+      end
+
+      def error(value)
+        return if validate?(value)
+
+        if required? && value.nil?
+          "can't be blank"
+        else
+          "must be typecast '#{validator.name}'"
+        end
+      end
+
+      def optional?
+        optional == true
+      end
+
+      def required?
+        !optional
+      end
+
+      def validate?(value)
+        # special exception to prevent Object === nil from validating
+        return false if value.nil? && !optional
+
+        optional || validator === value # rubocop:disable Style/CaseEquality
+      end
+
+      private
+
+      def coerce(value, klass)
+        return value unless coercer && !value.nil? # coercion not enabled or value was nil
+        return klass.public_send(coercion_method, value) if klass.respond_to?(coercion_method)
+
+        if coercer.respond_to?(:call)
+          coercer.call value
+        else
+          value
+        end
+      end
+
+      def coercion_method
+        "coerce_#{name}"
+      end
+    end
+  end
+end

data/lib/service_operation/params/dsl.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'service_operation/params'
+
+module ServiceOperation
+  module Params
+    # Build {Params::Attribute} DSL
+    class DSL
+      # @yield to the block containing the DSL
+      # @return [Array<Attribute>]
+      def self.run(&block)
+        dsl = new
+        dsl.instance_eval(&block)
+        dsl.instance_variable_get('@attributes').freeze
+      end
+
+      def initialize
+        @attributes = []
+      end
+
+      # rubocop:disable Naming/MethodName
+
+      def Any(*subvalidators)
+        Any.new(subvalidators)
+      end
+
+      def Anything
+        Anything
+      end
+
+      def ArrayOf(element_validator)
+        ArrayOf.new(element_validator)
+      end
+
+      def Bool
+        Bool
+      end
+
+      def EnumerableOf(element_validator)
+        EnumerableOf.new(element_validator)
+      end
+
+      # rubocop:enable Naming/MethodName
+
+      # @todo: move
+      def _query_params(default_sort: 'id')
+        id :integer, optional: true
+        ids [:integer], optional: true
+
+        filter :hash, optional: true,
+                      coerce: ->(f) { f.is_a?(Hash) ? f : Array(f).map { [f, nil] }.to_h }
+
+        includes [:string], optional: true
+        page :hash, optional: true, coerce: :json_api_page
+        sort :string, optional: true, default: default_sort
+      end
+
+      private
+
+      def def_attr(*args)
+        @attributes << Attribute.define(*args)
+      end
+
+      def method_missing(name, *args)
+        if respond_to_missing?(name)
+          def_attr(name, *args)
+        else
+          super
+        end
+      end
+
+      # any lowercase method name becomes an attribute
+      def respond_to_missing?(method_name, _include_private = nil)
+        first_letter = method_name.to_s.each_char.first
+        first_letter.eql?(first_letter.downcase)
+      end
+    end
+  end
+end

data/lib/service_operation/params/types.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/CaseEquality
+
+require 'service_operation/params'
+
+module ServiceOperation
+  module Params
+    # Matches true or false
+    module Bool
+      # @return [Boolean]
+      def self.===(other)
+        true.equal?(other) || false.equal?(other)
+      end
+    end
+
+    # Matches any value
+    module Anything
+      # @return [true]
+      def self.===(_other)
+        true
+      end
+    end
+
+    # @abstract for Enumerator based types
+    class EnumType
+      def ==(other)
+        other.is_a?(self.class) && other.inspect == inspect
+      end
+
+      # @abstract
+      def initialize(*_args)
+        freeze
+      end
+
+      def inspect
+        "<#{name}>"
+      end
+
+      def name
+        type.name
+      end
+
+      # @abstract
+      def type
+        raise('define in sub class')
+      end
+    end
+
+    # Matches any sub type
+    class Any < EnumType
+      attr_reader :sub_types
+
+      def initialize(sub_types)
+        @sub_types = Array(sub_types)
+        super
+      end
+
+      # @return [Boolean]
+      def ===(other)
+        sub_types.any? { |sv| sv === other }
+      end
+
+      # @return [String] representation of class and its sub classes
+      def name
+        "Any(#{sub_types.map(&:name).join(', ')})"
+      end
+    end
+
+    # Matches an Enumerable with specific sub types
+    # @example EnumerableOf.new(String, Integer)
+    class EnumerableOf < EnumType
+      attr_reader :element_type
+
+      def initialize(*args)
+        @element_type = args.length == 1 ? args.first : Any.new(args)
+
+        super
+      end
+
+      # @return [Boolean]
+      def ===(other)
+        type === other && other.all? { |element| element_type === element }
+      end
+
+      def name
+        "#{super}Of(#{element_type.name})"
+      end
+
+      def type
+        Enumerable
+      end
+    end
+
+    # Matches an Array with specific sub types
+    # @example ArrayOf.new(String)
+    # @example ArrayOf.new(String, Integer)
+    class ArrayOf < EnumerableOf
+      def type
+        Array
+      end
+    end
+  end
+end
+
+# rubocop:enable Style/CaseEquality