params_ready_rails5 0.0.7

data/lib/params_ready/restriction.rb

@@ -0,0 +1,252 @@
+module ParamsReady
+  class Restriction
+    module Wrapper
+      extend Forwardable
+      attr_reader :restriction
+      def_delegators :restriction, :name_permitted?, :permitted?, :permissions_for
+
+      def delegate(*args)
+        return self if @restriction.everything?
+
+        new_restriction = @restriction.delegate(*args)
+        clone(restriction: new_restriction)
+      end
+
+      def for_children(parameter)
+        return self if @restriction.everything?
+
+        new_restriction = @restriction.for_children parameter
+        clone(restriction: new_restriction)
+      end
+
+      def permit_all
+        return self if @restriction.everything?
+
+        clone(restriction: Restriction.blanket_permission)
+      end
+
+      def permit(*list)
+        restriction = Restriction.permit(*list)
+        return self if @restriction.everything? && restriction.everything?
+
+        clone(restriction: restriction)
+      end
+
+      def prohibit(*list)
+        restriction = Restriction.prohibit(*list)
+        return self if @restriction.everything? && restriction.everything?
+
+        clone(restriction: restriction)
+      end
+
+      def to_restriction
+        @restriction
+      end
+    end
+
+    class Everything
+      def self.key?(_)
+        true
+      end
+
+      def self.[](_)
+        Everything
+      end
+
+      def self.dup
+        self
+      end
+    end
+
+    class Nothing
+      def self.key?(_)
+        false
+      end
+
+      def self.[](_)
+        Nothing
+      end
+
+      def self.dup
+        self
+      end
+    end
+
+    def self.blanket_permission
+      @blanket_permission ||= Allowlist.new
+    end
+
+    def self.permit(*args)
+      Allowlist.instance(*args)
+    end
+
+    def self.prohibit(*args)
+      Denylist.instance(*args)
+    end
+
+    def self.from_array(arr)
+      arr.each_with_object({}) do |element, restriction|
+        case element
+        when String, Symbol
+          restriction[element.to_sym] = Everything
+        when Hash
+          element.each do |key, value|
+            restriction[key.to_sym] = value
+          end
+        else
+          raise TypeError.new("Unexpected as restriction item: #{element}")
+        end
+      end
+    end
+
+    def self.instance(*list)
+      return blanket_permission if list.length == 1 && list[0] == default
+
+      restriction_list = if list.length == 1 && list[0].is_a?(Regexp)
+        list[0]
+      else
+        from_array(list)
+      end
+      new restriction_list
+    end
+
+    attr_reader :restriction
+
+    def initialize(restriction = self.class.default)
+      @restriction = if restriction.is_a? self.class
+        restriction.restriction
+      else
+        restriction.freeze
+      end
+      freeze
+    end
+
+    def hash
+      @restriction.hash
+    end
+
+    def everything?
+      @restriction == self.class.default
+    end
+
+    def name_listed?(name)
+      if @restriction.is_a? Regexp
+        name =~ @restriction
+      else
+        @restriction.key?(name)
+      end
+    end
+
+    def permitted?(parameter)
+      name = parameter.name
+      return false unless name_permitted?(name)
+      return true unless parameter.respond_to? :permission_depends_on
+
+      children = parameter.permission_depends_on
+      intent = parameter.intent_for_children(self)
+      children.all? do |child|
+        intent.permitted?(child)
+      end
+    end
+
+    def delegate(parent, delegate_name, *others)
+      return self if everything?
+
+      list = restriction_list_for(parent)
+
+      self.class.instance({ delegate_name => list }, *others)
+    end
+
+    def for_children(parameter)
+      return self if everything?
+
+      list = restriction_list_for(parameter)
+      if list.is_a? Restriction
+        list
+      else
+        self.class.instance(*list)
+      end
+    end
+
+    def restriction_list_for(parameter)
+      name = parameter.name
+      raise ParamsReadyError, "Parameter '#{name}' not permitted" unless name_permitted? name
+      restriction_list_for_name(name)
+    end
+
+    def to_restriction
+      self
+    end
+
+    def permit_all
+      self.class.permit_all
+    end
+
+    def self.permit_all
+      new default
+    end
+
+    class Allowlist < Restriction
+      def self.default
+        Everything
+      end
+
+      def name_permitted?(name)
+        name_listed?(name)
+      end
+
+      def permit(*args)
+        self.class.permit(*args)
+      end
+
+      def ==(other)
+        return false unless other.is_a? self.class
+        return true if object_id == other.object_id
+
+        restriction == other.restriction
+      end
+
+      protected
+
+      def restriction_list_for_name(name)
+        if @restriction.is_a? Regexp
+          self.class.default
+        else
+          @restriction[name]
+        end
+      end
+    end
+
+    class Denylist < Restriction
+      def self.default
+        Nothing
+      end
+
+      def name_permitted?(name)
+        return true unless name_listed?(name)
+        return false unless @restriction.is_a?(Hash)
+        return true if @restriction[name].is_a?(Array)
+        return true if @restriction[name].is_a?(Symbol)
+        return true if @restriction[name] == self.class.default
+
+        false
+      end
+
+      def prohibit(*args)
+        self.class.prohibit(*args)
+      end
+
+      protected
+
+      def restriction_list_for_name(name)
+        if @restriction.is_a? Regexp
+          self.class.default
+        elsif @restriction[name].nil?
+          self.class.default
+        else
+          @restriction[name]
+        end
+      end
+    end
+  end
+end

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,210 @@
+require 'date'
+require_relative '../error'
+require_relative '../extensions/late_init'
+require_relative '../extensions/finalizer'
+require_relative '../extensions/class_reader_writer'
+
+module ParamsReady
+  module Value
+    module Coercion
+      def try_coerce(input, context)
+        coerce input, context
+      rescue => _error
+        raise CoercionError.new(input, value_class_name)
+      end
+
+      def strict_default?
+        true
+      end
+    end
+
+    class AbstractCoder
+      extend Extensions::ClassReaderWriter
+
+      def self.value_class_name
+        last = self.name.split("::").last
+        last.remove('Coder')
+      end
+
+      class_reader_writer :type_identifier
+      type_identifier :value
+    end
+
+    class Coder < AbstractCoder
+      extend Coercion
+
+      def self.instance(**opts)
+        raise ParamsReadyError, "No options expected, got: #{opts}" unless opts.empty?
+
+        self
+      end
+
+      class Instantiable < AbstractCoder
+        include Coercion
+
+        def self.instance(**opts)
+          new **opts
+        end
+
+        def type_identifier
+          self.class.type_identifier
+        end
+
+        def strict_default?
+          self.class.strict_default?
+        end
+
+        def value_class_name
+          self.class.value_class_name
+        end
+      end
+    end
+
+    class GenericCoder
+      extend Extensions::LateInit
+      extend Extensions::Finalizer
+      include Extensions::Finalizer::InstanceMethods
+      include Coercion
+
+      def initialize(name)
+        @name = name
+        @coerce = nil
+        @format = nil
+        @type_identifier = nil
+      end
+
+      late_init(:coerce, getter: false)
+      late_init(:format, getter: false)
+      late_init(:type_identifier, obligatory: false)
+
+      def value_class_name
+        @name
+      end
+
+      def coerce(input, context)
+        @coerce[input, context]
+      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