u-attributes 2.0.1 → 2.4.0

data/lib/micro/attributes/macros.rb

@@ -3,10 +3,49 @@
 module Micro
   module Attributes
     module Macros
+      def attributes_are_all_required?
+        false
+      end
+
+      def attributes_access
+        :indifferent
+      end
+
+      def __attribute_access__(value)
+        value
+      end
+
+      def __attribute_key__(value)
+        value.to_s
+      end
+
+      def __attributes_keys__(hash)
+        Utils::Hashes.stringify_keys(hash)
+      end
+
+      # NOTE: can't be renamed! It is used by u-case v4.
       def __attributes_data__
         @__attributes_data__ ||= {}
       end
 
+      def __attributes_required__
+        @__attributes_required__ ||= Set.new
+      end
+
+      def __attributes_required_add(name, is_required, hasnt_default)
+        if is_required || (attributes_are_all_required? && hasnt_default)
+          __attributes_required__.add(name)
+        end
+
+        nil
+      end
+
+      def __attributes_data_to_assign(name, options)
+        hasnt_default = !options.key?(:default)
+
+        hasnt_default ? __attributes_required_add(name, options[:required], hasnt_default) : options[:default]
+      end
+
       def __attributes
         @__attributes ||= Set.new
       end
@@ -17,48 +56,57 @@ module Micro
         attr_reader(name)
       end
 
-      def __attribute_set(key, can_overwrite, options)
-        name = key.to_s
+      def __attribute_assign(key, can_overwrite, options)
+        name = __attribute_access__(__attribute_key__(key))
         has_attribute = attribute?(name)
 
         __attribute_reader(name) unless has_attribute
-        __attributes_data__[name] = options[:default] if can_overwrite || !has_attribute
 
-        __call_after_attribute_set__(name, options)
+        __attributes_data__[name] = __attributes_data_to_assign(name, options) if can_overwrite || !has_attribute
+
+        __call_after_attribute_assign__(name, options)
       end
 
-      def __call_after_attribute_set__(attr_name, options); end
+      def __call_after_attribute_assign__(attr_name, options); end
 
+      # NOTE: can't be renamed! It is used by u-case v4.
       def __attributes_set_after_inherit__(arg)
-        arg.each { |key, val| __attribute_set(key, true, default: val) }
+        arg.each do |key, val|
+          __attribute_assign(key, true, val ? { default: val } : {})
+        end
       end
 
       def attribute?(name)
-        __attributes.member?(name.to_s)
+        __attributes.member?(__attribute_key__(name))
       end
 
       def attribute(name, options = Kind::Empty::HASH)
-        __attribute_set(name, false, options)
+        __attribute_assign(name, false, options)
       end
 
       def attributes(*args)
         return __attributes.to_a if args.empty?
 
         args.flatten!
+
+        options =
+          args.size > 1 && args.last.is_a?(::Hash) ? args.pop : Kind::Empty::HASH
+
         args.each do |arg|
           if arg.is_a?(String) || arg.is_a?(Symbol)
-            __attribute_set(arg, false, Kind::Empty::HASH)
+            __attribute_assign(arg, false, options)
           else
             raise Kind::Error.new('String/Symbol'.freeze, arg)
           end
         end
       end
 
+      # NOTE: can't be renamed! It is used by u-case v4.
       module ForSubclasses
         WRONG_NUMBER_OF_ARGS = 'wrong number of arguments (given 0, expected 1 or more)'.freeze
 
         def attribute!(name, options = Kind::Empty::HASH)
-          __attribute_set(name, true, options)
+          __attribute_assign(name, true, options)
         end
 
         private_constant :WRONG_NUMBER_OF_ARGS

data/lib/micro/attributes/utils.rb

@@ -1,17 +1,56 @@
 # frozen_string_literal: true
 
-module Micro
-  module Attributes
-    module Utils
-      def self.stringify_hash_keys(arg)
-        hash = Kind::Of.(::Hash, arg)
+module Micro::Attributes
+  module Utils
+    module Hashes
+      def self.kind(hash)
+        Kind::Of.(::Hash, hash)
+      end
+
+      def self.stringify_keys(arg)
+        hash = kind(arg)
+
+        return hash if hash.empty?
+        return hash.transform_keys(&:to_s) if hash.respond_to?(:transform_keys)
+
+        hash.each_with_object({}) { |(key, val), memo| memo[key.to_s] = val }
+      end
+
+      def self.symbolize_keys(arg)
+        hash = kind(arg)
 
         return hash if hash.empty?
+        return hash.transform_keys(&:to_sym) if hash.respond_to?(:transform_keys)
+
+        hash.each_with_object({}) { |(key, val), memo| memo[key.to_sym] = val }
+      end
+
+      def self.keys_as(type, hash)
+        return kind(hash) unless type
+
+        return symbolize_keys(hash) if type == Symbol || type == :symbol
+        return stringify_keys(hash) if type == String || type == :string
+
+        raise ArgumentError, 'argument must be one of these values: :symbol, :string, Symbol, String'.freeze
+      end
+
+      def self.assoc(hash, key)
+        value = hash[key.to_s]
+
+        value.nil? ? hash[key.to_sym] : value
+      end
+    end
+
+    module ExtractAttribute
+      def self.call(object, key:)
+        return object.public_send(key) if object.respond_to?(key)
+
+        Hashes.assoc(object, key) if object.respond_to?(:[])
+      end
 
-        if hash.respond_to?(:transform_keys)
-          hash.transform_keys { |key| key.to_s }
-        else
-          hash.each_with_object({}) { |(key, val), memo| memo[key.to_s] = val }
+      def self.from(object, keys:)
+        Kind::Of.(::Array, keys).each_with_object({}) do |key, memo|
+          memo[key] = call(object, key: key)
         end
       end
     end

data/lib/micro/attributes/version.rb

@@ -2,6 +2,6 @@
 
 module Micro
   module Attributes
-    VERSION = '2.0.1'.freeze
+    VERSION = '2.4.0'.freeze
   end
 end

data/lib/micro/attributes/with.rb

@@ -3,8 +3,10 @@
 require 'micro/attributes/features/diff'
 require 'micro/attributes/features/initialize'
 require 'micro/attributes/features/initialize/strict'
+require 'micro/attributes/features/keys_as_symbol'
 require 'micro/attributes/features/activemodel_validations'
 
+
 module Micro
   module Attributes
     module With
@@ -25,76 +27,156 @@ module Micro
         end
       end
 
-      module ActiveModelValidations
+      module StrictInitialize
+        def self.included(base)
+          base.send(:include, Initialize)
+          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
+        end
+      end
+
+      module KeysAsSymbol
         def self.included(base)
           base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
         end
       end
 
-      module StrictInitialize
+      module ActiveModelValidations
         def self.included(base)
           base.send(:include, Initialize)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
+          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
         end
       end
 
       #
       # Combinations
       #
-      module DiffAndInitialize
+      module AMValidations_Diff
         def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Initialize)
+          base.send(:include, ActiveModelValidations)
           base.send(:include, ::Micro::Attributes::Features::Diff)
         end
       end
 
-      module DiffAndStrictInitialize
+      module AMValidations_Diff_Init
         def self.included(base)
-          base.send(:include, DiffAndInitialize)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
+          base.send(:include, ActiveModelValidations)
+          base.send(:include, ::Micro::Attributes::Features::Diff)
         end
       end
 
-      module ActiveModelValidationsAndDiff
+      module AMValidations_Diff_Init_KeysAsSymbol
         def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
+          base.send(:include, ActiveModelValidations)
           base.send(:include, ::Micro::Attributes::Features::Diff)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
         end
       end
 
-      module ActiveModelValidationsAndInitialize
+      module AMValidations_Diff_InitStrict
         def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Initialize)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
+          base.send(:include, AMValidations_Diff_Init)
+          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
         end
       end
 
-      module ActiveModelValidationsAndStrictInitialize
+      module AMValidations_Diff_InitStrict_KeysAsSymbol
         def self.included(base)
-          base.send(:include, ActiveModelValidationsAndInitialize)
+          base.send(:include, AMValidations_Diff_Init)
           base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
         end
       end
 
-      module ActiveModelValidationsAndDiffAndInitialize
+      module AMValidations_Diff_KeysAsSymbol
         def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Initialize)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
+          base.send(:include, AMValidations_Diff)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module AMValidations_Init
+        def self.included(base)
+          base.send(:include, ActiveModelValidations)
+        end
+      end
+
+      module AMValidations_Init_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, AMValidations_Init)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module AMValidations_InitStrict
+        def self.included(base)
+          base.send(:include, ActiveModelValidations)
+          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
+        end
+      end
+
+      module AMValidations_InitStrict_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, AMValidations_InitStrict)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module AMValidations_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, ActiveModelValidations)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module Diff_Init
+        def self.included(base)
+          base.send(:include, Initialize)
           base.send(:include, ::Micro::Attributes::Features::Diff)
         end
       end
 
-      module ActiveModelValidationsAndDiffAndStrictInitialize
+      module Diff_Init_KeysAsSymbol
         def self.included(base)
-          base.send(:include, ActiveModelValidationsAndDiffAndInitialize)
+          base.send(:include, Diff_Init)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module Diff_InitStrict
+        def self.included(base)
+          base.send(:include, Diff_Init)
           base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
         end
       end
+
+      module Diff_InitStrict_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, Diff_InitStrict)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module Diff_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, Diff)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module Init_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, Initialize)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
+
+      module InitStrict_KeysAsSymbol
+        def self.included(base)
+          base.send(:include, StrictInitialize)
+          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
+        end
+      end
     end
   end
 end

data/u-attributes.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|assets)/}) }
   end
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-attributes
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Rodrigo Serradura
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-21 00:00:00.000000000 Z
+date: 2020-09-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kind
@@ -85,6 +85,7 @@ files:
 - lib/micro/attributes/features/diff.rb
 - lib/micro/attributes/features/initialize.rb
 - lib/micro/attributes/features/initialize/strict.rb
+- lib/micro/attributes/features/keys_as_symbol.rb
 - lib/micro/attributes/macros.rb
 - lib/micro/attributes/utils.rb
 - lib/micro/attributes/version.rb