u-attributes 1.1.0 → 2.1.0

data/Rakefile

@@ -1,10 +1,10 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
 end
 
 task :default => :test

data/bin/console

@@ -1,14 +1,14 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "micro/attributes"
+require 'bundler/setup'
+require 'micro/attributes'
 
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
 # (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
+# require 'pry'
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/lib/micro/attributes.rb

@@ -1,35 +1,30 @@
 # frozen_string_literal: true
 
-require "micro/attributes/version"
-require "micro/attributes/attributes_utils"
-require "micro/attributes/macros"
-require "micro/attributes/features"
+require 'kind'
 
 module Micro
   module Attributes
+    require 'micro/attributes/version'
+    require 'micro/attributes/utils'
+    require 'micro/attributes/diff'
+    require 'micro/attributes/macros'
+    require 'micro/attributes/features'
+
     def self.included(base)
       base.extend(::Micro::Attributes.const_get(:Macros))
 
       base.class_eval do
-        private_class_method :__attributes_data, :__attributes
-        private_class_method :__attributes_def, :__attributes_set
-        private_class_method :__attribute_reader, :__attribute_set
+        private_class_method :__attributes, :__attribute_reader
+        private_class_method :__attribute_assign, :__attributes_data_to_assign
       end
 
       def base.inherited(subclass)
-        subclass.attributes(self.attributes_data({}))
+        subclass.__attributes_set_after_inherit__(self.__attributes_data__)
+
         subclass.extend ::Micro::Attributes.const_get('Macros::ForSubclasses'.freeze)
       end
     end
 
-    def self.to_initialize(diff: false, activemodel_validations: false)
-      features(*Features.options(:initialize, diff, activemodel_validations))
-    end
-
-    def self.to_initialize!(diff: false, activemodel_validations: false)
-      features(*Features.options(:strict_initialize, diff, activemodel_validations))
-    end
-
     def self.without(*names)
       Features.without(names)
     end
@@ -38,32 +33,8 @@ module Micro
       Features.with(names)
     end
 
-    def self.feature(name)
-      self.with(name)
-    end
-
-    def self.features(*names)
-      names.empty? ? Features.all : Features.with(names)
-    end
-
-    protected def attributes=(arg)
-      self.class
-          .attributes_data(AttributesUtils.hash_argument!(arg))
-          .each { |name, value| __attribute_set(name, value) }
-
-      __attributes.freeze
-    end
-
-    private def __attributes
-      @__attributes ||= {}
-    end
-
-    private def __attribute_set(name, value)
-      __attributes[name] = instance_variable_set("@#{name}", value) if attribute?(name)
-    end
-
-    def attributes
-      __attributes
+    def self.with_all_features
+      Features.all
     end
 
     def attribute?(name)
@@ -83,5 +54,87 @@ module Micro
 
       raise NameError, "undefined attribute `#{name}"
     end
+
+    def attributes(*names)
+      return __attributes if names.empty?
+
+      names.each_with_object({}) do |name, memo|
+        memo[name] = attribute(name) if attribute?(name)
+      end
+    end
+
+    def defined_attributes
+      @defined_attributes ||= self.class.attributes
+    end
+
+    protected
+
+      def attributes=(arg)
+        hash = Utils.stringify_hash_keys(arg)
+
+        __attributes_missing!(hash)
+
+        __attributes_assign(hash)
+      end
+
+    private
+
+      ExtractAttribute = -> (other, key) {
+        return Utils::HashAccess.(other, key) if other.respond_to?(:[])
+
+        other.public_send(key) if other.respond_to?(key)
+      }
+
+      def extract_attributes_from(other)
+        defined_attributes.each_with_object({}) do |key, memo|
+          memo[key] = ExtractAttribute.(other, key)
+        end
+      end
+
+      def __attributes
+        @__attributes ||= {}
+      end
+
+      FetchValueToAssign = -> (value, default) do
+        if default.respond_to?(:call)
+          callable = default.is_a?(Proc) ? default : default.method(:call)
+
+          callable.arity > 0 ? callable.call(value) : callable.call
+        else
+          value.nil? ? default : value
+        end
+      end
+
+      def __attributes_assign(hash)
+        self.class.__attributes_data__.each do |name, default|
+          __attribute_assign(name, FetchValueToAssign.(hash[name], default)) if attribute?(name)
+        end
+
+        __attributes.freeze
+      end
+
+      def __attribute_assign(name, value)
+        __attributes[name] = instance_variable_set("@#{name}", value)
+      end
+
+      MISSING_KEYWORD = 'missing keyword'.freeze
+      MISSING_KEYWORDS = 'missing keywords'.freeze
+
+      def __attributes_missing!(hash)
+        required_keys = self.class.__attributes_required__
+
+        return if required_keys.empty?
+
+        missing_keys = required_keys.map { |name| ":#{name}" if !hash.key?(name) }
+        missing_keys.compact!
+
+        return if missing_keys.empty?
+
+        label = missing_keys.size == 1 ? MISSING_KEYWORD : MISSING_KEYWORDS
+
+        raise ArgumentError, "#{label}: #{missing_keys.join(', ')}"
+      end
+
+      private_constant :FetchValueToAssign, :MISSING_KEYWORD, :MISSING_KEYWORDS
   end
 end

data/lib/micro/attributes/diff.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Micro::Attributes
+  module Diff
+    class Changes
+      TO = 'to'.freeze
+      FROM = 'from'.freeze
+      FROM_TO_ERROR = 'pass the attribute name with the :from and :to values'.freeze
+
+      attr_reader :from, :to, :differences
+
+      def initialize(from:, to:)
+        raise ArgumentError, "expected an instance of #{from.class}" unless to.is_a?(from.class)
+        @from, @to = from, to
+        @differences = diff(from.attributes, to.attributes).freeze
+      end
+
+      def empty?
+        @differences.empty?
+      end
+      alias_method :blank?, :empty?
+
+      def present?
+        !empty?
+      end
+
+      def changed?(name = nil, from: nil, to: nil)
+        if name.nil?
+          return present? if from.nil? && to.nil?
+          raise ArgumentError, FROM_TO_ERROR
+        elsif from.nil? && to.nil?
+          differences.has_key?(name.to_s)
+        else
+          result = @differences[name.to_s]
+          result ? result[FROM] == from && result[TO] == to : false
+        end
+      end
+
+      private
+
+      def diff(from_attributes, to_attributes)
+        @from_attributes, @to_attributes = from_attributes, to_attributes
+        @from_attributes.each_with_object({}) do |(from_key, from_val), acc|
+          to_value = @to_attributes[from_key]
+          acc[from_key] = {FROM => from_val, TO => to_value}.freeze if from_val != to_value
+        end
+      end
+
+      private_constant :TO, :FROM, :FROM_TO_ERROR
+    end
+  end
+end

data/lib/micro/attributes/features.rb

@@ -1,22 +1,25 @@
 # frozen_string_literal: true
 
-require "micro/attributes/with"
+require 'micro/attributes/with'
 
 module Micro
   module Attributes
     module Features
       extend self
 
-      ALL = [
+      STRICT_INITIALIZE = 'strict_initialize'.freeze
+
+      ALL_VISIBLE = [
         DIFF = 'diff'.freeze,
         INITIALIZE = 'initialize'.freeze,
-        STRICT_INITIALIZE = 'strict_initialize'.freeze,
         ACTIVEMODEL_VALIDATIONS = 'activemodel_validations'.freeze
       ].sort.freeze
 
+      ALL = (ALL_VISIBLE + [STRICT_INITIALIZE]).sort.freeze
+
       INVALID_NAME = [
         'Invalid feature name! Available options: ',
-        ALL.map { |feature_name| ":#{feature_name}" }.join(', ')
+        ALL_VISIBLE.map { |feature_name| ":#{feature_name}" }.join(', ')
       ].join
 
       OPTIONS = {
@@ -32,8 +35,7 @@ module Micro
         'activemodel_validations:initialize' => With::ActiveModelValidationsAndInitialize,
         'activemodel_validations:strict_initialize' => With::ActiveModelValidationsAndStrictInitialize,
         'activemodel_validations:diff:initialize' => With::ActiveModelValidationsAndDiffAndInitialize,
-        'activemodel_validations:diff:strict_initialize' => With::ActiveModelValidationsAndDiffAndStrictInitialize,
-        ALL.join(':') => With::ActiveModelValidationsAndDiffAndStrictInitialize
+        'activemodel_validations:diff:strict_initialize' => With::ActiveModelValidationsAndDiffAndStrictInitialize
       }.freeze
 
       private_constant :OPTIONS, :INVALID_NAME
@@ -44,6 +46,8 @@ module Micro
 
       def with(args)
         valid_names!(args) do |names|
+          delete_initialize_if_has_strict_initialize(names)
+
           OPTIONS.fetch(names.sort.join(':'))
         end
       end
@@ -55,49 +59,53 @@ module Micro
         end
       end
 
-      def options(init, diff, activemodel_validations)
-        [init].tap do |options|
-          options << :diff if diff
-          options << :activemodel_validations if activemodel_validations
+      private
+
+        def fetch_feature_name(name)
+          return name unless name.is_a?(Hash)
+
+          STRICT_INITIALIZE if name[:initialize] == :strict
         end
-      end
 
-      private
+        def normalize_names(args)
+          names = Array(args).dup
 
-      def normalize_names(args)
-        Array(args).map { |arg| arg.to_s.downcase }.uniq
-      end
+          last_feature = fetch_feature_name(names.pop)
 
-      def valid_names?(names)
-        names.all? { |name| ALL.include?(name) }
-      end
+          features = names.empty? ? [last_feature] : names + [last_feature]
+          features.map! { |name| name.to_s.downcase }
+          features.uniq
+        end
 
-      def valid_names!(args)
-        names = normalize_names(args)
+        def valid_names?(names)
+          names.all? { |name| ALL.include?(name) }
+        end
 
-        raise ArgumentError, INVALID_NAME if args.empty? || !valid_names?(names)
+        def valid_names!(args)
+          names = normalize_names(args)
 
-        yield(names)
-      end
+          raise ArgumentError, INVALID_NAME if names.empty? || !valid_names?(names)
 
-      def has_strict_initialize?(names)
-        names.include?(STRICT_INITIALIZE)
-      end
+          yield(names)
+        end
 
-      def any_kind_of_initialize?(names)
-        names.include?(INITIALIZE) || has_strict_initialize?(names)
-      end
+        def an_initialize?(name)
+          name == INITIALIZE || name == STRICT_INITIALIZE
+        end
 
-      def an_initialize?(name)
-        name == INITIALIZE || name == STRICT_INITIALIZE
-      end
+        def delete_initialize_if_has_strict_initialize(names)
+          return unless names.include?(STRICT_INITIALIZE)
 
-      def except_options(names_to_exclude)
-        (ALL - names_to_exclude).tap do |names|
-          names.delete_if { |name| an_initialize?(name) } if any_kind_of_initialize?(names_to_exclude)
-          names.delete_if { |name| name == INITIALIZE } if has_strict_initialize?(names)
+          names.delete_if { |name| name == INITIALIZE }
+        end
+
+        def except_options(names_to_exclude)
+          (ALL - names_to_exclude).tap do |names|
+            names.delete_if { |name| an_initialize?(name) } if names_to_exclude.include?(INITIALIZE)
+
+            delete_initialize_if_has_strict_initialize(names)
+          end
         end
-      end
     end
   end
 end

data/lib/micro/attributes/features/activemodel_validations.rb

@@ -3,36 +3,30 @@
 module Micro::Attributes
   module Features
     module ActiveModelValidations
-      @@__active_model_required = false
-      @@__active_model_load_error = false
-
-      V32 = '3.2'
-
       def self.included(base)
-        if !@@__active_model_load_error && !@@__active_model_required
-          begin
-            require 'active_model'
-          rescue LoadError => e
-            @@__active_model_load_error = true
-          end
-          @@__active_model_required = true
-        end
+        begin
+          require 'active_model'
 
-        unless @@__active_model_load_error
           base.send(:include, ::ActiveModel::Validations)
+          base.extend(ClassMethods)
+        rescue LoadError
+        end
+      end
+
+      module ClassMethods
+        def __call_after_attribute_assign__(attr_name, options)
+          validate, validates = options.values_at(:validate, :validates)
 
-          if ::ActiveModel::VERSION::STRING >= V32
-            base.class_eval(<<-RUBY)
-              def initialize(arg)
-                self.attributes=arg
-                run_validations!
-              end
-            RUBY
-          end
+          self.validate(validate) if validate
+          self.validates(attr_name, validates) if validates
         end
       end
 
-      private_constant :V32
+      private
+
+        def __call_after_micro_attribute
+          run_validations! if respond_to?(:run_validations!, true)
+        end
     end
   end
 end

data/lib/micro/attributes/features/diff.rb

@@ -3,59 +3,11 @@
 module Micro::Attributes
   module Features
     module Diff
-      class Changes
-        TO = 'to'.freeze
-        FROM = 'from'.freeze
-        FROM_TO_ERROR = 'pass the attribute name with the :from and :to values'.freeze
-
-        attr_reader :from, :to, :differences
-
-        def initialize(from:, to:)
-          raise ArgumentError, "expected an instance of #{from.class}" unless to.is_a?(from.class)
-          @from, @to = from, to
-          @differences = diff(from.attributes, to.attributes).freeze
-        end
-
-        def empty?
-          @differences.empty?
-        end
-        alias_method :blank?, :empty?
-
-        def present?
-          !empty?
-        end
-
-        def changed?(name = nil, from: nil, to: nil)
-          if name.nil?
-            return present? if from.nil? && to.nil?
-            raise ArgumentError, FROM_TO_ERROR
-          elsif from.nil? && to.nil?
-            differences.has_key?(name.to_s)
-          else
-            result = @differences[name.to_s]
-            result ? result[FROM] == from && result[TO] == to : false
-          end
-        end
-
-        private
-
-        def diff(from_attributes, to_attributes)
-          @from_attributes, @to_attributes = from_attributes, to_attributes
-          @from_attributes.each_with_object({}) do |(from_key, from_val), acc|
-            to_value = @to_attributes[from_key]
-            acc[from_key] = {FROM => from_val, TO => to_value}.freeze if from_val != to_value
-          end
-        end
-
-        private_constant :TO, :FROM, :FROM_TO_ERROR
-      end
-
       def diff_attributes(to)
-        return Changes.new(from: self, to: to) if to.is_a?(::Micro::Attributes)
+        return Micro::Attributes::Diff::Changes.new(from: self, to: to) if to.is_a?(::Micro::Attributes)
+
         raise ArgumentError, "#{to.inspect} must implement Micro::Attributes"
       end
-
-      private_constant :Changes
     end
   end
 end