params_ready_rails5 0.0.7

data/lib/params_ready/helpers/rule.rb

@@ -0,0 +1,76 @@
+require 'set'
+
+module ParamsReady
+  module Helpers
+    def self.Rule(input)
+      return input if input.nil?
+      return input if input.is_a? Rule
+
+      Rule.instance(input).freeze
+    end
+
+      class Rule
+      attr_reader :hash, :mode, :values
+
+      def self.instance(input)
+        mode, values = case input
+        when :none, :all then [input, nil]
+        when Hash
+          if input.length > 1 || input.length < 1
+            raise ParamsReadyError, "Unexpected hash for rule: '#{input}'"
+          end
+          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: '#{input}'"
+        end
+        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
+        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,36 @@
+require_relative 'rule'
+
+module ParamsReady
+  module Helpers
+    class UsageRule
+      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)
+        @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

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 StructMarshaller
+        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, StructMarshaller
+          c.add_factory :string, StringMarshaller
+          c.default!(Hash)
+          c.freeze
+          c
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/builder_module.rb

@@ -0,0 +1,9 @@
+module ParamsReady
+  module Marshaller
+    module BuilderModule
+      def marshal(to: nil, using: nil, **opts)
+        @definition.set_marshaller(to: to, using: using, **opts)
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/collection.rb

@@ -0,0 +1,165 @@
+require_relative '../error'
+require_relative '../extensions/hash'
+
+module ParamsReady
+  module Marshaller
+    class InstanceCollection
+      attr_reader :default, :instances
+
+      def initialize(canonical, default = nil, instances = {})
+        @canonical = canonical
+        @default = default
+        @instances = instances
+      end
+
+      def canonicalize(definition, input, context, validator, **opts)
+        value_class = infer_class(input)
+        marshaller = instance(value_class)
+        raise ParamsReadyError, "Unexpected type for #{definition.name}: #{value_class.name}" if marshaller.nil?
+
+        marshaller.canonicalize(definition, input, context, validator, **opts)
+      end
+
+      def marshal_canonical(parameter, format, **opts)
+        marshaller = instance @canonical
+        if marshaller.nil?
+          value = parameter.send(:bare_value)
+          raise ParamsReadyError, "Value is not canonical" unless value.is_a? @canonical
+          value
+        else
+          marshaller.marshal(parameter, format, **opts)
+        end
+      end
+
+      def marshal(parameter, format, **opts)
+        default.marshal(parameter, format, **opts)
+      end
+
+      def infer_class(value)
+        if instances.key? value.class
+          value.class
+        elsif value.is_a?(Hash) || Extensions::Hash.acts_as_hash?(value)
+          Hash
+        else
+          value.class
+        end
+      end
+
+      def add_instance(value_class, instance)
+        raise ParamsReadyError, "Marshaller must be frozen" unless instance.frozen?
+
+        @instances[value_class] = instance
+      end
+
+      def instance(value_class)
+        @instances[value_class]
+      end
+
+      def instance?(value_class)
+        @instances.key?(value_class)
+      end
+
+      def default=(instance)
+        raise ParamsReadyError, "Default already defined" if default?
+        raise ParamsReadyError, "Marshaller must be frozen" unless instance.frozen?
+
+        @default = instance
+      end
+
+      def default!(value_class)
+        instance = instance(value_class)
+        raise ParamsReadyError, "No marshaller for class '#{value_class.name}'" if instance.nil?
+        self.default = instance
+      end
+
+      def default?
+        !@default.nil?
+      end
+
+      def reverse_merge(other)
+        clone = self.class.new(@canonical, @default, @instances.dup)
+        populate_clone(clone, other)
+      end
+
+      def populate_clone(clone, other)
+        if other.default? && !clone.default?
+          clone.default = other.default
+        end
+
+        other.instances.each do |value_class, i|
+          next if clone.instance?(value_class)
+
+          clone.add_instance value_class, i
+        end
+
+        clone
+      end
+
+      def freeze
+        @instance.freeze
+        super
+      end
+    end
+
+    class ClassCollection < InstanceCollection
+      attr_reader :factories
+
+      def initialize(canonical, default = nil, instances = {}, factories = {})
+        @factories = factories
+        super canonical, default, instances
+      end
+
+      def instance_collection
+        InstanceCollection.new(@canonical, nil, @instances.dup)
+      end
+
+      def add_factory(name, factory)
+        name = name.to_sym
+        raise ParamsReadyError, "Name '#{name}' already taken" if factory?(name)
+        raise ParamsReadyError, "Factory must be frozen" unless factory.frozen?
+
+        @factories[name] = factory
+      end
+
+      def add_instance(value_class, instance)
+        raise ParamsReadyError, "Marshaller for '#{value_class.name}' already exists" if instance?(value_class)
+
+        super
+      end
+
+      def build_instance(name, **opts)
+        factory(name).instance(**opts)
+      end
+
+      def factory(name)
+        @factories[name]
+      end
+
+      def factory?(name)
+        @factories.key? name
+      end
+
+      def freeze
+        @factories.freeze
+        super
+      end
+
+      def reverse_merge(other)
+        clone = self.class.new(@canonical, @default, @instances.dup, @factories.dup)
+        populate_clone(clone, other)
+      end
+
+      def populate_clone(clone, other)
+        merged = super
+
+        other.factories.each do |value_class, f|
+          next if merged.factory?(value_class)
+
+          clone.add_factory value_class, f
+        end
+
+        merged
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/definition_module.rb

@@ -0,0 +1,63 @@
+module ParamsReady
+  module Marshaller
+    module DefinitionModule
+      def self.[](collection)
+        mod = Module.new
+        mod.include self
+        mod.define_method :class_marshallers do
+          collection
+        end
+        mod
+      end
+
+      attr_reader :marshallers
+
+      def initialize(*args, marshaller: nil, **options)
+        @marshallers = class_marshallers.instance_collection
+        set_marshaller(**marshaller) unless marshaller.nil?
+
+        super *args, **options
+      end
+
+      def set_marshaller(to: nil, using: nil, **opts)
+        if using.is_a? Symbol
+          raise ParamsReadyError, "Expected ':to' argument to be nil, got #{to.class.name}" unless to.nil?
+          default_class, instance = class_marshallers.build_instance(using, **opts)
+          @marshallers.add_instance(default_class, instance)
+          @marshallers.default!(default_class)
+        elsif using.nil?
+          @marshallers.default!(to)
+        else
+          @marshallers.add_instance(to, using)
+          @marshallers.default!(to)
+        end
+      end
+
+      def marshal(parameter, intent, **opts)
+        if intent.marshal?(name_for_formatter)
+          @marshallers.marshal(parameter, intent, **opts)
+        else
+          @marshallers.marshal_canonical(parameter, intent, **opts)
+        end
+      end
+
+      def try_canonicalize(input, context, validator = nil, **opts)
+        @marshallers.canonicalize(self, input, context, validator, **opts)
+      end
+
+      def finish
+        unless @marshallers.default?
+          if class_marshallers.default?
+            @marshallers.default = class_marshallers.default
+          end
+        end
+        super
+      end
+
+      def freeze
+        @marshallers.freeze
+        super
+      end
+    end
+  end
+end