wardrobe 0.1.0

data/lib/wardrobe/plugins/validation/refinements/symbol.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Validation
+      module Refinements
+        refine Symbol do
+          def empty?
+            return if self.to_s.strip == ''
+            'must be empty'
+          end
+
+          def filled?
+            return unless self.to_s.strip == ''
+            'must be filled'
+          end
+
+          def format?(regex)
+            return if regex.match(self)
+            "must match #{regex.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/validation/refinements.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'refinements/_size'
+require_relative 'refinements/array'
+require_relative 'refinements/date'
+require_relative 'refinements/hash'
+require_relative 'refinements/integer'
+require_relative 'refinements/nil_class'
+require_relative 'refinements/numeric'
+require_relative 'refinements/object'
+require_relative 'refinements/set'
+require_relative 'refinements/string'
+require_relative 'refinements/symbol'

data/lib/wardrobe/plugins/validation/validation.rb

@@ -0,0 +1,63 @@
+module Wardrobe
+  module Plugins
+    module Validation
+
+      class Validation < Hash
+        def initialize(method, argument)
+          self[:method] = method
+          self[:argument] = argument
+        end
+
+        def method
+          self[:method]
+        end
+
+        def argument
+          self[:argument]
+        end
+
+        def args
+          @args ||= begin
+            arr = [ method ]
+            arr << argument if argument
+            arr
+          end
+        end
+
+        SPECIAL_METHODS = Set.new([:each?, :each_key?, :each_value?])
+
+        def type
+          @type ||= begin
+            if method[/^_.+_$/] || SPECIAL_METHODS.include?(method)
+              :special
+            else
+              :value
+            end
+          end
+        end
+
+        def &(other)
+          if method == :_and_
+            argument << other
+            self
+          else
+            self.class.new(:_and_, [self, other])
+          end
+        end
+
+        def |(other)
+          if method == :_or_
+            argument<< other
+            self
+          else
+            self.class.new(:_or_, [self, other])
+          end
+        end
+
+        def >(other)
+          self.class.new(:_then_, [self, other])
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/validation/validation_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Validation
+      class ValidationError < StandardError
+        attr_reader :errors
+
+        def initialize(errors)
+          @errors = errors.freeze
+        end
+
+        def to_s
+          errors.to_s
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/validation/validaton_runner.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Validation
+      class ValidationRunner
+        attr_reader :instance
+
+        def initialize(instance)
+          @instance = instance
+        end
+
+        def self.validate(instance)
+          new(instance).run
+        end
+
+        def Validate(value, atr, error_store)
+          Validator.new(value, atr, error_store).run
+        end
+
+        def run
+          instance._attribute_store.each do |_name, atr|
+            Validate(instance.send(atr.name), atr, error_store)
+          end
+          self
+        end
+
+        def error_store
+          @error_store ||= ErrorStore.new
+        end
+
+        def errors
+          error_store.store
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/validation/validator.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Validation
+      class Validator
+        using Refinements
+        attr_reader :value, :atr, :error_store, :validation
+
+        def initialize(value, atr, error_store, validation = nil)
+          @value = value
+          @atr = atr
+          @error_store = error_store
+          @validation = validation || atr.options[:validates]
+        end
+
+        def run(report = true)
+          if validation
+            validate(validation, report)
+          elsif value.respond_to?(:_validate!)
+            if value._validation_errors.any?
+              error_store.store[atr.name] = value._validation_errors
+            end
+          else
+            Wardrobe.logger.warn("Unable to validate #{value.class} class")
+          end
+        end
+
+        private
+
+        def report(*errors)
+          error_store.add(atr, *errors)
+        end
+
+        def validate(validation, report)
+          if validation.type == :special#method[/^_.+_$/]
+            send(*validation.args, report)
+          else
+            error = value.send(*validation.args)
+            report && error ? report(error) : error
+          end
+        end
+
+        def validate_list(validations, report)
+          validations.map do |validation|
+            validate(validation, report)
+          end.compact
+        end
+
+        def each?(validation, report)
+          errors = {}
+          value.each_with_index do |item, index|
+            result = Validator.new(item, nil, nil, validation).run(false)
+            result = [result] unless result.is_a?(Array)
+            errors[index] = result if result.any?
+          end
+          if errors.any?
+            report(errors) if report
+            errors
+          end
+        end
+
+        def each_key?(validation, report)
+          errors = {}
+          value.each do |key, _|
+            result = Validator.new(key, nil, nil, validation).run(false)
+            result = [result] unless result.is_a?(Array)
+            errors[key] = result.map { |error| 'key ' + error } if result.any?
+          end
+          if errors.any?
+            report(errors) if report
+            errors
+          end
+        end
+
+        def each_value?(validation, report)
+          errors = {}
+          value.each do |key, val|
+            result = Validator.new(val, nil, nil, validation).run(false)
+            result = [result] unless result.is_a?(Array)
+            errors[key] = result.map { |error| 'value ' + error } if result.any?
+          end
+          if errors.any?
+            report(errors) if report
+            errors
+          end
+        end
+
+        def _or_(validations, report)
+          errors = validate_list(validations, false)
+          error_string = errors.join(' or ')
+          report(error_string) if validations.size == errors.size && report
+          error_string
+        end
+
+        def _and_(validations, report)
+          errors = validate_list(validations, false)
+          report ? report(*errors) : errors
+        end
+
+        def _then_(validations, report)
+          error = validate(validations.first, false)
+          if error
+            report(error) if report
+            error
+          else
+            validate_list(validations[1..-1], report)
+          end
+        end
+
+        def _optional_(validation, report)
+          validate(validation, report)
+        rescue NoMethodError => e
+          raise e unless value.nil?
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/validation.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'validation/refinements'
+require_relative 'validation/deep_merge'
+require_relative 'validation/error_store'
+require_relative 'validation/instance_methods'
+require_relative 'validation/validation'
+require_relative 'validation/validator'
+require_relative 'validation/validaton_runner'
+require_relative 'validation/validation_error'
+require_relative 'validation/class_methods'
+require_relative 'validation/block_handler'
+
+# TODO:
+# - Setting to run validations automatically
+# - Support all Hanami/Dry validations
+# - Support advanced predicates
+
+module Wardrobe
+  module Plugins
+    module Validation
+      extend Wardrobe::Plugin
+      option :validates, Hash
+      option :required, Boolean, default: true
+    end
+  end
+  register_plugin(:validation, Plugins::Validation)
+end

data/lib/wardrobe/root_config.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  # Config class used on Wardrobe root module
+  class RootConfig
+    include Wardrobe
+    plugin :immutable
+    plugin :default
+    attribute :coerce, Boolean, default: true
+    attribute :logger, Object, default: ->() { Logger.new(STDOUT) }
+    attribute :default_plugins, Set[Symbol], default: Set.new([:coercible])
+
+    def register_default_plugin(name)
+      raise 'error' unless Wardrobe.plugins.key?(name)
+      default_plugins.add(name)
+    end
+
+    def coerce=(value)
+      if super == false
+        default_plugins.delete(:coercible)
+      end
+    end
+
+    def build(**args)
+      args.each do |k, v|
+        send("#{k}=", v)
+      end
+      self
+    end
+  end
+end

data/lib/wardrobe/store.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  class Store
+    include Enumerable
+    attr_reader :store, :parent
+
+    def initialize
+      @store = {}
+      freeze
+    end
+
+    def values
+      store.values
+    end
+
+    def [](name)
+      store[name]
+    end
+
+    def each(&blk)
+      store.each(&blk)
+    end
+
+    def freeze
+      store.freeze
+      super
+    end
+
+    def method_missing(name, *args, **key_args, &block)
+      if (atr = store[name])
+        atr
+      else
+        super
+      end
+    end
+
+    def merge(other, _calling_object, _config)
+      mutate do
+        @store = store.merge(other.store)
+        # I guess we have to loop through each item and do a custom merge...
+        # maybe not use Hash#merge?
+      end
+    end
+
+    def del(name)
+      mutate do
+        store.delete(name) { |key| raise "#{key} not found" }
+      end
+    end
+
+    private
+
+    def mutate(&blk)
+      dup.instance_exec do
+        @store = store.dup
+        instance_exec(&blk)
+        freeze
+      end
+    end
+  end
+end

data/lib/wardrobe/stores.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  class Stores
+    def self.registered_stores
+      @registered_stores ||= {}.freeze
+    end
+
+    def self.register_store(name, klass)
+      @registered_stores = registered_stores.merge(name => klass).freeze
+    end
+
+    register_store(:attribute_store, AttributeStore)
+    register_store(:plugin_store, PluginStore)
+    register_store(:option_store, OptionStore)
+
+    attr_reader :stores
+
+    def initialize
+      @stores = {}.freeze
+      self.class.registered_stores.each do |key, value|
+        add_store(key, value, initializer: true)
+      end
+      freeze
+    end
+
+    def update(&blk)
+      if frozen?
+        dup.update(&blk)
+      else
+        instance_exec(&blk)
+        freeze
+      end
+    end
+
+    def add_store(name, klass, initializer: false)
+      if frozen?
+        dup.add_store(name, klass)
+      else
+        @stores = stores.merge(name => klass)
+        instance_variable_set("@#{name}", klass.new)
+        define_singleton_method(name) { instance_variable_get("@#{name}") }
+        freeze unless initializer
+      end
+    end
+
+    def merge(other, calling_object)
+      if frozen?
+        dup.merge(other, calling_object)
+      else
+        (other.stores.keys - stores.keys).each do |name|
+          add_store(name, other.stores[name], initializer: true)
+        end
+        stores.each do |name, klass|
+          instance = respond_to?(name) ? send(name) : klass.new
+          instance_variable_set(
+            "@#{name}", instance.merge(other.send(name), calling_object, self)
+          )
+        end
+        freeze
+      end
+    end
+
+    def dup
+      duplicate = super
+      duplicate.stores.each do |name, _klass|
+        duplicate.define_singleton_method(name) do
+          instance_variable_get("@#{name}")
+        end
+      end
+      duplicate
+    end
+
+    def enable_plugin(name, **args)
+      if frozen?
+        dup.enable_plugin(name, **args)
+      else
+        @plugin_store = plugin_store.add(name, **args)
+        plugin_store[name][:klass].options.each do |option|
+          @option_store = option_store.add(option.name, option)
+        end
+        freeze
+      end
+    end
+
+    def add_attribute(name, klass, defining_object, **merged_args, &blk)
+      if frozen?
+        dup.add_attribute(name, klass, defining_object, **merged_args, &blk)
+      else
+        @attribute_store = attribute_store.add(
+          name, klass, defining_object, self, **merged_args, &blk
+        )
+        freeze
+      end
+    end
+
+    def remove_attribute(name)
+      if frozen?
+        dup.remove_attribute(name)
+      else
+        @attribute_store = attribute_store.del(name)
+        freeze
+      end
+    end
+  end
+end

data/lib/wardrobe/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  VERSION = '0.1.0'
+end

data/lib/wardrobe.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'wardrobe/version'
+require 'wardrobe/boolean'
+require 'wardrobe/store'
+require 'wardrobe/getter_setter'
+require 'wardrobe/attribute'
+require 'wardrobe/attribute_store'
+require 'wardrobe/option'
+require 'wardrobe/option_store'
+require 'wardrobe/plugin'
+require 'wardrobe/plugin_store'
+require 'wardrobe/stores'
+require 'wardrobe/block_setup'
+require 'wardrobe/class_methods'
+require 'wardrobe/instance_methods'
+require 'wardrobe/module_methods'
+
+# Top level Wardrobe module
+module Wardrobe
+  extend ModuleMethods
+end
+
+require 'wardrobe/root_config'
+
+# rubocop:disable Style/MethodName
+def Wardrobe(**options)
+  mod = Module.new do
+    extend Wardrobe::ModuleMethods
+  end
+  mod.configure { |config| config.build(options) }
+  mod
+end
+# rubocop:enable Style/MethodName

data/sandbox/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+gem 'virtus'
+gem 'wardrobe',        path: '../'
+gem 'derailed_benchmarks', group: :development
+gem 'stackprof',           group: :development

data/sandbox/Gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: ../
+  specs:
+    atrs (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    axiom-types (0.1.1)
+      descendants_tracker (~> 0.0.4)
+      ice_nine (~> 0.11.0)
+      thread_safe (~> 0.3, >= 0.3.1)
+    benchmark-ips (2.7.2)
+    coercible (1.0.0)
+      descendants_tracker (~> 0.0.1)
+    derailed_benchmarks (1.3.1)
+      benchmark-ips (~> 2)
+      get_process_mem (~> 0)
+      heapy (~> 0)
+      memory_profiler (~> 0)
+      rack (>= 1)
+      rake (> 10, < 12)
+      thor (~> 0.19)
+    descendants_tracker (0.0.4)
+      thread_safe (~> 0.3, >= 0.3.1)
+    equalizer (0.0.11)
+    get_process_mem (0.2.1)
+    heapy (0.1.2)
+    ice_nine (0.11.2)
+    memory_profiler (0.9.7)
+    rack (2.0.1)
+    rake (11.3.0)
+    stackprof (0.2.10)
+    thor (0.19.1)
+    thread_safe (0.3.5)
+    virtus (1.0.5)
+      axiom-types (~> 0.1)
+      coercible (~> 1.0)
+      descendants_tracker (~> 0.0, >= 0.0.3)
+      equalizer (~> 0.0, >= 0.0.9)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  atrs!
+  derailed_benchmarks
+  stackprof
+  virtus
+
+BUNDLED WITH
+   1.13.6

data/sandbox/bench_mutable_coercion.rb

@@ -0,0 +1,91 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+class AlmostArray < Array
+
+end
+module Wardrobe
+  module Coercions
+    refine AlmostArray.singleton_class do
+      def coerce(v, atr)
+        case v
+        when AlmostArray, Array then AlmostArray.new(v)
+        when Set      then AlmostArray.new(v.to_a)
+        when NilClass then []
+        else
+          raise UnsupportedError
+        end
+      end
+    end
+
+    refine AlmostArray do
+      class WrongNumberOfItemsError < StandardError; end
+      def coerce(v, atr)
+        result = case v
+        when Array, AlmostArray
+
+          # This check shold be moved to attribute creation time
+          raise StandardError, "`Array#{map(&:name)}' contains two many classes. No more than one is allowed." if count != 1
+          v.map! { |item| first.coerce(item, nil) }
+        when NilClass then AlmostArray.new
+        else
+          raise UnsupportedError
+        end
+      end
+    end
+  end
+end
+
+require 'wardrobe'
+require 'benchmark/ips'
+require 'pry'
+require 'pry-byebug'
+require 'ostruct'
+
+
+
+
+
+
+
+
+class Embedded
+  include Wardrobe
+  attribute :name, String
+end
+
+class One
+  include Wardrobe
+  attribute :array, Array[Embedded]
+end
+
+class Two
+  include Wardrobe
+  attribute :array, AlmostArray[Embedded]
+end
+
+one = One.new
+two = Two.new
+# one.array.unshift({name: 'asf'})
+# two.array.unshift({name: 'asf'})
+
+# binding.pry
+
+
+Benchmark.ips do |x|
+  x.report('With Array Coercion') {
+    one.array << { name: 'abcd' }
+  }
+  x.report('Without Array Coercion') {
+    two.array << { name: 'abcd' }
+  }
+  # x.report('Modules') {
+  #   modules.inject('') do |val, item|
+  #     item.call(val, instance)
+  #   end
+  # }
+  # x.report('Classes') {
+  #   classes.inject('') do |val, item|
+  #     item.new.call(val, instance)
+  #   end
+  # }
+  x.compare!
+end