params_ready_rails5 0.0.7

data/lib/params_ready/output_parameters.rb

@@ -0,0 +1,138 @@
+require_relative 'intent'
+
+module ParamsReady
+  class OutputParameters
+    attr_reader :scoped_id, :parameter
+
+    def method_missing(name, *args, &block)
+      if @parameter.respond_to? name, false
+        @parameter.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      if @parameter.respond_to? name, include_private
+        true
+      else
+        super
+      end
+    end
+
+    def self.decorate(parameter, *args)
+      intent = case args.length
+      when 0
+        Intent.instance(:frontend)
+      when 1
+        Intent.resolve(args[0])
+      when 2
+        format = args[0]
+        restriction = args[1]
+        Intent.new format, restriction
+      else
+        msg = "ArgumentError: wrong number of arguments (given #{args.length + 1}, expected 1..3)"
+        raise ParamsReadyError, msg
+      end
+      new parameter, intent
+    end
+
+    def initialize(parameter, intent, scoped_name = nil, scoped_id = nil)
+      raise ParamsReadyError, "Expected parameter '#{parameter.name}' to be frozen" unless parameter.frozen?
+      @parameter = parameter
+      @intent = Intent.resolve(intent)
+      @tree = {}
+      @scoped_name = scoped_name || @intent.hash_key(parameter).to_s
+      @scoped_id = scoped_id || @intent.hash_key(parameter).to_s
+    end
+
+    def scoped_name(multiple: false)
+      return @scoped_name unless multiple
+      @scoped_name + "[]"
+    end
+
+    def [](key)
+      if @tree.key? key
+        @tree[key]
+      elsif @parameter.respond_to? :[]
+        child = @parameter[key]
+        formatted_name = if @parameter.definition.is_a? Parameter::ArrayParameterDefinition::ArrayLike
+          key.to_s
+        else
+          @intent.hash_key(child).to_s
+        end
+        child_scoped_name = @scoped_name.empty? ? formatted_name : "#{@scoped_name}[#{formatted_name}]"
+        child_scoped_id = @scoped_id.empty? ? formatted_name : "#{@scoped_id}_#{formatted_name}"
+        intent = @parameter.intent_for_children(@intent)
+        decorated = OutputParameters.new(child, intent, child_scoped_name, child_scoped_id)
+        @tree[key] = decorated
+        decorated
+      else
+        raise ParamsReadyError, "Parameter '#{@parameter.name}' doesn't support square brackets access"
+      end
+    end
+
+
+    def to_a
+      if @parameter.definition.is_a? Parameter::ArrayParameterDefinition
+        (0...@parameter.length).map do |n|
+          self[n]
+        end
+      else
+        raise ParamsReadyError, "Unimplemented method 'to_a' for #{@parameter.definition.class.name}"
+      end
+    end
+
+    def flat_pairs(format = @intent.format, restriction: @intent.restriction, data: @intent.data)
+      self.class.flatten_hash(for_output(format, restriction: restriction, data: data), scoped_name)
+    end
+
+    def self.flatten_hash(hash, scope)
+      hash.flat_map do |key, value|
+        nested = scope.empty? ? key.to_s : "#{scope}[#{key}]"
+        if value.is_a? Hash
+          flatten_hash(value, nested)
+        else
+          [[nested, value]]
+        end
+      end
+    end
+
+    def to_hash(format = @intent.format, restriction: nil, data: @intent.data)
+      restriction = if restriction.nil?
+        Restriction.permit(name => @intent.restriction)
+      else
+        restriction
+      end
+      @parameter.to_hash(format, restriction: restriction, data: data)
+    end
+
+    def for_output(format = @intent.format, restriction: @intent.restriction, data: @intent.data)
+      @parameter.for_output(format, restriction: restriction, data: data)
+    end
+
+    def for_frontend(restriction: @intent.restriction, data: @intent.data)
+      @parameter.for_frontend(restriction: restriction, data: data)
+    end
+
+    def for_model(format = :update, restriction: @intent.restriction)
+      @parameter.for_model(format, restriction: restriction)
+    end
+
+    def format(format = @intent)
+      @parameter.format(format)
+    end
+
+    def build_select(context: @intent.restriction, **opts)
+      @parameter.build_select(context: context, **opts)
+    end
+
+    def build_relation(context: @intent.restriction, **opts)
+      @parameter.build_relation(context: context, **opts)
+    end
+
+    def perform_count(context: @intent.restriction, **opts)
+      @parameter.perform_count(context: context, **opts)
+    end
+  end
+end

data/lib/params_ready/pagination/abstract_pagination.rb

@@ -0,0 +1,18 @@
+module ParamsReady
+  module Pagination
+    module AbstractPagination
+      def num_pages(count:)
+        raise ParamsReadyError, 'Negative count unexpected' if count < 0
+        (count.to_f / limit.to_f).ceil.to_i
+      end
+
+      def first_page
+        update_in(first_page_value, [])
+      end
+
+      def last_page(*args, **opts)
+        update_in(last_page_value(*args, **opts), [])
+      end
+    end
+  end
+end

data/lib/params_ready/pagination/cursor.rb

@@ -0,0 +1,171 @@
+require_relative '../helpers/arel_builder'
+require_relative '../../arel/cte_name'
+
+module ParamsReady
+  module Pagination
+    class CursorBuilder
+      def initialize(keyset, arel_table, context)
+        @keyset = keyset.freeze
+        @arel_table = arel_table
+        @context = context
+        @select_list = []
+      end
+
+      def add(key, column)
+        attribute = if @keyset.key? key
+          Literal.new(key, @keyset[key], column.pk)
+        else
+          Selector.new(key, column)
+        end
+
+        @select_list << attribute
+      end
+
+      def build
+        cursor = Cursor.new(@select_list, @arel_table, @context)
+        @select_list = nil
+        freeze
+        cursor
+      end
+
+      class Selector
+        attr_reader :key
+        attr_reader :column
+
+        def initialize(key, column)
+          @key = key
+          @column = column
+          freeze
+        end
+
+        def expression(arel_table, context)
+          column.attribute(key, arel_table, context)
+        end
+
+        def rvalue(cte)
+          cte.project(key)
+        end
+      end
+
+      class Literal
+        attr_reader :key
+        attr_reader :pk
+
+        def initialize(key, value, pk)
+          @key = key
+          @value = Arel::Nodes::Quoted.new(value)
+          @pk = pk
+          freeze
+        end
+
+        def quoted
+          @value
+        end
+
+        def value
+          @value.value
+        end
+
+        def rvalue(_)
+          @value
+        end
+      end
+
+      class Cursor
+        attr_reader :select_list, :selectors, :literals, :cte
+
+        def initialize(select_list, arel_table, context)
+          @hash = select_list_to_hash(select_list)
+          @selectors, @literals = select_list.partition { |attr| attr.is_a? Selector }
+          @arel_table = arel_table
+          @context = context
+          names = column_names(@selectors)
+          @cte_ref = Arel::Table.new(cte_reference(names))
+          @cte_def = cte_definition(@cte_ref, names)
+
+          freeze
+        end
+
+        def select_list_to_hash(select_list)
+          res = select_list.each_with_object({}) do |item, hash|
+            raise ParamsReadyError, "Repeated key in select list: '#{item.key}'" if hash.key? item.key
+
+            hash[item.key] = item
+          end
+          res.freeze
+        end
+
+        def cte_for_relation(relation)
+          return nil if selectors.empty?
+
+          expressions = column_expressions(selectors)
+          relation = relation.where(**active_record_predicates(literals))
+                             .select(*expressions)
+          select = Arel::Nodes::SqlLiteral.new(relation.to_sql)
+          grouping = Arel::Nodes::Grouping.new(select)
+          as = Arel::Nodes::As.new(@cte_def, grouping)
+          Arel::Nodes::With.new([as])
+        end
+
+        def cte_for_query(query, arel_table)
+          return nil if selectors.empty?
+
+          query = query.deep_dup
+          expressions = column_expressions(selectors)
+          query = query.where(arel_predicates(literals, arel_table))
+                       .project(*expressions)
+          grouping = Arel::Nodes::Grouping.new(query)
+          Arel::Nodes::As.new(@cte_def, grouping)
+        end
+
+        def active_record_predicates(literals)
+          literals.select do |literal|
+            literal.pk
+          end.map do |literal|
+            [literal.key, literal.value]
+          end.to_h
+        end
+
+        def arel_predicates(literals, arel_table)
+          literals.reduce(nil) do |query, literal|
+            next query unless literal.pk
+
+            predicate = arel_table[literal.key].eq(literal.quoted)
+            next predicate if query.nil?
+
+            query.and(predicate)
+          end
+        end
+
+        def column_names(selectors)
+          selectors.lazy.map(&:key).map(&:to_s).force
+        end
+
+        def column_expressions(selectors)
+          selectors.map do |selector|
+            selector.expression(@arel_table, @context)
+          end
+        end
+
+        def cte_reference(names)
+          unsafe_name = "#{names.join('_')}_cte"
+          Helpers::ArelBuilder.safe_name(unsafe_name)
+        end
+
+        def cte_definition(reference, names)
+          node = Arel::Nodes::SqlLiteral.new(names.join(', '))
+          grouping = Arel::Nodes::Grouping.new(node)
+          # The name must be literal, otherwise
+          # it will be quoted by the visitor
+          expression = "#{reference.name} #{grouping.to_sql}"
+
+          Arel::Nodes::CteName.new(expression)
+        end
+
+        def rvalue(key)
+          @hash[key].rvalue(@cte_ref)
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/pagination/direction.rb

@@ -0,0 +1,148 @@
+require_relative '../error'
+require_relative 'tendency'
+require_relative 'nulls'
+require_relative 'cursor'
+require_relative 'keysets'
+
+module ParamsReady
+  module Pagination
+    module Direction
+      def self.instance(dir)
+        case dir
+        when :bfr, :before then Before
+        when :aft, :after then After
+        else
+          raise ParamsReadyError, "Unexpected direction: '#{dir}'"
+        end
+      end
+
+      def cursor_predicates(keyset, ordering, arel_table, context)
+        primary_keys = ordering.definition.primary_keys.dup
+        return [nil, nil] unless check_primary_keys_presence(keyset, primary_keys)
+
+        cursor = build_cursor(keyset, ordering, arel_table, context)
+        columns = ordering.to_array_with_context(context)
+
+        predicate = cursor_predicate(columns, cursor, ordering, arel_table, context, primary_keys)
+        grouping = Arel::Nodes::Grouping.new(predicate)
+        [cursor, grouping]
+      end
+
+      def check_primary_keys_presence(keyset, primary_keys)
+        primary_keys.all? do |pk|
+          keyset.key?(pk) && !keyset[pk].nil?
+        end
+      end
+
+      def cursor_predicate(columns, cursor, ordering, arel_table, context, primary_keys)
+        tuple, *rest = columns
+        key, column_ordering = tuple
+        column = ordering.definition.columns[key]
+
+        value_expression = cursor.rvalue(key)
+        column_expression = column.attribute(key, arel_table, context)
+
+        primary_keys.delete(key) if column.pk
+
+        if column.pk && primary_keys.empty?
+          pk_predicate(column_ordering, column_expression, value_expression)
+        else
+          nested = cursor_predicate(rest, cursor, ordering, arel_table, context, primary_keys)
+          if column.nulls == :default
+            non_nullable_predicate(column_ordering, column_expression, value_expression, nested)
+          else
+            nullable_predicate(column_ordering, column.nulls, column_expression, value_expression, nested)
+          end
+        end
+      end
+
+      def build_cursor(keyset, ordering, arel_table, context)
+        builder = CursorBuilder.new(keyset, arel_table, context)
+        ordering.to_array_with_context(context).each do |(key, _)|
+          column = ordering.definition.columns[key]
+          builder.add(key, column)
+        end
+        builder.build
+      end
+
+      def pk_predicate(ordering, column, value)
+        tendency(ordering).comparison_predicate(column, value)
+      end
+
+      def non_nullable_predicate(ordering, column, value, nested)
+        tendency(ordering).non_nullable_predicate(column, value, nested)
+      end
+
+      def nullable_predicate(ordering, nulls, column, value, nested)
+        strategy = nulls_strategy(nulls)
+        if_null = strategy.if_null_predicate(column, nested)
+        tendency = tendency(ordering)
+        expression = Arel::Nodes::Grouping.new(value)
+        if_not_null = strategy.if_not_null_predicate(tendency, column, value, nested)
+        Arel::Nodes::Case.new.when(expression.eq(nil))
+                             .then(if_null)
+                             .else(if_not_null)
+      end
+
+      module Before
+        extend Direction
+
+        def self.invert_ordering?
+          true
+        end
+
+        def self.tendency(ordering)
+          case ordering
+          when :desc then Tendency::Growing
+          when :asc then Tendency::Falling
+          else
+            raise ParamsReadyError, "Unexpected ordering: '#{ordering}'"
+          end
+        end
+
+        def self.nulls_strategy(strategy)
+          case strategy
+          when :first then Nulls::Last
+          when :last then Nulls::First
+          else
+            raise ParamsReadyError, "Unexpected nulls strategy: '#{strategy}'"
+          end
+        end
+
+        def self.keysets(_, keysets, &block)
+          BeforeKeysets.new(keysets, &block)
+        end
+      end
+
+      module After
+        extend Direction
+
+        def self.invert_ordering?
+          false
+        end
+
+        def self.tendency(ordering)
+          case ordering
+          when :asc then Tendency::Growing
+          when :desc then Tendency::Falling
+          else
+            raise ParamsReadyError, "Unexpected ordering: '#{ordering}'"
+          end
+        end
+
+        def self.nulls_strategy(strategy)
+          case strategy
+          when :first then Nulls::First
+          when :last then Nulls::Last
+          else
+            raise ParamsReadyError, "Unexpected nulls strategy: '#{strategy}'"
+          end
+        end
+
+        def self.keysets(last, keysets, &block)
+          AfterKeysets.new(last, keysets, &block)
+        end
+      end
+    end
+  end
+end