adornable 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2b36a2ad558b19305d75b4d59c81b93574b2d4635a267d00cb97bbd26e218e76
-  data.tar.gz: 7e23c912633d929ae70078e8d10ec286d379196e5e59bb27f877764494cce4a0
+  metadata.gz: f70e9c6dc00ff446a979d776bb8effbe0063b8e3cb1269081fe3dd78749b1a6d
+  data.tar.gz: dd2ee8ef02b67f5c1c48f83d3f04e9869bac1705c8eb12101c5e90e06274e6d8
 SHA512:
-  metadata.gz: 3a8b0dfb923e8f997e24ca6636de35d8f5f432f0f13143ff5bdd108b0c0ae6d9a74b42c5f4d2da59576ce8c9724918ed4ad8d20b7dae25347807192acb7a11e6
-  data.tar.gz: 4e5df5251a5ca785fca8ce87bf849e29234c514951012dde337dd865ea823d1abe50f59c085eaf10c95d6dabcd0a317f0c08ed9c2b7de0a2bd84a5feeb11911e
+  metadata.gz: 4cc9f4866c9e130ca8fc7d8cf2988a43c252604bf9030b919526d289badc3554d91c2eb4f825462ff6ac491f0f6519aaacff2e2bdd5c5c8a16dda33bd865c735
+  data.tar.gz: 1ecc141ccfff6820a76811bef1427ff90ca4072c35690b732dfbae24a45c6f7c901b8aa83e8172e57d69ad3eca84a50736f8835cfaf3339b56b980a1b72dd1c6

data/.github/workflows/main.yml

@@ -21,6 +21,9 @@ jobs:
     strategy:
       matrix:
         ruby-version:
+          - 3.2
+          - 3.1
+          - 3.0
           - 2.7
           - 2.6
           - 2.5

data/.rubocop.yml

@@ -7,6 +7,7 @@ require:
 
 AllCops:
   NewCops: enable
+  TargetRubyVersion: 2.5
 
 # Gemspec
 
@@ -29,6 +30,7 @@ Layout/FirstArrayElementIndentation:
 # Metrics
 
 Metrics/AbcSize:
+  Max: 20
   CountRepeatedAttributes: false
   Exclude:
     - 'spec/**/*_spec.rb'
@@ -65,10 +67,13 @@ Metrics/ModuleLength:
   Exclude:
     - 'spec/**/*_spec.rb'
 
+Metrics/ParameterLists:
+  CountKeywordArgs: false
+
 # Rspec
 
 RSpec/ExampleLength:
-  Max: 30
+  Max: 40
 
 RSpec/MessageSpies:
   Enabled: false

data/Gemfile

@@ -9,6 +9,7 @@ gemspec
 
 group :development, :test do
   gem "bundler", "~> 2.2"
+  gem "pry"
   gem "rake", "~> 13.0"
   gem "rspec", "~> 3.0"
   gem "rubocop", "~> 1.10"

data/README.md

@@ -4,6 +4,8 @@ Adornable provides the ability to cleanly decorate methods in Ruby. You can make
 
 ## Installation
 
+**NOTE:** This library is tested with Ruby versions 2.5.x through 3.2.x.
+
 ### Locally (to your application)
 
 Add the gem to your application's `Gemfile`:
@@ -232,7 +234,9 @@ The **required argument** is an instance of `Adornable::Context`, which has some
 
 - `Adornable::Context#method_name`: the name of the decorated method being called (a symbol; e.g., `:some_method` or `:other_method`)
 - `Adornable::Context#method_receiver`: the actual object that the decorated method (the `#method_name`) belongs to/is being called on (an object/class; e.g., the class `Foo` if it's a decorated class method, or an instance of `Foo` if it's a decorated instance method)
-- `Adornable::Context#method_arguments`: an array of arguments passed to the decorated method, including keyword arguments as a final hash (e.g., if `:yet_another_method` was called like `Foo.new.yet_another_method(123, bar: true)` then `arguments` would be `[123, {:bar=>true}]`)
+- `Adornable::Context#method_arguments`: an array of arguments passed to the decorated method, including keyword arguments as a final hash (e.g., if `:yet_another_method` was called like `Foo.new.yet_another_method(123, bar: true, baz: 456)` then `method_arguments` would be `[123, {:bar=>true,:baz=>456}]`)
+- `Adornable::Context#method_positional_args`: an array of just the positional arguments passed to the decorated method, excluding keyword arguments (e.g., if `:yet_another_method` was called like `Foo.new.yet_another_method(123, bar: true, baz: 456)` then `method_positional_args` would be `[123]`)
+- `Adornable::Context#method_kwargs`: a hash of just the keyword arguments passed to the decorated method (e.g., if `:yet_another_method` was called like `Foo.new.yet_another_method(123, { bam: "hi" }, bar: true, baz: 456)` then `method_kwargs` would be `{:bar=>true,:baz=>456}`)
 
 ##### Custom keyword arguments (optional)
 

data/adornable.gemspec

@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
   spec.description = "Adornable provides the ability to cleanly decorate methods in Ruby. You can make and use your own decorators, and you can also use some of the built-in ones that the gem provides. _Decorating_ methods is as simple as slapping a `decorate :some_decorator` above your method definition. _Defining_ decorators can be as simple as defining a method that yields to a block, or as complex as manipulating the decorated method's receiver and arguments, and/or changing the functionality of the decorator based on custom options supplied to it when initially applying the decorator." # rubocop:disable Layout/LineLength
   spec.homepage = "https://github.com/kjleitz/adornable"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.4.7"
+  spec.required_ruby_version = ">= 2.5.0"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

data/bin/asdf_switch

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+
+# First argument should be desired ruby version. If a partial version is given
+# (e.g., 2.6) and multiple versions are found to be installed (e.g., 2.6.9 and
+# 2.6.10), then the highest version (in semver version order) will be selected.
+SELECTED_RUBY_VERSION=$(asdf list ruby | sort -V | sed -e 's/^[[:space:]]*//' | grep "^$1" | tail -n 1)
+
+if [ -z "$SELECTED_RUBY_VERSION" ]; then
+  echo "Ruby version $1 is not installed. Try running:"
+  echo "  asdf install ruby $1"
+  exit 1
+fi
+
+echo "Using Ruby version $SELECTED_RUBY_VERSION"
+
+echo "(setting global Ruby)"
+asdf global ruby $SELECTED_RUBY_VERSION
+
+echo "(reshimming for this version)"
+asdf reshim ruby $SELECTED_RUBY_VERSION
+
+echo "(reinstalling bundled gems)"
+bundle install --redownload
+

data/lib/adornable/context.rb

@@ -8,14 +8,26 @@ module Adornable
       method_receiver
       method_name
       method_arguments
+      method_positional_args
+      method_kwargs
       decorator_name
       decorator_options
     ])
 
-    def initialize(method_receiver:, method_name:, method_arguments:, decorator_name:, decorator_options:)
+    def initialize(
+      method_receiver:,
+      method_name:,
+      method_arguments:,
+      method_positional_args:,
+      method_kwargs:,
+      decorator_name:,
+      decorator_options:
+    )
       @method_receiver = method_receiver
       @method_name = method_name
       @method_arguments = method_arguments
+      @method_positional_args = method_positional_args
+      @method_kwargs = method_kwargs
       @decorator_name = decorator_name
       @decorator_options = decorator_options
     end

data/lib/adornable/machinery.rb

@@ -38,14 +38,14 @@ module Adornable
       clear_accumulated_decorators!
     end
 
-    def run_decorated_instance_method(bound_method, *args)
+    def run_decorated_instance_method(bound_method, *args, **kwargs)
       decorators = get_instance_method_decorators(bound_method.name)
-      run_decorators(decorators, bound_method, *args)
+      run_decorators(decorators, bound_method, *args, **kwargs)
     end
 
-    def run_decorated_class_method(bound_method, *args)
+    def run_decorated_class_method(bound_method, *args, **kwargs)
       decorators = get_class_method_decorators(bound_method.name)
-      run_decorators(decorators, bound_method, *args)
+      run_decorators(decorators, bound_method, *args, **kwargs)
     end
 
     private
@@ -88,8 +88,10 @@ module Adornable
       @class_method_decorators[name] = decorators || []
     end
 
-    def run_decorators(decorators, bound_method, *method_arguments)
-      return bound_method.call(*method_arguments) if Adornable::Utils.blank?(decorators)
+    def run_decorators(decorators, bound_method, *method_positional_args, **method_kwargs)
+      if Adornable::Utils.blank?(decorators)
+        return Adornable::Utils.empty_aware_send(bound_method, :call, method_positional_args, method_kwargs)
+      end
 
       decorator, *remaining_decorators = decorators
       decorator_name = decorator[:name]
@@ -97,22 +99,30 @@ module Adornable
       decorator_options = decorator[:options]
       validate_decorator!(decorator_name, decorator_receiver, bound_method)
 
+      # This is for backwards-compatibility between Ruby 2.x and Ruby 3.x; in v3
+      # keyword arguments are treated differently than in v2 with respect to
+      # hash parameter equivalency. Previously, it was easy to just assume
+      # `method_arguments` could be an array with a hash at the end representing
+      # any given keyword arguments. However, in Ruby 3.x, we have to be able to
+      # distinguish between kwargs and trailing positional args of type `Hash`,
+      # so we'll shim `Adornable::Context#method_arguments` to look like it used
+      # to and then provide two new properties, `#method_positional_args` and
+      # `#method_kwargs`, to `Adornable::Context` for explicitness.
+      method_arguments = method_positional_args.dup
+      method_arguments << method_kwargs if Adornable::Utils.present?(method_kwargs)
+
       context = Adornable::Context.new(
         method_receiver: bound_method.receiver,
         method_name: bound_method.name,
         method_arguments: method_arguments,
+        method_positional_args: method_positional_args,
+        method_kwargs: method_kwargs,
         decorator_name: decorator_name,
         decorator_options: decorator_options,
       )
 
-      send_parameters = if Adornable::Utils.present?(decorator_options)
-        [decorator_name, context, decorator_options]
-      else
-        [decorator_name, context]
-      end
-
-      decorator_receiver.send(*send_parameters) do
-        run_decorators(remaining_decorators, bound_method, *method_arguments)
+      Adornable::Utils.empty_aware_send(decorator_receiver, decorator_name, [context], decorator_options) do
+        run_decorators(remaining_decorators, bound_method, *method_positional_args, **method_kwargs)
       end
     end
 

data/lib/adornable/utils.rb

@@ -23,6 +23,29 @@ module Adornable
         end
         "`#{receiver_name}#{name_delimiter}#{method_name}`"
       end
+
+      # This craziness is here because Ruby 2.6 and below don't like when you
+      # pass even _empty_ arguments to `#call` or `#send` or any other method
+      # with a splat, for callables that take no arguments. For example, this
+      # takes the place of:
+      #
+      #   receiver.send(method_name, *splat_args, **splat_kwargs)
+      #
+      # ...or:
+      #
+      #   receiver.some_method(*splat_args, **splat_kwargs)
+      #
+      # ...which is not cool <= 2.6.x apparently, if `#some_method` takes zero
+      # arguments even if both `splat_args` and `splat_kwargs` are empty (thus
+      # passing it zero arguments in actuality). Oh well.
+      #
+      def empty_aware_send(receiver, method_name, splat_args, splat_kwargs, &block)
+        return receiver.send(method_name, &block) if splat_args.empty? && splat_kwargs.empty?
+        return receiver.send(method_name, *splat_args, &block) if splat_kwargs.empty?
+        return receiver.send(method_name, **splat_kwargs, &block) if splat_args.empty?
+
+        receiver.send(method_name, *splat_args, **splat_kwargs, &block)
+      end
     end
   end
 end

data/lib/adornable/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Adornable
-  VERSION = "1.2.1"
+  VERSION = "1.3.0"
 end

data/lib/adornable.rb

@@ -36,10 +36,16 @@ module Adornable
 
     machinery.apply_accumulated_decorators_to_instance_method!(method_name)
     original_method = instance_method(method_name)
-    define_method(method_name) do |*args|
+
+    # NB: If you only supply `*args` to the block, you get kwargs as a trailing
+    # Hash member in the `args` array. If you supply both `*args, **kwargs` to
+    # the block, kwargs are excluded from the `args` array and only appear in
+    # the `kwargs` argument as a Hash.
+    define_method(method_name) do |*args, **kwargs|
       bound_method = original_method.bind(self)
-      machinery.run_decorated_instance_method(bound_method, *args)
+      machinery.run_decorated_instance_method(bound_method, *args, **kwargs)
     end
+
     super
   end
 
@@ -49,9 +55,15 @@ module Adornable
 
     machinery.apply_accumulated_decorators_to_class_method!(method_name)
     original_method = method(method_name)
-    define_singleton_method(method_name) do |*args|
-      machinery.run_decorated_class_method(original_method, *args)
+
+    # NB: If you only supply `*args` to the block, you get kwargs as a trailing
+    # Hash member in the `args` array. If you supply both `*args, **kwargs` to
+    # the block, kwargs are excluded from the `args` array and only appear in
+    # the `kwargs` argument as a Hash.
+    define_singleton_method(method_name) do |*args, **kwargs|
+      machinery.run_decorated_class_method(original_method, *args, **kwargs)
     end
+
     super
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: adornable
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Keegan Leitz
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-07-07 00:00:00.000000000 Z
+date: 2023-07-10 00:00:00.000000000 Z
 dependencies: []
 description: Adornable provides the ability to cleanly decorate methods in Ruby. You
   can make and use your own decorators, and you can also use some of the built-in
@@ -33,6 +33,7 @@ files:
 - README.md
 - Rakefile
 - adornable.gemspec
+- bin/asdf_switch
 - bin/console
 - bin/setup
 - lib/adornable.rb
@@ -55,14 +56,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.7
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.1
 signing_key: 
 specification_version: 4
 summary: Method decorators for Ruby