trinkets 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb82b9c6f72cce48f7d303e989870bc05e77429508c17f266428d15bc0821628
-  data.tar.gz: 1dc0a8334a869e8be5b4e397caeed6be9ff16b495514425e184938d538b0b2e1
+  metadata.gz: 1b95bff0eaa948f0edc0375709fd3ec786ad10e970f5b5abcd501247dceb1e74
+  data.tar.gz: 3d4d1bce01e034167209cad41d9bf4ad356d79ddf100cfc1968d16b9686a06f9
 SHA512:
-  metadata.gz: 4b57aecbcc07de7c710804302accad6fe49d610c133fabf74040a0cca376129258dc064eb967c0ff50570d72b46d641160fda6485222d29f47f06117b57db55c
-  data.tar.gz: 7714dbbd7e295d87d9f6c98aac8d6aade0d6a57d86e69368c039e8022824511f897f1a2d8f90f5f70b1fb598741b4bfbfdbb5308a164f40dc2fcb6da01491148
+  metadata.gz: 5b3a7cc743fae16ee12cfab9d9efc4236b31d69d8a570fe1bbf009cc3558be08d3cef3a38aa110403fb40dea019a3236adbf4a00c983c5f1f4e148a909bfb884
+  data.tar.gz: e94881a3dc54ca93be7ea759b0b6aff8607b9d91d7d1247d3ec2f59d265ecb2ea4c7f014754ca9a4a351ee6994eabb2fcae0e93fe0d14d27a46b01985370c3f6

data/CHANGELOG.md

@@ -1,4 +1,7 @@
 
+### [0.4.0](https://github.com/SilverPhoenix99/trinkets/tree/v0.4.0)
+* `Class::init`: Allow default values for keyword arguments.
+ 
 ### [0.3.1](https://github.com/SilverPhoenix99/trinkets/tree/v0.3.1)
 * Fixed repeated arguments in `Class::init`.
 

data/doc/class/init.md

@@ -9,6 +9,10 @@ To use it, define a class and call `::init` like you would call `::attr` methods
     * can be `:accessor`, `:reader`, `:writer` or `:none` 
     * defaults to `:accessor`
   * `kw` : if arguments are to be set as keyword arguments
+    * when `false`, it's a mandatory positional argument
+    * when `true`, it becomes a mandatory keyword argument, like `(a:)`
+    * when it's a hash, like `{ default: <VALUE> }`, it's an optional keyword argument
+    * an empty hash `{}` is equivalent to `{ default: nil }`
     * defaults to `false`
 
 The same options can be used per individual argument.
@@ -147,6 +151,33 @@ test.a = 5
 # => raises NoMethodError
 ```
 
+## Default values for keyword arguments
+
+```ruby
+class TestDefaultKw
+  init [:a, kw: true],
+       :b,
+       kw: {default: 3}
+end
+
+# would be the same as
+class TestDefaultKw
+  attr_accessor :a, :b
+  def initialize(a: , b: 3)
+    @a = a
+    @b = b
+  end
+end
+
+test = TestDefaultKw.new(a: 2)
+
+test.a
+# 2
+
+test.b
+# 3
+``` 
+
 ## Mixed together
 ```ruby
 class TestMixed

data/lib/explicit/trinkets/extend/class/init.rb

@@ -6,13 +6,9 @@ module Trinkets
       ATTR = %i[accessor reader writer none].freeze
 
       def init(*attrs, attr: ATTR.first, kw: false)
-        raise ArgumentError, 'At least 1 attribute is required.' if attrs.empty?
-        raise ArgumentError, '`attr` must be one of :accessor (default), :reader, :writer or :none' unless ATTR.include?(attr)
-
-        default_attr_options = { attr: attr, kw: kw }
-
-        attrs = ::Trinkets::Class.send(:sanitize_attrs, attrs, default_attr_options)
+        attrs = Init.send(:sanitize_attrs, attrs, attr: attr, kw: kw)
 
+        # @type [Hash[Symbol, Method]]
         attr_methods = (ATTR - [:none])
           .each_with_object({}) do |name, h|
             h[name] = method("attr_#{name}")
@@ -21,77 +17,98 @@ module Trinkets
         # even though options like `kw` aren't used, they serve here to validate the `attrs` options
         attr_init = ->(name, attr: ATTR.first, kw: false) do
           unless ATTR.include?(attr)
-            raise ArgumentError, "attr `#{name}`, option attr` must be one of :accessor (default), :reader, :writer or :none"
+            raise ArgumentError, "wrong `attr` type for `#{name.inspect}` (given #{attr.inspect}, expected :accessor (default), :reader, :writer or :none)"
           end
           attr_methods[attr].call(name) unless attr == :none
         end
 
         attrs.each { |name, opts| attr_init.call(name, **opts) }
 
-        # 2 hashes: { :name => bool }
-        kw_attrs, attrs = attrs
-          .map  { |name, opts| [name, opts[:kw]] }
-          .partition { |_, kw_opt| kw_opt }
-          .map(&:to_h)
-
-        init_method = ::Trinkets::Class.send(:define_initialize, attrs, kw_attrs)
+        # hash with 3 keys: {
+        #   FalseClass => []  # positional args
+        #   TrueClass  => []  # mandatory kw args
+        #   Hash       => []  # optional kw args with default value
+        # }
+        grouped_params = attrs
+          .map { |name, opts| [name, opts[:kw] || false] }
+          .group_by { _1.last.class }
+
+        pos_params    = [*grouped_params[FalseClass]].map(&:first)
+        kw_params     = [*grouped_params[TrueClass]].map(&:first)
+        opt_kw_params = [*grouped_params[Hash]].to_h
+          .transform_values! { _1[:default] }
+
+        init_method = Init.send(:define_initialize, pos_params, kw_params, opt_kw_params)
         define_method :initialize, init_method
       end
-    end
-
-    class << self
-      private def sanitize_attrs(attrs, default_attr_options)
-        # Normalize attrs into an array: [[:name, **options], ...]
-        # @type [Array[Array[Symbol, Hash]]]
-        attrs = attrs.map do |a|
-          name, opts = [*a]
-          name = name.to_s.sub(/^@/, '').to_sym
-          opts = default_attr_options.merge(opts || {})
-          [name, opts]
-        end
-
-        repeated_attrs = attrs.map(&:first)
-          .tally
-          .select { |_, count| count > 1 }
-          .keys
-
-        raise ArgumentError, "duplicated argument names: #{repeated_attrs.join(', ')}" if repeated_attrs.any?
 
-        attrs.to_h
-      end
+      class << self
+        private def sanitize_attrs(attrs, **default_options)
 
-      # @param [Hash[Symbol  Boolean]] attrs
-      # @param [Hash[Symbol  Boolean]] kw_attrs
-      private def define_initialize(attrs, kw_attrs)
-        ->(*values, **kw_values) do
+          raise ArgumentError, 'At least 1 attribute is required.' if attrs.empty?
 
-          unless attrs.size == values.size
-            raise ArgumentError, "wrong number of arguments (given #{values.size}, expected #{attrs.size})"
+          unless ::Trinkets::Class::Init::ATTR.include?(default_options[:attr])
+            attr = default_options[:attr].inspect
+            raise ArgumentError, "wrong `attr` type (given #{attr}, expected :accessor (default), :reader, :writer or :none)"
           end
 
-          missing_keys = kw_attrs.except(*kw_values.keys)
-          unless missing_keys.empty?
-            missing_keys = missing_keys.keys.map(&:inspect).join(', ')
-            raise ArgumentError, "missing keywords: #{missing_keys}"
+          # Normalize attrs into an array: [[:name, **options], ...]
+          # @type [Array[Array[Symbol, Hash]]]
+          attrs = attrs.map do |a|
+            name, opts = [*a]
+            name = name.to_s.sub(/^@/, '').to_sym
+            opts = default_options.merge(opts || {})
+            [name, opts]
           end
 
-          unknown_keywords = kw_values.except(*kw_attrs.keys)
-          unless unknown_keywords.empty?
-            unknown_keywords = unknown_keywords.keys.map(&:to_sym).map(&:inspect).join(', ')
-            raise ArgumentError, "unknown keywords: #{unknown_keywords}"
-          end
+          repeated_attrs = attrs.map(&:first)
+            .tally
+            .select { |_, count| count > 1 }
+            .keys
 
-          attrs.keys.zip(values).each do |name, value|
-            instance_variable_set "@#{name}", value
-          end
+          raise ArgumentError, "duplicated argument names: #{repeated_attrs.join(', ')}" if repeated_attrs.any?
 
-          kw_values.each do |name, value|
-            instance_variable_set "@#{name}", value
-          end
+          attrs.to_h
+        end
+
+        # @param [Array[Symbol]] pos_params
+        # @param [Array[Symbol]] kw_params
+        # @param [Hash[Symbol, Object]] opt_kw_params
+        private def define_initialize(pos_params, kw_params, opt_kw_params)
+          ->(*values, **kw_values) do
+
+            unless pos_params.size == values.size
+              raise ArgumentError, "wrong number of arguments (given #{values.size}, expected #{pos_params.size})"
+            end
+
+            missing_keys = kw_params - kw_values.keys
+            unless missing_keys.empty?
+              missing_keys = missing_keys.map(&:inspect).join(', ')
+              raise ArgumentError, "missing keywords: #{missing_keys}"
+            end
+
+            unknown_keywords = kw_values.except(*kw_params, *opt_kw_params.keys)
+            unless unknown_keywords.empty?
+              unknown_keywords = unknown_keywords.keys.map(&:to_sym).map(&:inspect).join(', ')
+              raise ArgumentError, "unknown keywords: #{unknown_keywords}"
+            end
+
+            pos_params.zip(values).each do |name, value|
+              instance_variable_set "@#{name}", value
+            end
+
+            kw_params.each do |name|
+              instance_variable_set "@#{name}", kw_values[name]
+            end
+
+            opt_kw_params.each do |name, default_value|
+              value = kw_values.include?(name) ? kw_values[name] : default_value
+              instance_variable_set "@#{name}", value
+            end
 
+          end
         end
       end
     end
-
   end
 end

data/lib/trinkets/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Trinkets
-  VERSION = '0.3.1'
+  VERSION = '0.4.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trinkets
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - SilverPhoenix99
@@ -65,7 +65,6 @@ homepage: https://github.com/SilverPhoenix99/trinkets
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/SilverPhoenix99/trinkets
   source_code_uri: https://github.com/SilverPhoenix99/trinkets
   changelog_uri: https://github.com/SilverPhoenix99/trinkets/blob/master/CHANGELOG.md
   bug_tracker_uri: https://github.com/SilverPhoenix99/trinkets/issues