wardrobe 0.1.0

data/lib/wardrobe/plugins/coercible/refinements/integer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Coercible
+      module Refinements
+        refine Integer.singleton_class do
+          def coerce(v, _atr)
+            case v
+            when self          then v
+            when String, Float then v.to_i
+            when Time          then v.to_i
+            when Date          then v.to_time.to_i
+            when NilClass      then nil
+            else
+              raise UnsupportedError
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/coercible/refinements/object.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Coercible
+      module Refinements
+        refine Object.singleton_class do
+          def coerce(v, _atr)
+            new(v)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/coercible/refinements/set.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'set'
+module Wardrobe
+  module Plugins
+    module Coercible
+      module Refinements
+        refine Set.singleton_class do
+          def coerce(v, _atr)
+            case v
+            when self then v
+            when Array then v.to_set
+            when NilClass then new
+            else
+              raise UnsupportedError
+            end
+          end
+        end
+        refine Set do
+          def coerce(v, _atr)
+            case v
+            when NilClass then self.class.new
+            when Array, Set
+              v.to_set.map! { |i| first.coerce(i, nil) }
+            else
+              raise UnsupportedError
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/coercible/refinements/string.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Coercible
+      module Refinements
+        refine String.singleton_class do
+          def coerce(v, _atr)
+            case v
+            when self then v
+            when Integer, Float, Symbol then v.to_s
+            when NilClass then nil
+            else
+              raise UnsupportedError
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Coercible
+      module Refinements
+        refine Symbol.singleton_class do
+          def coerce(v, _atr)
+            case v
+            when self     then v
+            when String   then v.to_sym
+            when NilClass then nil
+            else
+              raise UnsupportedError
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/coercible/refinements/time.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/CyclomaticComplexity
+
+require 'time'
+
+module Wardrobe
+  module Plugins
+    module Coercible
+      module Refinements
+        refine Time.singleton_class do
+          def coerce(v, _atr)
+            case v
+            when self     then v
+            when String   then Time.parse(v)
+            when Integer  then Time.at(v)
+            when Float    then Time.at(v)
+            when Date     then v.to_time
+            when NilClass then nil
+            else
+              raise UnsupportedError
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Metrics/CyclomaticComplexity

data/lib/wardrobe/plugins/coercible/refinements/unsupported_error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Coercible
+      module Refinements
+        class UnsupportedError < StandardError; end
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/coercible.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require 'wardrobe/plugins/coercible/refinements/unsupported_error'
+require 'wardrobe/plugins/coercible/refinements/array'
+require 'wardrobe/plugins/coercible/refinements/set'
+require 'wardrobe/plugins/coercible/refinements/date'
+require 'wardrobe/plugins/coercible/refinements/date_time'
+require 'wardrobe/plugins/coercible/refinements/float'
+require 'wardrobe/plugins/coercible/refinements/hash'
+require 'wardrobe/plugins/coercible/refinements/integer'
+require 'wardrobe/plugins/coercible/refinements/object'
+require 'wardrobe/plugins/coercible/refinements/string'
+require 'wardrobe/plugins/coercible/refinements/boolean'
+require 'wardrobe/plugins/coercible/refinements/symbol'
+require 'wardrobe/plugins/coercible/refinements/time'
+
+module Wardrobe
+  class Attribute
+    using Plugins::Coercible::Refinements
+
+    def coerce(val)
+      klass.coerce(val, self)
+    rescue Plugins::Coercible::Refinements::UnsupportedError => e
+      raise e.class,
+            "Can't coerce #{val.class} `#{val}` into #{klass}"
+    end
+  end
+
+  register_setter(
+    name: :coercer,
+    priority: -100,
+    use_if: ->(_atr) { true },
+    setter: lambda do |value, atr, _instance|
+      atr.coerce(value)
+    end
+  )
+
+  module Plugins
+    module Coercible
+      extend Wardrobe::Plugin
+      option :coerce, Boolean, default: true, setter: :coercer
+
+      module ClassMethods
+        def coerce(val, _atr)
+          return new if val.nil?
+          return new(**val) if val.is_a?(Hash)
+          new(val)
+        end
+      end
+    end
+  end
+  register_plugin(:coercible, Plugins::Coercible)
+end

data/lib/wardrobe/plugins/configurable/configurable_store.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Configurable
+      class ConfigurableStore < Store
+        using ImmutableInstanceMethods
+        def register(name, klass)
+          mutate do
+            store.merge!(name => klass.new.freeze)
+          end
+        end
+
+        def update(name, &blk)
+          if frozen?
+            dup.update(name, &blk)
+          else
+            duplicate = @store[name].mutate(&blk)
+            @store = @store.merge(name => duplicate)
+            freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/configurable.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'configurable/configurable_store'
+
+module Wardrobe
+  module Plugins
+    module Configurable
+      extend Wardrobe::Plugin
+
+      module ClassMethods
+        extend Forwardable
+        def_delegators :@wardrobe_stores, :configurable_store
+        
+        def self.extended(base)
+          super
+          base.wardrobe_stores do
+            add_store(:configurable_store, ConfigurableStore)
+          end
+        end
+
+        def configurable(name, blk_name, klass)
+          wardrobe_stores do
+            @configurable_store = configurable_store.register(name, klass)
+          end
+
+          define_singleton_method(name) do
+            wardrobe_stores.configurable_store[name]
+          end
+
+          define_singleton_method(blk_name) do |&blk|
+            wardrobe_stores do
+              @configurable_store = configurable_store.update(name, &blk)
+            end
+          end
+        end
+      end
+    end
+  end
+  register_plugin(:configurable, Plugins::Configurable)
+end

data/lib/wardrobe/plugins/default.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Default
+      extend Wardrobe::Plugin
+
+      Wardrobe.register_setter(
+        name: :default_setter,
+        priority: 5,
+        use_if: ->(atr) { !atr.options[:default].nil? },
+        setter: lambda do |value, atr, instance|
+          if !value.nil? && ![{},[]].include?(value)
+            value
+          else
+            default = atr.options[:default]
+            case default
+            when Symbol
+              default.match?(/default$/) ? instance.send(default) : default
+            when Proc
+              default.arity.zero? ? default.call : default.call(instance)
+            else
+              default
+            end
+          end
+        end
+      )
+
+      option :default, Object, setter: :default_setter
+    end
+  end
+  register_plugin(:default, Plugins::Default)
+end

data/lib/wardrobe/plugins/dirty_tracker.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module DirtyTracker
+      extend Wardrobe::Plugin
+
+      Wardrobe.register_setter(
+        name: :dirty_tracker,
+        priority: 25,
+        use_if: ->(atr) { atr.options[:track] },
+        setter: lambda do |value, atr, instance|
+          return value if instance._initializing?
+          instance._dirty! if value != instance._get_attribute_value(atr)
+          value
+        end
+      )
+
+      Wardrobe.register_getter(
+        name: :dirty_tracker,
+        priority: 5,
+        use_if: ->(atr) { atr.options[:track] },
+        getter: lambda do |value, atr, instance|
+          instance._register_get(atr, value)
+          value
+        end
+      )
+
+      option :track, Boolean, default: true, setter: :dirty_tracker,
+             getter: :dirty_tracker#setter(10,&setter_proc)
+
+      module InstanceMethods
+        def _changed?
+          _fetched_attributes.delete_if do |atr, val|
+            if val == :wardrobe_instance
+              _dirty! if _get_attribute_value(atr)._changed?
+            else
+              _dirty! if _get_attribute_value(atr).hash != val
+            end
+            true
+          end
+          @changed ||= false
+        end
+
+        def _dirty!
+          @changed = true
+        end
+
+        def _register_get(atr, value)
+          _fetched_attributes[atr] ||= if value.respond_to?(:_changed?)
+                                         :wardrobe_instance
+                                       else
+                                         value.hash
+                                       end
+        end
+
+        private
+
+        def _fetched_attributes
+          @_fetched_attributes ||= {}
+        end
+      end
+    end
+  end
+  register_plugin(:dirty_tracker, Plugins::DirtyTracker)
+end

data/lib/wardrobe/plugins/equality.rb

@@ -0,0 +1,19 @@
+module Wardrobe
+  module Plugins
+    module Equality
+      extend Wardrobe::Plugin
+
+      option :include_in_equality, Boolean, default: true
+
+      module InstanceMethods
+        def ==(other)
+          _attribute_store.all? do |_name, atr|
+            return true unless atr.options[:include_in_equality]
+            send(atr.name) == other.send(atr.name)
+          end
+        end
+      end
+    end
+  end
+  register_plugin(:equality, Plugins::Equality)
+end

data/lib/wardrobe/plugins/html_initializer.rb

@@ -0,0 +1,38 @@
+module Wardrobe
+  module Plugins
+    module HtmlInitializer
+      extend Wardrobe::Plugin
+
+      option :html_selector, Proc
+
+      def self.parse(html)
+        parser.parse(html)
+      end
+
+      def self.parser
+        @parser ||= begin
+          unless defined? Nokogiri
+            require 'nokogiri'
+          end
+          Nokogiri::HTML
+        end
+      end
+
+      module InstanceMethods
+        def initialize(html = nil, **args)
+          if html
+            define_singleton_method(:_attribute_init) do |atr, doc, _name|
+              value = atr.options[:html_selector].call(doc, atr, self)
+              send(atr.setter_name, value)
+            end
+            html = HtmlInitializer.parse(html) if html.is_a?(String)
+            _wardrobe_init(html)
+          else
+            super(**args)
+          end
+        end
+      end
+    end
+  end
+  register_plugin(:html_initializer, Plugins::HtmlInitializer)
+end

data/lib/wardrobe/plugins/immutable.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+require 'set'
+
+module Wardrobe
+  module Plugins
+    module ImmutableInstanceMethods
+      IMMUTABLE_CORE_CLASSES = Set.new(
+        [NilClass, TrueClass, FalseClass, Integer, Symbol]
+      )
+
+      refine Object do
+        def _mutating?
+          instance_variable_defined?(:@_mutating) && @_mutating
+        end
+
+        def mutate(**args, &blk)
+          dup.instance_exec do
+            instance_variable_set(:@_mutating, true)
+            blk.call(self) if block_given?
+            args.each do |name, _value|
+              if (atr = _attribute_store[name])
+                _attribute_init(atr, args, name)
+              end
+            end
+            remove_instance_variable(:@_mutating)
+            deep_freeze
+            self
+          end
+        end
+
+        def mutate!
+          return self if IMMUTABLE_CORE_CLASSES.include?(self.class)
+          dup.instance_exec do
+            instance_variable_set(:@_mutating, true)
+            self
+          end
+        end
+      end
+
+      refine Hash do
+        def deep_freeze
+          each { |_k, v| v.deep_freeze }
+          freeze
+        end
+      end
+      refine String do
+        def deep_freeze
+          freeze
+        end
+      end
+      refine Logger do
+        def deep_freeze
+          freeze
+        end
+      end
+      refine Set do
+        def deep_freeze
+          # Refinements does not work here when using &:deep_freeze like in array
+          each { |item| item.deep_freeze }
+          remove_instance_variable(:@_mutating) if instance_variable_defined?(:@_mutating)
+          freeze
+        end
+      end
+      refine Array do
+        def deep_freeze
+          each(&:deep_freeze)
+          remove_instance_variable(:@_mutating) if instance_variable_defined?(:@_mutating)
+          freeze
+        end
+
+        def mutate!
+          dup.instance_exec do
+            instance_variable_set(:@_mutating, true)
+            map!(&:mutate!)
+            self
+          end
+        end
+      end
+      IMMUTABLE_CORE_CLASSES.each do |klass|
+        refine klass do
+          def deep_freeze
+            freeze
+          end
+        end
+      end
+      refine Wardrobe::InstanceMethods do
+        def mutate!
+          dup.instance_exec do
+            instance_variable_set(:@_mutating, true)
+            self
+          end
+        end
+
+        def deep_freeze
+          _attribute_store.each do |_name, atr|
+            instance_variable_get(atr.ivar_name).deep_freeze
+          end
+          remove_instance_variable(:@_mutating) if instance_variable_defined?(:@_mutating)
+          freeze
+        end
+      end
+    end
+
+    module Immutable
+      extend Wardrobe::Plugin
+
+      # This plugin will disable all setters. A "set(key, value)" will be enabled. Should we also use hash storage?
+      # This should also depend on the optonal_setter plugin and set it to default on
+
+      Wardrobe.register_setter(
+        name: :disable_setter_for_immutable_plugin,
+        priority: -101,
+        use_if: ->(_atr) { true },
+        setter: lambda do |value, atr, instance|
+          return value if instance._initializing? || !instance.frozen?
+          raise NoMethodError, <<~eos
+            undefined method `#{atr.name}=' for #{instance}.
+            The instance is immutable. Use `#mutate(key, value)' or `#mutate { |obj| obj.#{atr.name} = #{value.inspect}}'
+          eos
+        end
+      )
+
+      Wardrobe.register_getter(
+        name: :dup_when_using_set_block,
+        priority: 100,
+        use_if: ->(_atr) { true },
+        getter: lambda do |value, atr, instance|
+          using ImmutableInstanceMethods
+          if instance._initializing?
+            value
+          elsif instance._mutating?
+            instance._set_attribute_value(atr, value.mutate!)
+            # instance.instance_variable_set(atr.ivar_name, value.mutate!)
+          else
+            value
+          end
+        end
+      )
+
+      option :immutable, Boolean, default: true,
+                                  setter: :disable_setter_for_immutable_plugin,
+                                  getter: :dup_when_using_set_block
+
+      module InstanceMethods
+        using ImmutableInstanceMethods
+        def initialize(**hash)
+          super
+          _data.deep_freeze if instance_variable_defined?(:@_data)
+          freeze
+        end
+
+        def mutate(**args, &blk)
+          super
+        end
+
+        def _attribute_init(atr, hash, name)
+          super
+          send(atr.name).deep_freeze
+        end
+      end
+    end
+  end
+  register_plugin(:immutable, Plugins::Immutable)
+end

data/lib/wardrobe/plugins/ivy_presenter.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'presenter/refinements'
+module Wardrobe
+  module Plugins
+    module IvyPresenter
+      extend Wardrobe::Plugin
+
+      option :preset, Set
+      option :source, Boolean
+
+      module InstanceMethods
+        def _ivy_present(**args)
+          attributes_hash = IvyPresenter.build_attributes_hash(_attribute_store, **args)
+          _present(attributes: attributes_hash)
+        end
+
+
+        # using Refinements
+        # def _present(wardrobe: nil)
+        #   result = {}
+        #   _attribute_store.store.each do |key, atr|
+        #     if wardrobe.nil? || (wardrobe && wardrobe.key?(key))
+        #       result[key] = send(atr.name)._present(wardrobe: (wardrobe[key] if wardrobe))
+        #     end
+        #   end
+        #   result
+        # end
+      end
+
+      def self.build_attributes_hash(set, preset: nil, source: nil)
+        result = {}
+        set.each do |key, atr|
+          next unless atr.options[:preset]&.include?(preset) || atr.options[:source] == source
+          result[key] = nil
+        end
+        result
+      end
+    end
+  end
+  register_plugin(:ivy_presenter, Plugins::IvyPresenter)
+end

data/lib/wardrobe/plugins/json_initializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module JsonInitializer
+      extend Wardrobe::Plugin
+
+      def self.parse(json)
+        raise InvalidJsonError unless json.match(/\A[\[{].+[\]}]\z/m)
+        case parser.to_s
+        when 'JSON'
+          parser.parse(json, symbolize_names: true)
+        when 'MultiJson'
+          parser.load(json, symbolize_keys: true)
+        end
+      end
+
+      def self.parser
+        @parser ||= select_parser
+      end
+
+      def self.select_parser
+        return MultiJson if defined? MultiJson
+        return JSON if defined? JSON
+        require 'json'
+        JSON
+      end
+
+      module InstanceMethods
+        def initialize(json_string = nil, **args)
+          if json_string
+            super(**JsonInitializer.parse(json_string))
+          else
+            super(**args)
+          end
+        end
+      end
+    end
+  end
+  register_plugin(:json_initializer, Plugins::JsonInitializer)
+end