params_ready 0.0.1

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,15 @@
+module ParamsReady
+  module Extensions
+    class Undefined
+      def self.dup
+        self
+      end
+
+      def self.value_indefinite?(value)
+        value == self || value.nil?
+      end
+
+      freeze
+    end
+  end
+end

data/lib/params_ready/format.rb

@@ -0,0 +1,130 @@
+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),
+      attributes: Format.new(marshal: :none, omit: %i(undefined), naming_scheme: :standard, remap: false, local: true, name: :attributes),
+      json: Format.new(marshal: { except: [:array, :tuple, :boolean, :number] }, omit: [], naming_scheme: :alternative, remap: true, local: false, name: :json)
+    }.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

data/lib/params_ready/helpers/arel_builder.rb

@@ -0,0 +1,68 @@
+require_relative '../error'
+
+module ParamsReady
+  module Helpers
+    class ArelBuilder
+      def self.instance(object, arel_table: nil)
+        case object
+        when Arel::Nodes::Node, Arel::Nodes::SqlLiteral, Arel::Attribute
+          raise ParamsReadyError, "Arel table unexpected" unless arel_table.nil? || arel_table == :none
+          ArelObject.new(object)
+        when Proc
+          raise ParamsReadyError, "Arel table unexpected" unless arel_table.nil? || arel_table == :none
+          Callable.new(object)
+        when String, Symbol
+          Literal.new(object, arel_table)
+        else
+          raise ParamsReadyError, "Unexpected type for arel builder: #{object.class.name}"
+        end
+      end
+
+      def self.safe_name(name)
+        name[0...64]
+      end
+
+      class Callable
+        def initialize(proc)
+          @proc = proc
+        end
+
+        def to_arel(*args)
+          result = @proc.call(*args)
+          case result
+          when String, Symbol
+            Helpers::ArelBuilder.instance(result).to_arel(*args)
+          else
+            result
+          end
+        end
+      end
+
+      class Literal
+        def initialize(literal, arel_table)
+          @literal = literal.to_s
+          @arel_table = arel_table
+        end
+
+        def to_arel(default_table, _, _)
+          arel_table = @arel_table || default_table
+          if arel_table == :none
+            Arel::Nodes::SqlLiteral.new(@literal)
+          else
+            arel_table[@literal]
+          end
+        end
+      end
+
+      class ArelObject
+        def initialize(node)
+          @node = node
+        end
+
+        def to_arel(_, _, _)
+          @node
+        end
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/conditional_block.rb

@@ -0,0 +1,31 @@
+require_relative 'rule'
+require_relative '../error'
+
+module ParamsReady
+  module Helpers
+    class Conditional
+      def initialize(rule: nil)
+        @rule = Helpers::Rule(rule)
+        freeze
+      end
+
+      def perform?(general_rule, name)
+        if @rule.nil?
+          general_rule
+        else
+          @rule.include?(name)
+        end
+      end
+    end
+
+    class ConditionalBlock < Conditional
+      attr_reader :block
+
+      def initialize(rule: nil, &block)
+        raise ParamsReadyError, "Block must not be empty" if block.nil?
+        @block = block
+        super(rule: rule)
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/find_in_hash.rb

@@ -0,0 +1,22 @@
+require_relative '../extensions/undefined'
+require_relative 'key_map'
+
+module ParamsReady
+  module Helpers
+    module FindInHash
+      def self.find_in_hash(hash, name_or_path)
+        return false, Extensions::Undefined if hash.nil?
+
+        found = if name_or_path.is_a? Array
+          *path, name = name_or_path
+          Helpers::KeyMap::Mapping::Path.dig(name, hash, path)
+        else
+          Extensions::Hash.indifferent_access(hash, name_or_path, Extensions::Undefined)
+        end
+
+        return false, Extensions::Undefined if found == Extensions::Undefined
+        return true, found
+      end
+    end
+  end
+end

data/lib/params_ready/helpers/key_map.rb

@@ -0,0 +1,176 @@
+require_relative '../error'
+require_relative '../extensions/undefined'
+require_relative '../extensions/hash'
+
+module ParamsReady
+  module Helpers
+    class KeyMap
+      class Mapping
+        class Path
+          attr_reader :path, :names
+
+          def initialize(path, names = [])
+            @path = path.map(&:to_sym).freeze
+            @names = names
+          end
+
+          def add_names(names)
+            names.each{ |name| add_name(name) }
+          end
+
+          def add_name(name)
+            @names << name
+          end
+
+          def dig(name, hash)
+            self.class.dig(name, hash, @path)
+          end
+
+          def self.dig(name, hash, path)
+            result = path.reduce(hash) do |current, name|
+              next unless Extensions::Hash.acts_as_hash?(current)
+
+              Extensions::Hash.indifferent_access current, name, nil
+            end
+
+            return Extensions::Undefined unless Extensions::Hash.acts_as_hash?(result)
+
+            Extensions::Hash.indifferent_access result, name, Extensions::Undefined
+          end
+
+          def store(name, value, hash)
+            self.class.store(name, value, hash, @path)
+          end
+
+          def self.store(name, value, hash, path)
+            return if value == Extensions::Undefined
+
+            result = path.reduce(hash) do |current, name|
+              current[name] ||= {}
+              current[name]
+            end
+
+            result[name] = value
+            result
+          end
+
+          def =~(other)
+            raise ParamsReadyError, "Can't match path with #{other.class.name}" unless other.is_a? Path
+            path == other.path
+          end
+
+          def ==(other)
+            raise ParamsReadyError, "Can't compare path with #{other.class.name}" unless other.is_a? Path
+            path == other.path && names == other.names
+          end
+        end
+
+        def initialize(alt_path, alt_names, std_path, std_names)
+          if alt_names.length != std_names.length
+            msg = "Expected equal number of alternative and standard names, got #{alt_names.length}/#{std_names.length}"
+            raise ParamsReadyError, msg
+          end
+
+          @alt = Path.new(alt_path, alt_names)
+          @std = Path.new(std_path, std_names)
+        end
+
+        def add_names(altn, stdn)
+          @alt.add_name altn
+          @std.add_name stdn
+        end
+
+        def remap(from, to, input, target)
+          path(from).names.each_with_index do |input_name, idx|
+            value = dig(from, input_name, input)
+            target_name = path(to).names[idx]
+            store(to, target_name, value, target)
+          end
+        end
+
+        def merge!(other)
+          raise ParamsReadyError, "Can't merge non_matching mapping" unless self =~ other
+
+          @alt.add_names(other.alt.names)
+          @std.add_names(other.std.names)
+        end
+
+        def dig(schema, name, hash)
+          path(schema).dig(name, hash)
+        end
+
+        def store(schema, name, value, hash)
+          path(schema).store(name, value, hash)
+        end
+
+        def path(schema)
+          case schema
+          when :alt then @alt
+          when :std then @std
+          else
+            raise ParamsReadyError, "Unexpected naming schema: #{schema}"
+          end
+        end
+
+        def =~(other)
+          raise ParamsReadyError, "Can't match path with #{other.class.name}" unless other.is_a? Mapping
+          return false unless path(:alt) =~ other.path(:alt)
+          return false unless path(:std) =~ other.path(:std)
+
+          true
+        end
+
+        protected
+        attr_reader :alt, :std
+      end
+
+      def initialize
+        @mappings = []
+      end
+
+      def map(from, to:)
+        alt_path, alt_names = self.class.split_map(from)
+        std_path, std_names = self.class.split_map(to)
+        mapping = Mapping.new(alt_path, alt_names, std_path, std_names)
+        merge_or_add_mapping(mapping)
+        self
+      end
+
+      def merge_or_add_mapping(mapping)
+        if (existing = @mappings.find { |candidate| candidate =~ mapping })
+          existing.merge!(mapping)
+        else
+          @mappings << mapping
+        end
+        mapping
+      end
+
+      def to_standard(hash)
+        remap(:alt, :std, hash)
+      end
+
+      def to_alternative(hash)
+        remap(:std, :alt, hash)
+      end
+
+      def remap(from, to, input)
+        @mappings.each_with_object({}) do |mapping, result|
+          mapping.remap(from, to, input, result)
+        end
+      end
+
+      def freeze
+        @mappings.each(&:freeze)
+        super
+      end
+
+      def self.split_map(array)
+        raise ParamsReadyError, "Array expected, got: #{array.class.name}" unless array.is_a? Array
+        names = array.last || []
+        raise ParamsReadyError, "Array expected, got: #{names.class.name}" unless names.is_a? Array
+        paths = array[0...-1]
+        [paths, names]
+      end
+    end
+  end
+end