u-attributes 1.2.0 → 2.0.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,29 @@
 # 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_set, :__attribute_reader
       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,28 +32,26 @@ module Micro
       Features.with(names)
     end
 
-    def self.feature(name)
-      self.with(name)
+    def self.with_all_features
+      Features.all
     end
 
-    def self.features(*names)
-      names.empty? ? Features.all : Features.with(names)
+    def attribute?(name)
+      self.class.attribute?(name)
     end
 
-    protected def attributes=(arg)
-      self.class
-          .attributes_data(AttributesUtils.hash_argument!(arg))
-          .each { |name, value| __attribute_set(name, value) }
+    def attribute(name)
+      return unless attribute?(name)
 
-      __attributes.freeze
-    end
+      value = public_send(name)
 
-    private def __attributes
-      @__attributes ||= {}
+      block_given? ? yield(value) : value
     end
 
-    private def __attribute_set(name, value)
-      __attributes[name] = instance_variable_set("@#{name}", value) if attribute?(name)
+    def attribute!(name, &block)
+      attribute(name) { |name| return block ? block[name] : name }
+
+      raise NameError, "undefined attribute `#{name}"
     end
 
     def attributes(*names)
@@ -70,22 +62,40 @@ module Micro
       end
     end
 
-    def attribute?(name)
-      self.class.attribute?(name)
-    end
+    protected
 
-    def attribute(name)
-      return unless attribute?(name)
+      def attributes=(arg)
+        hash = Utils.stringify_hash_keys(arg)
 
-      value = public_send(name)
+        __attributes_set(hash, self.class.__attributes_data__)
+      end
 
-      block_given? ? yield(value) : value
-    end
+    private
 
-    def attribute!(name, &block)
-      attribute(name) { |name| return block ? block[name] : name }
+      def __attributes
+        @__attributes ||= {}
+      end
 
-      raise NameError, "undefined attribute `#{name}"
-    end
+      def __attribute_set(name, value)
+        __attributes[name] = instance_variable_set("@#{name}", value) if attribute?(name)
+      end
+
+      def __attributes_set(hash, att_data)
+        att_data.each do |key, default|
+          value = hash[key]
+
+          final_value =
+            if default.respond_to?(:call)
+              callable = default.is_a?(Proc) ? default : default.method(:call)
+              callable.arity > 0 ? callable.call(value) : callable.call
+            else
+              value || default
+            end
+
+          __attribute_set(key, final_value)
+        end
+
+        __attributes.freeze
+      end
   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 = {
@@ -56,48 +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 an_initialize?(name)
-        name == INITIALIZE || name == STRICT_INITIALIZE
-      end
+          yield(names)
+        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 delete_initialize_if_has_strict_initialize(names)
+          return unless names.include?(STRICT_INITIALIZE)
 
-        names.delete_if { |name| name == INITIALIZE }
-      end
+          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)
+        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)
+            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_set__(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