ruby-method-arguments 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f98c731e8db7e8e471e0933be31868fe5551aff1a85202deec96d8c32b6b1aa7
+  data.tar.gz: fec0a5cfcbe4f7d120f741c24dbcf09cd8899b211b4a4cedb8f1ad4a2898b95b
+SHA512:
+  metadata.gz: 12f76e8e6e3b6f13b0785ac28f95e2137d90267155c73f6c98e8aa07dd486485a34ffc9067d07cea3039684e46a9d77568ec032c3b920a5f3df191b9673d94a9
+  data.tar.gz: 3f78d6c1fc80d5370f5c18358046b3471ff77ae2f4ca5991a7d9eb601ad0c27fa36c814958bf249f9b2474eddad532635d73cbbe49f5813c44cd25906ff35dbc

data/README.md

@@ -0,0 +1,126 @@
+# method_arguments gem
+
+With the [method_arguments](https://github.com/gorodulin/method_arguments?tab=readme-ov-file#method_arguments-gem) gem you can easily set object attributes from method arguments.
+
+Transform this:
+
+```ruby
+  def initialize(user_entity, first_name:, last_name:, email:, phone:, dob:)
+    @user_entity = user_entity
+    @first_name = first_name
+    @last_name = last_name
+    @email = email
+    @phone = phone
+    @dob = dob
+  end
+```
+
+into this streamlined version:
+
+```ruby
+  def initialize(user_entity, first_name:, last_name:, email:, phone:, dob:)
+    set_instance_vars(__method_args__)
+  end
+```
+
+## Features
+
+### 1. Reading Method Arguments
+
+Within any method, call `__method_args__` to retrieve its arguments as a Hash.
+
+```ruby
+  def initialize(user_entity, first_name:, last_name:, age:, **kw_rest)
+    "Method ##{__method__} received #{__method_args__.inspect} arguments"
+  end
+```
+
+<details>
+  <summary>Limitations</summary>
+  <br>
+  
+  1. Argument types `*rest` and `**keyrest` are ignored regardless of their name:
+     
+      ```ruby
+      def initialize(arg, *arg_rest, kw_arg:, **kw_rest)
+        __method_args__ # returns { a: <value>, kw_arg: <value> }
+      end
+      ```
+      
+      Casting unknown arbitrary arguments to instance variables is not recommended for security reasons.
+      
+  2. The method does not support [argument forwarding](https://docs.ruby-lang.org/en/3.2/syntax/methods_rdoc.html#label-Argument+Forwarding):
+
+      ```ruby
+      def self.call(...)
+        new(__method_args__).call # raises error
+      end
+      ```
+  
+</details>
+
+### 2. Filling instance @variables
+
+Use `set_instance_vars(hash)` to assign instance variables from a Hash.
+
+### 3. Filling instance @variables using attribute writers
+
+To leverage setters ([attribute writers](https://docs.ruby-lang.org/en/3.1/Module.html#method-i-attr_writer)), add `use_writers: true` argument. If a writer with the corresponding name exists, it will be invoked.
+
+<details>
+  <summary>Example</summary>
+  <br>
+  
+  Before:
+
+  ```ruby
+  def initialize(user_entity, first_name:, last_name:, age:)
+    @user_entity = user_entity
+    @first_name = first_name
+    @last_name = last_name
+    self.age = age
+  end
+
+  def age=(val)
+    @age = Integer(val)
+  end
+  ```
+
+  After:
+
+  ```ruby
+  def initialize(user_entity, first_name:, last_name:, age:, ...)
+    set_instance_vars(__method_args__, use_writers: true)
+  end
+
+  def age=(val)
+    @age = Integer(val)
+  end
+  ```
+</details>
+
+## Installation
+
+1. Add to your Gemfile, then run `bundle install`:
+
+    ```ruby
+    gem "method_arguments"
+    ```
+
+2. Prepend your code with
+
+    ```ruby
+    require "method_arguments"
+    ```
+
+
+## Supported Ruby Versions
+
+This gem is designed to be compatible with Ruby 2.7 and above. It has been tested on the following MRI versions:
+
+- v2.7.2
+- v3.0.3
+- v3.1.2
+
+If you encounter any issues with later versions, please feel free to report them.
+

data/lib/method_arguments/version.rb

@@ -0,0 +1,4 @@
+
+module MethodArguments
+  VERSION = "0.1.0"
+end

data/lib/method_arguments.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module MethodArguments
+  module InstanceMethods
+
+    def set_instance_vars(args, use_writers: false)
+      raise "Call this method on instances only" if self.instance_of?(Class) || self.instance_of?(Module)
+
+      args.each_pair do |name, value|
+        if use_writers && respond_to?(writer = :"#{name}=", true)
+          send(writer, value)
+        else
+          instance_variable_set("@#{name}", value)
+        end
+      end
+    end
+
+  end
+
+  module BindingMethods
+    # See https://bugs.ruby-lang.org/issues/18487
+    define_method :__method_args__, ::Kernel::method(:binding) >> ->(bng) {
+      caller_info = caller_locations(1,1)[0]
+      caller_method_name = caller_info.base_label
+      begin
+        params = bng.receiver.method(caller_method_name).parameters.map do |type, varname|
+          (type == :keyrest || type == :rest || type == :block) ? nil : varname
+        end.compact
+        params.map { |varname| [varname, bng.local_variable_get(varname)] }.to_h
+      rescue NameError => err
+        raise err unless err.message.start_with?("undefined method `<")
+        raise RuntimeError, "__method_args__ called outside method", cause: nil
+      end
+    }
+  end
+end
+
+Object.include MethodArguments::BindingMethods  unless Object.included_modules.include?(MethodArguments::BindingMethods)
+Object.include MethodArguments::InstanceMethods unless Object.included_modules.include?(MethodArguments::InstanceMethods)

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: ruby-method-arguments
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vladimir Gorodulin
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-03-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: |
+  The 'method_arguments' gem simplifies the process of setting object attributes from method arguments in Ruby.
+  It introduces a streamlined approach to assign instance variables directly from method arguments with minimal boilerplate code.
+  This utility is especially useful in constructors or methods with numerous parameters, enhancing code readability and maintainability.
+email:
+- ru.hostmaster@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/method_arguments.rb
+- lib/method_arguments/version.rb
+homepage: https://github.com/gorodulin/method_arguments
+licenses:
+- MIT
+metadata:
+  changelog_uri: https://github.com/gorodulin/method_arguments/CHANGELOG.md
+  homepage_uri: https://github.com/gorodulin/method_arguments
+  source_code_uri: https://github.com/gorodulin/method_arguments
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key:
+specification_version: 4
+summary: Read method arguments and assign instance variables
+test_files: []