trinkets 0.3.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb82b9c6f72cce48f7d303e989870bc05e77429508c17f266428d15bc0821628
-  data.tar.gz: 1dc0a8334a869e8be5b4e397caeed6be9ff16b495514425e184938d538b0b2e1
+  metadata.gz: 2e815777ee25a04feffd792fc975e68256e346eb3ff77126bd3610b949deadb2
+  data.tar.gz: 77a0c78f5dc7699e2d90e7db69333b246023145c66e408901ae328d29d377385
 SHA512:
-  metadata.gz: 4b57aecbcc07de7c710804302accad6fe49d610c133fabf74040a0cca376129258dc064eb967c0ff50570d72b46d641160fda6485222d29f47f06117b57db55c
-  data.tar.gz: 7714dbbd7e295d87d9f6c98aac8d6aade0d6a57d86e69368c039e8022824511f897f1a2d8f90f5f70b1fb598741b4bfbfdbb5308a164f40dc2fcb6da01491148
+  metadata.gz: e57c30e56c22137542e58d2128d9a8ddb31e78acca1756c3337fa54a906046790997fecb8737b2c442528920756cfc8ccab465ac47489bb44257c4cecb9c9d03
+  data.tar.gz: 49ed92fdb96d888727ebc972cd71520f08fb603cad2345d9832cf9f8704d99e979cf02cd10c268dea5c12e8681f4bccdd49b8c9eca7a68a2025db002b349c74b

data/CHANGELOG.md

@@ -1,4 +1,10 @@
 
+### [0.5.0](https://github.com/SilverPhoenix99/trinkets/tree/v0.5.0)
+* `Class::init`: Added `:super` option.
+
+### [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,7 +9,14 @@ 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`
+  * `super` : if the argument should be passed to `super()`
+    * the super class can have a `initialize` or call `init`
+    * default: `false`
 
 The same options can be used per individual argument.
 
@@ -40,8 +47,9 @@ end
 class Test
   attr_accessor :a, :b
   def initialize(a, b)
-    @a = a
-    @b = b
+    super()
+    @a = a unless instance_variable_defined?(:@a)
+    @b = b unless instance_variable_defined?(:@b)
   end
 end
 
@@ -67,8 +75,9 @@ end
 class TestAttr
   attr_reader :a, :b
   def initialize(a, b)
-    @a = a
-    @b = b
+    super()
+    @a = a unless instance_variable_defined?(:@a)
+    @b = b unless instance_variable_defined?(:@b)
   end
 end
 
@@ -94,8 +103,9 @@ end
 class TestKW
   attr_accessor :a, :b
   def initialize(a:, b:)
-    @a = a
-    @b = b
+    super()
+    @a = a unless instance_variable_defined?(:@a)
+    @b = b unless instance_variable_defined?(:@b)
   end
 end
 
@@ -122,10 +132,11 @@ class TestAttrOptions
   attr_reader :a
   attr_accessor :b, :c
   def initialize(b, d, a:, c:)
-    @a = a
-    @b = b
-    @c = c
-    @d = d
+    super()
+    @a = a unless instance_variable_defined?(:@a)
+    @b = b unless instance_variable_defined?(:@b)
+    @c = c unless instance_variable_defined?(:@c)
+    @d = d unless instance_variable_defined?(:@d)
   end
 end
 
@@ -147,6 +158,54 @@ 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)
+    super()
+    @a = a unless instance_variable_defined?(:@a)
+    @b = b unless instance_variable_defined?(:@b)
+  end
+end
+
+test = TestDefaultKw.new(a: 2)
+
+test.a
+# 2
+
+test.b
+# 3
+``` 
+
+## Super
+```ruby
+class TestParent
+  init :a # also works with a plain initialize()
+end
+
+class TestChild
+  init [:a, super: true], :b
+end
+
+# would be the same as
+class TestChild
+  attr_accessor :a, :b
+  def initialize(a, b)
+    super(a)
+    @a = a unless instance_variable_defined?(:@a)
+    @b = b unless instance_variable_defined?(:@b)
+  end
+end
+```
+
 ## Mixed together
 ```ruby
 class TestMixed
@@ -160,8 +219,9 @@ class TestMixed
   attr_reader :a
   attr_accessor :b
   def initialize(a:, b:)
-    @a = a
-    @b = b
+    super()
+    @a = a unless instance_variable_defined?(:@a)
+    @b = b unless instance_variable_defined?(:@b)
   end
 end
 

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

@@ -5,93 +5,191 @@ module Trinkets
     module Init
       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)
+      class Parameter
+        attr_reader :name, :attr, :kw, :super
+        def initialize(name:, attr:, kw:, super:)
+          @name  = name
+          @attr  = attr
+          @kw    = kw
+          @super = [super:].first[:super]
+        end
+      end
 
-        default_attr_options = { attr: attr, kw: kw }
+      class BoundParameter < Parameter
 
-        attrs = ::Trinkets::Class.send(:sanitize_attrs, attrs, default_attr_options)
+        attr_reader :value
 
-        attr_methods = (ATTR - [:none])
-          .each_with_object({}) do |name, h|
-            h[name] = method("attr_#{name}")
+        def initialize(name:, attr:, kw:, super:, value:)
+          super(name:, attr:, kw:, super:)
+          @value = value
+        end
+      end
+
+      # @!attribute r req
+      #   @return [Array[Parameter]]
+      # @!attribute r key_req
+      #   @return [Array[Parameter]]
+      # @!attribute r key_opt
+      #   @return [Array[Parameter]]
+      class Parameters < Struct.new(:req, :key_req, :key_opt, keyword_init: true)
+
+        #@return [Parameters]
+        def self.build(params, **default_options)
+
+          raise ArgumentError, 'At least 1 attribute is required.' if params.empty?
+
+          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
 
-        # 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"
+          # @type [Array[Parameter]]
+          params = params.map do |name, opts|
+            name = name.to_s.sub(/^@/, '').to_sym
+
+            opts ||= {}
+            opts.reject! { |_, v| v.nil? }
+            opts = default_options.merge(opts)
+
+            Parameter.new(name:, **opts)
           end
-          attr_methods[attr].call(name) unless attr == :none
-        end
 
-        attrs.each { |name, opts| attr_init.call(name, **opts) }
+          repeated_params = params.map(&:name)
+            .tally
+            .select { |_, count| count > 1 }
+            .keys
 
-        # 2 hashes: { :name => bool }
-        kw_attrs, attrs = attrs
-          .map  { |name, opts| [name, opts[:kw]] }
-          .partition { |_, kw_opt| kw_opt }
-          .map(&:to_h)
+          raise ArgumentError, "duplicated argument names: #{repeated_params.join(', ')}" if repeated_params.any?
 
-        init_method = ::Trinkets::Class.send(:define_initialize, attrs, kw_attrs)
-        define_method :initialize, init_method
-      end
-    end
+          # hash with 3 keys: {
+          #   FalseClass => { :name => Parameter }  # positional args
+          #   TrueClass  => { :name => Parameter }  # mandatory kw args
+          #   Hash       => { :name => Parameter }  # optional kw args with default value
+          # }
+          #@type [Hash[Class, Array[Parameter]]]
+          params = params.group_by { |param| param.kw.class }
+
+          Parameters.new(
+            req:     [*params[FalseClass]],
+            key_req: [*params[TrueClass]],
+            key_opt: [*params[Hash]]
+          )
 
-    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
+        #@return [Parameters]
+        def bind(values, kw_values)
 
-        raise ArgumentError, "duplicated argument names: #{repeated_attrs.join(', ')}" if repeated_attrs.any?
+          validate values, kw_values
 
-        attrs.to_h
-      end
+          req = self.req.zip(values).map do |(param, value)|
+            BoundParameter.new(
+              name: param.name,
+              attr: param.attr,
+              kw: param.kw,
+              super: param.super,
+              value:
+            )
+          end
+
+          key_req = self.key_req.map do |param|
+            BoundParameter.new(
+              name: param.name,
+              attr: param.attr,
+              kw: param.kw,
+              super: param.super,
+              value: kw_values[param.name]
+            )
+          end
+
+          key_opt = self.key_opt.map do |param|
+            key, value = kw_values.assoc(param.name)
+            BoundParameter.new(
+              name: param.name,
+              attr: param.attr,
+              kw: param.kw,
+              super: param.super,
+              value: key ? value : param.kw[:default]
+            )
+          end
+
+          Parameters.new(req:, key_req:, key_opt:)
 
-      # @param [Hash[Symbol  Boolean]] attrs
-      # @param [Hash[Symbol  Boolean]] kw_attrs
-      private def define_initialize(attrs, kw_attrs)
-        ->(*values, **kw_values) do
+        end
+
+        def all_params = req + all_key_params
+
+        def all_key_params = key_req + key_opt
+
+        private def validate(values, kw_values)
 
-          unless attrs.size == values.size
-            raise ArgumentError, "wrong number of arguments (given #{values.size}, expected #{attrs.size})"
+          unless req.size == values.size
+            raise ArgumentError, "wrong number of arguments (given #{values.size}, expected #{req.size})"
           end
 
-          missing_keys = kw_attrs.except(*kw_values.keys)
+          missing_keys = key_req.map(&:name) - kw_values.keys
           unless missing_keys.empty?
-            missing_keys = missing_keys.keys.map(&:inspect).join(', ')
+            missing_keys = missing_keys.map(&:inspect).join(', ')
             raise ArgumentError, "missing keywords: #{missing_keys}"
           end
 
-          unknown_keywords = kw_values.except(*kw_attrs.keys)
+          unknown_keywords = kw_values.except(*all_key_params.map(&:name))
           unless unknown_keywords.empty?
             unknown_keywords = unknown_keywords.keys.map(&:to_sym).map(&:inspect).join(', ')
             raise ArgumentError, "unknown keywords: #{unknown_keywords}"
           end
 
-          attrs.keys.zip(values).each do |name, value|
-            instance_variable_set "@#{name}", value
+        end
+      end
+
+      def init(*params, attr: ATTR.first, kw: false, super: false)
+
+        params = Parameters.build(params, attr:, kw:, super:)
+
+        # @type [Hash[Symbol, Method]]
+        attr_methods = (ATTR - [:none])
+          .each_with_object({}) do |name, h|
+            h[name] = method("attr_#{name}")
           end
 
-          kw_values.each do |name, value|
-            instance_variable_set "@#{name}", value
+        attr_init = ->(name, attr: ATTR.first) do
+          unless ATTR.include?(attr)
+            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
 
+        params.all_params.each do |param|
+          attr_init.call param.name, attr: param.attr
         end
+
+        init_method = Init.send(:define_initialize, params)
+        define_method :initialize, init_method
       end
-    end
 
+      class << self
+
+        # @param [Parameters] params
+        private def define_initialize(params)
+          ->(*values, **kw_values) do
+
+            params = params.bind(values, kw_values)
+
+            super_req = params.req.select(&:super).map(&:value)
+            super_kws = params.all_key_params.select(&:super)
+              .each_with_object({}) do |param, h|
+                h[param.name] = param.value
+              end
+
+            super *super_req, **super_kws
+
+            params.all_params.each do |param|
+              name = "@#{param.name}"
+              instance_variable_set(name, param.value) unless instance_variable_defined?(name)
+            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.5.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trinkets
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.5.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