u-attributes 1.0.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,65 +1,39 @@
 # 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))
+    def self.without(*names)
+      Features.without(names)
     end
 
     def self.with(*names)
       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)
@@ -79,5 +53,49 @@ 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
+
+    protected
+
+      def attributes=(arg)
+        hash = Utils.stringify_hash_keys(arg)
+
+        __attributes_set(hash, self.class.__attributes_data__)
+      end
+
+    private
+
+      def __attributes
+        @__attributes ||= {}
+      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,18 +1,33 @@
 # frozen_string_literal: true
 
-require "micro/attributes/with"
+require 'micro/attributes/with'
 
 module Micro
   module Attributes
     module Features
-      INVALID_FEATURES = 'Invalid feature name! Available options: :initialize, :strict_initialize, :diff, :activemodel_validations'.freeze
+      extend self
+
+      STRICT_INITIALIZE = 'strict_initialize'.freeze
+
+      ALL_VISIBLE = [
+        DIFF = 'diff'.freeze,
+        INITIALIZE = 'initialize'.freeze,
+        ACTIVEMODEL_VALIDATIONS = 'activemodel_validations'.freeze
+      ].sort.freeze
+
+      ALL = (ALL_VISIBLE + [STRICT_INITIALIZE]).sort.freeze
+
+      INVALID_NAME = [
+        'Invalid feature name! Available options: ',
+        ALL_VISIBLE.map { |feature_name| ":#{feature_name}" }.join(', ')
+      ].join
 
       OPTIONS = {
         # Features
-        'diff' => With::Diff,
-        'initialize' => With::Initialize,
-        'strict_initialize' => With::StrictInitialize,
-        'activemodel_validations' => With::ActiveModelValidations,
+        DIFF => With::Diff,
+        INITIALIZE => With::Initialize,
+        STRICT_INITIALIZE => With::StrictInitialize,
+        ACTIVEMODEL_VALIDATIONS => With::ActiveModelValidations,
         # Combinations
         'diff:initialize' => With::DiffAndInitialize,
         'diff:strict_initialize' => With::DiffAndStrictInitialize,
@@ -23,24 +38,74 @@ module Micro
         'activemodel_validations:diff:strict_initialize' => With::ActiveModelValidationsAndDiffAndStrictInitialize
       }.freeze
 
-      private_constant :OPTIONS
+      private_constant :OPTIONS, :INVALID_NAME
 
-      def self.all
-        With::ActiveModelValidationsAndDiffAndInitialize
+      def all
+        @all ||= self.with(ALL)
       end
 
-      def self.with(names)
-        option = OPTIONS[names.map { |name| name.to_s.downcase }.sort.join(':')]
-        return option if option
-        raise ArgumentError, INVALID_FEATURES
+      def with(args)
+        valid_names!(args) do |names|
+          delete_initialize_if_has_strict_initialize(names)
+
+          OPTIONS.fetch(names.sort.join(':'))
+        end
       end
 
-      def self.options(init, diff, activemodel_validations)
-        [init].tap do |options|
-          options << :diff if diff
-          options << :activemodel_validations if activemodel_validations
+      def without(args)
+        valid_names!(args) do |names_to_exclude|
+          names = except_options(names_to_exclude)
+          names.empty? ? ::Micro::Attributes : self.with(names)
         end
       end
+
+      private
+
+        def fetch_feature_name(name)
+          return name unless name.is_a?(Hash)
+
+          STRICT_INITIALIZE if name[:initialize] == :strict
+        end
+
+        def normalize_names(args)
+          names = Array(args).dup
+
+          last_feature = fetch_feature_name(names.pop)
+
+          features = names.empty? ? [last_feature] : names + [last_feature]
+          features.map! { |name| name.to_s.downcase }
+          features.uniq
+        end
+
+        def valid_names?(names)
+          names.all? { |name| ALL.include?(name) }
+        end
+
+        def valid_names!(args)
+          names = normalize_names(args)
+
+          raise ArgumentError, INVALID_NAME if names.empty? || !valid_names?(names)
+
+          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)
+
+          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

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