params_ready 0.0.1

data/lib/params_ready/helpers/memo.rb

@@ -0,0 +1,42 @@
+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,39 @@
+require_relative 'storage'
+require_relative 'usage_rule'
+
+module ParamsReady
+  module Helpers
+    class Options < Storage
+      attr_reader :parameters, :relations
+
+      def initialize
+        super
+        @parameter_rules = Hash.new
+        @relation_rules = Hash.new
+        @state = nil
+      end
+
+      def use_parameter(param, rule_args = :all)
+        rule = UsageRule.new(param, rule_args)
+        @parameter_rules[param.name] = rule
+      end
+
+      def use_relation(relation, rule_args = :all)
+        rule = UsageRule.new(relation, rule_args)
+        @relation_rules[relation.name] = rule
+      end
+
+      def parameter_rules
+        @parameter_rules.each_value do |rule|
+          yield rule
+        end
+      end
+
+      def relation_rules
+        @relation_rules.each_value do |rule|
+          yield rule
+        end
+      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,36 @@
+require_relative 'storage'
+require_relative '../error'
+
+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
+    end
+  end
+end

data/lib/params_ready/helpers/parameter_user_class_methods.rb

@@ -0,0 +1,31 @@
+module ParamsReady
+  module Helpers
+    module ParameterUserClassMethods
+      def params_ready_storage
+        @params_ready_storage ||= ParamsReady::Helpers::Options.new
+      end
+
+      def use_parameter(name, rule = :all)
+        parameter = parameter_definition name
+        params_ready_storage.use_parameter parameter, rule
+      end
+
+      def use_relation(name, rule = :all)
+        relation = relation_definition name
+        params_ready_storage.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 include_relations(parameter_definer)
+        parameter_definer.all_relations.values.each do |d|
+          params_ready_storage.add_relation(d)
+        end
+      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

data/lib/params_ready/helpers/rule.rb

@@ -0,0 +1,57 @@
+require 'set'
+
+module ParamsReady
+  module Helpers
+    def self.Rule(input)
+      return input if input.nil?
+      return input if input.is_a? Rule
+
+      Rule.new(input).freeze
+    end
+
+    class Rule
+      attr_reader :hash
+
+      def initialize(value)
+        @mode, @values = case value
+        when :none, :all then [value, nil]
+        when Hash
+          if value.length > 1 || value.length < 1
+            raise ParamsReadyError, "Unexpected hash for rule: '#{value}'"
+          end
+          key, values = value.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}'"
+        end
+        @values.freeze
+        @hash = [@mode, @values].hash
+        freeze
+      end
+
+      def include?(name)
+        case @mode
+        when :none then false
+        when :all then true
+        when :only then @values.member? name
+        when :except
+          !@values.member? name
+        else
+          raise ParamsReadyError, "Unexpected mode for rule: '#{@mode}'"
+        end
+      end
+
+      def ==(other)
+        return false unless other.is_a? Rule
+        return true if object_id == other.object_id
+        return false unless @mode == other.instance_variable_get(:@mode)
+
+        @values == other.instance_variable_get(:@values)
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/storage.rb

@@ -0,0 +1,30 @@
+module ParamsReady
+  module Helpers
+    class Storage
+      attr_reader :parameters, :relations
+
+      def initialize
+        @parameters = Hash.new
+        @relations = Hash.new
+      end
+
+      def has_relation?(name)
+        relations.key? name
+      end
+
+      def has_parameter?(name)
+        parameters.key? name
+      end
+
+      def add_relation(relation)
+        raise ParamsReadyError, "Relation already exists: #{relation.name}" if self.has_relation?(relation.name)
+        @relations[relation.name] = relation
+      end
+
+      def add_parameter(param)
+        raise ParamsReadyError, "Parameter already exists: #{param.name}" if self.has_parameter?(param.name)
+        @parameters[param.name] = param
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/usage_rule.rb

@@ -0,0 +1,18 @@
+require_relative 'rule'
+
+module ParamsReady
+  module Helpers
+    class UsageRule
+      attr_reader :parameter_definition
+
+      def initialize(parameter_definition, rule = :all)
+        @parameter_definition = parameter_definition
+        @rule = ParamsReady::Helpers::Rule(rule)
+      end
+
+      def valid_for(method)
+        @rule.include? method
+      end
+    end
+  end
+end

data/lib/params_ready/input_context.rb

@@ -0,0 +1,31 @@
+require 'forwardable'
+require_relative 'format'
+
+module ParamsReady
+  class InputContext
+    include Format::Wrapper
+    extend Forwardable
+
+    attr_reader :data
+
+    def_delegator :data, :[]
+
+    def initialize(format, data = {})
+      @format = Format.resolve(format).freeze
+      @data = data.freeze
+    end
+
+    def self.resolve(unknown)
+      case unknown
+      when nil
+        Format.instance(:frontend)
+      when InputContext, Format
+        unknown
+      when Symbol
+        Format.instance(unknown)
+      else
+        raise ParamsReadyError, "Unexpected type for InputContext: #{unknown.class.name}"
+      end
+    end
+  end
+end

data/lib/params_ready/intent.rb

@@ -0,0 +1,70 @@
+require 'forwardable'
+require_relative 'restriction'
+require_relative 'format'
+require_relative 'parameter/parameter'
+
+module ParamsReady
+  class Intent
+    extend Forwardable
+    include Restriction::Wrapper
+    include Format::Wrapper
+
+    def clone(restriction:)
+      Intent.new @format, restriction, data: @data
+    end
+
+    attr_reader :data, :hash
+
+    def initialize(format, restriction = Restriction.blanket_permission, data: nil)
+      @format = Format.resolve(format).freeze
+      raise ParamsReadyError, "Restriction expected, got: #{restriction.inspect}" unless restriction.is_a? Restriction
+      @restriction = restriction
+      @data = check_data(data)
+      @hash = [@format, @restriction, @data].hash
+      freeze
+    end
+
+    def check_data(data)
+      return if data.nil?
+      # The reason we require data object to be
+      # a Parameter is that it must be deep frozen
+      # for the output memoizing feature to work properly.
+      raise 'Data object must be a parameter' unless data.is_a? Parameter::Parameter
+      raise 'Data object must be frozen' unless data.frozen?
+
+      data
+    end
+
+    def omit?(parameter)
+      return true unless permitted?(parameter)
+      @format.omit?(parameter)
+    end
+
+    def preserve?(parameter)
+      !omit?(parameter)
+    end
+
+    def self.instance(name)
+      format = Format.instance(name)
+      Intent.new(format)
+    end
+
+    def self.resolve(intent_or_name)
+      if intent_or_name.is_a? Intent
+        intent_or_name
+      else
+        instance(intent_or_name)
+      end
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Intent)
+      return true if object_id == other.object_id
+      restriction == other.restriction && format == other.format && data == other.data
+    end
+
+    def eql?(other)
+      self == other
+    end
+  end
+end

data/lib/params_ready/marshaller/array_marshallers.rb

@@ -0,0 +1,132 @@
+require_relative 'collection'
+require_relative '../extensions/undefined'
+require_relative '../extensions/hash'
+require_relative '../helpers/find_in_hash'
+
+module ParamsReady
+  module Marshaller
+    class ArrayMarshallers
+      module AbstractMarshaller
+        def marshal(parameter, intent)
+          array = parameter.send(:bare_value)
+          definition = parameter.definition
+          compact = definition.compact?
+
+          elements = array.map do |element|
+            if element.eligible_for_output?(intent)
+              element.format_self_permitted(intent)
+            end
+          end
+          elements = elements.compact if compact
+          do_marshal(elements, intent, compact)
+        end
+      end
+
+      module ArrayMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, array, context, validator, freeze: false)
+          canonical = array.map do |value|
+            next if definition.compact? && value.nil?
+
+            element = definition.prototype.create
+            element.set_from_input(value, context, validator)
+            next if definition.compact? && element.is_nil?
+
+            element.freeze if freeze
+            element
+          end.compact
+
+          [canonical, validator]
+        end
+
+        def self.do_marshal(array, _, _)
+          array
+        end
+
+        freeze
+      end
+
+      module HashMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, hash, context, validator)
+          if definition.compact?
+            ArrayMarshaller.canonicalize(definition, hash.values, context, validator)
+          else
+            count_key = :cnt
+            found, count = Helpers::FindInHash.find_in_hash hash, count_key
+            raise ParamsReadyError, "Count not found" unless found
+
+            count = Integer(count)
+            array = (0...count).map do |index|
+              found, value = Helpers::FindInHash.find_in_hash hash, index
+              element = definition.prototype.create
+              element.set_from_input(value, context, validator) if found
+              element
+            end
+            [array, validator]
+          end
+        end
+
+        def self.do_marshal(array, _, compact)
+          return array if compact
+
+          result = array.each_with_index.reduce({}) do |result, (element, index)|
+            index = index.to_s
+            result[index] = element
+            result
+          end
+
+          result['cnt'] = array.length.to_s
+          result
+        end
+
+        freeze
+      end
+
+      class StringMarshaller
+        include AbstractMarshaller
+
+        attr_reader :separator
+
+        def self.instance(separator:, split_pattern: nil)
+          instance = new separator, split_pattern
+          [String, instance.freeze]
+        end
+
+        def initialize(separator, split_pattern)
+          @separator = separator.to_s.freeze
+          @split_pattern = split_pattern.freeze
+        end
+
+        def split_pattern
+          @split_pattern || @separator
+        end
+
+        def canonicalize(definition, string, context, validator)
+          array = string.split(split_pattern).map(&:strip).reject(&:empty?)
+          ArrayMarshaller.canonicalize(definition, array, context, validator)
+        end
+
+        def do_marshal(array, _, _)
+          array.join(separator)
+        end
+
+        freeze
+      end
+
+      def self.collection
+        @collection ||= begin
+          c = ClassCollection.new Array
+          c.add_instance Array, ArrayMarshaller
+          c.add_instance Hash, HashMarshaller
+          c.add_factory :string, StringMarshaller
+          c.default!(Hash)
+          c.freeze
+          c
+        end
+      end
+    end
+  end
+end