params_ready 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 16b29937985fac59ceb959ed77ada492f9e943a81e926eb1fb0d5668f3868f97
+  data.tar.gz: 4aab416caa7d1663265d09eacf8229a3e280db9a1d1e29c8b154d07b74543a50
+SHA512:
+  metadata.gz: 7e1ae323719b369cf6da284cd95e8596fe7e2071e0d4e7cb4e20253559a02b8ac06d34e1e79b02d7b16fd12ad0acfabd14ea57429895c0f55510e2fbf78a4790
+  data.tar.gz: 9df1e4edf7cb7996a4f91e4036c2656abad0c980100c37166de5b014431f9093ff307a3ff374360a0eae20357b2f60ca28ac64ef33df105ec80f3b76229684a8

data/lib/arel/cte_name.rb

@@ -0,0 +1,20 @@
+module Arel # :nodoc: all
+  module Nodes
+    class CteName < Unary
+      alias :name :expr
+
+      def initialize(expr)
+        expr = SqlLiteral.new(expr)
+        super expr
+      end
+    end
+  end
+
+  module Visitors
+    class ToSql < Visitor
+      def visit_Arel_Nodes_CteName(o, collector)
+        collector << o.expr
+      end
+    end
+  end
+end

data/lib/params_ready.rb

@@ -0,0 +1,36 @@
+require 'ruby2_keywords'
+require 'arel'
+
+require_relative 'params_ready/parameter/array_parameter'
+require_relative 'params_ready/parameter/hash_parameter'
+require_relative 'params_ready/parameter/hash_set_parameter'
+require_relative 'params_ready/parameter/polymorph_parameter'
+require_relative 'params_ready/parameter/tuple_parameter'
+require_relative 'params_ready/parameter/value_parameter'
+
+require_relative 'params_ready/value/custom'
+require_relative 'params_ready/value/validator'
+
+require_relative 'params_ready/input_context'
+require_relative 'params_ready/output_parameters'
+require_relative 'params_ready/parameter_definer'
+require_relative 'params_ready/parameter_user'
+require_relative 'params_ready/query_context'
+
+require_relative 'params_ready/query/array_grouping'
+require_relative 'params_ready/query/custom_predicate'
+require_relative 'params_ready/query/exists_predicate'
+require_relative 'params_ready/query/fixed_operator_predicate'
+require_relative 'params_ready/query/nullness_predicate'
+require_relative 'params_ready/query/polymorph_predicate'
+require_relative 'params_ready/query/relation'
+require_relative 'params_ready/query/variable_operator_predicate'
+
+
+module ParamsReady
+  VERSION = '0.0.1'.freeze
+
+  def self.gem_version
+    ::Gem::Version.new(VERSION)
+  end
+end

data/lib/params_ready/builder.rb

@@ -0,0 +1,140 @@
+require_relative 'extensions/registry'
+require_relative 'helpers/rule'
+
+module ParamsReady
+  class AbstractBuilder
+    module HavingArelTable
+      def arel_table(arel_table)
+        @definition.set_arel_table arel_table
+      end
+    end
+
+    module HavingModel
+      def model(model_class)
+        @definition.set_model_class model_class
+      end
+    end
+
+    extend Extensions::Registry
+    registry :builders, as: :builder, getter: true do |name, _|
+      full_name = "define_#{name}"
+      raise ParamsReadyError, "Reserved name: #{full_name}" if method_defined?(full_name)
+      Builder.define_singleton_method(full_name) do |*args, **opts, &block|
+        define_parameter(name, *args, **opts, &block)
+      end
+    end
+
+    def self.register(name)
+      register_builder(name, self)
+    end
+
+    def self.define_parameter(type, *args, **opts, &block)
+      builder_class = builder(type)
+      builder = builder_class.instance(*args, **opts)
+      builder.include(&block) unless block.nil?
+      builder.build
+    end
+
+    def self.define_registered_parameter(name, *args, **opts, &block)
+      full_name = "define_#{name}"
+      send(full_name, *args, **opts, &block)
+    end
+
+    def self.resolve(input, *args, **opts, &block)
+      if input.is_a? Parameter::AbstractDefinition
+        input
+      else
+        define_registered_parameter(input, *args, **opts, &block)
+      end
+    end
+
+    def self.instance(*args, **opts)
+      new *args, **opts
+    end
+
+    private_class_method :new
+
+    def initialize(definition)
+      @definition = definition
+    end
+
+    def include(&block)
+      instance_eval(&block)
+      self
+    end
+
+    def fetch
+      d = @definition
+      @definition = nil
+      d
+    end
+
+    def build
+      @definition.finish
+      @definition
+    end
+
+    def open?
+      return false if @definition.nil?
+      return false if @definition.frozen?
+
+      true
+    end
+
+    module HavingValue
+      def optional
+        @definition.set_optional true
+      end
+
+      def default(val)
+        @definition.set_default(val, **{})
+      end
+
+      def no_output(rule: nil)
+        @definition.set_no_output Helpers::Rule(rule) || true
+      end
+
+      def local(*arr, rule: nil)
+        @definition.set_local *arr, rule: rule
+      end
+
+      def preprocess(rule: nil, &block)
+        @definition.set_preprocessor rule: rule, &block
+      end
+
+      def populate(&block)
+        @definition.set_populator block
+      end
+
+      def postprocess(rule: nil, &block)
+        @definition.set_postprocessor rule: rule, &block
+      end
+
+      def marshal(*args, **opts)
+        @definition.set_marshaller(*args, **opts)
+      end
+
+      def memoize(slots = 1)
+        @definition.set_memoize(slots)
+      end
+    end
+  end
+
+  class Builder < AbstractBuilder
+    include HavingValue
+
+    def helper(name, &block)
+      @definition.add_helper [name, block]
+    end
+  end
+
+  module DelegatingBuilder
+    def self.[](delegee_name)
+      mod = Module.new
+      Extensions::Delegation.delegate(mod) do
+        @definition.send(delegee_name)
+      end
+      mod
+    end
+  end
+end

data/lib/params_ready/error.rb

@@ -0,0 +1,31 @@
+module ParamsReady
+  class ParamsReadyError < RuntimeError; end
+
+  class ErrorWrapper < ParamsReadyError
+    attr_reader :error
+
+    def initialize(error)
+      @error = error
+    end
+
+    def message
+      @error.message
+    end
+  end
+
+  class PreprocessorError < ErrorWrapper; end
+  class PostprocessorError < ErrorWrapper; end
+  class PopulatorError < ErrorWrapper; end
+
+  class ValueMissingError < StandardError
+    def initialize(name)
+      super "#{name}: value is nil"
+    end
+  end
+
+  class CoercionError < RuntimeError
+    def initialize(input, class_name)
+      super "can't coerce '#{input}' into #{class_name}"
+    end
+  end
+end

data/lib/params_ready/extensions/class_reader_writer.rb

@@ -0,0 +1,33 @@
+require_relative '../error'
+
+module ParamsReady
+  module Extensions
+    module ClassReaderWriter
+      def class_reader_writer(method_name)
+        ivar = :"@#{method_name}"
+        define_singleton_method method_name do |*args|
+          if args.length == 0
+            value = instance_variable_get(ivar)
+            if value.nil?
+              if superclass.respond_to? method_name
+                superclass.send method_name
+              else
+                raise ParamsReadyError, "Class variable '#{ivar}' not set for '#{name}'"
+              end
+            else
+              value
+            end
+          elsif args.length == 1
+            if instance_variable_get(ivar).nil?
+              instance_variable_set(ivar, args[0])
+            else
+              raise ParamsReadyError, "Class variable '#{ivar}' already set for '#{name}'"
+            end
+          else
+            raise ParamsReadyError, "Unexpected parameters to '#{method_name}': #{args}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/extensions/collection.rb

@@ -0,0 +1,43 @@
+require_relative '../error'
+
+module ParamsReady
+  module Extensions
+    module Collection
+      def collection(
+        collection_name,
+        element_name,
+        freeze_collection: true,
+        freeze_value: true,
+        getter: true,
+        obligatory: false,
+        &block
+      )
+        full_name = "@#{collection_name}"
+        define_method "add_#{element_name}" do |value|
+          value = instance_exec(value, &block) unless block.nil?
+          next if value == Extensions::Undefined
+
+          collection = send collection_name
+          value.freeze if freeze_value
+          collection << value
+        end
+
+        if getter
+          define_method collection_name do
+            if instance_variable_defined? full_name
+              instance_variable_get full_name
+            elsif frozen?
+              [].freeze
+            else
+              instance_variable_set full_name, []
+              instance_variable_get full_name
+            end
+          end
+        end
+
+        obligatory! collection_name if obligatory
+        freeze_variable collection_name if freeze_collection
+      end
+    end
+  end
+end

data/lib/params_ready/extensions/delegation.rb

@@ -0,0 +1,25 @@
+module ParamsReady
+  module Extensions
+    module Delegation
+      def self.delegate(mod, &to)
+        mod.define_method :method_missing do |name, *args, &block|
+          delegee = instance_eval(&to)
+          if delegee.respond_to? name
+            delegee.send name, *args, &block
+          else
+            super name, *args, &block
+          end
+        end
+
+        mod.define_method :respond_to_missing? do |name, include_private = false|
+          delegee = instance_eval(&to)
+          if delegee.respond_to? name
+            true
+          else
+            super name, include_private
+          end
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/extensions/finalizer.rb

@@ -0,0 +1,26 @@
+module ParamsReady
+  module Extensions
+    module Finalizer
+      def obligatory!(*args)
+        obligatory.concat args
+      end
+
+      def obligatory
+        @obligatory ||= []
+      end
+
+      module InstanceMethods
+        def finish
+          self.class.obligatory.each do |name|
+            value = instance_variable_get("@#{name}")
+            raise ParamsReadyError, "Obligatory property is nil: #{name}" if value.nil?
+            if value.respond_to? :empty? and value.empty?
+              raise ParamsReadyError, "Obligatory property is empty: #{name}"
+            end
+          end
+          self
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/extensions/freezer.rb

@@ -0,0 +1,49 @@
+module ParamsReady
+  module Extensions
+    module Freezer
+      def variables_to_freeze
+        # This works on assumption classes
+        # are not redefined during runtime
+        @cached_variables_to_freeze ||= begin
+          names = if defined? @variables_to_freeze
+            @variables_to_freeze.dup
+          else
+            []
+          end
+          names += superclass.variables_to_freeze if superclass.respond_to? :variables_to_freeze
+          names
+        end
+      end
+
+      def freeze_variable(name, &block)
+        ivar = :"@#{name}"
+        if defined? @variables_to_freeze
+          @variables_to_freeze << [ivar, block]
+        else
+          @variables_to_freeze = [[ivar, block]]
+          define_method :freeze_variables do
+            next if frozen?
+            self.class.variables_to_freeze.each do |(ivar, block)|
+              variable = instance_variable_get ivar
+              block.call(variable) unless block.nil?
+              variable.freeze
+            end
+          end
+        end
+      end
+
+      def freeze_variables(*names)
+        names.each do |name|
+          freeze_variable name
+        end
+      end
+
+      module InstanceMethods
+        def freeze
+          freeze_variables if respond_to? :freeze_variables
+          super
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/extensions/hash.rb

@@ -0,0 +1,46 @@
+module ParamsReady
+  module Extensions
+    module Hash
+      refine ::Hash do
+        def deep_merge(other)
+          merger = proc { |_, v1, v2| ::Hash === v1 && ::Hash === v2 ? v1.merge(v2, &merger) : v2 }
+          merge(other, &merger)
+        end
+      end
+
+      def self.try_deep_freeze(object)
+        if object.is_a? ::Hash
+          object.values.each do |value|
+            try_deep_freeze(value)
+          end
+        end
+        object.freeze
+        object
+      end
+
+      def self.acts_as_hash?(object)
+        return false unless object.respond_to? :[]
+        return false unless object.respond_to? :key?
+        return false unless object.respond_to? :fetch
+
+        true
+      end
+
+      def self.indifferent_access(hash, key, default)
+        hash.fetch(key) do
+          case key
+          when String
+            hash.fetch(key.to_sym, default)
+          when Symbol
+            hash.fetch(key.to_s, default)
+          else
+            string_key = key.to_s
+            hash.fetch(string_key) do
+              hash.fetch(string_key.to_sym, default)
+            end
+          end
+        end
+      end
+    end
+  end
+end