params_ready 0.0.2 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e0db6411b802c544350d14eb54c921ae019ac7b2365fc2639b4f2f1b77ee40a
-  data.tar.gz: 3811299181627e888b1ac97970a4264f850db87f0475be355a138a30aa825eb1
+  metadata.gz: f153e27fbce45bc4e81a566ef856825db2dea6a144e2122202728e6f937e7b9f
+  data.tar.gz: 1d5c56bcc909fa607022cb1f236a91ab4707dbf6753cd4f8ed1d1702a80be997
 SHA512:
-  metadata.gz: f2f339b6dd2a649244d53c94168ad3e3b238a42268632175c08c3928e01861d75c5c19d7fc3c29b8e0482e8658ed6e5f3a17d9ccda34d0b63808b5e1538b4870
-  data.tar.gz: 355252607fd9c47d58acf4cf1176bc5d35677390bbfeecfe1e24d881f9303be23d20dbcc8611b9c4cff25ff277944e0a2ad9e85aef7ccf0e7174a0a02856f1c3
+  metadata.gz: a8f822219c2fa60a422bf9afb4d483e882eb61aa25a16491534feadf351c8eae8648576e3efcd9bc4e45889701946d8c48a1b5870b440d8e2eb2692cb9368c9a
+  data.tar.gz: 93ce29aafd6b755cc9a628f8ee7ff58c4d2b7c8f5f0b9dede9a75f8fb67e1255dd6e89ae9890ab61ef3737dcdf1d4d9c847dcab9ddd371250ed71a729f135e39

data/lib/params_ready/builder.rb

@@ -28,6 +28,23 @@ module ParamsReady
       register_builder(name, self)
     end
 
+    def self.register_deprecated(name, use:)
+      raise ParamsReadyError, 'Recommended replacement must not be nil' if use.nil?
+      @deprecated ||= {}
+      @deprecated[name] = use.to_s.freeze
+      register_builder(name, self)
+    end
+
+    class << self
+      alias_method :fetch_builder, :builder
+    end
+
+    def self.builder(name)
+      use = @deprecated[name] if @deprecated&.key? name
+      warn "Builder name deprecated: #{name}, use: #{use}" unless use.nil?
+      fetch_builder(name)
+    end
+
     def self.define_parameter(type, *args, **opts, &block)
       builder_class = builder(type)
       builder = builder_class.instance(*args, **opts)
@@ -94,6 +111,10 @@ module ParamsReady
         @definition.set_no_output Helpers::Rule(rule) || true
       end
 
+      def no_input(*arr, rule: nil)
+        @definition.set_no_input *arr, rule: rule
+      end
+
       def local(*arr, rule: nil)
         @definition.set_local *arr, rule: rule
       end

data/lib/params_ready/extensions/delegation.rb

@@ -10,6 +10,7 @@ module ParamsReady
             super name, *args, &block
           end
         end
+        mod.send(:ruby2_keywords, :method_missing)
 
         mod.define_method :respond_to_missing? do |name, include_private = false|
           delegee = instance_eval(&to)

data/lib/params_ready/extensions/freezer.rb

@@ -25,6 +25,8 @@ module ParamsReady
             next if frozen?
             self.class.variables_to_freeze.each do |(ivar, block)|
               variable = instance_variable_get ivar
+              next if Extensions::Undefined.value_indefinite?(variable)
+              
               block.call(variable) unless block.nil?
               variable.freeze
             end

data/lib/params_ready/extensions/undefined.rb

@@ -5,6 +5,14 @@ module ParamsReady
         self
       end
 
+      def self.present?
+        false
+      end
+
+      def self.blank?
+        true
+      end
+      
       def self.value_indefinite?(value)
         value == self || value.nil?
       end

data/lib/params_ready/format.rb

@@ -100,8 +100,10 @@ module ParamsReady
     @names = {
       backend: Format.new(marshal: :none, omit: [], naming_scheme: :standard, remap: false, local: true, name: :backend),
       frontend: Format.new(marshal: :all, omit: OMIT_ALL, naming_scheme: :alternative, remap: false, local: false, name: :frontend),
-      attributes: Format.new(marshal: :none, omit: %i(undefined), naming_scheme: :standard, remap: false, local: true, name: :attributes),
-      json: Format.new(marshal: { except: [:array, :tuple, :boolean, :number] }, omit: [], naming_scheme: :alternative, remap: true, local: false, name: :json)
+      create: Format.new(marshal: :none, omit: [], naming_scheme: :standard, remap: false, local: true, name: :create),
+      update: Format.new(marshal: :none, omit: %i(undefined), naming_scheme: :standard, remap: false, local: true, name: :update),
+      json: Format.new(marshal: { except: [:array, :tuple, :boolean, :number] }, omit: [], naming_scheme: :alternative, remap: true, local: false, name: :json),
+      inspect: Format.new(marshal: :none, omit: [], naming_scheme: :standard, remap: false, local: false, name: :inspect)
     }.freeze
 
     def self.define(name, format)

data/lib/params_ready/helpers/arel_builder.rb

@@ -2,26 +2,7 @@ require_relative '../error'
 
 module ParamsReady
   module Helpers
-    class ArelBuilder
-      def self.instance(object, arel_table: nil)
-        case object
-        when Arel::Nodes::Node, Arel::Nodes::SqlLiteral, Arel::Attribute
-          raise ParamsReadyError, "Arel table unexpected" unless arel_table.nil? || arel_table == :none
-          ArelObject.new(object)
-        when Proc
-          raise ParamsReadyError, "Arel table unexpected" unless arel_table.nil? || arel_table == :none
-          Callable.new(object)
-        when String, Symbol
-          Literal.new(object, arel_table)
-        else
-          raise ParamsReadyError, "Unexpected type for arel builder: #{object.class.name}"
-        end
-      end
-
-      def self.safe_name(name)
-        name[0...64]
-      end
-
+    module ArelBuilder
       class Callable
         def initialize(proc)
           @proc = proc
@@ -31,38 +12,118 @@ module ParamsReady
           result = @proc.call(*args)
           case result
           when String, Symbol
-            Helpers::ArelBuilder.instance(result).to_arel(*args)
+            to_literal(result).to_arel(*args)
           else
             result
           end
         end
+
+        def to_literal(*)
+          raise ParamsReadyError, "Unimplemented: #{self.class.name}##{__callee__}"
+        end
+      end
+
+      class ArelObject
+        def initialize(node)
+          @node = node
+        end
+
+        def to_arel(*)
+          @node
+        end
+      end
+
+      def self.safe_name(name)
+        name[0...64]
       end
 
       class Literal
-        def initialize(literal, arel_table)
-          @literal = literal.to_s
-          @arel_table = arel_table
+        def initialize(literal)
+          @literal = literal.to_s.freeze
         end
 
-        def to_arel(default_table, _, _)
-          arel_table = @arel_table || default_table
-          if arel_table == :none
-            Arel::Nodes::SqlLiteral.new(@literal)
+        def to_arel(*)
+          Arel::Nodes::SqlLiteral.new(@literal)
+        end
+      end
+
+      class Attribute
+        def self.instance(object, arel_table: nil)
+          case object
+          when Arel::Nodes::Node, Arel::Nodes::SqlLiteral, Arel::Attribute
+            raise ParamsReadyError, "Arel table unexpected" unless arel_table.nil? || arel_table == :none
+            ArelObject.new(object)
+          when Proc
+            raise ParamsReadyError, "Arel table unexpected" unless arel_table.nil? || arel_table == :none
+            Callable.new(object)
+          when String, Symbol
+            Literal.new(object, arel_table)
           else
-            arel_table[@literal]
+            raise ParamsReadyError, "Unexpected type for arel builder: #{object.class.name}"
+          end
+        end
+
+        class Callable < ArelBuilder::Callable
+          def to_literal(string)
+            Helpers::ArelBuilder::Attribute.instance(string)
+          end
+        end
+
+        class Literal < ArelBuilder::Literal
+          def initialize(literal, arel_table)
+            super literal
+            @arel_table = arel_table
+          end
+
+          def to_arel(default_table, *args)
+            arel_table = @arel_table || default_table
+            if arel_table == :none
+              super(*args)
+            else
+              arel_table[@literal]
+            end
           end
         end
       end
 
-      class ArelObject
-        def initialize(node)
-          @node = node
+      class Table
+        def self.instance(object, table_alias: nil)
+          case object
+          when Arel::Table, Arel::Nodes::TableAlias
+            raise ParamsReadyError, "Table alias unexpected" unless table_alias.nil?
+            ArelObject.new(object)
+          when Proc
+            Callable.new(object, table_alias)
+          when String, Symbol
+            Literal.new(object, table_alias)
+          else
+            raise ParamsReadyError, "Unexpected type for arel builder: #{object.class.name}"
+          end
         end
 
-        def to_arel(_, _, _)
-          @node
+        class Callable < ArelBuilder::Callable
+          def initialize(proc, table_alias)
+            super proc
+            @table_alias = table_alias
+          end
+
+          def to_literal(string)
+            Helpers::ArelBuilder::Table.instance(string, table_alias: @table_alias)
+          end
+        end
+
+        class Literal < ArelBuilder::Literal
+          def initialize(literal, table_alias)
+            super literal
+            raise "Table alias must be present" if table_alias.nil?
+            @table_alias = table_alias.to_s.freeze
+          end
+
+          def to_arel(*)
+            Arel::Table.new(@literal).as(@table_alias)
+          end
         end
       end
     end
   end
-end
+end

data/lib/params_ready/helpers/callable.rb

@@ -0,0 +1,14 @@
+module ParamsReady
+  module Helpers
+    class Callable
+      def initialize(&block)
+        @block = block
+        freeze
+      end
+
+      def call
+        @block.call
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/interface_definer.rb

@@ -0,0 +1,48 @@
+module ParamsReady
+  module Helpers
+    class InterfaceDefiner
+      def initialize(action_names, user)
+        @action_names = action_names
+        @user = user
+      end
+
+      def parameters(*names)
+        names.each do |name|
+          parameter(name)
+        end
+      end
+
+      def relations(*names)
+        names.each do |name|
+          relation(name)
+        end
+      end
+
+      def parameter(name)
+        @user.use_parameter(name, only: @action_names)
+      end
+
+      def relation(name)
+        @user.use_relation(name, only: @action_names)
+      end
+
+      def define(parameter: nil, relation: nil, parameters: [], relations: [], &block)
+        parameters = self.class.complete_list(parameter, parameters)
+        parameters(*parameters)
+        relations = self.class.complete_list(relation, relations)
+        relations(*relations)
+        instance_eval(&block) unless block.nil?
+        @option
+      end
+
+      def self.complete_list(singular, plural)
+        list = singular.nil? ? plural : [singular, *plural]
+        normalize_list(list)
+      end
+
+      def self.normalize_list(list)
+        list.map(&:to_sym)
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/memo.rb

@@ -21,7 +21,6 @@ module ParamsReady
       end
 
       def cache_value(value, key)
-
         stale = @cache
         return if stale&.key? key
 

data/lib/params_ready/helpers/options.rb

@@ -3,37 +3,105 @@ require_relative 'usage_rule'
 
 module ParamsReady
   module Helpers
-    class Options < Storage
+    class Options
       attr_reader :parameters, :relations
 
       def initialize
-        super
         @parameter_rules = Hash.new
         @relation_rules = Hash.new
-        @state = nil
+        @memo = { definitions: {} }
+      end
+
+      def reset_memo!(*args)
+        args.each do |key|
+          @memo[key].clear
+        end
+      end
+
+      def dup
+        duplicate = Options.new
+        @parameter_rules.each do |_, rule|
+          duplicate.merge_parameter_rule(rule)
+        end
+        @relation_rules.each do |_, rule|
+          duplicate.merge_relation_rule(rule)
+        end
+        duplicate
+      end
+
+      def relation_definitions_for(name)
+        definitions_for(name, relation_rules)
+      end
+
+      def parameter_definitions_for(name)
+        definitions_for(name, parameter_rules)
+      end
+
+      def definitions_for(name, rules)
+        rules.each_with_object([]) do |(_, rule), result|
+          next unless rule.valid_for?(name)
+
+          result << rule.parameter_definition
+        end
       end
 
       def use_parameter(param, rule_args = :all)
         rule = UsageRule.new(param, rule_args)
-        @parameter_rules[param.name] = rule
+        merge_parameter_rule(rule)
+      end
+
+      def merge_parameter_rule(rule)
+        reset_memo!(:definitions)
+        @parameter_rules = self.class.merge_rule(rule, @parameter_rules)
       end
 
       def use_relation(relation, rule_args = :all)
         rule = UsageRule.new(relation, rule_args)
-        @relation_rules[relation.name] = rule
+        merge_relation_rule(rule)
+      end
+
+      def merge_relation_rule(rule)
+        reset_memo!(:definitions)
+        @relation_rules = self.class.merge_rule(rule, @relation_rules)
       end
 
       def parameter_rules
-        @parameter_rules.each_value do |rule|
-          yield rule
+        if block_given?
+          @parameter_rules.each_value do |rule|
+            yield rule
+          end
         end
+        @parameter_rules
       end
 
       def relation_rules
-        @relation_rules.each_value do |rule|
-          yield rule
+        if block_given?
+          @relation_rules.each_value do |rule|
+            yield rule
+          end
+        end
+        @relation_rules
+      end
+
+      def create_state_for(key)
+        @memo[:definitions][key] ||= begin
+          builder = Parameter::StateBuilder.instance
+          parameter_definitions_for(key).each do |definition|
+            builder.add definition
+          end
+          relation_definitions_for(key).each do |definition|
+            builder.relation definition
+          end
+          builder.build
         end
       end
+
+      def self.merge_rule(rule, rules)
+        existing = rules[rule.name]
+        merged = rule.merge(existing)
+        rules[rule.name] = merged
+        rules
+      end
     end
   end
 end

data/lib/params_ready/helpers/parameter_storage_class_methods.rb

@@ -1,5 +1,6 @@
 require_relative 'storage'
 require_relative '../error'
+require_relative 'rule'
 
 module ParamsReady
   module Helpers
@@ -31,6 +32,32 @@ module ParamsReady
           raise ParamsReadyError, "Unknown parameter '#{sym_key}'"
         end
       end
+
+      def include_parameters(parameter_definer, rule = nil)
+        rule = Helpers::Rule(rule)
+        parameter_definer.all_parameters.each do |key, definition|
+          next if rule && !rule.include?(key)
+
+          add_parameter(definition)
+        end
+      end
+
+      def add_parameter(definition)
+        params_ready_storage.add_parameter(definition)
+      end
+
+      def include_relations(parameter_definer, rule = nil)
+        rule = Helpers::Rule(rule)
+        parameter_definer.all_relations.each do |key, definition|
+          next if rule && !rule.include?(key)
+
+          add_relation(definition)
+        end
+      end
+
+      def add_relation(definition)
+        params_ready_storage.add_relation(definition)
+      end
     end
   end
 end

data/lib/params_ready/helpers/parameter_user_class_methods.rb

@@ -1,31 +1,35 @@
+require_relative 'interface_definer'
+
 module ParamsReady
   module Helpers
     module ParameterUserClassMethods
-      def params_ready_storage
-        @params_ready_storage ||= ParamsReady::Helpers::Options.new
+      def params_ready_option
+        @params_ready_option ||= begin
+          if superclass.respond_to? :params_ready_option
+            # This works on assumption that superclass
+            # definition doesn't change during execution
+            superclass.params_ready_option.dup
+          else
+            ParamsReady::Helpers::Options.new
+          end
+        end
       end
 
       def use_parameter(name, rule = :all)
         parameter = parameter_definition name
-        params_ready_storage.use_parameter parameter, rule
+        params_ready_option.use_parameter parameter, rule
       end
 
       def use_relation(name, rule = :all)
         relation = relation_definition name
-        params_ready_storage.use_relation relation, rule
+        params_ready_option.use_relation relation, rule
       end
 
-      def include_parameters(parameter_definer)
-        parameter_definer.all_parameters.values.each do |p|
-          params_ready_storage.add_parameter(p)
-        end
-      end
+      def action_interface(*action_names, **opts, &block)
+        definer = InterfaceDefiner.new(action_names, self)
 
-      def include_relations(parameter_definer)
-        parameter_definer.all_relations.values.each do |d|
-          params_ready_storage.add_relation(d)
-        end
+        definer.define(**opts, &block)
       end
     end
   end
-end
+end

data/lib/params_ready/helpers/rule.rb

@@ -6,33 +6,52 @@ module ParamsReady
       return input if input.nil?
       return input if input.is_a? Rule
 
-      Rule.new(input).freeze
+      Rule.instance(input).freeze
     end
 
-    class Rule
-      attr_reader :hash
+      class Rule
+      attr_reader :hash, :mode, :values
 
-      def initialize(value)
-        @mode, @values = case value
-        when :none, :all then [value, nil]
+      def self.instance(input)
+        mode, values = case input
+        when :none, :all then [input, nil]
         when Hash
-          if value.length > 1 || value.length < 1
-            raise ParamsReadyError, "Unexpected hash for rule: '#{value}'"
+          if input.length > 1 || input.length < 1
+            raise ParamsReadyError, "Unexpected hash for rule: '#{input}'"
           end
-          key, values = value.first
+          key, values = input.first
           case key
           when :except, :only then [key, values.to_set.freeze]
           else
             raise ParamsReadyError, "Unexpected mode for rule: '#{key}'"
           end
         else
-          raise ParamsReadyError, "Unexpected input for rule: '#{value}'"
+          raise ParamsReadyError, "Unexpected input for rule: '#{input}'"
         end
-        @values.freeze
+        new(mode, values)
+      end
+
+      def initialize(mode, values)
+        @mode = mode
+        @values = values.freeze
         @hash = [@mode, @values].hash
         freeze
       end
 
+      def merge(other)
+        return self if other.nil?
+        raise ParamsReadyError, "Can't merge with #{other.class.name}" unless other.is_a? Rule
+        raise ParamsReadyError, "Can't merge incompatible rules: #{mode}/#{other.mode}" if other.mode != mode
+
+        case mode
+        when :all, :none
+          self
+        when :only, :except
+          values = self.values + other.values
+          Rule.new(mode, values)
+        end
+      end
+
       def include?(name)
         case @mode
         when :none then false

data/lib/params_ready/helpers/usage_rule.rb

@@ -3,16 +3,34 @@ require_relative 'rule'
 module ParamsReady
   module Helpers
     class UsageRule
-      attr_reader :parameter_definition
+      attr_reader :parameter_definition, :rule
 
       def initialize(parameter_definition, rule = :all)
         @parameter_definition = parameter_definition
         @rule = ParamsReady::Helpers::Rule(rule)
+        freeze
       end
 
-      def valid_for(method)
+      def valid_for?(method)
         @rule.include? method
       end
+
+      def name
+        parameter_definition.name
+      end
+
+      def merge(other)
+        return self if other.nil?
+        raise ParamsReadyError, "Can't merge into #{other.class.name}" unless other.is_a? UsageRule
+
+        unless parameter_definition == other.parameter_definition
+          message = "Can't merge incompatible rules: #{parameter_definition.name}/#{other.parameter_definition.name}"
+          raise ParamsReadyError, message
+        end
+
+        rule = self.rule.merge(other.rule)
+        UsageRule.new(parameter_definition, rule)
+      end
     end
   end
-end
+end

data/lib/params_ready/marshaller/array_marshallers.rb

@@ -47,7 +47,7 @@ module ParamsReady
         freeze
       end
 
-      module HashMarshaller
+      module StructMarshaller
         extend AbstractMarshaller
 
         def self.canonicalize(definition, hash, context, validator)
@@ -58,7 +58,8 @@ module ParamsReady
             found, count = Helpers::FindInHash.find_in_hash hash, count_key
             raise ParamsReadyError, "Count not found" unless found
 
-            count = Integer(count)
+            base = 10 if count.is_a? String
+            count = Integer(count, base)
             array = (0...count).map do |index|
               found, value = Helpers::FindInHash.find_in_hash hash, index
               element = definition.prototype.create
@@ -120,7 +121,7 @@ module ParamsReady
         @collection ||= begin
           c = ClassCollection.new Array
           c.add_instance Array, ArrayMarshaller
-          c.add_instance Hash, HashMarshaller
+          c.add_instance Hash, StructMarshaller
           c.add_factory :string, StringMarshaller
           c.default!(Hash)
           c.freeze