otoroshi 0.0.4 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 22e2b21cfce2f6c2a95ef146e1d06b54d6c94d517069045262027de1e3511627
-  data.tar.gz: 6fe3ced425d76d05fd9e214871fadf8211b7b18d00d2c5fc5c20274cce9eb925
+  metadata.gz: e8733049cbcd069bfdb9ba26863300e6b5547f67dae40ead37c757536f60d3e2
+  data.tar.gz: 1e92ac383197980ba7e7579236525989a627dc9517ca3112e062a5fd5e09fc5e
 SHA512:
-  metadata.gz: 8aa7cd811fb08539425530d17c3633142b52a7602894708291cdeaea609c669340d43a8b645fd32a8b3b8679c2782a8ff2ef1cca8edfcaf6eb9dede7db36c2f8
-  data.tar.gz: ec5a6f08aece81a5be8b7db5e3ad5d2b10cf73800fd308f29cae84ad6650d21911f06fbe267a04a930a0b0f05c0900f816916d78bd6c4822e93576777899933f
+  metadata.gz: 54fd97b58be1a21e910d03fafa2c55bced96d549030c5014254674fbaec98f69633b9a0d9a698624f3d09259275920ee2f23bccc7a2425427547da20592b25a7
+  data.tar.gz: d9116888ba124a752fddbc1b31e1f11733931d4bd946beb7c9c159e43a60847da0337da32cb4172d4cbf25e44881e599478d97ef5405bd79c1507d08a2dbcc85

data/lib/otoroshi.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Otoroshi entry-point
+module Otoroshi
+  require_relative 'otoroshi/sanctuary'
+  require_relative 'otoroshi/exceptions'
+end

data/lib/otoroshi/exceptions.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative './initializer'
+
+module Otoroshi
+  class Error < StandardError; end
+
+  # Manages errors raised when value is not an instance of the expected class
+  class TypeError < Error
+    # @param property [Symbol] name of the property
+    # @param type [Class] class to match
+    # @example
+    #   ":number is not an instance of Integer"
+    def initialize(property, type)
+      super ":#{property} is not an instance of #{type}"
+    end
+  end
+
+  # Manages errors raised when value is not accepted (not in the "one_of")
+  class OneOfError < Error
+    # @param property [Symbol] name of the property
+    # @param values [Array] accepted values
+    # @example
+    #   ":fruit is not in [:apple, :pear]"
+    def initialize(property, values)
+      # reintegrate the colon for symbols which is lost during interpolation
+      to_s = ->(v) { v.is_a?(Symbol) ? ":#{v}" : v }
+      list = values.map { |v| to_s.call(v) }.join(', ')
+      super ":#{property} is not in [#{list}]"
+    end
+  end
+
+  # Manages errors raised when value does not pass the assertion
+  class AssertError < Error
+    # @param property [Symbol] name of the property
+    # @example
+    #   ":number does not respect the assertion"
+    def initialize(property)
+      super ":#{property} does not respect the assertion"
+    end
+  end
+
+  module Collection
+    # Manages errors raised when value should be an collection
+    class ArrayError < Error
+      # @param property [Symbol] name of the property
+      # @example
+      #   ":numbers is not an array"
+      def initialize(property)
+        super ":#{property} is not an array"
+      end
+    end
+
+    # Manages errors raised when at least one element of the collection is not an instance of the expected class
+    class TypeError < Error
+      # @param property [Symbol] name of the property
+      # @param type [Class] class to match
+      # @example
+      #   ":numbers contains elements that are not instances of Integer"
+      def initialize(property, type)
+        super ":#{property} contains elements that are not instances of #{type}"
+      end
+    end
+
+    # Manages errors raised when at least one element of the collection is not accepted (not in the "one_of")
+    class OneOfError < Error
+      # @param property [Symbol] name of the property
+      # @param values [Array] accepted values
+      # @example
+      #   ":fruits contains elements that are not in [:apple, :pear]"
+      def initialize(property, values)
+        # reintegrate the colon for symbols which is lost during interpolation
+        to_s = ->(v) { v.is_a?(Symbol) ? ":#{v}" : v }
+        list = values.map { |v| to_s.call(v) }.join(', ')
+        super ":#{property} contains elements that are not in [#{list}]"
+      end
+    end
+
+    # Manages errors raised when value does not pass the assertion
+    class AssertError < Error
+      # @param property [Symbol] name of the property
+      # @example
+      #   ":numbers contains elements that do not respect the assertion"
+      def initialize(property)
+        super ":#{property} contains elements that do not respect the assertion"
+      end
+    end
+  end
+end

data/lib/otoroshi/initializer.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Otoroshi
+  # Drawing of #initialize method
+  #
+  class Initializer
+    class << self
+      # Draw a stringified initialize method
+      #
+      # @param properties [Hash] a description of the class properties
+      #
+      # @return [String]
+      #
+      # @example
+      #   <<-RUBY
+      #   def initialize(number: 0, message:, fruits: [])
+      #     self.number = number
+      #     self.message = message
+      #     self.fruits = fruits
+      #     bind = self
+      #     @fruits.singleton_class.send(:define_method, :<<) do |v|
+      #       bind.send(:"validate_fruits!", [v])
+      #       push(v)
+      #     end
+      #   end
+      #   RUBY
+      def draw(properties)
+        new(properties).draw
+      end
+    end
+
+    # Initialize an instance
+    #
+    # @param properties [Hash] a description of the class properties
+    def initialize(properties = {})
+      @properties = properties
+    end
+
+    # Draws a stringified initialize method
+    #
+    # @return [String]
+    #
+    # @example
+    #   <<-RUBY
+    #   def initialize(foo:, bar: 0)
+    #     self.foo = foo
+    #     self.bar = bar
+    #   end
+    #   RUBY
+    def draw
+      <<~RUBY
+        def initialize(#{initialize_parameters})
+          #{initialize_assignments}
+          #{initialize_push_singletons}
+        end
+      RUBY
+    end
+
+    private
+
+    attr_reader :properties
+
+    # Generates initialize method parameters
+    #
+    # @return [String]
+    #
+    # @example
+    #   "foo:, bar: 0"
+    def initialize_parameters
+      parameters =
+        properties.map do |key, options|
+          "#{key}:#{default_parameter_for(options)}"
+        end
+      parameters.join(', ')
+    end
+
+    # Generates the default value of a parameter depending on options
+    #
+    # @return [String]
+    #
+    # @example when nil is allowed and default is set
+    #   " \"default\""
+    # @example when nil is allowed and default is not set
+    #   " nil"
+    # @example when nil is not allowed
+    #   ""
+    def default_parameter_for(options)
+      default, allow_nil = options.values_at(:default, :allow_nil)
+      if default.nil?
+        allow_nil ? ' nil' : ''
+      else
+        " #{prefix(default)}#{default}#{suffix(default)}"
+      end
+    end
+
+    # Generates the characters to put before the value
+    # @note it avoids symbol without colon or string without quotes
+    #   which would be interpreted as methods
+    def prefix(default)
+      case default
+      when Symbol then ':'
+      when String then '"'
+      end
+    end
+
+    # Generates the characters to put after the value
+    # @note it avoids string without quotes which would be interpreted as method
+    def suffix(default)
+      case default
+      when String then '"'
+      end
+    end
+
+    # Generates initialize method assignments
+    #
+    # @return [String]
+    #
+    # @example Given properties { foo: { allow_nil: false, default: nil }, { allow_nil: true, default: 0 } }
+    #   <<-RUBY
+    #   self.foo = foo
+    #   self.bar = bar
+    #   RUBY
+    def initialize_assignments
+      assignments =
+        properties.keys.map do |name|
+          "self.#{name} = #{name}"
+        end
+      assignments.join("\n  ")
+    end
+
+    # Generates push singleton for each array property
+    #
+    # @return [String]
+    #
+    # @example
+    #   <<-RUBY
+    #   bind = self
+    #   @fruits.singleton_class.send(:define_method, :<<) do |v|
+    #     bind.send(:"validate_fruits!", [v])
+    #     push(v)
+    #   end
+    #   @numbers.singleton_class.send(:define_method, :<<) do |v|
+    #     bind.send(:"validate_numbers!", [v])
+    #     push(v)
+    #   end
+    #   RUBY
+    def initialize_push_singletons
+      collections =
+        properties.select do |_, options|
+          options[:type].is_a?(Array) || options[:type] == Array
+        end
+      return if collections.empty?
+
+      singletons =
+        collections.keys.map do |name|
+          initialize_push_singleton(name)
+        end
+      # assign self to a variable so the instance is accessible from the singleton scope
+      ['bind = self', singletons.join].join("\n")
+    end
+
+    # Generates singleton on collection instance variable to overide <<
+    # so value is validated before being added to the collection
+    #
+    # @return [String]
+    #
+    # @example
+    #   <<-RUBY
+    #   @fruits.singleton_class.send(:define_method, :<<) do |v|
+    #     bind.send(:"validate_fruits!", [v])
+    #     push(v)
+    #   end
+    #   RUBY
+    def initialize_push_singleton(name)
+      <<-RUBY
+  @#{name}.singleton_class.send(:define_method, :<<) do |v|
+    bind.send(:"validate_#{name}!", [v])
+    push(v)
+  end
+      RUBY
+    end
+  end
+end

data/lib/otoroshi/sanctuary.rb

@@ -1,16 +1,22 @@
 # frozen_string_literal: true
 
+require_relative 'initializer'
+
 module Otoroshi
-  # This module is designed to be included in a class. This will provide
+  # This module is designed to be in a class. This will provide
   # the "property" ({Sanctuary::ClassMethods.property}) method for defining class properties.
+  #
   # @example
   #   class Importer
   #     include Otoroshi::Sanctuary
   #
-  #     property :file_path, String, validate: ->(v) { v.match? /.+\.csv/ }
-  #     property :headers, [TrueClass, FalseClass], default: false
-  #     property :col_sep, String, validate: ->(v) { v.in? [',', ';', '\s', '\t', '|'] }, default: ','
-  #     property :converters, Symbol, validate: ->(v) { v.in? %i[integer float date] }, allow_nil: true
+  #     property :whatever
+  #     property :number, Integer
+  #     property :numbers, [Integer]
+  #     property :positive_number, Integer, verify: ->(v) { v >= 0 }
+  #     property :number_or_nil, Integer, allow_nil: true
+  #     property :number_with_default, Integer, default: 42
+  #     property :number_in_collection, Integer, one_of: [1, 2, 3, 5, 8, 13, 21, 34]
   #   end
   module Sanctuary
     class << self
@@ -23,125 +29,188 @@ module Otoroshi
     # Class methods extended for the base class
     module ClassMethods
       # Adds a new "property" to the class
+      #
       # @param name [Symbol] the property name
-      # @param type [Class] the expected value type
-      # @param validate [Proc] a lambda processing the value and returning true or false
+      # @param type [Class, Array<Class>] the expected value or values type
+      # @param one_of [Array] the accepted values
+      # @param assert [Proc] a lambda processing the value and returning true or false
       # @param allow_nil [true, false] allow nil as a value
       # @param default [Object] default value if not set on initialization
+      #
       # @return [void]
+      #
       # @example
-      #   property name, type: String, validate: ->(v) { v.length > 3 }, allow_nil: true
+      #   property name, type: String, assert: ->(v) { v.length > 3 }, allow_nil: true
       # @example
-      #   property score, type: Integer, validate: ->(v) { v >= 0 }, default: 0
-      def property(name, type = Object, validate: ->(_) { true }, allow_nil: false, default: nil)
-        add_to_properties(name, allow_nil, default)
-        define_validate_type!(name, type, allow_nil)
-        define_validate_lambda!(name, validate, allow_nil)
+      #   property scores, type: [Integer], assert: ->(v) { v >= 0 }, default: []
+      def property(name, type = Object, one_of: nil, assert: ->(_) { true }, allow_nil: false, default: nil)
+        add_to_properties(name, type, allow_nil, default)
+        expected_type = type.is_a?(Array) ? type.first || Object : type
+        collection = expected_type == Array || type.is_a?(Array)
+        define_validate_type!(name, expected_type, collection, allow_nil)
+        define_validate_one_of!(name, collection, one_of, allow_nil)
+        define_validate_assertion!(name, collection, assert, allow_nil)
+        define_validate!(name)
         define_getter(name)
         define_setter(name)
-        redefine_initialize
+        puts Initializer.draw(properties)
+        class_eval Initializer.draw(properties), __FILE__, __LINE__ + 1
       end
 
-      # Returns the class properties
+      # Class properties
+      #
       # @return [Hash]
-      # @note this method will be updated by {add_to_properties}
+      #
+      # @example
+      #   {
+      #     number: { type: Integer, allow_nil: false, default: 0 },
+      #     message: { type: Integer, allow_nil: true, default: nil }
+      #   }
       def properties
         {}
       end
 
       private
 
-      # Updates {properties} to add new property to the returned ones
-      # @return [void]
-      def add_to_properties(name, allow_nil, default)
+      # Adds a properties to the {properties}
+      def add_to_properties(name, type, allow_nil, default)
         current_state = properties
-        current_state[name] = { allow_nil: allow_nil, default: default }
+        current_state[name] = {
+          type: type,
+          allow_nil: allow_nil,
+          default: default
+        }
         define_singleton_method(:properties) { current_state }
       end
 
-      # Defines a private method that raises an error if type is not respected
-      # @param name [Symbol] the property name
-      # @param type [Class] the type to test against
-      # @param allow_nil [true, false] allow nil as a value
-      # @return [void]
-      # @example
-      #   define_validate_type!(score, Integer, false) => def validate_score_type!(value) ...
-      # @example Generated method
+      # Defines a private method that validates type condition
+      #
+      #   Given name = :score, type = Integer, allow_nil = false
+      #
       #   def validate_score_type!(value)
       #     return if Integer.nil? || false && value.nil?
       #     return if value.is_a? Integer
       #
-      #     raise ArgumentError, ":score does not match required type"
+      #     raise Otoroshi::TypeError, :score, Integer
       #   end
-      def define_validate_type!(name, type, allow_nil)
-        lambda = type_validation(type)
+      def define_validate_type!(name, type, collection, allow_nil)
+        validator = validate_type?(name, type, collection)
         define_method :"validate_#{name}_type!" do |value|
-          return if type.nil? || allow_nil && value.nil?
-          return if lambda.call(value)
-
-          raise ArgumentError, ":#{name} does not match required type"
+          allow_nil && value.nil? || validator.call(value)
         end
         private :"validate_#{name}_type!"
       end
 
-      # Defines a lambda to be call to validate that value matches the type
-      # @param type [Class] the type to test against
-      # @return [Proc] the lambda to use in order to test the value matches the type
-      # @example
-      #   type_validation(Integer) #=> ->(v) { v.is_a? Integer }
-      # @example
-      #   type_validation([String, Symbol]) #=> ->(v) { [String, Symbol].any? { |t| v.is_a? t } }
-      def type_validation(type)
-        if type.is_a? Array
-          ->(v) { type.any? { |t| v.is_a? t } }
+      # Lambda that validates (value) respects the type condition
+      # @return [Proc]
+      def validate_type?(name, type, collection)
+        if collection
+          # validate each element of (v) is an instance of the type
+          lambda do |v|
+            v.is_a?(Array) || raise(Otoroshi::Collection::ArrayError, name)
+            v.all? { |elt| elt.is_a? type } || raise(Otoroshi::Collection::TypeError.new(name, type))
+          end
         else
-          ->(v) { v.is_a? type }
+          # validate (v) is an instance of the type
+          ->(v) { v.is_a?(type) || raise(Otoroshi::TypeError.new(name, type)) }
         end
       end
 
-      # Defines a private method that raises an error if validate block returns false
-      # @param name [Symbol] the property name
-      # @param validate [Proc] a lambda processing the value and returning true or false
-      # @param allow_nil [true, false] allow nil as a value
-      # @return [void]
-      # @example
-      #   define_validate_lambda!("score", ->(v) { v >= 0 }, false) #=> def validate_score_lambda!(value) ...
-      # @example Generated instance method
-      #   def validate_score_lambda!(value)
+      # Defines a private method that validates one_of condition
+      #
+      #   Given name = :side, collection = false, one_of = [:left, :right], allow_nil = false
+      #
+      #   def validate_side_type!(value)
+      #     return if false && value.nil?
+      #     return if [:left, :right].include? value
+      #
+      #     raise Otoroshi::OneOfError, :side, [:left, :right]
+      #   end
+      def define_validate_one_of!(name, collection, one_of, allow_nil)
+        validator = validate_one_of?(name, one_of, collection)
+        define_method(:"validate_#{name}_one_of!") do |value|
+          allow_nil && value.nil? || validator.call(value)
+        end
+        private :"validate_#{name}_one_of!"
+      end
+
+      # Lambda that validates (value) respects the one_of condition
+      # @return [Proc]
+      def validate_one_of?(name, one_of, collection)
+        return ->(_) {} unless one_of
+
+        if collection
+          lambda do |v|
+            v.all? { |e| one_of.include? e } || raise(Otoroshi::Collection::OneOfError.new(name, one_of))
+          end
+        else
+          lambda do |v|
+            one_of.include?(v) || raise(Otoroshi::OneOfError.new(name, one_of))
+          end
+        end
+      end
+
+      # Defines a private method that validates assert condition
+      #
+      #   Given name = :score, assert = ->(v) { v >= 0 }, allow_nil = false
+      #
+      #   def validate_score_assertion!(value)
       #     return if false && value.nil?
       #     return if value >= 0
       #
-      #     raise ArgumentError, ":score does not match validation"
+      #     raise Otoroshi::AssertError, :score
       #   end
-      def define_validate_lambda!(name, validate, allow_nil)
-        define_method :"validate_#{name}_lambda!" do |value|
-          return if allow_nil && value.nil?
-          return if instance_exec(value, &validate)
+      def define_validate_assertion!(name, collection, assert, allow_nil)
+        validator = validate_assert?(name, assert, collection)
+        define_method :"validate_#{name}_assertion!" do |value|
+          allow_nil && value.nil? || validator.call(value)
+        end
+        private :"validate_#{name}_assertion!"
+      end
 
-          raise ArgumentError, ":#{name} does not match validation"
+      # Lambda that validates (value) respects the assert condition
+      # @return [Proc]
+      def validate_assert?(name, assert, collection)
+        if collection
+          ->(v) { v.all? { |e| instance_exec(e, &assert) } || raise(Otoroshi::Collection::AssertError, name) }
+        else
+          ->(v) { instance_exec(v, &assert) || raise(Otoroshi::AssertError, name) }
         end
-        private :"validate_#{name}_lambda!"
       end
 
-      # Defines a getter method for the property
-      # @param name [Symbol] the property name
-      # @return [void]
-      # @example
-      #   define_getter(:score) #=> def score ...
-      # @example Generated instance method
-      #     def score
-      #       instance_variable_get(@score)
-      #     end
+      # Defines a private method that calls all validations
+      #
+      #   Given name = :score
+      #
+      #   def validate_score!(value)
+      #     validate_score_type!(value)
+      #     validate_score_one_of!(value)
+      #     validate_score_assert(value)
+      #   end
+      def define_validate!(name)
+        define_method :"validate_#{name}!" do |value|
+          __send__(:"validate_#{name}_type!", value)
+          __send__(:"validate_#{name}_one_of!", value)
+          __send__(:"validate_#{name}_assertion!", value)
+        end
+        private :"validate_#{name}!"
+      end
+
+      # Defines a getter
+      #
+      #   Given name = :score
+      #
+      #   def score
+      #     instance_variable_get(@score)
+      #   end
       def define_getter(name)
         define_method(name) { instance_variable_get("@#{name}") }
       end
 
-      # Defines a setter method for the property
-      # @param name [Symbol] the property name
-      # @return [void]
-      # @example
-      #   define_getter(:score) #=> def score=(value) ...
-      # @example Generated instance method
+      # Defines a setter
+      #
+      #   Given name = :score
+      #
       #   def score=(value)
       #     validate_score_type!(value)
       #     validate_score!(value)
@@ -149,63 +218,10 @@ module Otoroshi
       #   end
       def define_setter(name)
         define_method :"#{name}=" do |value|
-          __send__(:"validate_#{name}_type!", value)
-          __send__(:"validate_#{name}_lambda!", value)
+          __send__(:"validate_#{name}!", value)
           instance_variable_set("@#{name}", value)
         end
       end
-
-      # Redefines initialize method
-      # @return [void]
-      # @note method is defined with `class_eval`
-      # @example Generated method
-      #   def initialize(foo:, bar: 0)
-      #     self.foo = foo
-      #     self.bar = bar
-      #   end
-      def redefine_initialize
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def initialize(#{initialize_parameters})
-            #{initialize_body}
-          end
-        RUBY
-      end
-
-      # Defines initialize method parameters
-      # @return [String]
-      # @example Given properties { foo: { allow_nil: false, default: nil }, { allow_nil: true, default: 0 } }
-      #   redefine_initialize #=> "foo:, bar: 0"
-      def initialize_parameters
-        parameters =
-          properties.map do |key, options|
-            allow_nil, default = options.values
-            "#{key}:#{default_parameter_for(allow_nil, default)}"
-          end
-        parameters.join(', ')
-      end
-
-      # Defines the default value of a parameter depending on options
-      # @param options [Hash]
-      # @return [String]
-      # @example when nil is allowed and default is set
-      #   default_parameter_for(true, 0) #=> " 0"
-      # @example when nil is allowed and default is not set
-      #   default_parameter_for(true, nil) #=> " nil"
-      # @example when nil is not allowed
-      #   default_parameter_for(false, nil) #=> ""
-      def default_parameter_for(allow_nil, default)
-        return " #{default}" if default
-
-        allow_nil ? ' nil' : ''
-      end
-
-      # Defines initialize method body
-      # @return [String]
-      # @example Given properties { foo: { allow_nil: false, default: nil }, { allow_nil: true, default: 0 } }
-      #   initialize_body #=> "self.foo = foo\nself.bar = bar"
-      def initialize_body
-        properties.keys.map { |key| "self.#{key} = #{key}" }.join("\n")
-      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: otoroshi
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.9
 platform: ruby
 authors:
 - Edouard Piron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-10 00:00:00.000000000 Z
+date: 2020-10-16 00:00:00.000000000 Z
 dependencies: []
 description: Help defining class properties
 email: ed.piron@gmail.com
@@ -16,6 +16,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/otoroshi.rb
+- lib/otoroshi/exceptions.rb
+- lib/otoroshi/initializer.rb
 - lib/otoroshi/sanctuary.rb
 homepage: https://rubygems.org/gems/otoroshi
 licenses: