wardrobe 0.1.0

data/lib/wardrobe/class_methods.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Wardrobe
+  module ClassMethods
+    extend Forwardable
+    def_delegators :@wardrobe_stores, :attribute_store, :plugin_store, :option_store
+
+    def self.extended(base)
+      wardrobe_methods = base.instance_variable_set(:@wardrobe_methods, Module.new)
+      base.include(wardrobe_methods)
+      base.instance_variable_set(:@wardrobe_stores, Stores.new)
+    end
+
+    # This is called when included in another module/class
+    def included(base)
+      base.include(Wardrobe) unless base.respond_to? :wardrobe_stores
+      base.merge(wardrobe_stores)
+    end
+
+    def inherited(child)
+      wardrobe_methods = child.instance_variable_set(:@wardrobe_methods, Module.new)
+      child.include(wardrobe_methods)
+      child.instance_variable_set(:@wardrobe_stores, Stores.new)
+      child.merge(wardrobe_stores)
+      child.root_config = root_config
+    end
+
+    def wardrobe_stores(&blk)
+      if block_given?
+        @wardrobe_stores = wardrobe_stores.update(&blk)
+      else
+        @wardrobe_stores
+      end
+    end
+
+    def root_config=(input)
+      @root_config = input
+    end
+
+    def root_config
+      @root_config if instance_variable_defined?(:@root_config)
+    end
+
+    def default_getters
+      [
+        Wardrobe.getters[:getter]
+      ]
+    end
+
+    def default_setters
+      [
+        Wardrobe.setters[:setter]
+      ]
+    end
+
+    def merge(config)
+      @wardrobe_stores = wardrobe_stores.merge(config, self)
+    end
+
+    def define_getter(atr)
+      @wardrobe_methods.instance_exec do
+        define_method(atr.name) do
+          atr.getters.inject(nil) do |val, getter|
+            getter.block.call(val, atr, self)
+          end
+        end
+      end
+    end
+
+    def define_setter(atr)
+      @wardrobe_methods.instance_exec do
+        define_method(atr.setter_name) do |input|
+          atr.setters.inject(input) do |val, setter|
+            setter.block.call(val, atr, self)
+          end
+        end
+      end
+    end
+
+
+    def attribute(name, klass, *args, &blk)
+      merged_args = option_store.defaults.merge(args.inject({}) { |input, val| input.merge! val })
+      @wardrobe_stores = wardrobe_stores.add_attribute(
+        name, klass, self, **merged_args, &blk
+      )
+      define_getter(attribute_store[name])
+      define_setter(attribute_store[name])
+    end
+
+    def attributes(**kargs, &blk)
+      BlockSetup.new(self).run(**kargs, &blk)
+    end
+
+    def remove_attributes(*wardrobe)
+      wardrobe.each do |name|
+        @wardrobe_stores = wardrobe_stores.remove_attribute(name)
+      end
+    end
+
+    alias remove_attribute remove_attributes
+
+    def plugin(name, **args)
+      @wardrobe_stores = wardrobe_stores.enable_plugin(name, **args)
+      plugin = plugin_store[name][:klass]
+
+      if plugin.const_defined?(:ClassMethods)
+        extend(plugin.const_get(:ClassMethods))
+      end
+
+      if plugin.const_defined?(:InstanceMethods)
+        include(plugin.const_get(:InstanceMethods))
+      end
+
+      # Currently these are not needed
+      #
+      # if plugin.const_defined?(:AttributeClassMethods)
+      #   Attribute.extend(plugin.const_get(:AttributeClassMethods))
+      # end
+      #
+      # if plugin.const_defined?(:AttributeInstanceMethods)
+      #   Attribute.include(plugin.const_get(:AttributeInstanceMethods))
+      # end
+    end
+  end
+end

data/lib/wardrobe/getter_setter.rb

@@ -0,0 +1,48 @@
+module Wardrobe
+  class << self
+    attr_reader :setters, :getters
+  end
+  @setters = {}
+  @getters = {}
+
+  class SetterGetter
+    attr_reader :name, :priority, :block, :use_if
+
+    def initialize(name, priority, block, use_if)
+      @name = name
+      @priority = priority
+      @block = block
+      @use_if = use_if
+    end
+
+    def <=>(other)
+      priority <=> other.priority
+    end
+  end
+
+  def self.register_setter(name:, priority:, setter:, use_if: ->(_atr) { true })
+    raise 'Name taken' if setters[name]
+    setters[name] = SetterGetter.new(name, priority, setter, use_if)
+  end
+
+  def self.register_getter(name:, priority:, getter:, use_if: ->(_atr) { true })
+    raise 'Name taken' if getters[name]
+    getters[name] = SetterGetter.new(name, priority, getter, use_if)
+  end
+
+  Wardrobe.register_getter(
+    name: :getter,
+    priority: 0,
+    getter: lambda do |_value, atr, instance|
+      instance.instance_variable_get(atr.ivar_name)
+    end
+  )
+
+  Wardrobe.register_setter(
+    name: :setter,
+    priority: 100,
+    setter: lambda do |value, atr, instance|
+      instance.instance_variable_set(atr.ivar_name, value)
+    end
+  )
+end

data/lib/wardrobe/instance_methods.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module InstanceMethods
+    def initialize(**hash)
+      # raise "POC: More than one arg not supported..." if args.length > 1
+      # kargs = args.first.merge(kargs) if args.any?
+      _initialize { _wardrobe_init(hash) }
+    end
+
+    def _initializing?
+      instance_variable_defined?(:@_initializing) && @_initializing
+    end
+
+    def _attribute_store
+      _attribute_store_singleton || self.class.attribute_store
+    end
+
+    def _add_attribute(name, klass, **args, &blk)
+      @_wardrobe_set_singleton = _attribute_store.add(
+        name, klass, self.class, self.class.wardrobe_stores, **args, &blk
+      )
+    end
+
+    def _set_attribute_value(atr, value)
+      instance_variable_set(atr.ivar_name, value)
+    end
+
+    def _get_attribute_value(atr)
+      instance_variable_get(atr.ivar_name)
+    end
+
+    private
+
+    def _initialize
+      instance_variable_set(:@_initializing, true)
+      yield
+      remove_instance_variable(:@_initializing)
+    end
+
+    def _attribute_store_singleton
+      @_wardrobe_set_singleton if instance_variable_defined?('@_wardrobe_set_singleton')
+    end
+
+    def _wardrobe_init(data)
+      # Should we also loop over the hash and report on missing or additional attributes?
+      _attribute_store.each do |name, atr|
+        _attribute_init(atr, data, name)
+      end
+    end
+
+    def _attribute_init(atr, hash, name)
+      send(atr.setter_name, hash[name])
+    end
+  end
+end

data/lib/wardrobe/module_methods.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Wardrobe
+  # This module is extended in Wardrobe and extended to anonymous modules created by
+  # Wardrobe() method.
+  module ModuleMethods
+    def included(base)
+      base.extend(ClassMethods)
+      unless base.to_s == 'Wardrobe::RootConfig'
+        base.root_config = config
+        config.default_plugins.each do |plugin|
+          # TODO: Support k_args
+          base.plugin plugin
+        end
+      end
+      base.include(InstanceMethods)
+    end
+
+    def create_class(plugins: [], attributes: [])
+      Class.new.class_exec do
+        include Wardrobe
+        plugin(*plugins)
+        attributes.each do |atr|
+          attribute(atr[:name], const_get(atr[:class]), atr.fetch(:options, {}))
+        end
+        self
+      end
+    end
+
+    def config
+      @config ||= begin
+        callee = caller_locations.first
+        if callee.label == 'config' && callee.lineno == (__LINE__ + 3)
+          RootConfig.new
+        else
+          Wardrobe.config
+        end
+      end
+    end
+
+    def configure(&blk)
+      @config = config.mutate(&blk)
+    end
+
+    def logger
+      config.logger
+    end
+  end
+end

data/lib/wardrobe/option.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  class Option
+    attr_reader :name, :klass, :plugin, :default, :options, :setter, :getter
+
+    def initialize(name, klass, plugin, **kargs)
+      @name = name
+      @klass = klass
+      @plugin = plugin
+      @default = kargs.fetch(:default, nil)
+      @getter = Wardrobe.getters[kargs.fetch(:getter, nil)]
+      @setter = Wardrobe.setters[kargs.fetch(:setter, nil)]
+      @options = kargs
+      freeze
+    end
+
+    def klass_name
+      klass.to_s[/([^:]+)$/,1].downcase
+    end
+
+    def use_getter_for_atr?(atr)
+      getter&.use_if&.call(atr)
+    end
+
+    def use_setter_for_atr?(atr)
+      setter&.use_if&.call(atr)
+    end
+  end
+end

data/lib/wardrobe/option_store.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  class OptionStore < Store
+    attr_reader :store, :defaults
+
+    def freeze
+      @defaults = select_defaults
+      super
+    end
+
+    def add(name, instance)
+      mutate { store[name] = instance }
+    end
+
+    private
+
+    def select_defaults
+      store.reject { |_k, v| v.default.nil? }.transform_values(&:default)
+    end
+  end
+end

data/lib/wardrobe/plugin.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  class PluginNameTakenError < StandardError; end
+  class PluginOptionKeywordTakenError < StandardError; end
+
+  class << self
+    attr_reader :plugins, :options
+  end
+  @plugins = {}
+  @options = {}
+
+  def self.register_plugin(name, mod)
+    raise PluginNameTakenError, "Plugin #{name} already in use" if plugins[name]
+    plugins[name] = mod
+  end
+
+  module Plugin
+    def options
+      @options ||= []
+    end
+
+    def option(name, klass, **kargs, &blk)
+      raise PluginOptionKeywordTaken if Wardrobe.options[name]
+      option_instance = Option.new(name, klass, self, **kargs, &blk)
+      Wardrobe.options[name] = option_instance
+      BlockSetup.register_option(option_instance)
+      options << option_instance
+      #
+      # # TODO: Refactor this to apply only if plugin is in use
+      #
+      # raise PluginOptionKeywordTaken if Wardrobe.options[:name]
+      # # These needs to go somewhere else
+      # @option_name = name
+      # @option_klass = klass
+      # @option_default = default
+    end
+  end
+end

data/lib/wardrobe/plugin_store.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  class NoPluginRegisteredError < StandardError; end
+
+  class PluginStore < Store
+    attr_reader :store
+    def add(name, **args)
+      begin
+        plugin = Wardrobe.plugins.fetch(name)
+      rescue KeyError
+        begin
+          if require "wardrobe/plugins/#{name}"
+            retry
+          end
+        rescue LoadError
+          raise NoPluginRegisteredError, name
+        end
+      end
+      mutate do
+        store[name] = {
+          klass: plugin,
+          options: args
+        }
+      end
+    end
+  end
+end

data/lib/wardrobe/plugins/alias_setters.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module AliasSetters
+      extend Wardrobe::Plugin
+
+      option :alias_setter, Array
+
+      module ClassMethods
+        def define_setter(atr)
+          super
+          atr.options[:alias_setter]&.each do |alias_setter|
+            alias_method "#{alias_setter}=", atr.setter_name
+          end
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        def _attribute_init(atr, hash, name)
+          return super unless atr.options[:alias_setter]
+          return super if atr.options[:alias_setter].empty?
+          keys_in_hash = atr.options[:alias_setter].select { |key| hash.key?(key) }
+          return super unless keys_in_hash.any?
+          keys_in_hash.reverse.each do |key|
+            send("#{name}=", atr.coerce(hash[key]))
+          end
+        end
+      end
+    end
+  end
+  register_plugin(:alias_setters, Plugins::AliasSetters)
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Coercible
+      module Refinements
+        refine Array.singleton_class do
+          def coerce(v, _atr)
+            case v
+            when self     then v
+            when Set      then v.to_a
+            when NilClass then []
+            else
+              raise UnsupportedError
+            end
+          end
+        end
+
+
+
+        refine Array do
+          class WrongNumberOfItemsError < StandardError; end
+
+          module ArrayInstanceCoercer
+            def _wardrobe_init(atr, coercer: nil)
+              @_wardrobe_atr = atr
+              @_wardrobe_coercer = coercer
+              self
+            end
+
+            def _coerce(item)
+              @_wardrobe_coercer.coerce(item, @_wardrobe_atr)
+            end
+
+            def <<(item)
+              super(_coerce(item))
+            end
+
+            def push(*items)
+              super(*items.map { |i| _coerce(i) })
+            end
+
+            def unshift(*items)
+              super(*items.map { |i| _coerce(i) })
+            end
+          end
+
+          def coerce(v, atr)
+            res = case v
+                  when Array
+                    v.map! { |item| first.coerce(item, nil) }
+                  when NilClass then []
+                  else
+                    raise UnsupportedError
+                  end
+            res.singleton_class.include(ArrayInstanceCoercer)
+            res._wardrobe_init(atr, coercer: first)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Coercible
+      module Refinements
+        TRUE_STRINGS = Set.new(['1', 'yes', 'true']).freeze
+        FALSE_STRINGS = Set.new(['0', 'no', 'false']).freeze
+        refine Wardrobe::Boolean.singleton_class do
+          def coerce(v, _atr)
+            case v
+            when TrueClass, FalseClass then v
+            when Integer then integer(v)
+            when String then string(v)
+            when NilClass then nil
+            else
+              raise UnsupportedError
+            end
+          end
+
+          def integer(v)
+            return false if v == 0
+            return true if v == 1
+            raise UnsupportedError
+          end
+
+          def string(v)
+            return false if FALSE_STRINGS.include?(v)
+            return true if TRUE_STRINGS.include?(v)
+            raise UnsupportedError
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/CyclomaticComplexity
+
+require 'date'
+module Wardrobe
+  module Plugins
+    module Coercible
+      module Refinements
+        refine Date.singleton_class do
+          def coerce(v, _atr)
+            case v
+            # DateTime has to be first. `DateTime.new === Date.new # => true`
+            when DateTime then v.to_date
+            when self     then v
+            when String   then Date.parse(v)
+            when Time     then v.to_date
+            when Integer  then Time.at(v).to_date
+            when Float    then Time.at(v).to_date
+            when NilClass then nil
+            else
+              raise UnsupportedError
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Metrics/CyclomaticComplexity

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

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

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

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

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Wardrobe
+  module Plugins
+    module Coercible
+      module Refinements
+        refine Hash.singleton_class do
+          def coerce(v, _atr)
+            case v
+            when self then v
+            when Array then self[*v]
+            when NilClass then {}
+            end
+          end
+        end
+
+        refine Hash do
+          def coerce(v, atr)
+            case v
+            when Hash
+              coerce_hash(v, atr)
+            when Array
+              coerce_hash(self.class[*v], atr)
+            when NilClass then {}
+            else
+              raise UnsupportedError
+            end
+          end
+
+          HASH_SINGLETON_MODIFIER = lambda { |coercer, atr_object|
+            @_coercer = coercer
+            @_atr = atr_object
+
+            def _coercer
+              self.singleton_class.instance_variable_get(:@_coercer)
+            end
+
+            def self._atr; @_atr; end
+
+            def _coerce(key, value)
+              return _coercer[0].coerce(key, nil),
+              _coercer[1].coerce(value, nil)
+            end
+
+            def []=(key, value)
+              super(*_coerce(key,value))
+            end
+          }
+
+          private
+
+          def coerce_hash(h, atr)
+            hash = h.map do |key, value|
+              #TODO: Since we pass around the atr object, how should this work here? Just pass nil?
+              [self.first[0].coerce(key, nil), self.first[1].coerce(value, nil)]
+            end.to_h
+
+            hash.singleton_class.class_exec(first,atr, &HASH_SINGLETON_MODIFIER)
+            hash
+          end
+        end
+      end
+    end
+  end
+end