statinize 0.0.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 51c0c480de402d268d6d85db85624f112019e8ee9456e7f32553dac8f42821d5
-  data.tar.gz: fd177fd2e864c68370840a2c5cdbc0725b7eaa8eeff9358d2a14061176a16de5
+  metadata.gz: 7814eb5a73fe5fb67c846398c6d22573b183cafd88c243175ef4fb39c5f71fbe
+  data.tar.gz: b7eec7d141ae6a0deda224802f67dae791ea7b9c96957922c9a7fa9c1b052e6a
 SHA512:
-  metadata.gz: a262a3f5f8afee169fab603fbc1530f4f84052d7786d47f3eb2bfbed4b3a2c939e15175e800a0aee1c9ce6f47cc0d4627395fe8c8c2862d40cc1d155754278b0
-  data.tar.gz: 752cb938cef235da3efdf2da7be11b96a3319cab0ee6eda7f58c8a3326d9c8b33c7622d8da7163f9e71a5e9341eb679904e82ef77184de62a0c64033b00da528
+  metadata.gz: 8bea982ae518d67bb7f9c0a9cab47dd081d869dabbdf01874e14de5c2004217bd6f395e5e040f93499cbe5de413e1d3ed6b59222e9d8089cb6b01289748d1be9
+  data.tar.gz: '08111b888a705bb74fe044f9de93ebcfd6863646df65510bf62e0566b23af1e4ef410609a22b0fc1afb1b15ffac62edbd9b43264a02191504e25296a99eab1e8'

data/lib/statinize/attribute/options/conditions.rb

@@ -0,0 +1,35 @@
+module Statinize
+  class Attribute
+    module Options
+      class Conditions < Array
+        def truthy?(instance)
+          all? do |condition|
+            if condition.is_a?(Symbol)
+              !!condition.to_proc.call(instance)
+            elsif condition.lambda?
+              !!instance.instance_exec(&condition)
+            elsif condition.is_a?(Proc)
+              !!condition.call(instance)
+            else
+              raise InvalidConditionError, "condition should be a Symbol, Proc, or a lambda"
+            end
+          end
+        end
+
+        def falsey?(instance)
+          all? do |condition|
+            if condition.is_a?(Symbol)
+              !condition.to_proc.call(instance)
+            elsif condition.lambda?
+              !instance.instance_exec(&condition)
+            elsif condition.is_a?(Proc)
+              !condition.call(instance)
+            else
+              raise InvalidConditionError, "condition should be a Symbol, Proc, or a lambda"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/statinize/attribute/options.rb

@@ -0,0 +1,65 @@
+module Statinize
+  class Attribute
+    module Options
+      def self.extended(instance)
+        raise "Cannot extend #{instance}" unless instance.is_a? Hash
+
+        instance.transform_values! do |value|
+          if %i[if unless].include?(instance.key(value))
+            Conditions.new(Array(value))
+          else
+            value
+          end
+        end
+      end
+
+      def validators
+        @validators ||= defined_validators
+          .transform_keys { |validator| Object.const_get validator }
+      end
+
+      def all_validators_defined?
+        validators_class_names
+          .all? { |validator, _| Object.const_defined? validator }
+      end
+
+      def should_cast?
+        key?(:type) && key?(:cast)
+      end
+
+      def should_validate?(instance)
+        return false if validators.empty?
+        return true unless key?(:unless) || key?(:if)
+        return false if key?(:unless) && !unless_passed?(instance)
+
+        if_passed?(instance)
+      end
+
+      private
+
+      def unless_passed?(instance)
+        self[:unless].falsey?(instance)
+      end
+
+      def if_passed?(instance)
+        self[:if].truthy?(instance)
+      end
+
+      def filtered_validators
+        reject do |k, _|
+          ::Statinize::Validator::NOT_VALIDATORS.include? k
+        end
+      end
+
+      def defined_validators
+        validators_class_names
+          .select { |validator, _| Object.const_defined? validator }
+      end
+
+      def validators_class_names
+        filtered_validators
+          .transform_keys { |validator| "::Statinize::#{validator.to_s.capitalize}Validator" }
+      end
+    end
+  end
+end

data/lib/statinize/attribute/options_collection.rb

@@ -0,0 +1,11 @@
+module Statinize
+  class Attribute
+    class OptionsCollection < Array
+      def all_validators_defined?
+        raise "Not an option!" unless all? { _1.respond_to? :validators }
+
+        all?(&:all_validators_defined?)
+      end
+    end
+  end
+end

data/lib/statinize/attribute.rb

@@ -2,25 +2,39 @@ module Statinize
   class Attribute
     include Comparable
 
-    attr_reader :klass, :name, :options, :validators
+    attr_reader :klass, :name, :options
 
-    def initialize(klass, name, options)
+    def initialize(klass, name, opts)
       @klass = klass
       @name = name
-      @options = options
-      @validators = options.keys
+      @options = OptionsCollection.new
+      @options << opts.clone.extend(Options) unless opts.empty?
     end
 
-    def self.create(klass, name, options)
-      new(klass, name, options).create
+    def self.create(klass, name, opts)
+      new(klass, name, opts).create
     end
 
     def create
-      statinizer.add_attribute(self) unless attribute_exists?
-      klass.send(:attr_accessor, name)
+      statinizer.add_attribute(self) unless attribute?
+      klass.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def #{name}
+          @#{name}
+        end
+
+        def #{name}=(attr)
+          @#{name} = attr
+          validate if respond_to?(:validate)
+          attr
+        end
+      RUBY_EVAL
       self
     end
 
+    def add_options(opts)
+      options << opts.extend(Options)
+    end
+
     def <=>(other)
       name == other.name &&
         options == other.options &&
@@ -33,8 +47,8 @@ module Statinize
       klass.statinizer
     end
 
-    def attribute_exists?
-      statinizer.attribute_exists?(self)
+    def attribute?
+      statinizer.attribute?(self)
     end
   end
 end

data/lib/statinize/caster.rb

@@ -8,14 +8,14 @@ module Statinize
       Rational => :to_r,
       Symbol => :to_sym,
       Enumerator => :to_enum,
-      Proc => :to_proc
+      Proc => :to_proc,
     }.freeze
 
-    def initialize(instance, attr_name, attr_value, validator_value)
+    def initialize(instance, attr, option)
       @instance = instance
-      @attr_name = attr_name
-      @attr_value = attr_value
-      @validator_value = validator_value
+      @attr_name = attr.name
+      @attr_value = instance.public_send(attr_name)
+      @validator_value = option[:type]
     end
 
     def cast
@@ -25,10 +25,6 @@ module Statinize
       true
     end
 
-    def self.cast(instance, attr_name, attr_value, validator_value)
-      new(instance, attr_name, attr_value, validator_value).cast
-    end
-
     private
 
     attr_reader :instance, :attr_name, :attr_value, :validator_value

data/lib/statinize/configuration.rb

@@ -0,0 +1,11 @@
+module Statinize
+  class Configuration
+    include Singleton
+
+    attr_accessor :force
+
+    def self.configure
+      yield instance if block_given?
+    end
+  end
+end

data/lib/statinize/errors.rb

@@ -1,17 +1,17 @@
 module Statinize
-  class NotStatinizableError < StandardError; end
-
   class ValidationError < StandardError; end
 
   class NoSuchValidatorError < StandardError; end
 
-  class UncastableAttributeError < StandardError; end
+  class InvalidConditionError < StandardError; end
+
+  class UndefinedAttribute < StandardError; end
 
   class Errors < Array
     def to_s
       nice_errors = map do |i|
-        "#{i.keys.first.to_s.capitalize} #{i.values.first}"
-      end.join(', ')
+        "#{i.keys.first.to_s.split("_").tap { |attr| attr.first.capitalize! }.join(" ")} #{i.values.first}"
+      end.join("; ")
 
       "ValidationError: #{nice_errors}"
     end

data/lib/statinize/statinizable.rb

@@ -6,48 +6,58 @@ module Statinize
     end
 
     module PrependedMethods
-      def initialize(*args, **kwargs)
-        self.class.statinizer.attrs.map(&:name).each do |attr|
-          instance_variable_set("@#{attr}", kwargs.delete(attr)) if kwargs.key?(attr)
+      def initialize(*args, **kwargs, &block)
+        if private_methods(false).include? :initialize
+          super(*args, **kwargs, &block)
+          check_defined!(kwargs)
+        else
+          statinizer.attributes.map(&:name).each do |attr|
+            instance_variable_set("@#{attr}", kwargs[attr]) if kwargs.key?(attr)
+          end
         end
 
-        validator.validate
+        define_validation
+        validate!
+      end
 
-        super(*args, **kwargs)
+      def validation
+        @validation ||= Validation.new(statinizer, self)
       end
 
-      def valid?
-        validator.valid?
+      def attributes
+        @attributes = Hash[
+          statinizer.attributes.map { |a| [a.name, public_send(a.name)] }
+        ]
       end
 
-      def errors
-        validator.errors
+      alias_method :define_validation, :validation
+
+      def statinizer
+        self.class.statinizer
       end
 
       private
 
-      def validator
-        Validator.new(self)
+      def check_defined!(kwargs)
+        statinizer.attributes.map(&:name).each do |attr|
+          undefined_attrs << attr if public_send(attr) != kwargs[attr] || !kwargs.key?(attr)
+        end
+
+        raise UndefinedAttributeError, "Not all attributes defined in statinize block are defined in initialize"
       end
     end
 
     module ClassMethods
-      def statinize(force: false, &block)
-        instance_variable_set('@statinizer', Statinizer.new(self, force))
+      def statinize(&block)
+        @statinizer = Statinizer.new(self)
 
-        class_eval do
-          def self.statinizer
-            @statinizer
-          end
-        end
+        statinizer.instance_eval(&block)
 
-        block.call
+        statinizer.check_validators_exist!
       end
 
-      def attributes(*attrs, **options)
-        attrs.each do |attr|
-          Attribute.create(self, attr, options)
-        end
+      def statinizer
+        @statinizer
       end
     end
   end

data/lib/statinize/statinizer.rb

@@ -1,27 +1,72 @@
 module Statinize
   class Statinizer
-    attr_reader :attrs, :force
+    attr_reader :klass
 
-    def initialize(klass, force)
+    def initialize(klass)
       @klass = klass
-      @force = force
-      @attrs = Set.new
+      @force = config.force
+    end
+
+    def attribute(*attrs, **options)
+      options.merge!(@with) if @with
+
+      attrs.each do |attr|
+        Attribute.create(klass, attr, options)
+      end
+    end
+
+    def validate(*attrs, **options)
+      options.merge!(@with) if @with
+
+      attrs.each do |attr|
+        attribute = attributes.find { _1.name == attr }
+        attribute&.add_options(options)
+      end
+    end
+
+    def with(**kwargs, &block)
+      @with = kwargs
+      instance_exec(&block)
+
+      remove_instance_variable(:@with) if @with
+    end
+
+    def force(force = nil)
+      force.nil? ? @force : @force = force
+    end
+
+    def self.configure(&block)
+      Configuration.configure(&block)
+    end
+
+    def config
+      @config ||= Configuration.instance
+    end
+
+    def force?
+      @force
     end
 
     def add_attribute(attribute)
-      @attrs.add(attribute)
+      attributes.add(attribute)
     end
 
-    def forced_attributes
-      attrs.select { |attr| attr.validators.include? :force }
+    def attributes
+      @attributes ||= Set.new
     end
 
-    def casted_attributes
-      attrs.select { |attr| attr.validators.include? :cast }
+    def attribute?(attribute)
+      attributes.include? attribute
     end
 
-    def attribute_exists?(attribute)
-      attrs.include? attribute
+    def check_validators_exist!
+      raise NoSuchValidatorError unless all_validators_defined?
+    end
+
+    private
+
+    def all_validators_defined?
+      attributes.map { |attr| attr.options.all_validators_defined? }.all? { !!_1 }
     end
   end
 end

data/lib/statinize/validation.rb

@@ -0,0 +1,90 @@
+module Statinize
+  class Validation
+    INSTANCE_METHODS = %i[validate validate! valid? invalid? errors]
+
+    attr_reader :statinizer, :instance, :errors
+
+    def initialize(statinizer, instance)
+      @statinizer = statinizer
+      @instance = instance
+
+      define_instance_methods
+    end
+
+    def validate
+      @errors = Errors.new
+      @erroneous_attributes = Hash.new { |h, k| h[k] = Set.new }
+      @erroneous_forced_attributes = Hash.new { |h, k| h[k] = Set.new }
+
+      fill_errors
+    end
+
+    def validate!
+      validate
+
+      raise ValidationError, errors.to_s if should_raise?
+    end
+
+    def valid?
+      errors.empty?
+    end
+
+    def invalid?
+      !valid?
+    end
+
+    private
+
+    def fill_errors
+      attributes.each do |attr|
+        attr.options.each do |option|
+          next unless option.should_validate?(instance)
+
+          attr_value = instance.public_send(attr.name)
+
+          option.validators.each do |validator_class, validator_value|
+            validator_instance = validator_class.new(attr_value, validator_value)
+
+            next if validator_instance.valid?
+            next if validator_class == TypeValidator && cast(attr, option)
+
+            force = option[:force] ||
+              (statinizer.force? && option[:force].nil?)
+
+            erroneous_attributes[attr.name].add option
+            erroneous_forced_attributes[attr.name].add option if force
+            @errors << { attr.name => validator_instance.error }
+          end
+        end
+      end
+    end
+
+    def cast(attr, option)
+      caster = Caster.new(instance, attr, option)
+
+      option.should_cast? && caster.cast
+    end
+
+    def should_raise?
+      return false if valid?
+
+      erroneous_attributes.keys.intersect?(erroneous_forced_attributes.keys)
+    end
+
+    def attributes
+      statinizer.attributes
+    end
+
+    def define_instance_methods
+      INSTANCE_METHODS.each do |meth|
+        instance.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          def #{meth}
+            validation.#{meth}
+          end
+        RUBY_EVAL
+      end
+    end
+
+    attr_reader :erroneous_attributes, :erroneous_forced_attributes
+  end
+end

data/lib/statinize/validator.rb

@@ -1,112 +1,20 @@
 module Statinize
   class Validator
-    NOT_VALIDATORS = %i[force cast].freeze
+    NOT_VALIDATORS = %i[force cast if unless]
 
-    def initialize(instance)
-      @instance = instance
+    attr_accessor :attr_value, :validator_value
 
-      raise NotStatinizableError unless instance&.class&.statinizer.is_a?(Statinizer)
-      raise NoSuchValidatorError unless validators_exist?
-
-      @errors = Errors.new
-      @erroneous_attrs = Set.new
+    def initialize(attr_value, validator_value)
+      @attr_value = attr_value
+      @validator_value = validator_value
     end
 
     def valid?
-      validate
-      return false unless errors.empty?
-
-      true
-    end
-
-    def invalid?
-      !valid?
-    end
-
-    def validate
-      attrs.each do |attr|
-        attr.options.each do |validator, validator_value|
-          next if NOT_VALIDATORS.include? validator
-
-          attr_name = attr.name
-
-          validator_class = Object.const_get("Statinize::#{validator.to_s.capitalize}Validator")
-
-          validator_instance = validator_class.new(instance)
-
-          validator_class.public_send(
-            :attr_accessor,
-            *%i[attr_name attr_value validator_value]
-          )
-
-          attr_value = instance.public_send attr_name
-
-          validator_instance.instance_variable_set('@attr_name', attr_name)
-          validator_instance.instance_variable_set('@attr_value', attr_value)
-          validator_instance.instance_variable_set('@validator_value', validator_value)
-
-          next if validator_instance.valid?
-          next if should_cast?(validator, attr_name) && casted?(attr_name, attr_value, validator_value)
-
-          @erroneous_attrs.add attr_name
-          add_error validator_instance.error
-        end
-      end
-
-      raise ValidationError, errors.to_s if should_raise?
-    end
-
-    protected
-
-    attr_reader :instance, :errors
-
-    def statinizer
-      @statinizer ||= instance.class.statinizer
-    end
-
-    def attrs
-      statinizer.attrs
-    end
-
-    def force?
-      statinizer.force
-    end
-
-    def should_raise?
-      force? || @erroneous_attrs.intersect?(forced_attributes.map(&:name))
-    end
-
-    def forced_attributes
-      statinizer.forced_attributes
-    end
-
-    def casted_attributes
-      statinizer.casted_attributes
-    end
-
-    def add_error(error)
-      return if error.nil?
-
-      @errors << error
-    end
-
-    private
-
-    def validators_exist?
-      attrs
-        .flat_map(&:validators).uniq
-        .reject { |validator| NOT_VALIDATORS.include? validator }
-        .map(&:to_s).map(&:capitalize)
-        .all? { |validator| Object.const_defined?("Statinize::#{validator}Validator") }
-    end
-
-    def should_cast?(validator, attr_name)
-      validator == :type &&
-        statinizer.casted_attributes.map(&:name).include?(attr_name)
+      raise NoMethodError, "#valid? method is not implemented on a #{self.class}"
     end
 
-    def casted?(attr_name, attr_value, validator_value)
-      ::Statinize::Caster.cast(instance, attr_name, attr_value, validator_value)
+    def error
+      raise NoMethodError, "#error method is not implemented on a #{self.class}"
     end
   end
 end

data/lib/statinize/validators/inclusion_validator.rb

@@ -0,0 +1,11 @@
+module Statinize
+  class InclusionValidator < Validator
+    def valid?
+      validator_value.is_a?(Array) && validator_value.include?(attr_value)
+    end
+
+    def error
+      "should be one of #{validator_value.join(", ")}"
+    end
+  end
+end

data/lib/statinize/validators/presence_validator.rb

@@ -9,7 +9,7 @@ module Statinize
     end
 
     def error
-      { attr_name => 'is blank' }
+      "is blank"
     end
 
     private
@@ -23,7 +23,7 @@ module Statinize
     end
 
     def empty_string?
-      attr_value == ''
+      attr_value == ""
     end
   end
 end

data/lib/statinize/validators/type_validator.rb

@@ -1,11 +1,11 @@
 module Statinize
   class TypeValidator < Validator
     def valid?
-      attr_value.is_a?(validator_value) || attr_value.nil?
+      attr_value.is_a?(validator_value)
     end
 
     def error
-      { attr_name => "should be #{validator_value}, found #{attr_value.class} instead" }
+      "should be #{validator_value}, found #{attr_value.class} instead"
     end
   end
 end

data/lib/statinize.rb

@@ -1,10 +1,17 @@
-require 'set'
-require 'pry'
-require_relative 'statinize/validator'
-require_relative 'statinize/caster'
-require_relative 'statinize/errors'
-require_relative 'statinize/validators/type_validator'
-require_relative 'statinize/validators/presence_validator'
-require_relative 'statinize/attribute'
-require_relative 'statinize/statinizer'
-require_relative 'statinize/statinizable'
+require "set"
+require "pry"
+require "singleton"
+require_relative "statinize/statinizable"
+require_relative "statinize/statinizer"
+require_relative "statinize/configuration"
+require_relative "statinize/attribute"
+require_relative "statinize/attribute/options"
+require_relative "statinize/attribute/options/conditions"
+require_relative "statinize/attribute/options_collection"
+require_relative "statinize/validator"
+require_relative "statinize/validation"
+require_relative "statinize/validators/type_validator"
+require_relative "statinize/validators/presence_validator"
+require_relative "statinize/validators/inclusion_validator"
+require_relative "statinize/caster"
+require_relative "statinize/errors"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statinize
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Barseek
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-01 00:00:00.000000000 Z
+date: 2022-07-08 00:00:00.000000000 Z
 dependencies: []
 description: Statinization gem. Allows for creation of attributes for a class with
   a given type.
@@ -19,11 +19,17 @@ extra_rdoc_files: []
 files:
 - lib/statinize.rb
 - lib/statinize/attribute.rb
+- lib/statinize/attribute/options.rb
+- lib/statinize/attribute/options/conditions.rb
+- lib/statinize/attribute/options_collection.rb
 - lib/statinize/caster.rb
+- lib/statinize/configuration.rb
 - lib/statinize/errors.rb
 - lib/statinize/statinizable.rb
 - lib/statinize/statinizer.rb
+- lib/statinize/validation.rb
 - lib/statinize/validator.rb
+- lib/statinize/validators/inclusion_validator.rb
 - lib/statinize/validators/presence_validator.rb
 - lib/statinize/validators/type_validator.rb
 homepage: