params_ready 0.0.1

data/lib/params_ready/result.rb

@@ -0,0 +1,109 @@
+require_relative 'error'
+
+module ParamsReady
+  class AbstractReporter
+    attr_reader :name
+
+    def initialize(name)
+      @name = name.to_s.freeze
+    end
+
+    def error!(err)
+      report_error(nil, err)
+    end
+
+    def full_path(path)
+      return [name] if path.nil? || path.empty?
+      [name, *path]
+    end
+
+    def for_child(name)
+      Reporter.new name, self
+    end
+  end
+
+  class Result < AbstractReporter
+    class Error < ParamsReadyError; end
+
+    def initialize(name)
+      super
+      @errors = []
+      @children = {}
+    end
+
+    def full_scope(scope)
+      return name if scope.empty?
+
+      "#{scope}.#{name}"
+    end
+
+    def errors(scope = '')
+      scope = full_scope(scope)
+      proper = @errors.empty? ? {} : { scope => @errors }
+      @children.values.reduce(proper) do |result, child|
+        result.merge(child.errors(scope))
+      end
+    end
+
+    def report_error(path, err)
+      raise ParamsReadyError, "Is not Error: #{err}" unless err.is_a? StandardError
+
+      name, *path = path
+      if name.nil?
+        @errors << err
+      else
+        @children[name] ||= Result.new(name)
+        @children[name].report_error(path, err)
+      end
+    end
+
+    def ok?
+      return false unless @errors.empty?
+
+      @children.values.all? do |child|
+        child.ok?
+      end
+    end
+
+    def child_ok?(path)
+      name, *path = path
+      return ok? if name.nil?
+      return true unless @children.key? name
+
+      @children[name].child_ok?(path)
+    end
+
+    def error
+      return nil if ok?
+
+      Result::Error.new(error_messages(' -- '))
+    end
+
+    def error_messages(separator = "\n")
+      errors.flat_map do |scope, errors|
+        ["errors for #{scope}"] + errors.map { |err| err.message }
+      end.join(separator)
+    end
+  end
+
+  class Reporter < AbstractReporter
+    attr_reader :name
+
+    def initialize(name, parent)
+      super name
+      @parent = parent
+    end
+
+    def ok?
+      child_ok?(nil)
+    end
+
+    def child_ok?(path)
+      @parent.child_ok?(full_path(path))
+    end
+
+    def report_error(path, err)
+      @parent.report_error(full_path(path), err)
+    end
+  end
+end

data/lib/params_ready/value/coder.rb

@@ -0,0 +1,181 @@
+require 'date'
+require_relative '../error'
+require_relative '../extensions/late_init'
+require_relative '../extensions/finalizer'
+require_relative '../extensions/class_reader_writer'
+
+module ParamsReady
+  module Value
+    class Coder
+      extend Extensions::ClassReaderWriter
+
+      class_reader_writer :type_identifier
+      type_identifier :value
+
+      def self.value_class_name
+        last = self.name.split("::").last
+        last.remove('Coder')
+      end
+
+      def self.try_coerce(input, context)
+        coerce input, context
+      rescue => _error
+        raise CoercionError.new(input, value_class_name)
+      end
+
+      def self.strict_default?
+        true
+      end
+    end
+
+    class GenericCoder
+      extend Extensions::LateInit
+      extend Extensions::Finalizer
+      include Extensions::Finalizer::InstanceMethods
+
+      def initialize(name)
+        @name = name
+        @coerce = nil
+        @format = nil
+        @type_identifier = nil
+      end
+
+      def strict_default?; true; end
+
+      late_init(:coerce, getter: false)
+      late_init(:format, getter: false)
+      late_init(:type_identifier, obligatory: false)
+
+      def value_class_name
+        @name
+      end
+
+      def try_coerce(input, context)
+        @coerce[input, context]
+      rescue => _error
+        raise CoercionError.new(input, @name)
+      end
+
+      def format(value, format)
+        @format[value, format]
+      end
+
+      def finish
+        super
+        freeze
+      end
+    end
+  
+    class IntegerCoder < Coder
+      type_identifier :number
+
+      def self.coerce(input, _)
+        return nil if input.nil? || input == ''
+        Integer(input)
+      end
+  
+      def self.format(value, format)
+        value.to_s
+      end
+    end
+  
+    class DecimalCoder < Coder
+      type_identifier :number
+
+      def self.coerce(input, _)
+        return nil if input.nil? || input == ''
+        BigDecimal(input)
+      end
+  
+      def self.format(value, format)
+        value.to_s('F')
+      end
+    end
+  
+    class BooleanCoder < Coder
+      type_identifier :boolean
+
+      def self.coerce(input, _)
+        return nil if input.nil? || input == ''
+        return input if input.is_a?(TrueClass) || input.is_a?(FalseClass)
+        str = input.to_s
+        case str
+        when 'true', 'TRUE', 't', 'T', '1'
+          true
+        when 'false', 'FALSE', 'f', 'F', '0'
+          false
+        else
+          raise
+        end
+      end
+  
+      def self.format(value, format)
+        value.to_s
+      end
+    end
+  
+    class StringCoder < Coder
+      def self.coerce(input, _)
+        input.to_s
+      end
+  
+      def self.format(value, _)
+        value
+      end
+    end
+  
+    class SymbolCoder < Coder
+      type_identifier :symbol
+
+      def self.coerce(input, _)
+        input.to_sym
+      end
+  
+      def self.format(value, format)
+        value.to_s
+      end
+    end
+  
+    class DateCoder < Coder
+      type_identifier :date
+
+      def self.coerce(input, _)
+        return nil if input.nil? || input == ''
+        if input.is_a?(Numeric)
+          Time.at(input).to_date
+        elsif input.is_a?(String)
+          Date.parse(input)
+        elsif input.respond_to?(:to_date)
+          input.to_date
+        else
+          raise ParamsReadyError, "Unimplemented for type #{input.class.name}"
+        end
+      end
+  
+      def self.format(value, format)
+        value.to_s
+      end
+    end
+  
+    class DateTimeCoder < Coder
+      type_identifier :date
+
+      def self.coerce(input, _)
+        return nil if input.nil? || input == ''
+        if input.is_a?(Numeric)
+          Time.at(input).to_datetime
+        elsif input.is_a?(String)
+          DateTime.parse(input)
+        elsif input.respond_to?(:to_datetime)
+          input.to_datetime
+        else
+          raise ParamsReadyError, "Unimplemented for type #{input.class.name}"
+        end
+      end
+  
+      def self.format(value, format)
+        value.to_s
+      end
+    end
+  end
+end

data/lib/params_ready/value/constraint.rb

@@ -0,0 +1,198 @@
+require 'set'
+require_relative '../extensions/undefined'
+require_relative '../extensions/registry'
+require_relative '../error'
+
+module ParamsReady
+  module Value
+
+    class Constraint
+      class Error < ParamsReadyError; end
+
+      extend Extensions::Registry
+      registry :constraint_types, as: :constraint_type, getter: true
+
+      def self.register(name)
+        Constraint.register_constraint_type(name, self)
+      end
+
+      attr_reader :condition
+
+      def initialize(cond)
+        @condition = cond.freeze
+        freeze
+      end
+
+      def clamp?; false; end
+
+      def self.build(cond, *args, **opts, &block)
+        if block.nil?
+          new cond, *args, **opts
+        else
+          new cond, block, *args, **opts
+        end
+      end
+
+      def self.instance(cond, *args, **opts)
+        case cond
+        when Range
+          RangeConstraint.new(cond, *args, **opts)
+        when Array, Set
+          EnumConstraint.new(cond, *args, **opts)
+        else
+          raise ParamsReadyError, "Unknown constraint type: " + cond.class.name
+        end
+      end
+
+      def valid?(input)
+        raise ParamsReadyError, 'This is an abstract class'
+      end
+
+      def error_message
+        "didn't pass validation"
+      end
+    end
+
+    class RangeConstraint < Constraint
+      register :range
+
+      def initialize(cond, *args, **opts)
+        raise ParamsReadyError, "Expected Range, got: " + cond.class.name unless cond.is_a?(Range)
+        super cond, *args, **opts
+      end
+
+      def valid?(input)
+        @condition.include?(input)
+      end
+
+      def error_message
+        'not in range'
+      end
+
+      def clamp(value)
+        if value < @condition.min
+          @condition.min
+        elsif value > @condition.max
+          @condition.max
+        else
+          value
+        end
+      end
+
+      def clamp?
+        return false if @condition.min.nil? || @condition.max.nil?
+
+        true
+      end
+    end
+
+    class EnumConstraint < Constraint
+      register :enum
+
+      def initialize(cond, *args, **opts)
+        raise ParamsReadyError, "Expected Set or Array, got: " + cond.class.name unless
+          cond.is_a?(Set) ||
+          cond.is_a?(Array)
+        super cond, *args, **opts
+      end
+
+      def valid?(input)
+        if input.is_a?(String)
+          @condition.include?(input) || @condition.include?(input.to_sym)
+        else
+          @condition.include?(input)
+        end
+      end
+
+      def error_message
+        'not in enum'
+      end
+    end
+
+    class OperatorConstraint < Constraint
+      register :operator
+
+      OPERATORS = [:=~, :<, :<=, :==, :>=, :>].to_set.freeze
+
+      def initialize(operator, value, *args, **opts)
+        unless OPERATORS.member? operator
+          raise ParamsReadyError, "Unsupported operator: #{operator}"
+        end
+        cond = Condition.instance(operator, value)
+        super(cond, *args, **opts)
+      end
+
+      def clamp(value)
+        return value if valid?(value)
+
+        @condition.clamp(value)
+      end
+
+      def clamp?
+        @condition.clamp?
+      end
+
+      def valid?(input)
+        @condition.true?(input)
+      end
+
+      def error_message
+        @condition.error_message
+      end
+
+      module ClampingCondition
+        CLAMPING_OPERATORS = %i(<= == >=).to_set.freeze
+        def clamp(_)
+          case @operator
+          when :<=, :>=, :==
+            get_value
+          else
+            raise "Unexpected operator: #{@operator}"
+          end
+        end
+
+        def clamp?
+          CLAMPING_OPERATORS.member? @operator
+        end
+      end
+
+      class Condition
+        include ClampingCondition
+
+        def initialize(operator, value)
+          @operator = operator
+          @value = value
+        end
+
+        def true?(input)
+          input.send(@operator, get_value)
+        end
+
+        def error_message
+          "not #{@operator} #{get_value}"
+        end
+
+        def self.instance(operator, value)
+          case value
+          when Method, Proc
+             DynamicCondition.new operator, value
+          else
+             StaticCondition.new operator, value
+          end
+        end
+      end
+
+      class StaticCondition < Condition
+        def get_value
+          @value
+        end
+      end
+
+      class DynamicCondition < Condition
+        def get_value
+          @value.call
+        end
+      end
+    end
+  end
+end