statinize 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 51c0c480de402d268d6d85db85624f112019e8ee9456e7f32553dac8f42821d5
+  data.tar.gz: fd177fd2e864c68370840a2c5cdbc0725b7eaa8eeff9358d2a14061176a16de5
+SHA512:
+  metadata.gz: a262a3f5f8afee169fab603fbc1530f4f84052d7786d47f3eb2bfbed4b3a2c939e15175e800a0aee1c9ce6f47cc0d4627395fe8c8c2862d40cc1d155754278b0
+  data.tar.gz: 752cb938cef235da3efdf2da7be11b96a3319cab0ee6eda7f58c8a3326d9c8b33c7622d8da7163f9e71a5e9341eb679904e82ef77184de62a0c64033b00da528

data/lib/statinize/attribute.rb

@@ -0,0 +1,40 @@
+module Statinize
+  class Attribute
+    include Comparable
+
+    attr_reader :klass, :name, :options, :validators
+
+    def initialize(klass, name, options)
+      @klass = klass
+      @name = name
+      @options = options
+      @validators = options.keys
+    end
+
+    def self.create(klass, name, options)
+      new(klass, name, options).create
+    end
+
+    def create
+      statinizer.add_attribute(self) unless attribute_exists?
+      klass.send(:attr_accessor, name)
+      self
+    end
+
+    def <=>(other)
+      name == other.name &&
+        options == other.options &&
+        klass == other.klass
+    end
+
+    private
+
+    def statinizer
+      klass.statinizer
+    end
+
+    def attribute_exists?
+      statinizer.attribute_exists?(self)
+    end
+  end
+end

data/lib/statinize/caster.rb

@@ -0,0 +1,48 @@
+module Statinize
+  class Caster
+    TYPE_CASTINGS = {
+      Integer => :to_i,
+      String => :to_s,
+      Float => :to_f,
+      Complex => :to_c,
+      Rational => :to_r,
+      Symbol => :to_sym,
+      Enumerator => :to_enum,
+      Proc => :to_proc
+    }.freeze
+
+    def initialize(instance, attr_name, attr_value, validator_value)
+      @instance = instance
+      @attr_name = attr_name
+      @attr_value = attr_value
+      @validator_value = validator_value
+    end
+
+    def cast
+      return false unless castable?
+
+      instance.public_send("#{attr_name}=", casted)
+      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
+
+    def castable?
+      attr_value.respond_to? casting
+    end
+
+    def casting
+      @casting ||= TYPE_CASTINGS[validator_value]
+    end
+
+    def casted
+      @casted ||= attr_value.public_send(casting)
+    end
+  end
+end

data/lib/statinize/errors.rb

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

data/lib/statinize/statinizable.rb

@@ -0,0 +1,54 @@
+module Statinize
+  module Statinizable
+    def self.included(klass)
+      klass.extend(ClassMethods)
+      klass.prepend(PrependedMethods)
+    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)
+        end
+
+        validator.validate
+
+        super(*args, **kwargs)
+      end
+
+      def valid?
+        validator.valid?
+      end
+
+      def errors
+        validator.errors
+      end
+
+      private
+
+      def validator
+        Validator.new(self)
+      end
+    end
+
+    module ClassMethods
+      def statinize(force: false, &block)
+        instance_variable_set('@statinizer', Statinizer.new(self, force))
+
+        class_eval do
+          def self.statinizer
+            @statinizer
+          end
+        end
+
+        block.call
+      end
+
+      def attributes(*attrs, **options)
+        attrs.each do |attr|
+          Attribute.create(self, attr, options)
+        end
+      end
+    end
+  end
+end

data/lib/statinize/statinizer.rb

@@ -0,0 +1,27 @@
+module Statinize
+  class Statinizer
+    attr_reader :attrs, :force
+
+    def initialize(klass, force)
+      @klass = klass
+      @force = force
+      @attrs = Set.new
+    end
+
+    def add_attribute(attribute)
+      @attrs.add(attribute)
+    end
+
+    def forced_attributes
+      attrs.select { |attr| attr.validators.include? :force }
+    end
+
+    def casted_attributes
+      attrs.select { |attr| attr.validators.include? :cast }
+    end
+
+    def attribute_exists?(attribute)
+      attrs.include? attribute
+    end
+  end
+end

data/lib/statinize/validator.rb

@@ -0,0 +1,112 @@
+module Statinize
+  class Validator
+    NOT_VALIDATORS = %i[force cast].freeze
+
+    def initialize(instance)
+      @instance = instance
+
+      raise NotStatinizableError unless instance&.class&.statinizer.is_a?(Statinizer)
+      raise NoSuchValidatorError unless validators_exist?
+
+      @errors = Errors.new
+      @erroneous_attrs = Set.new
+    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)
+    end
+
+    def casted?(attr_name, attr_value, validator_value)
+      ::Statinize::Caster.cast(instance, attr_name, attr_value, validator_value)
+    end
+  end
+end

data/lib/statinize/validators/presence_validator.rb

@@ -0,0 +1,29 @@
+module Statinize
+  class PresenceValidator < Validator
+    def valid?
+      validator_value &&
+        !empty_array? &&
+        !empty_hash? &&
+        !empty_string? &&
+        !attr_value.nil?
+    end
+
+    def error
+      { attr_name => 'is blank' }
+    end
+
+    private
+
+    def empty_array?
+      attr_value == []
+    end
+
+    def empty_hash?
+      attr_value == {}
+    end
+
+    def empty_string?
+      attr_value == ''
+    end
+  end
+end

data/lib/statinize/validators/type_validator.rb

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

data/lib/statinize.rb

@@ -0,0 +1,10 @@
+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'

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: statinize
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Barseek
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-07-01 00:00:00.000000000 Z
+dependencies: []
+description: Statinization gem. Allows for creation of attributes for a class with
+  a given type.
+email: sergey.b@hey.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/statinize.rb
+- lib/statinize/attribute.rb
+- lib/statinize/caster.rb
+- lib/statinize/errors.rb
+- lib/statinize/statinizable.rb
+- lib/statinize/statinizer.rb
+- lib/statinize/validator.rb
+- lib/statinize/validators/presence_validator.rb
+- lib/statinize/validators/type_validator.rb
+homepage:
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Statinize!
+test_files: []