params_ready_rails5 0.0.7

data/lib/params_ready/marshaller/enum_set_marshallers.rb

@@ -0,0 +1,96 @@
+require_relative 'collection'
+require_relative 'struct_marshallers'
+
+module ParamsReady
+  module Marshaller
+    class EnumSetMarshallers
+      module AbstractMarshaller
+        def canonicalize_collection(definition, context, validator, freeze: false)
+          hash = {}
+          definition.names.each do |name, definition|
+            child = definition.create
+            value = yield child
+            child.set_from_input(value, context, validator)
+            child.freeze if freeze
+            hash[name] = child
+          end
+          [hash, validator]
+        end
+      end
+
+      module StructMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, hash, context, validator)
+          canonicalize_collection(definition, context, validator) do |child|
+            _, value = child.find_in_hash(hash, context)
+            value
+          end
+        end
+
+        def self.marshal(parameter, intent)
+          if intent.marshal? parameter.name_for_formatter
+            StructMarshallers::StructMarshaller.marshal(parameter, intent)
+          else
+            SetMarshaller.marshal(parameter, intent)
+          end
+        end
+
+        freeze
+      end
+
+      module SetMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, set, context, validator, freeze: false)
+          canonicalize_collection(definition, context, validator, freeze: freeze) do |child|
+            value = definition.values[child.name]
+            set.member?(value) || set.member?(value.to_s)
+          end
+        end
+
+        def self.marshal(parameter, intent)
+          intent = parameter.class.intent_for_set(intent)
+
+          members = parameter.send(:bare_value).select do |_, m|
+            m.unwrap_or(false) == true && m.eligible_for_output?(intent)
+          end.map do |key, _|
+            parameter.definition.values[key]
+          end
+
+          members.to_set
+        end
+
+        freeze
+      end
+
+      module ArrayMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, array, context, validator)
+          set = array.to_set
+          SetMarshaller.canonicalize(definition, set, context, validator)
+        end
+
+        def self.marshal(parameter, intent)
+          set = SetMarshaller.marshal(parameter, intent)
+          set.to_a
+        end
+
+        freeze
+      end
+
+      def self.collection
+        @collection ||= begin
+          c = ClassCollection.new Hash
+          c.add_instance Hash, StructMarshaller
+          c.add_instance Set, SetMarshaller
+          c.add_instance Array, ArrayMarshaller
+          c.default!(Hash)
+          c.freeze
+          c
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/parameter_module.rb

@@ -0,0 +1,11 @@
+module ParamsReady
+  module Marshaller
+    module ParameterModule
+      def marshal(intent)
+        return nil if is_nil?
+
+        definition.marshal(self, intent)
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/polymorph_marshallers.rb

@@ -0,0 +1,67 @@
+require_relative 'collection'
+
+module ParamsReady
+  module Marshaller
+    class PolymorphMarshallers
+      class StructMarshaller
+        attr_reader :type_identifier
+
+        def self.instance(type_identifier:)
+          marshaller = new type_identifier
+          marshaller.freeze
+          [Hash, marshaller]
+        end
+
+        def initialize(type_identifier)
+          @type_identifier = type_identifier.to_sym
+        end
+
+        def reserved?(name)
+          name == type_identifier
+        end
+
+        def canonicalize(definition, hash, context, validator)
+          raise ParamsReadyError, "Type key can't be retrieved" unless hash.length == 1
+          key = hash.keys.first
+          value = hash.values.first
+          value = type(definition, key, value, context, validator)
+
+
+          [value, validator]
+        end
+
+        def type(definition, key, value, context, validator)
+          type_key = key.to_sym == type_identifier ? value : key
+          prototype = definition.type(type_key, context)
+          raise ParamsReadyError, "Unexpected type for #{definition.name}: #{type_key}" if prototype.nil?
+
+          type = prototype.create
+          return type if type_key == value
+          type.set_from_input(value, context, validator)
+          type
+        end
+
+        def marshal(parameter, intent)
+          type = parameter.send(:bare_value)
+
+          hash = type.to_hash_if_eligible(intent)
+          return hash unless hash.nil?
+
+          value = type.hash_key(intent)
+          { type_identifier => value }
+        end
+
+        freeze
+      end
+
+      def self.collection
+        @collection ||= begin
+          c = ClassCollection.new Hash
+          c.add_factory :hash, StructMarshaller
+          c.freeze
+          c
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/struct_marshallers.rb

@@ -0,0 +1,100 @@
+require 'json'
+require 'base64'
+require_relative 'collection'
+
+module ParamsReady
+  module Marshaller
+    class StructMarshallers
+      module AbstractMarshaller
+        def extract_bare_value(parameter, intent)
+          parameter.names.keys.reduce({}) do |result, name|
+            c = parameter[name]
+            hash = c.to_hash_if_eligible(intent)
+            if hash.nil?
+              result
+            else
+              result.deep_merge(hash)
+            end
+          end
+        end
+      end
+
+      module Base64Marshaller
+        def self.instance
+          [String, self]
+        end
+
+        def self.canonicalize(definition, string, context, validator)
+          json = Base64.urlsafe_decode64(string)
+          hash = JSON.parse(json)
+          StructMarshaller.canonicalize(definition, hash, context, validator)
+        end
+
+        def self.marshal(parameter, intent)
+          hash = StructMarshaller.marshal(parameter, intent)
+          json = JSON.generate(hash)
+          Base64.urlsafe_encode64(json)
+        end
+
+        freeze
+      end
+
+      module StructMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, hash, context, validator, freeze: false)
+          hash = if definition.respond_to?(:remap?) && definition.remap?(context)
+            definition.key_map.to_standard(hash)
+          else
+            hash
+          end
+
+          value = definition.names.each_with_object({}) do |(name, child_def), result|
+            child = child_def.create
+            child.set_from_hash(hash, validator: validator&.for_child(name), context: context)
+            child.freeze if freeze
+            result[name] = child
+          end
+          [value, validator]
+        end
+
+        def self.marshal(parameter, intent)
+          value = extract_bare_value(parameter, intent)
+
+          definition = parameter.definition
+
+          if value == {}
+            if intent.marshal?(definition.name_for_formatter)
+              if definition.optional? || definition.default_defined?
+                parameter.class::EMPTY_HASH
+              elsif intent.omit?(parameter)
+                nil
+              else
+                value
+              end
+            else
+              value
+            end
+          elsif definition.respond_to?(:remap?) && definition.remap?(intent)
+            definition.key_map.to_alternative(value)
+          else
+            value
+          end
+        end
+
+        freeze
+      end
+
+      def self.collection
+        @collection ||= begin
+          c = ClassCollection.new Hash
+          c.add_instance Hash, StructMarshaller
+          c.add_factory :base64, Base64Marshaller
+          c.default!(Hash)
+          c.freeze
+          c
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/marshaller/tuple_marshallers.rb

@@ -0,0 +1,103 @@
+require_relative 'collection'
+require_relative '../extensions/undefined'
+require_relative '../extensions/hash'
+
+module ParamsReady
+  module Marshaller
+    class TupleMarshallers
+      module AbstractMarshaller
+        def self.marshal_fields(fields, intent)
+          fields.map do |field|
+            field.format(intent)
+          end
+        end
+
+        def marshal(parameter, intent)
+          fields = parameter.send(:bare_value)
+          fields = AbstractMarshaller.marshal_fields(fields, intent)
+          do_marshal(fields, intent)
+        end
+      end
+
+      module ArrayMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, array, context, validator, freeze: false)
+          if array.length != definition.arity
+            raise ParamsReadyError, "Unexpected array length: #{array.length}"
+          end
+
+          canonical = definition.fields.each_with_index.map do |field_definition, index|
+            element = field_definition.create
+            element.set_from_input(array[index], context, validator)
+            element.freeze if freeze
+            element
+          end
+          [canonical, validator]
+        end
+
+        def self.do_marshal(fields, _)
+          fields
+        end
+
+        freeze
+      end
+
+      module StructMarshaller
+        extend AbstractMarshaller
+
+        def self.canonicalize(definition, hash, context, validator)
+          array = (0...definition.arity).map do |idx|
+            Extensions::Hash.indifferent_access(hash, idx, Extensions::Undefined)
+          end
+          ArrayMarshaller.canonicalize(definition, array, context, validator)
+        end
+
+        def self.do_marshal(fields, _)
+          fields.each_with_index.map do |field, index|
+            [index.to_s, field]
+          end.to_h
+        end
+
+        freeze
+      end
+
+      class StringMarshaller
+        include AbstractMarshaller
+
+        attr_reader :separator
+
+        def self.instance(separator:)
+          instance = new separator
+          [String, instance.freeze]
+        end
+
+        def initialize(separator)
+          @separator = separator.to_s.freeze
+        end
+
+        def canonicalize(definition, string, context, validator)
+          array = string.split(separator)
+          ArrayMarshaller.canonicalize(definition, array, context, validator)
+        end
+
+        def do_marshal(fields, _)
+          fields.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.freeze
+          c
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/ordering/column.rb

@@ -0,0 +1,60 @@
+require_relative '../error'
+require_relative '../helpers/arel_builder'
+
+module ParamsReady
+  module Ordering
+    class Column
+      DIRECTIONS = Set.new %i(none asc desc)
+
+      attr_reader :ordering, :table, :nulls, :required, :pk
+
+      NULLS_FIRST = { null: 0, not_null: 1 }.freeze
+      NULLS_LAST = { null: 1, not_null: 0 }.freeze
+
+      def initialize(ordering, arel_table:, expression:, nulls: :default, required: false, pk: false)
+        raise ParamsReadyError, "Invalid ordering value: #{ordering}" unless DIRECTIONS.include? ordering
+        @ordering = ordering
+        @table = arel_table
+        @expression = expression
+        @nulls = nulls
+        @required = required
+        @pk = pk
+      end
+
+      def expression(name)
+        @expression || name
+      end
+
+      def attribute(name, default_table, context)
+        arel_table = table || default_table
+        arel_builder = Helpers::ArelBuilder.instance(expression(name), arel_table: arel_table)
+        arel_builder.to_arel(arel_table, context, self)
+      end
+
+      def clauses(attribute, direction, inverted: false)
+        clause = attribute.send direction
+        if nulls == :default
+          [clause]
+        else
+          values = null_substitution_values(nulls, inverted)
+
+          nulls_last = Arel::Nodes::Case.new
+            .when(attribute.eq(nil)).then(values[:null])
+            .else(values[:not_null])
+          [nulls_last, clause]
+        end
+      end
+
+      def null_substitution_values(policy, inverted)
+        case [policy, inverted]
+        when [:first, false], [:last, true]
+          NULLS_FIRST
+        when [:last, false], [:first, true]
+          NULLS_LAST
+        else
+          raise ParamsReadyError, "Unimplemented null handling policy: '#{nulls}' (inverted: #{inverted})"
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/ordering/ordering.rb

@@ -0,0 +1,276 @@
+require 'set'
+require_relative '../parameter/definition'
+require_relative '../builder'
+require_relative '../parameter/parameter'
+require_relative 'column'
+
+module ParamsReady
+  module Ordering
+    class OrderingParameter < Parameter::ArrayParameter
+      def_delegators :definition, :required?
+
+      def marshal(intent)
+        arr = to_array(intent)
+        return arr unless intent.marshal?(name_for_formatter)
+
+        arr.join(definition.class::COLUMN_DELIMITER)
+      end
+
+      def to_array(intent = Intent.instance(:backend))
+        arr = bare_value
+        arr.map do |tuple|
+          name = tuple.first.unwrap
+          next unless intent.name_permitted?(name) || definition.required?(name)
+
+          tuple.format(intent)
+        end.compact
+      end
+
+      def by_columns
+        bare_value.each_with_index.each_with_object(Hash.new([:none, nil])) do |(tuple, index), hash|
+          hash[tuple[0].unwrap] = [tuple[1].unwrap, index]
+        end
+      end
+
+      def toggle_schema(schema)
+        case schema
+        when :desc
+          [:desc, :asc]
+        when :asc
+          [:asc, :desc]
+        else
+          [:none, :none]
+        end
+      end
+
+      def filtered(name)
+        bare_value.map do |tuple|
+          tuple.format(Intent.instance(:backend))
+        end.partition do |item|
+          next item[0] == name
+        end
+      end
+
+      def prepend_item(name, direction, array)
+        return array if direction == :none
+        [[name, direction], *array]
+      end
+
+      def inverted_order_value
+        bare_value.map do |tuple|
+          name = tuple.first.unwrap
+          case tuple.second.unwrap
+          when :asc
+            [name, :desc]
+          when :desc
+            [name, :asc]
+          else
+            raise ParamsReadyError, "Unexpected ordering: '#{tuple.second.unwrap}'"
+          end
+        end
+      end
+
+      def inverted_order
+        update_in(inverted_order_value, [])
+      end
+
+      def toggled_order_value(name)
+        drop, save = filtered(name)
+
+        old_dir = drop.count > 0 ? drop.first[1] : :none
+        primary, secondary = toggle_schema(definition.columns[name.to_sym].ordering)
+        new_dir = old_dir == primary ? secondary : primary
+
+        prepend_item(name, new_dir, save)
+      end
+
+      def toggled_order(name)
+        update_in(toggled_order_value(name), [])
+      end
+
+      def reordered_value(name, new_dir)
+        _, save = filtered(name)
+        prepend_item(name, new_dir, save)
+      end
+
+      def reordered(name, new_dir)
+        update_in(reordered_value(name, new_dir), [])
+      end
+
+      def restriction_from_context(context)
+        restriction = context.to_restriction
+        return restriction if restriction.name_permitted? :ordering || !required?
+
+        Restriction.permit({ ordering: [] })
+      end
+
+      def to_arel(default_table, context: Restriction.blanket_permission, inverted: false)
+        ordering = inverted ? inverted_order : self
+        ordering.to_array_with_context(context).flat_map do |(column_name, direction)|
+          column = definition.columns[column_name]
+          attribute = column.attribute(column_name, default_table, context)
+          column.clauses(attribute, direction, inverted: inverted)
+        end
+      end
+
+      def to_array_with_context(context)
+        intent = Intent.instance(:backend).clone(restriction: restriction_from_context(context))
+        to_array(intent.for_children(self))
+      end
+
+      def order_for(name)
+        order = bare_value.find do |tuple|
+          tuple[0].unwrap == name
+        end
+        return :none if order.nil?
+
+        order[1].unwrap
+      end
+    end
+
+    class OrderingParameterBuilder < Builder
+      def self.instance
+        new OrderingParameterDefinition.new({})
+      end
+
+      def column(name, ordering, arel_table: nil, expression: nil, nulls: :default, required: false, pk: false)
+        @definition.add_column(
+          name,
+          ordering,
+          arel_table: arel_table,
+          expression: expression,
+          nulls: nulls,
+          required: required,
+          pk: pk
+        )
+      end
+
+      def default(*array)
+        super array
+      end
+    end
+
+    class OrderingParameterDefinition < Parameter::ArrayParameterDefinition
+      COLUMN_DELIMITER = '|'
+      FIELD_DELIMITER = '-'
+      attr_reader :columns, :primary_keys
+
+      parameter_class OrderingParameter
+
+      def initialize(columns, default = Extensions::Undefined)
+        invalid = columns.values.uniq.reject do |column|
+          column.is_a? Column
+        end
+        raise ParamsReadyError, "Invalid ordering values: #{invalid.join(", ")}" unless invalid.length == 0
+        @columns = columns.transform_keys { |k| k.to_sym }
+        @required_columns = nil
+        @primary_keys = Set.new
+        super :ordering, altn: :ord, prototype: nil, default: default
+      end
+
+      def set_default(value)
+        raise ParamsReadyError, "Prototype for ordering expected to be nil" unless @prototype.nil?
+        set_required_columns
+
+        @prototype = create_prototype columns
+        super value
+      end
+
+      def set_required_columns
+        return unless @required_columns.nil?
+
+        @required_columns = @columns.select do |_name, value|
+          value.required
+        end.map do |name, _value|
+          name
+        end
+      end
+
+      def required?(name = nil)
+        return !@required_columns.empty? if name.nil?
+
+        @required_columns.member?(name)
+      end
+
+      def add_column(
+        name,
+        ordering,
+        expression:,
+        arel_table:,
+        nulls: :default,
+        required: false,
+        pk: false
+      )
+        raise ParamsReadyError, "Column name taken: #{name}" if @columns.key? name
+        raise ParamsReadyError, "Can't add column after default defined" unless @default == Extensions::Undefined
+        @primary_keys << name if pk == true
+
+        column = Column.new(
+          ordering,
+          expression: expression,
+          arel_table: arel_table,
+          nulls: nulls,
+          required: required,
+          pk: pk
+        )
+        @columns[name] = column
+      end
+
+      def create_prototype(columns)
+        Builder.define_tuple(:column) do
+          marshal using: :string, separator: FIELD_DELIMITER
+          field :symbol, :column_name do
+            constrain Value::EnumConstraint.new(columns.keys)
+          end
+          field :symbol, :column_ordering do
+            constrain Value::EnumConstraint.new(Column::DIRECTIONS)
+          end
+        end
+      end
+
+      def try_canonicalize(input, context, validator = nil, freeze: false)
+        input ||= [%w(none none)]
+        canonical, validator = case input
+        when String
+          raise ParamsReadyError, "Freeze option expected to be false" if freeze
+          array = input.split(COLUMN_DELIMITER)
+          try_canonicalize(array, context, validator, freeze: false)
+        when Array
+          super
+        else
+          raise ParamsReadyError, "Unexpected type for #{name}: #{input.class.name}"
+        end
+        unique_columns = unique_columns(canonical)
+        with_required = with_required(unique_columns)
+        [with_required.values, validator]
+      end
+
+      def unique_columns(array)
+        array.each_with_object({}) do |column, hash|
+          name = column.first.unwrap
+          next if hash.key? name
+
+          hash[name] = column
+        end
+      end
+
+      def with_required(hash)
+        @required_columns.each_with_object(hash) do |name, result|
+          next if result.key? name
+          column = @columns[name]
+          _, tuple = @prototype.from_input([name, column.ordering])
+          hash[name] = tuple
+        end
+      end
+
+      def finish
+        raise ParamsReadyError, "No ordering column defined" if @columns.empty?
+        set_required_columns
+        set_default([]) unless default_defined?
+        super
+      end
+
+      freeze_variables :columns, :required_columns, :primary_keys, :prototype
+    end
+  end
+end