marameters 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b609969a342c64c1ab5c475f0198bee7f8677d2bb9641234a9f13acbdfd39120
-  data.tar.gz: 11cdc1166b5c66f13d81558f1691e833d4378ddd4c04c547a0e6b5135e53a1d2
+  metadata.gz: 0656ba29b3d12d44f9f34ae3a012542dc3a274712d2cabf8ba153053d1491310
+  data.tar.gz: 21e3a15d709561a6c30adb4a212b1193c0d45a2e0f783761719054412a014136
 SHA512:
-  metadata.gz: 6a1b20eb861d4ca7b1d821f52e77631dd23a71896973c259235c959e96e81f8e3dafc4bdea64729e758ff4ed0e42b06967a96e27e091f2ddaebb80c8d345fc4e
-  data.tar.gz: 0d7d78973c128a0281dd868d21ac56a0f742578c82f42531c78408487432ec0af217bfbe103fc0c2c1f6aa95545733df76aeb5d4236072e44df8bf72f6e1c80d
+  metadata.gz: 152aa26bb96768bc363f55a7fa43b5aed99f08038ac1bbb4a943a1efdf8b5138ce214b6a4b8012f179f12d00894a44869df6d25d938521712de35a3ab2c6efbd
+  data.tar.gz: 620bf72c7c8bbe25b48dc370cee7d3a0e1b03f5df8090c326bc760be1dfb400168d62dac304e55acded56f75da24ca821c4ce04fa9cfb2740ad749434de69fec

data/README.adoc

@@ -64,7 +64,6 @@ Marameters.categorize parameters, arguments
 Marameters.of self, :demo            # []
 
 probe = Marameters.probe parameters
-probe.to_h                           # {:req=>:one, :opt=>:two, :key=>:three}
 probe.to_a                           # [[:req, :one], [:opt, :two], [:key, :three]]
 probe.positionals                    # [:one, :two]
 probe.keywords                       # [:three]
@@ -72,23 +71,12 @@ probe.block                          # nil
 
 # Marameters::Signature wrapper
 
-Marameters.signature({req: :one, opt: [:two, 2], key: [:three, 3]})
+Marameters.signature({req: :one, opt: [:two, 2], key: [:three, 3]}).to_s
 # one, two = 2, three: 3
 ----
 
 Read on to learn more about the details on how each of these methods work and the objects they wrap.
 
-=== Kinds
-
-Should you need a list of the kinds of parameters supported, you can use the `KINDS` constant. Example:
-
-[source,ruby]
-----
-Marameters::KINDS  # [:req, :opt, :rest, :keyreq, :key, :keyrest, :block]
-----
-
-All keys are listed in order of precedence.
-
 === Probe
 
 The probe allows you to analyze a method's parameters. To understand how, consider the following demonstration class:
@@ -135,7 +123,6 @@ probe.positionals?         # true
 probe.splats               # [:three, :six]
 probe.splats?              # true
 probe.to_a                 # [[:req, :one], [:opt, :two], [:rest, :three], [:keyreq, :four], [:key, :five], [:keyrest, :six], [:block, :seven]]
-probe.to_h                 # {:req=>:one, :opt=>:two, :rest=>:three, :keyreq=>:four, :key=>:five, :keyrest=>:six, :block=>:seven}
 ----
 
 In contrast the above, we can also probe the `#none` method which has no parameters for a completely
@@ -162,12 +149,11 @@ probe.positionals?         # false
 probe.splats               # []
 probe.splats?              # false
 probe.to_a                 # []
-probe.to_h                 # {}
 ----
 
 === Categorizer
 
-The categorizer allows you to dynamically build positional, keyword, and block arguments for message passing. This is most valuable when you know the object, method, and arguments while also needing to assemble _and validate_ the arguments are in the right order. Here's a demonstration where {amazing_print_link} (i.e. `ap`) is used to format the output:
+The categorizer allows you to dynamically build positional, keyword, and block arguments for message passing. This is most valuable when you know the object, method, and arguments while also needing to assemble the arguments are in the right order. Here's a demonstration where {amazing_print_link} (i.e. `ap`) is used to format the output:
 
 [source,ruby]
 ----
@@ -198,14 +184,15 @@ end
 
 Inspector.call [1, nil, nil, {four: 4}]
 
-# #<Struct:Marameters::Splat:0x00001068
-#  block = nil,
-#  keywords = {
-#    :four => 4
-#  },
-#  positionals = [
-#    1
-#  ]
+# #<Struct:Marameters::Splat:0x00021930
+#   block = nil,
+#   keywords = {
+#     :four => 4
+#   },
+#   positionals = [
+#     1,
+#     nil
+#   ]
 # >
 #
 # The .test method received the following arguments:
@@ -235,30 +222,30 @@ Inspector.call [1, 2, [98, 99], {four: 4}, {five: 5}, {twenty: 20, thirty: 30},
 
 # Output
 
-#<Struct:Marameters::Splat:0x00001068
-  block = #<Proc:0x000000011b19e300 /snippet:32>,
-  keywords = {
-      :four => 4,
-      :five => 5,
-    :twenty => 20,
-    :thirty => 30
-  },
-  positionals = [
-    1,
-    2,
-    98,
-    99
-  ]
->
-
-The .test method received the following arguments:
-1. 1
-2. 2
-3. [98, 99]
-4. 4
-5. 5
-6. {:twenty=>20, :thirty=>30}
-7. #<Proc:0x000000011b19e300 /snippet:32>
+# #<Struct:Marameters::Splat:0x00029cc0
+#   block = #<Proc:0x000000010a88cec0 (irb):1>,
+#   keywords = {
+#       :four => 4,
+#       :five => 5,
+#     :twenty => 20,
+#     :thirty => 30
+#   },
+#   positionals = [
+#     1,
+#     2,
+#     98,
+#     99
+#   ]
+# >
+#
+# The .test method received the following arguments:
+# 1. 1
+# 2. 2
+# 3. [98, 99]
+# 4. 4
+# 5. 5
+# 6. {:twenty=>20, :thirty=>30}
+# 7. #<Proc:0x000000010a88cec0 (irb):1>
 ----
 
 Once again, it is important to keep in mind that the argument positions _must_ align with the parameter positions since the parameters are an array of elements too. For illustration purposes -- and using the above example -- we can compare the parameters to the arguments as follows:

data/lib/marameters/categorizer.rb

@@ -23,17 +23,16 @@ module Marameters
     attr_reader :parameters, :model, :record
 
     def map arguments
-      parameters.each.with_index { |pair, index| filter pair, arguments[index], arguments }
+      parameters.each.with_index { |pair, index| filter pair, arguments[index] }
     end
 
-    def filter pair, value, arguments
+    def filter pair, value
       case pair
-        in [:rest] | [:rest, :*] then splat_positionals arguments
-        in [:keyrest] | [:keyrest, :**] then splat_keywords arguments
-        in [:block, :&] then forward_block arguments
-        in [:req, *] then record.positionals.append value
-        in [:opt, *] then record.positionals.append value if value
+        in [:rest] | [:rest, :*] then splat_positional value
+        in [:keyrest] | [:keyrest, :**] then record.keywords = Hash value
+        in [:req, *] | [:opt, *] then record.positionals.append value
         in [:rest, *] then record.positionals.append(*value)
+        in [:nokey] then nil
         in [:keyreq, *] | [:key, *] then record.keywords.merge! value if value
         in [:keyrest, *] then record.keywords.merge!(**value) if value
         in [:block, *] then record.block = value
@@ -43,19 +42,10 @@ module Marameters
       raise TypeError, "#{value.inspect} is an invalid #{pair.first.inspect} value."
     end
 
-    def splat_positionals arguments
-      arguments.reject { |item| item in Hash | Proc }
-               .flatten
-               .then { |values| record.positionals.append(*values) }
-    end
-
-    def splat_keywords arguments
-      arguments.each { |value| record.keywords.merge! value if value.is_a? Hash }
-    end
+    def splat_positional value
+      return unless value
 
-    def forward_block arguments
-      arguments.find { |item| item.is_a? Proc }
-               .then { |block| record.block = block }
+      record.positionals = value.is_a?(Array) ? value : [value]
     end
   end
 end

data/lib/marameters/probe.rb

@@ -7,6 +7,12 @@ module Marameters
   class Probe
     using Refinements::Arrays
 
+    CATEGORIES = {
+      positionals: %i[req opt],
+      keywords: %i[keyreq key],
+      splats: %i[rest keyrest]
+    }.freeze
+
     def self.of klass, name, collection: []
       method = klass.instance_method name
       collection << new(method.parameters)
@@ -16,32 +22,32 @@ module Marameters
       collection
     end
 
-    def initialize parameters
+    attr_reader :keywords, :positionals, :splats
+
+    def initialize parameters, categories: CATEGORIES
       @parameters = parameters
-      @items = parameters.reduce({}) { |all, (kind, name)| all.merge kind => name }
+      categories.each { |category, kinds| define_variable category, kinds }
     end
 
-    def block = items[:block]
+    def block = parameters.find { |kind, name| break name if kind == :block }
 
-    def block? = items.key? :block
+    def block? = (parameters in [*, [:block, *]])
 
-    def empty? = items.empty?
+    def empty? = parameters.empty?
 
     def keyword_slice collection, keys:
       collection.select { |key| !keys.include?(key) || keywords.include?(key) }
     end
 
-    def keywords = items.values_at(:keyreq, :key).compress!
-
     def keywords? = keywords.any?
 
-    def kind?(kind) = items.key? kind
+    def kind?(value) = parameters.any? { |kind, _name| kind == value }
 
-    def kinds = items.keys
+    def kinds = parameters.map { |kind, _name| kind }
 
-    def name?(name) = items.value? name
+    def name?(value) = parameters.any? { |_kind, name| name == value }
 
-    def names = items.values
+    def names = parameters.map { |_kind, name| name }
 
     def only_bare_splats? = (parameters in [[:rest]] | [[:keyrest]] | [[:rest], [:keyrest]])
 
@@ -49,20 +55,19 @@ module Marameters
 
     def only_single_splats? = (parameters in [[:rest, *]])
 
-    def positionals = items.values_at(:req, :opt).compress!
-
     def positionals? = positionals.any?
 
-    def splats = items.values_at(:rest, :keyrest).compress!
-
     def splats? = splats.any?
 
     def to_a = parameters
 
-    def to_h = items
-
     private
 
-    attr_reader :parameters, :items
+    attr_reader :parameters
+
+    def define_variable category, kinds
+      parameters.filter_map { |kind, name| next name if kinds.include? kind }
+                .then { |collection| instance_variable_set "@#{category}", collection }
+    end
   end
 end

data/lib/marameters.rb

@@ -6,8 +6,6 @@ Zeitwerk::Loader.for_gem.setup
 
 # Main namespace.
 module Marameters
-  KINDS = %i[req opt rest keyreq key keyrest block].freeze
-
   def self.categorize(parameters, arguments) = Categorizer.new(parameters).call(arguments)
 
   def self.of(...) = Probe.of(...)

data/marameters.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "marameters"
-  spec.version = "0.7.0"
+  spec.version = "0.8.0"
   spec.authors = ["Brooke Kuhlmann"]
   spec.email = ["brooke@alchemists.io"]
   spec.homepage = "https://www.alchemists.io/projects/marameters"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: marameters
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Brooke Kuhlmann
@@ -28,7 +28,7 @@ cert_chain:
   CxDe2+VuChj4I1nvIHdu+E6XoEVlanUPKmSg6nddhkKn2gC45Kyzh6FZqnzH/CRp
   RFE=
   -----END CERTIFICATE-----
-date: 2022-09-01 00:00:00.000000000 Z
+date: 2022-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: refinements