trinkets 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b95bff0eaa948f0edc0375709fd3ec786ad10e970f5b5abcd501247dceb1e74
-  data.tar.gz: 3d4d1bce01e034167209cad41d9bf4ad356d79ddf100cfc1968d16b9686a06f9
+  metadata.gz: 2e815777ee25a04feffd792fc975e68256e346eb3ff77126bd3610b949deadb2
+  data.tar.gz: 77a0c78f5dc7699e2d90e7db69333b246023145c66e408901ae328d29d377385
 SHA512:
-  metadata.gz: 5b3a7cc743fae16ee12cfab9d9efc4236b31d69d8a570fe1bbf009cc3558be08d3cef3a38aa110403fb40dea019a3236adbf4a00c983c5f1f4e148a909bfb884
-  data.tar.gz: e94881a3dc54ca93be7ea759b0b6aff8607b9d91d7d1247d3ec2f59d265ecb2ea4c7f014754ca9a4a351ee6994eabb2fcae0e93fe0d14d27a46b01985370c3f6
+  metadata.gz: e57c30e56c22137542e58d2128d9a8ddb31e78acca1756c3337fa54a906046790997fecb8737b2c442528920756cfc8ccab465ac47489bb44257c4cecb9c9d03
+  data.tar.gz: 49ed92fdb96d888727ebc972cd71520f08fb603cad2345d9832cf9f8704d99e979cf02cd10c268dea5c12e8681f4bccdd49b8c9eca7a68a2025db002b349c74b

data/CHANGELOG.md

@@ -1,4 +1,7 @@
 
+### [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.
  

data/doc/class/init.md

@@ -14,6 +14,9 @@ To use it, define a class and call `::init` like you would call `::attr` methods
     * 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.
 
@@ -44,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
 
@@ -71,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
 
@@ -98,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
 
@@ -126,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
 
@@ -152,7 +159,6 @@ test.a = 5
 ```
 
 ## Default values for keyword arguments
-
 ```ruby
 class TestDefaultKw
   init [:a, kw: true],
@@ -163,9 +169,10 @@ end
 # would be the same as
 class TestDefaultKw
   attr_accessor :a, :b
-  def initialize(a: , b: 3)
-    @a = a
-    @b = b
+  def initialize(a:, b: 3)
+    super()
+    @a = a unless instance_variable_defined?(:@a)
+    @b = b unless instance_variable_defined?(:@b)
   end
 end
 
@@ -178,6 +185,27 @@ 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
@@ -191,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,107 +5,188 @@ module Trinkets
     module Init
       ATTR = %i[accessor reader writer none].freeze
 
-      def init(*attrs, attr: ATTR.first, kw: false)
-        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}")
-          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, "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
+      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
 
-        attrs.each { |name, opts| attr_init.call(name, **opts) }
-
-        # 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 }
+      class BoundParameter < Parameter
 
-        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] }
+        attr_reader :value
 
-        init_method = Init.send(:define_initialize, pos_params, kw_params, opt_kw_params)
-        define_method :initialize, init_method
+        def initialize(name:, attr:, kw:, super:, value:)
+          super(name:, attr:, kw:, super:)
+          @value = value
+        end
       end
 
-      class << self
-        private def sanitize_attrs(attrs, **default_options)
+      # @!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)
 
-          raise ArgumentError, 'At least 1 attribute is required.' if attrs.empty?
+        #@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
 
-          # Normalize attrs into an array: [[:name, **options], ...]
-          # @type [Array[Array[Symbol, Hash]]]
-          attrs = attrs.map do |a|
-            name, opts = [*a]
+          # @type [Array[Parameter]]
+          params = params.map do |name, opts|
             name = name.to_s.sub(/^@/, '').to_sym
-            opts = default_options.merge(opts || {})
-            [name, opts]
+
+            opts ||= {}
+            opts.reject! { |_, v| v.nil? }
+            opts = default_options.merge(opts)
+
+            Parameter.new(name:, **opts)
           end
 
-          repeated_attrs = attrs.map(&:first)
+          repeated_params = params.map(&:name)
             .tally
             .select { |_, count| count > 1 }
             .keys
 
-          raise ArgumentError, "duplicated argument names: #{repeated_attrs.join(', ')}" if repeated_attrs.any?
+          raise ArgumentError, "duplicated argument names: #{repeated_params.join(', ')}" if repeated_params.any?
+
+          # 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]]
+          )
 
-          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
+        #@return [Parameters]
+        def bind(values, kw_values)
 
-            unless pos_params.size == values.size
-              raise ArgumentError, "wrong number of arguments (given #{values.size}, expected #{pos_params.size})"
-            end
+          validate values, kw_values
 
-            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
+          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
 
-            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
+          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
 
-            pos_params.zip(values).each do |name, value|
-              instance_variable_set "@#{name}", value
-            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
 
-            kw_params.each do |name|
-              instance_variable_set "@#{name}", kw_values[name]
-            end
+          Parameters.new(req:, key_req:, key_opt:)
 
-            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
 
+        def all_params = req + all_key_params
+
+        def all_key_params = key_req + key_opt
+
+        private def validate(values, kw_values)
+
+          unless req.size == values.size
+            raise ArgumentError, "wrong number of arguments (given #{values.size}, expected #{req.size})"
+          end
+
+          missing_keys = key_req.map(&:name) - 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(*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
+
+        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
+
+        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
+
+      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

data/lib/trinkets/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: trinkets
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - SilverPhoenix99