otoroshi 0.0.8 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fba1623080c055e87c2055001a7f2370e459b5fe1a28774375cef3dd9e7da802
-  data.tar.gz: 4c01c52a123157e572b4fdcef7c2e7eb6f0cc6ef2162e49237b5a49785708b70
+  metadata.gz: 631d80a9acb35b29a4f484aaf3ac8939f4aec80266ae85ec3ae1ba8025134789
+  data.tar.gz: 5fbb90ac33bfdd9ab712e5778479d3acca98486ec926761eddd5821c9fe251c2
 SHA512:
-  metadata.gz: 8b89127bff4d54b14be27fe723db61e6f0786b7f0f9f6d4df612ed49b3d86d59f1a1df55038178662e5ce247c4b2f6af16b35e05650730d8b9889debd354ed48
-  data.tar.gz: 177fbc07e846a1cb9cbc7b3e595ce5c0878ff153d6293d9e0ccf986745a0b898e3b2a9be144218b97425ad87b78b4170848b20496ca39bf232ee898f5b1fcb19
+  metadata.gz: 886d405d6229444887764ac8b07142e08ca9f78ceeb8f73217ed3a52b3782a303e56f5ec920bf749d7f32057bbc2030a1f0f47df7f33904eba63681d82e01e2f
+  data.tar.gz: d01ba382078e0dac14e9a1e2965c85c659cc6bd14e99a986746c209ff4b8982bbe62e2d2194b15c57919555378aa31e6b42331af32e3208e48155c716b7183a3

data/lib/otoroshi.rb

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

data/lib/otoroshi/exceptions.rb

@@ -1,73 +1,89 @@
 # frozen_string_literal: true
 
+require_relative './initializer'
+
 module Otoroshi
   class Error < StandardError; end
 
-  # Manages errors raised when value type is not as expected
-  class WrongTypeError < Error
-    # Initialize an error
-    #
+  # 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
-    # @param collection [true, false] define if it is a collection
-    def initialize(property, type, collection: false)
-      expected_type = type.is_a?(Array) ? type.first || Object : type
-      msg =
-        if collection
-          ":#{property} contains elements that are not instances of #{expected_type}"
-        else
-          ":#{property} is not an instance of #{expected_type}"
-        end
-      super(msg)
-    end
-  end
-
-  # Manages errors raised when value should be an collection
-  class NotAnArray < Error
-    # Initialize an error
-    #
-    # @param property [Symbol] name of the property
-    def initialize(property)
-      msg = ":#{property} is not an array"
-      super(msg)
+    # @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 included in the "one_of")
-  class NotAcceptedError < Error
-    # Initialize an error
-    #
+  # Manages errors raised when value is not accepted (not in the "one_of")
+  class OneOfError < Error
     # @param property [Symbol] name of the property
-    # @param accepted_values [Array] accepted values
-    # @param collection [true, false] define if it is an collection
-    def initialize(property, accepted_values, collection: false)
+    # @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 }
-      accepted_values_list = accepted_values.map { |v| to_s.call(v) }.join(', ')
-      msg =
-        if collection
-          ":#{property} contains elements that are not included in [#{accepted_values_list}]"
-        else
-          ":#{property} is not included in [#{accepted_values_list}]"
-        end
-      super(msg)
+      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 AssertionError < Error
-    # Initialize an error
-    #
+  class AssertError < Error
     # @param property [Symbol] name of the property
-    # @param collection [true, false] define if it is an collection
-    def initialize(property, collection: false)
-      msg =
-        if collection
-          ":#{property} contains elements that do not respect the assertion"
-        else
-          ":#{property} does not respect the assertion"
-        end
-      super(msg)
+    # @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

@@ -13,9 +13,10 @@ module Otoroshi
       #
       # @example
       #   <<-RUBY
-      #   def initialize(foo:, bar: 0)
-      #     self.foo = foo
-      #     self.bar = bar
+      #   def initialize(number: 0, message:, fruits: [])
+      #     self.number = number
+      #     self.message = message
+      #     self.fruits = fruits
       #   end
       #   RUBY
       def draw(properties)
@@ -42,10 +43,9 @@ module Otoroshi
     #   end
     #   RUBY
     def draw
-      <<-RUBY
+      <<~RUBY
         def initialize(#{initialize_parameters})
-          #{initialize_assignments}
-          #{initialize_push_singletons}
+          #{initialize_body}
         end
       RUBY
     end
@@ -58,8 +58,8 @@ module Otoroshi
     #
     # @return [String]
     #
-    # @example Given properties { foo: { allow_nil: false, default: nil }, { allow_nil: true, default: 0 } }
-    #   redefine_initialize #=> "foo:, bar: 0"
+    # @example
+    #   "foo:, bar: 0"
     def initialize_parameters
       parameters =
         properties.map do |key, options|
@@ -68,23 +68,41 @@ module Otoroshi
       parameters.join(', ')
     end
 
-    # Fixes the default value of a parameter depending on options
+    # Generates the default value of a parameter depending on options
     #
     # @return [String]
     #
     # @example when nil is allowed and default is set
-    #   default_parameter_for #=> " 0"
+    #   " \"default\""
     # @example when nil is allowed and default is not set
-    #   default_parameter_for #=> " nil"
+    #   " nil"
     # @example when nil is not allowed
-    #   default_parameter_for #=> ""
+    #   ""
     def default_parameter_for(options)
       default, allow_nil = options.values_at(:default, :allow_nil)
-      if default
-        symbol_prefix = default.is_a?(Symbol) ? ':' : ''
-        " #{symbol_prefix}#{default}"
-      else
-        allow_nil ? ' nil' : ''
+      return ' nil' if default.nil? && allow_nil
+      return '' if default.nil? && !allow_nil
+
+      " #{prefix(default)}#{default}#{suffix(default)}"
+    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 '"'
+      when Time, Date, DateTime 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 '"'
+      when Time, Date, DateTime then '"'
       end
     end
 
@@ -93,45 +111,16 @@ module Otoroshi
     # @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_assignments
+    #   <<-RUBY
+    #   self.foo = foo
+    #   self.bar = bar
+    #   RUBY
+    def initialize_body
       assignments =
         properties.keys.map do |name|
           "self.#{name} = #{name}"
         end
-      assignments.join("\n")
-    end
-
-    # Generates push singleton for each array property
-    #
-    # @return [String]
-    def initialize_push_singletons
-      collections =
-        properties.select do |_, options|
-          options[:type].is_a?(Array) || options[:type] == Array
-        end
-      singletons =
-        collections.keys.map do |name|
-          initialize_push_singleton(name)
-        end
-      singletons.join("\n")
-    end
-
-    # Generates singleton on collection instance variable to overide <<
-    # so value is validated before being added to the collection
-    #
-    # @return [String]
-    def initialize_push_singleton(name)
-      <<-RUBY
-      bind = self
-      @#{name}.singleton_class.send(:define_method, :<<) do |v|
-        bind.send(:"validate_#{name}_type!", [v])
-        bind.send(:"validate_#{name}_inclusion!", [v])
-        bind.send(:"validate_#{name}_assertion!", [v])
-
-        push(v)
-      end
-      RUBY
+      assignments.join("\n  ")
     end
   end
 end

data/lib/otoroshi/sanctuary.rb

@@ -3,7 +3,7 @@
 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
@@ -45,29 +45,33 @@ module Otoroshi
       #   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)
-        collection = type == Array || type.is_a?(Array)
-        define_validate_type!(name, type, collection, allow_nil)
-        define_validate_inclusion!(name, collection, one_of, allow_nil)
-        define_validate_assertion!(name, collection, assert, allow_nil)
+        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)
         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]
+      # Adds a properties to the {properties}
       def add_to_properties(name, type, allow_nil, default)
         current_state = properties
         current_state[name] = {
@@ -78,180 +82,142 @@ module Otoroshi
         define_singleton_method(:properties) { current_state }
       end
 
-      # Defines a private method that raises an error if type is not respected
+      # Defines a private method that validates type condition
       #
-      # @return [void]
+      #   Given name = :score, type = Integer, allow_nil = false
       #
-      # @example
-      #   define_validate_type!(:score, Integer, false) => def validate_score_type!(value) ...
-      # @example Generated method
-      #   # given name: :score, type: Integer, allow_nil: false
-      #   def validate_score_type!(value)
+      #   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, collection, allow_nil)
-        lambda = type_validation(type)
-        check_collection = ->(v) { v.is_a?(Array) || raise(Otoroshi::NotAnArray, name) }
-        define_method :"validate_#{name}_type!" do |value|
-          return if allow_nil && value.nil?
-
-          collection && check_collection.call(value)
-          return if lambda.call(value)
-
-          raise Otoroshi::WrongTypeError.new(name, type, collection: collection)
+      def define_validate_type(name, type, collection, allow_nil)
+        validator = validate_type?(name, type, collection)
+        define_method :"validate_#{name}_type" do |value|
+          allow_nil && value.nil? || validator.call(value)
         end
-        private :"validate_#{name}_type!"
+        private :"validate_#{name}_type"
       end
 
-      # Defines a lambda to be called to validate that value matches the type
-      #
-      # @return [Proc] the lambda to use in order to test that 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 } }
-      #
-      # @note params are used for binding in define_method scope
-      def type_validation(type)
-        if type == Array
-          # no expected type for each element, return nil
-          ->(_) {}
-        elsif type.is_a?(Array)
-          # get the real expected type
-          # e.g. if type is [Integer] then element_type should be Integer
-          # e.g. if type is [] then element_type should be Object
-          element_type = type.first || Object
-          # apply type_validation lambda on each element
-          ->(v) { v.all? { |e| type_validation(element_type).call(e) } }
+      # 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
-          # check the value matches the type
-          ->(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 value is not included in the accepted ones
+      # Defines a private method that validates one_of condition
       #
-      # @return [void]
+      #   Given name = :side, collection = false, one_of = [:left, :right], allow_nil = false
       #
-      # @example
-      #   # given @name = :side
-      #   define_validate_inclusion!(:side, ...) => def validate_side_type!(value) ...
-      # @example Generated method
-      #   # given name: :side, collection: false, one_of: [:left, :right], allow_nil: false
-      #   def validate_side_type!(value)
+      #   def validate_side_type(value)
       #     return if false && value.nil?
       #     return if [:left, :right].include? value
       #
-      #     raise ArgumentError, ":side is not included in accepted values"
+      #     raise Otoroshi::OneOfError, :side, [:left, :right]
       #   end
-      def define_validate_inclusion!(name, collection, one_of, allow_nil)
-        validator = collection ? each_inside?(name, one_of) : inside?(name, one_of)
-        if one_of
-          define_method(:"validate_#{name}_inclusion!") do |value|
-            allow_nil && value.nil? || validator.call(value)
-          end
-        else
-          define_method(:"validate_#{name}_inclusion!") { |_| }
+      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}_inclusion!"
+        private :"validate_#{name}_one_of"
       end
 
-      # Defines a lambda to be called to validate that value is included in accepted ones
-      #
-      # @return [Proc] the lambda to use in order to test that value is included in accepted ones
-      def inside?(name, one_of)
-        lambda do |v|
-          one_of.include?(v) || raise(Otoroshi::NotAcceptedError.new(name, one_of))
-        end
-      end
+      # Lambda that validates (value) respects the one_of condition
+      # @return [Proc]
+      def validate_one_of?(name, one_of, collection)
+        return ->(_) {} unless one_of
 
-      # Defines a lambda to be called to validate that each value is included in accepted ones
-      #
-      # @return [Proc] the lambda to use in order to test that each value is included in accepted ones
-      def each_inside?(name, one_of)
-        lambda do |v|
-          v.all? { |e| one_of.include? e } || raise(Otoroshi::NotAcceptedError.new(name, one_of, collection: true))
+        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 raises an error if assert lambda returns false
+      # Defines a private method that validates assert condition
       #
-      # @return [void]
+      #   Given name = :score, assert = ->(v) { v >= 0 }, allow_nil = false
       #
-      # @example
-      #   define_validate_assertion!(:score, ...) #=> def validate_score_assertion!(value) ...
-      # @example Generated instance method
-      #   # given name: :score, assert: >(v) { v >= 0 }, allow_nil: false
-      #   def validate_score_assertion!(value)
+      #   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_assertion!(name, collection, assert, allow_nil)
-        validator = collection ? each_assert?(name, assert) : assert?(name, assert)
-        define_method :"validate_#{name}_assertion!" do |value|
+      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!"
+        private :"validate_#{name}_assertion"
       end
 
-      # Defines a lambda to be called to validate that value respects the specific
-      #
-      # @return [Proc] the lambda to use in order to test that value respects the specific
-      def assert?(name, assert)
-        lambda do |value|
-          instance_exec(value, &assert) || raise(Otoroshi::AssertionError, name)
+      # 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
       end
 
-      # Defines a lambda to be called to validate that value respects the specific
+      # Defines a private method that calls all validations
       #
-      # @return [Proc] the lambda to use in order to test that each value respects the specific
-      def each_assert?(name, assert)
-        lambda do |value|
-          value.all? { |e| instance_exec(e, &assert) } ||
-            raise(Otoroshi::AssertionError.new(name, collection: true))
+      #   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 method for the property
+      # Defines a getter
       #
-      # @return [void]
+      #   Given name = :score
       #
-      # @example
-      #   define_getter(:score) #=> def score ...
-      # @example Generated instance method
-      #   # given name: :score
       #   def score
       #     instance_variable_get(@score)
       #   end
       def define_getter(name)
-        define_method(name) { instance_variable_get("@#{name}") }
+        define_method(name) { instance_variable_get("@#{name}").clone.freeze }
       end
 
-      # Defines a setter method for the property
+      # Defines a setter
       #
-      # @return [void]
+      #   Given name = :score
       #
-      # @example
-      #   define_setter(:score) #=> def score=(value) ...
-      # @example Generated instance method
-      #   # given name: :score
       #   def score=(value)
-      #     validate_score_type!(value)
+      #     validate_score_type(value)
       #     validate_score!(value)
       #     instance_variable_set(@score, value)
       #   end
       def define_setter(name)
         define_method :"#{name}=" do |value|
-          __send__(:"validate_#{name}_type!", value)
-          __send__(:"validate_#{name}_inclusion!", value)
-          __send__(:"validate_#{name}_assertion!", value)
+          __send__(:"validate_#{name}!", value)
           instance_variable_set("@#{name}", value)
         end
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: otoroshi
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.3
 platform: ruby
 authors:
 - Edouard Piron