u-attributes 2.4.0 → 2.8.0

data/lib/micro/attributes/utils.rb

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

data/lib/micro/attributes/version.rb

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

data/lib/micro/attributes.rb

@@ -15,7 +15,8 @@ module Micro
 
       base.class_eval do
         private_class_method :__attributes, :__attribute_reader
-        private_class_method :__attribute_assign, :__attributes_data_to_assign
+        private_class_method :__attribute_assign, :__attributes_groups
+        private_class_method :__attributes_required_add, :__attributes_data_to_assign
       end
 
       def base.inherited(subclass)
@@ -37,8 +38,8 @@ module Micro
       Features.all
     end
 
-    def attribute?(name)
-      self.class.attribute?(name)
+    def attribute?(name, include_all = false)
+      self.class.attribute?(name, include_all)
     end
 
     def attribute(name)
@@ -52,10 +53,12 @@ module Micro
     def attribute!(name, &block)
       attribute(name) { |name| return block ? block[name] : name }
 
-      raise NameError, "undefined attribute `#{name}"
+      raise NameError, __attribute_access_error_message(name)
     end
 
-    def defined_attributes
+    def defined_attributes(option = nil)
+      return self.class.attributes_by_visibility if option == :by_visibility
+
       @defined_attributes ||= self.class.attributes
     end
 
@@ -86,45 +89,76 @@ module Micro
     protected
 
       def attributes=(arg)
-        hash = self.class.__attributes_keys__(arg)
+        hash = self.class.__attributes_keys_transform__(arg)
 
         __attributes_missing!(hash)
 
+        __call_before_attributes_assign
         __attributes_assign(hash)
+        __call_after_attributes_assign
+
+        __attributes
       end
 
     private
 
+      def __call_before_attributes_assign; end
+      def __call_after_attributes_assign; end
+
       def extract_attributes_from(other)
         Utils::ExtractAttribute.from(other, keys: defined_attributes)
       end
 
+      def __attribute_access_error_message(name)
+        return "tried to access a private attribute `#{name}" if attribute?(name, true)
+
+        "undefined attribute `#{name}"
+      end
+
       def __attribute_key(value)
-        self.class.__attribute_key__(value)
+        self.class.__attribute_key_transform__(value)
       end
 
       def __attributes
         @__attributes ||= {}
       end
 
-      FetchValueToAssign = -> (value, default) do
-        if default.is_a?(Proc)
-          default.arity > 0 ? default.call(value) : default.call
-        else
-          value.nil? ? default : value
-        end
+      FetchValueToAssign = -> (init_hash, value, attribute_data, keep_proc = false) do
+        default = attribute_data[0]
+
+        value_to_assign =
+          if default.is_a?(Proc) && !keep_proc
+            case default.arity
+            when 0 then default.call
+            when 2 then default.call(value, init_hash)
+            else default.call(value)
+            end
+          else
+            value.nil? ? default : value
+          end
+
+        return value_to_assign unless to_freeze = attribute_data[2]
+        return value_to_assign.freeze if to_freeze == true
+        return value_to_assign.dup.freeze if to_freeze == :after_dup
+        return value_to_assign.clone.freeze if to_freeze == :after_clone
+
+        raise NotImplementedError
       end
 
       def __attributes_assign(hash)
-        self.class.__attributes_data__.each do |name, default|
-          __attribute_assign(name, FetchValueToAssign.(hash[name], default)) if attribute?(name)
+        self.class.__attributes_data__.each do |name, attribute_data|
+          __attribute_assign(name, hash, attribute_data) if attribute?(name, true)
         end
 
         __attributes.freeze
       end
 
-      def __attribute_assign(name, value)
-        __attributes[name] = instance_variable_set("@#{name}", value)
+      def __attribute_assign(name, init_hash, attribute_data)
+        value_to_assign = FetchValueToAssign.(init_hash, init_hash[name], attribute_data)
+
+        ivar_value = instance_variable_set("@#{name}", value_to_assign)
+
+        __attributes[name] = ivar_value if attribute_data[3] == :public
       end
 
       MISSING_KEYWORD = 'missing keyword'.freeze

data/u-attributes.gemspec

@@ -9,11 +9,10 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Rodrigo Serradura']
   spec.email         = ['rodrigo.serradura@gmail.com']
 
-  spec.summary       = %q{Create "immutable" objects. No setters, just getters!}
+  spec.summary       = %q{Create "immutable" objects with no setters, just getters.}
   spec.description   =
-    "This gem allows you to define \"immutable\" objects, and your objects will have only getters and no setters. "\
-    "So, if you change some object attribute, you will have a new object instance. " \
-    "That is, you transform the object instead of modifying it."
+    'This gem allows you to define "immutable" objects, when using it your objects will only have getters and no setters.' \
+    'So, if you change an attribute of the object, you’ll have a new object instance.'
   spec.homepage      = 'https://github.com/serradura/u-attributes'
   spec.license       = 'MIT'
 
@@ -28,7 +27,7 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.2.0'
 
-  spec.add_runtime_dependency 'kind', '>= 3.0', '< 5.0'
+  spec.add_runtime_dependency 'kind', '>= 4.0', '< 6.0'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake', '~> 13.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: u-attributes
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.8.0
 platform: ruby
 authors:
 - Rodrigo Serradura
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-09-12 00:00:00.000000000 Z
+date: 2021-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: kind
@@ -16,20 +16,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '4.0'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -58,29 +58,32 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '13.0'
-description: This gem allows you to define "immutable" objects, and your objects will
-  have only getters and no setters. So, if you change some object attribute, you will
-  have a new object instance. That is, you transform the object instead of modifying
-  it.
+description: This gem allows you to define "immutable" objects, when using it your
+  objects will only have getters and no setters.So, if you change an attribute of
+  the object, you’ll have a new object instance.
 email:
 - rodrigo.serradura@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
-- ".travis.sh"
-- ".travis.yml"
+- ".vscode/settings.json"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
+- bin/prepare_coverage
 - bin/setup
+- bin/test
 - lib/micro/attributes.rb
 - lib/micro/attributes/diff.rb
 - lib/micro/attributes/features.rb
+- lib/micro/attributes/features/accept.rb
+- lib/micro/attributes/features/accept/strict.rb
 - lib/micro/attributes/features/activemodel_validations.rb
 - lib/micro/attributes/features/diff.rb
 - lib/micro/attributes/features/initialize.rb
@@ -89,15 +92,13 @@ files:
 - lib/micro/attributes/macros.rb
 - lib/micro/attributes/utils.rb
 - lib/micro/attributes/version.rb
-- lib/micro/attributes/with.rb
 - lib/u-attributes.rb
-- test.sh
 - u-attributes.gemspec
 homepage: https://github.com/serradura/u-attributes
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -112,8 +113,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.2.17
+signing_key:
 specification_version: 4
-summary: Create "immutable" objects. No setters, just getters!
+summary: Create "immutable" objects with no setters, just getters.
 test_files: []

data/.travis.sh

@@ -1,31 +0,0 @@
-#!/bin/bash
-
-bundle exec rake test
-
-ACTIVEMODEL_VERSION='3.2' bundle update
-ACTIVEMODEL_VERSION='3.2' bundle exec rake test
-
-ACTIVEMODEL_VERSION='4.0' bundle update
-ACTIVEMODEL_VERSION='4.0' bundle exec rake test
-
-ACTIVEMODEL_VERSION='4.1' bundle update
-ACTIVEMODEL_VERSION='4.1' bundle exec rake test
-
-ACTIVEMODEL_VERSION='4.2' bundle update
-ACTIVEMODEL_VERSION='4.2' bundle exec rake test
-
-ACTIVEMODEL_VERSION='5.0' bundle update
-ACTIVEMODEL_VERSION='5.0' bundle exec rake test
-
-ACTIVEMODEL_VERSION='5.1' bundle update
-ACTIVEMODEL_VERSION='5.1' bundle exec rake test
-
-if [[ ! $ruby_v =~ '2.2.0' ]]; then
-  ACTIVEMODEL_VERSION='5.2' bundle update
-  ACTIVEMODEL_VERSION='5.2' bundle exec rake test
-fi
-
-if [[ $ruby_v =~ '2.5.' ]] || [[ $ruby_v =~ '2.6.' ]] || [[ $ruby_v =~ '2.7.' ]]; then
-  ACTIVEMODEL_VERSION='6.0' bundle update
-  ACTIVEMODEL_VERSION='6.0' bundle exec rake test
-fi

data/.travis.yml

@@ -1,28 +0,0 @@
-language: ruby
-
-rvm:
-- 2.2.2
-- 2.3.0
-- 2.4.0
-- 2.5.0
-- 2.6.0
-- 2.7.0
-- truffleruby-head
-
-cache: bundler
-
-before_install:
-  - gem uninstall -v '>= 2' -i $(rvm gemdir)@global -ax bundler || true
-  - gem install bundler -v '< 2'
-
-install: bundle install --jobs=3 --retry=3
-
-before_script:
-  - curl -L https://codeclimate.com/downloads/test-reporter/test-reporter-latest-linux-amd64 > ./cc-test-reporter
-  - chmod +x ./cc-test-reporter
-  - './cc-test-reporter before-build'
-
-script: './.travis.sh'
-
-after_success:
-  - './cc-test-reporter after-build -t simplecov'

data/lib/micro/attributes/with.rb

@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-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
-      #
-      # Features
-      #
-      module Diff
-        def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-        end
-      end
-
-      module Initialize
-        def self.included(base)
-          base.send(:include, ::Micro::Attributes)
-          base.send(:include, ::Micro::Attributes::Features::Initialize)
-        end
-      end
-
-      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::KeysAsSymbol)
-        end
-      end
-
-      module ActiveModelValidations
-        def self.included(base)
-          base.send(:include, Initialize)
-          base.send(:include, ::Micro::Attributes::Features::ActiveModelValidations)
-        end
-      end
-
-      #
-      # Combinations
-      #
-      module AMValidations_Diff
-        def self.included(base)
-          base.send(:include, ActiveModelValidations)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-        end
-      end
-
-      module AMValidations_Diff_Init
-        def self.included(base)
-          base.send(:include, ActiveModelValidations)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-        end
-      end
-
-      module AMValidations_Diff_Init_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, ActiveModelValidations)
-          base.send(:include, ::Micro::Attributes::Features::Diff)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module AMValidations_Diff_InitStrict
-        def self.included(base)
-          base.send(:include, AMValidations_Diff_Init)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
-        end
-      end
-
-      module AMValidations_Diff_InitStrict_KeysAsSymbol
-        def self.included(base)
-          base.send(:include, AMValidations_Diff_Init)
-          base.send(:include, ::Micro::Attributes::Features::Initialize::Strict)
-          base.send(:include, ::Micro::Attributes::Features::KeysAsSymbol)
-        end
-      end
-
-      module AMValidations_Diff_KeysAsSymbol
-        def self.included(base)
-          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 Diff_Init_KeysAsSymbol
-        def self.included(base)
-          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