params_ready_rails5 0.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 66d9de173024436c9fb9ebe426ac1f7b751ed955575473d83721cf9df4918fe0
+  data.tar.gz: 40bb30ea77ca4d56770ee2bb1bbbb9364d23ec03452c53f1124dc97216f44631
+SHA512:
+  metadata.gz: 985bb72fb65626fa445292ecde4e7a81d548ba7ff48e147df8771b397cf01adc66a9251f10df840edc135ad087bffa92c70df480f22dd31492f66f8a92198d7b
+  data.tar.gz: fa273d9975c6fd5e1de9b81b88b6848df207fc3a1995e5575fd9cba4bfb03ea7741e2f2735451d126b9d41af04c49a5976239621e9c11db50f4df8a6730651e6

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 < Reduce
+      def visit_Arel_Nodes_CteName(o, collector)
+        collector << o.expr
+      end
+    end
+  end
+end

data/lib/params_ready/builder.rb

@@ -0,0 +1,161 @@
+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.register_deprecated(name, use:)
+      raise ParamsReadyError, 'Recommended replacement must not be nil' if use.nil?
+      @deprecated ||= {}
+      @deprecated[name] = use.to_s.freeze
+      register_builder(name, self)
+    end
+
+    class << self
+      alias_method :fetch_builder, :builder
+    end
+
+    def self.builder(name)
+      use = @deprecated[name] if @deprecated&.key? name
+      warn "Builder name deprecated: #{name}, use: #{use}" unless use.nil?
+      fetch_builder(name)
+    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 no_input(*arr, rule: nil)
+        @definition.set_no_input *arr, rule: rule
+      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

data/lib/params_ready/extensions/late_init.rb

@@ -0,0 +1,38 @@
+require_relative '../error'
+
+module ParamsReady
+  module Extensions
+    module LateInit
+      def late_init(
+        name,
+        obligatory: true,
+        freeze: true,
+        getter: true,
+        boolean: false,
+        once: true,
+        definite: true,
+        &block
+      )
+        ivar = :"@#{name}"
+        define_method "set_#{name}" do |value|
+          raise ParamsReadyError, "Can't initialize '#{name}' to nil" if value.nil? && definite
+          value = instance_exec(value, &block) unless block.nil?
+          next if value == Extensions::Undefined
+
+          current = instance_variable_get ivar
+          raise ParamsReadyError, "Variable '#{name}' already set" unless current.nil? || !once
+          value.freeze if freeze
+          instance_variable_set "@#{name}", value
+        end
+
+        if boolean
+          define_method "#{name}?" do
+            instance_variable_get ivar
+          end
+        end
+        attr_reader name if getter
+        obligatory! name if obligatory
+      end
+    end
+  end
+end

data/lib/params_ready/extensions/registry.rb

@@ -0,0 +1,44 @@
+module ParamsReady
+  module Extensions
+    module Registry
+      def registry(registry_name, name_method: nil, as: nil, getter: false, &block)
+        class_variable_name = "@@#{registry_name}"
+
+        class_variable_set class_variable_name, {}
+        if as
+          if name_method.nil?
+            define_singleton_method "register_#{as}" do |name, entry|
+              registry = class_variable_get class_variable_name
+              raise ParamsReadyError, "Name '#{name}' already taken for '#{human_string(as)}'" if registry.key? name
+              instance_exec name, entry, &block unless block.nil?
+              registry[name] = entry
+            end
+          else
+            define_singleton_method "register_#{as}" do |entry|
+              name = entry.send name_method
+              registry = class_variable_get class_variable_name
+              raise ParamsReadyError, "Name '#{name}' already taken for '#{human_string(as)}'" if registry.key? name
+              instance_exec name, entry, &block unless block.nil?
+              registry[name] = entry
+            end
+          end
+        end
+        if getter
+          define_singleton_method as do |name|
+            registry = class_variable_get class_variable_name
+            raise ParamsReadyError, "Name '#{name}' not found in #{human_string(registry_name)}" unless registry.key? name
+            registry[name]
+          end
+        end
+        define_singleton_method "has_#{as}?" do |name|
+          registry = class_variable_get class_variable_name
+          registry.key? name
+        end
+      end
+
+      def human_string(string)
+        string.to_s.gsub("_", " ")
+      end
+    end
+  end
+end

data/lib/params_ready/extensions/undefined.rb

@@ -0,0 +1,23 @@
+module ParamsReady
+  module Extensions
+    class Undefined
+      def self.dup
+        self
+      end
+
+      def self.present?
+        false
+      end
+
+      def self.blank?
+        true
+      end
+      
+      def self.value_indefinite?(value)
+        value == self || value.nil?
+      end
+
+      freeze
+    end
+  end
+end

data/lib/params_ready/format.rb

@@ -0,0 +1,132 @@
+require 'set'
+require_relative 'error'
+require_relative 'helpers/rule'
+
+module ParamsReady
+ class Format
+    module Wrapper
+      attr_reader :format
+
+      extend Forwardable
+      def_delegators :format,
+                     :alternative?,
+                     :standard?,
+                     :hash_key,
+                     :marshal,
+                     :marshal?,
+                     :remap?,
+                     :local?,
+                     :name
+    end
+
+    attr_reader :marshal, :naming_scheme, :name, :hash
+
+    OMIT_ALL = %i(undefined nil default no_output).freeze
+    def initialize(marshal:, naming_scheme:, remap:, omit:, local:, name: nil)
+      @marshal = Helpers::Rule(marshal)
+      @naming_scheme = naming_scheme
+      @remap = remap
+      @omit = omit.to_set.freeze
+      @local = local
+      @name = name.nil? ? name : name.to_sym
+      @hash = [@marshal, @naming_scheme, @remap, @omit, @local, @name].hash
+      freeze
+    end
+
+    def ==(other)
+      return false unless other.is_a? Format
+      return true if self.object_id == other.object_id
+      return false unless marshal == other.marshal
+      return false unless naming_scheme == other.naming_scheme
+      return false unless remap? == other.remap?
+      return false unless @omit == other.instance_variable_get(:@omit)
+      return false unless local? == other.local?
+      return false unless name == other.name
+
+      true
+    end
+
+    def alternative?
+      @naming_scheme == :alternative
+    end
+
+    def standard?
+      @naming_scheme == :standard
+    end
+
+    def remap?
+      @remap
+    end
+
+    def hash_key(parameter)
+      case @naming_scheme
+      when :standard then parameter.name
+      when :alternative then parameter.altn
+      else
+        raise ParamsReadyError, "Unexpected option: #{@naming_scheme}"
+      end
+    end
+
+    def omit?(parameter)
+      return true if parameter.no_output?(self)
+      return true if parameter.is_undefined? && @omit.member?(:undefined)
+      return true if parameter.is_nil? && @omit.member?(:nil)
+      return true if parameter.is_default? && @omit.member?(:default)
+      false
+    end
+
+    def local?
+      @local
+    end
+
+    def preserve?(parameter)
+      !omit?(parameter)
+    end
+
+    def marshal?(type)
+      @marshal.include?(type)
+    end
+
+    def update(**opts)
+      opts = instance_variables.reject { |ivar| ivar == :@hash }.map do |ivar|
+        value = instance_variable_get(ivar)
+        name = ivar.to_s.gsub(/^@/, '').to_sym
+        [name, value]
+      end.to_h.merge(opts)
+
+      Format.new(**opts)
+    end
+
+    @names = {
+      backend: Format.new(marshal: :none, omit: [], naming_scheme: :standard, remap: false, local: true, name: :backend),
+      frontend: Format.new(marshal: :all, omit: OMIT_ALL, naming_scheme: :alternative, remap: false, local: false, name: :frontend),
+      create: Format.new(marshal: :none, omit: [], naming_scheme: :standard, remap: false, local: true, name: :create),
+      update: Format.new(marshal: :none, omit: %i(undefined), naming_scheme: :standard, remap: false, local: true, name: :update),
+      json: Format.new(marshal: { except: [:array, :tuple, :boolean, :number] }, omit: [], naming_scheme: :alternative, remap: true, local: false, name: :json),
+      inspect: Format.new(marshal: :none, omit: [], naming_scheme: :standard, remap: false, local: false, name: :inspect)
+    }.freeze
+
+    def self.define(name, format)
+      @names = @names.dup
+      @names[name] = format
+      @names.freeze
+    end
+
+    def self.instance(name)
+      raise ParamsReadyError, "Unknown format '#{name}'" unless @names.key? name
+      @names[name]
+    end
+
+    def self.resolve(format_or_name)
+      if format_or_name.is_a? Format
+        format_or_name
+      elsif format_or_name.is_a? Symbol
+        instance(format_or_name)
+      elsif format_or_name.respond_to? :format
+        format_or_name.format
+      else
+        raise ParamsReadyError, "Not an acceptable format: #{format_or_name}"
+      end
+    end
+  end
+end