params_ready_rails5 0.0.7

data/lib/params_ready/helpers/arel_builder.rb

@@ -0,0 +1,68 @@
+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
+
+      class Callable
+        def initialize(proc)
+          @proc = proc
+        end
+
+        def to_arel(*args)
+          result = @proc.call(*args)
+          case result
+          when String, Symbol
+            Helpers::ArelBuilder.instance(result).to_arel(*args)
+          else
+            result
+          end
+        end
+      end
+
+      class Literal
+        def initialize(literal, arel_table)
+          @literal = literal.to_s
+          @arel_table = arel_table
+        end
+
+        def to_arel(default_table, _, _)
+          arel_table = @arel_table || default_table
+          if arel_table == :none
+            Arel::Nodes::SqlLiteral.new(@literal)
+          else
+            arel_table[@literal]
+          end
+        end
+      end
+
+      class ArelObject
+        def initialize(node)
+          @node = node
+        end
+
+        def to_arel(_, _, _)
+          @node
+        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/conditional_block.rb

@@ -0,0 +1,31 @@
+require_relative 'rule'
+require_relative '../error'
+
+module ParamsReady
+  module Helpers
+    class Conditional
+      def initialize(rule: nil)
+        @rule = Helpers::Rule(rule)
+        freeze
+      end
+
+      def perform?(general_rule, name)
+        if @rule.nil?
+          general_rule
+        else
+          @rule.include?(name)
+        end
+      end
+    end
+
+    class ConditionalBlock < Conditional
+      attr_reader :block
+
+      def initialize(rule: nil, &block)
+        raise ParamsReadyError, "Block must not be empty" if block.nil?
+        @block = block
+        super(rule: rule)
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/find_in_hash.rb

@@ -0,0 +1,22 @@
+require_relative '../extensions/undefined'
+require_relative 'key_map'
+
+module ParamsReady
+  module Helpers
+    module FindInHash
+      def self.find_in_hash(hash, name_or_path)
+        return false, Extensions::Undefined if hash.nil?
+
+        found = if name_or_path.is_a? Array
+          *path, name = name_or_path
+          Helpers::KeyMap::Mapping::Path.dig(name, hash, path)
+        else
+          Extensions::Hash.indifferent_access(hash, name_or_path, Extensions::Undefined)
+        end
+
+        return false, Extensions::Undefined if found == Extensions::Undefined
+        return true, found
+      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/key_map.rb

@@ -0,0 +1,176 @@
+require_relative '../error'
+require_relative '../extensions/undefined'
+require_relative '../extensions/hash'
+
+module ParamsReady
+  module Helpers
+    class KeyMap
+      class Mapping
+        class Path
+          attr_reader :path, :names
+
+          def initialize(path, names = [])
+            @path = path.map(&:to_sym).freeze
+            @names = names
+          end
+
+          def add_names(names)
+            names.each{ |name| add_name(name) }
+          end
+
+          def add_name(name)
+            @names << name
+          end
+
+          def dig(name, hash)
+            self.class.dig(name, hash, @path)
+          end
+
+          def self.dig(name, hash, path)
+            result = path.reduce(hash) do |current, name|
+              next unless Extensions::Hash.acts_as_hash?(current)
+
+              Extensions::Hash.indifferent_access current, name, nil
+            end
+
+            return Extensions::Undefined unless Extensions::Hash.acts_as_hash?(result)
+
+            Extensions::Hash.indifferent_access result, name, Extensions::Undefined
+          end
+
+          def store(name, value, hash)
+            self.class.store(name, value, hash, @path)
+          end
+
+          def self.store(name, value, hash, path)
+            return if value == Extensions::Undefined
+
+            result = path.reduce(hash) do |current, name|
+              current[name] ||= {}
+              current[name]
+            end
+
+            result[name] = value
+            result
+          end
+
+          def =~(other)
+            raise ParamsReadyError, "Can't match path with #{other.class.name}" unless other.is_a? Path
+            path == other.path
+          end
+
+          def ==(other)
+            raise ParamsReadyError, "Can't compare path with #{other.class.name}" unless other.is_a? Path
+            path == other.path && names == other.names
+          end
+        end
+
+        def initialize(alt_path, alt_names, std_path, std_names)
+          if alt_names.length != std_names.length
+            msg = "Expected equal number of alternative and standard names, got #{alt_names.length}/#{std_names.length}"
+            raise ParamsReadyError, msg
+          end
+
+          @alt = Path.new(alt_path, alt_names)
+          @std = Path.new(std_path, std_names)
+        end
+
+        def add_names(altn, stdn)
+          @alt.add_name altn
+          @std.add_name stdn
+        end
+
+        def remap(from, to, input, target)
+          path(from).names.each_with_index do |input_name, idx|
+            value = dig(from, input_name, input)
+            target_name = path(to).names[idx]
+            store(to, target_name, value, target)
+          end
+        end
+
+        def merge!(other)
+          raise ParamsReadyError, "Can't merge non_matching mapping" unless self =~ other
+
+          @alt.add_names(other.alt.names)
+          @std.add_names(other.std.names)
+        end
+
+        def dig(schema, name, hash)
+          path(schema).dig(name, hash)
+        end
+
+        def store(schema, name, value, hash)
+          path(schema).store(name, value, hash)
+        end
+
+        def path(schema)
+          case schema
+          when :alt then @alt
+          when :std then @std
+          else
+            raise ParamsReadyError, "Unexpected naming schema: #{schema}"
+          end
+        end
+
+        def =~(other)
+          raise ParamsReadyError, "Can't match path with #{other.class.name}" unless other.is_a? Mapping
+          return false unless path(:alt) =~ other.path(:alt)
+          return false unless path(:std) =~ other.path(:std)
+
+          true
+        end
+
+        protected
+        attr_reader :alt, :std
+      end
+
+      def initialize
+        @mappings = []
+      end
+
+      def map(from, to:)
+        alt_path, alt_names = self.class.split_map(from)
+        std_path, std_names = self.class.split_map(to)
+        mapping = Mapping.new(alt_path, alt_names, std_path, std_names)
+        merge_or_add_mapping(mapping)
+        self
+      end
+
+      def merge_or_add_mapping(mapping)
+        if (existing = @mappings.find { |candidate| candidate =~ mapping })
+          existing.merge!(mapping)
+        else
+          @mappings << mapping
+        end
+        mapping
+      end
+
+      def to_standard(hash)
+        remap(:alt, :std, hash)
+      end
+
+      def to_alternative(hash)
+        remap(:std, :alt, hash)
+      end
+
+      def remap(from, to, input)
+        @mappings.each_with_object({}) do |mapping, result|
+          mapping.remap(from, to, input, result)
+        end
+      end
+
+      def freeze
+        @mappings.each(&:freeze)
+        super
+      end
+
+      def self.split_map(array)
+        raise ParamsReadyError, "Array expected, got: #{array.class.name}" unless array.is_a? Array
+        names = array.last || []
+        raise ParamsReadyError, "Array expected, got: #{names.class.name}" unless names.is_a? Array
+        paths = array[0...-1]
+        [paths, names]
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/memo.rb

@@ -0,0 +1,41 @@
+require_relative '../extensions/undefined'
+require_relative '../extensions/hash'
+
+
+
+module ParamsReady
+  module Helpers
+    class Memo
+      def initialize(slots = 1)
+        raise ParamsReadyError, "Expected positive value for number of slots, got: '#{slots}'" unless slots > 0
+        @slots = slots
+        @cache = nil
+      end
+
+      def cached_value(key)
+        cache = @cache
+        return Extensions::Undefined if cache.nil?
+        return Extensions::Undefined unless cache.key? key
+
+        cache[key]
+      end
+
+      def cache_value(value, key)
+        stale = @cache
+        return if stale&.key? key
+
+        frozen = Extensions::Hash.try_deep_freeze(value)
+
+        fresh = if stale.nil? || @slots == 1
+          { key => frozen }
+        else
+          kept = stale.to_a.last(@slots - 1)
+
+          [*kept, [key, frozen]].to_h
+        end
+
+        @cache = fresh.freeze
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/options.rb

@@ -0,0 +1,107 @@
+require_relative 'storage'
+require_relative 'usage_rule'
+
+module ParamsReady
+  module Helpers
+    class Options
+      attr_reader :parameters, :relations
+
+      def initialize
+        @parameter_rules = Hash.new
+        @relation_rules = Hash.new
+        @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)
+        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)
+        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
+        if block_given?
+          @parameter_rules.each_value do |rule|
+            yield rule
+          end
+        end
+        @parameter_rules
+      end
+
+      def relation_rules
+        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_definer_class_methods.rb

@@ -0,0 +1,39 @@
+require_relative 'relation_builder_wrapper'
+require_relative '../builder'
+
+module ParamsReady
+  module Helpers
+    module ParameterDefinerClassMethods
+      def define_relation(*args, **opts, &block)
+        wrapper = ParamsReady::Helpers::RelationBuilderWrapper.new self, *args, **opts
+        wrapper.instance_eval(&block) unless block.nil?
+        relation = wrapper.build
+        params_ready_storage.add_relation relation
+      end
+
+      def define_parameter(type, *args, **opts, &block)
+        full_name = "define_#{type}"
+        parameter = Builder.send(full_name, *args, **opts, &block)
+        params_ready_storage.add_parameter parameter
+      end
+
+      def all_relations
+        relations = if superclass.respond_to? :all_relations
+          superclass.all_relations
+        else
+          {}
+        end
+        relations.merge(params_ready_storage.relations)
+      end
+
+      def all_parameters
+        parameters = if superclass.respond_to? :all_parameters
+          superclass.all_parameters
+        else
+          {}
+        end
+        parameters.merge(params_ready_storage.parameters)
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/parameter_storage_class_methods.rb

@@ -0,0 +1,63 @@
+require_relative 'storage'
+require_relative '../error'
+require_relative 'rule'
+
+module ParamsReady
+  module Helpers
+    module ParameterStorageClassMethods
+      def params_ready_storage
+        @params_ready_storage ||= Storage.new
+      end
+
+      def relation_definition(key)
+        relations = params_ready_storage.relations
+        sym_key = key.to_sym
+        if relations.key?(sym_key)
+          relations[sym_key]
+        elsif superclass.respond_to? :relation_definition
+          superclass.relation_definition sym_key
+        else
+          raise ParamsReadyError, "Unknown relation '#{sym_key}'"
+        end
+      end
+
+      def parameter_definition(key)
+        parameters = params_ready_storage.parameters
+        sym_key = key.to_sym
+        if parameters.key? sym_key
+          parameters[sym_key]
+        elsif superclass.respond_to? :parameter_definition
+          superclass.parameter_definition sym_key
+        else
+          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

@@ -0,0 +1,35 @@
+require_relative 'interface_definer'
+
+module ParamsReady
+  module Helpers
+    module ParameterUserClassMethods
+      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_option.use_parameter parameter, rule
+      end
+
+      def use_relation(name, rule = :all)
+        relation = relation_definition name
+        params_ready_option.use_relation relation, rule
+      end
+
+      def action_interface(*action_names, **opts, &block)
+        definer = InterfaceDefiner.new(action_names, self)
+
+        definer.define(**opts, &block)
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/relation_builder_wrapper.rb

@@ -0,0 +1,35 @@
+require_relative '../query/relation'
+
+module ParamsReady
+  module Helpers
+    class RelationBuilderWrapper
+      def initialize(cache, *args, **opts)
+        @cache = cache
+        @builder = Query::RelationParameterBuilder.instance *args, **opts
+      end
+
+      def capture(*names)
+        names.each do |name|
+          definition = @cache.parameter_definition(name)
+          @builder.add definition
+        end
+      end
+
+      ruby2_keywords def method_missing(name, *args, &block)
+        if @builder.respond_to? name
+          @builder.send name, *args, &block
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        if @builder.respond_to? name
+          true
+        else
+          super
+        end
+      end
+    end
+  end
+end