as_method 0.1.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8c21ee102f42fb035e7548aa149656c9ce4dac89a7801ad20d4a3f8211d45a9
-  data.tar.gz: e50f9a3f26f0e44b9ba912703c78d47d8ca6540be1345ad6f63ab8e3b3933299
+  metadata.gz: 2d9af230121d5102e4fe40bad36aa60286115dd5ffc13fb69c2f7228d3d27d7a
+  data.tar.gz: 53d7e4db5c3ea9c77d767794fbee5466f205aa4038e2e25753a605dc40ae6813
 SHA512:
-  metadata.gz: db3c2fb9ed080a528aa9b6adae0c55f52c862e74e9993776f42d6e30adce5f8248f5973539938bd8bafb3ed325e6b2d16ca54c595f14be60632507cfddd44a22
-  data.tar.gz: ec21c57976ba5024d23d6c4650f5330dce9a0b0a9bac65210510ba6983ce8edc1e895d847c7e54872a3c2ca247fcb465c0992dbe0c920a920843dcf988f22d2d
+  metadata.gz: 0b76457eed2af6cc5ef73eaa254d3beb927bfe06bd3a1fed6b4eb9ddc6e01e3767ec3585b13e14885594bd11b61f2ec0ab3aec8cf1b562f278a0c2092b877b88
+  data.tar.gz: e8dd515b04ee6afd28b7b18ff8e2f0a32f0f0ef7f64636517c9b99f40ae66b25780a81118eab4c0dbd8c54a4ba1fad950a7421503799d58f9b494d254509a33c

data/README.md

@@ -1,12 +1,14 @@
-# Includable Service Objects
+# Service Object Injection
+
+Static dependency injection at its best.
 
 Usage example:
 
 ```ruby
 class CreateUser
-  include as_method ValidateUserAttributes, name: :validate!
-  include as_method Generators::GeneratePassword
-  include as_method SaveModel, name: :save
+  include as_method ValidateUserEntity, name: :validate!
+  include as_method Generators::GeneratePassword # -> generate_password()
+  include as_method SaveEntity, name: :save
 
   def call(name, email)
     @name = name
@@ -16,6 +18,8 @@ class CreateUser
     save(user)
   end
 
+  def self.call(...) = new.call(...)
+
   private
 
   def attributes
@@ -31,24 +35,59 @@ end
 ## Why?
 
 This approach allows you to:
-- keep bringing reusable methods in the old-fashioned way via `include`, just like our ancestors did;
-- make methods extracted to SOs look and feel just like regular methods;
-- have all used Service Objects (SOs) listed as explicit dependencies;
+- keep bringing reusable methods in the old-fashioned way via `include` or `extend`, just like our ancestors did;
+- make Service Objects (SOs) look and feel just like regular methods;
+- have all used SOs listed as explicit dependencies in-place;
+
+## YouTube video about the Gem
+
+Click on the image below:
+
+<div align="left">
+      <a href="https://www.youtube.com/watch?v=eX7DLJJUEI8">
+         <img src="https://img.youtube.com/vi/eX7DLJJUEI8/0.jpg" style="width:100%;">
+      </a>
+</div>
 
 ## Compatibility
 
-Tested on Ruby v2.4 .. v3.1, but it is expected to work on all 2.x versions.
+Tested on Ruby v2.4 .. v3.x, but it is expected to work on all 2.x versions.
 
 ## Installation
 
+> [!IMPORTANT]  
+> Due to a temporary issue the RubyGems currently installs an outdated version of the gem.
+>
+> **For the Latest Version:** To access the most recent version of the gem, please clone it directly from this GitHub repository.
+
+
 Add to your `Gemfile`
 
 ```ruby
 gem "as_method"
 ```
 
-To make `as_method` class method available in all classes, add this line to your application loader:
+To make `as_method` class method available in _all classes and modules_, add this line to your application loader:
 
 ```ruby
 require "as_method/setup"
 ```
+
+or enable it in place:
+
+```ruby
+class MyClass
+  extend AsMethod::Allow
+  ...
+end
+```
+
+## Alternatives
+
+If you require dependency injection _during object construction_, you might consider using [dry-auto_inject](https://dry-rb.org/gems/dry-auto_inject).
+
+However, be aware of the following points:
+
+- Dependencies are somewhat implicit as they are defined in a separate file.
+- Object constructors get modified, as explained in detail [here](https://dry-rb.org/gems/dry-auto_inject/0.6/how-does-it-work/)."
+- Resulting methods don't invoke 'call' on objects, they return callables instead.

data/lib/as_method/allow.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module AsMethod
+  module Allow
+
+    def self.included(_)
+      raise "Don't include, extend instead"
+    end
+
+    def self.extended(base)
+      if base.is_a?(Class)
+        base.extend(Helpers::ClassMethods)
+        base.include(Helpers::InstanceMethods)
+      else
+        base.singleton_class.include(Helpers::ClassMethods)
+      end
+    end
+
+  end # ... Allow
+end # ... AsMethod

data/lib/as_method/find_or_define_module.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module AsMethod
+  class FindOrDefineModule
+    def self.call(**args)
+      new.call(**args)
+    end
+
+    def call(module_template:, module_name:, vars:)
+      @vars = vars
+      @module_name = module_name
+      @module_template = module_template
+
+      instance_eval(generate_module_source_code) unless module_exists?
+
+      includable_module
+    end
+
+    private
+
+    def generate_module_source_code
+      payload = @vars.merge(module_name: @module_name)
+      ::ERB.new(@module_template).result_with_hash(payload)
+    end
+
+    def includable_module
+      Object.const_get(@module_name)
+    end
+
+    def module_exists?
+      Object.const_defined?(@module_name)
+    end
+  end # ... FindOrDefineModule
+end # ... AsMethod

data/lib/as_method/get_service_object.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module AsMethod
+  class GetServiceObject
+    AMBIGUOUS_NAME_ERROR_MSG = <<-MSG
+      Ambiguous name. %s has both class and instance methods named %s.
+      Please use '::method_name' or '#method_name' to specify which one you want.
+    MSG
+
+    def self.call(obj, method_name)
+      new.call(obj, method_name)
+    end
+
+    def call(obj, method_name)
+      raise ArgumentError, "expected #{obj} to be a Module or Class" unless obj.is_a?(Module)
+
+      @obj = obj
+      @method_name = method_name
+
+      if method_name[0, 2] == "::"
+        get_method(nil, method_name[2..-1])
+      elsif method_name[0] == "#"
+        get_method(method_name[1..-1], nil)
+      else
+        get_method(method_name, method_name)
+      end
+    end
+
+    private
+
+    def get_instance_method(name)
+      return unless name
+      return unless @obj.method_defined?(name) || @obj.private_method_defined?(name)
+
+      @obj.instance_method(name)
+    end
+
+    def get_class_method(name)
+      return unless name
+      return unless @obj.singleton_class.method_defined?(name) || @obj.singleton_class.private_method_defined?(name)
+
+      @obj.method(name)
+    end
+
+    def get_method(instance_method_name, class_method_name)
+      imethod = get_instance_method(instance_method_name)
+      cmethod = get_class_method(class_method_name)
+
+      if [imethod, cmethod].none?
+        raise NameError, "undefined method #{@method_name.inspect} for #{@obj.inspect}"
+      end
+
+      if [imethod, cmethod].all?
+        raise NameError, format(AMBIGUOUS_NAME_ERROR_MSG, @obj.inspect, @method_name.inspect)
+      end
+
+      (cmethod || imethod).owner.instance_variable_get(:@_injectable_object)
+    end
+  end # ... GetServiceObject
+end # ... AsMethod

data/lib/as_method/helpers.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module AsMethod
+  module Helpers
+
+    module InstanceMethods
+      def service_object_for(method_name)
+        self.class.service_object_for(method_name)
+      end
+    end
+
+    module ClassMethods
+      def service_object_for(method_name)
+        GetServiceObject.call(self, method_name)
+      end
+
+      # rubocop:disable Metrics/AbcSize
+      def as_method(object, name: nil, access: :private)
+        raise ArgumentError unless %w[private public protected].include?(access.to_s)
+
+        ValidateServiceObject.call(object)
+
+        # generate method name from object, if none given
+        method_name = name&.to_s || MethodName::GenerateFromClassName.call(object.name)
+
+        MethodName::Validate.call(method_name)
+
+        module_name = "::#{object.name}::As#{access.capitalize}Method__#{ModuleName::GenerateFromSnakeCase.call(method_name)}" # rubocop:disable Layout/LineLength
+
+        # define module, or return existing module:
+        includable_module = FindOrDefineModule.call \
+          module_template: File.read(File.join(__dir__, "templates", "includable_module.rb.erb")),
+          module_name: module_name,
+          vars: {
+            object: object,
+            method_name: method_name,
+            method_access: access,
+          }
+
+        # return generated module ready for inclusion:
+        included_modules.include?(includable_module) ? Kernel : includable_module
+      end
+      # rubocop:enable Metrics/AbcSize
+
+    end # ... ClassMethods
+  end # ... Helpers
+end # ... AsMethod

data/lib/as_method/method_name/{generate_from_module_name.rb → generate_from_class_name.rb}

@@ -2,15 +2,15 @@
 
 module AsMethod
   module MethodName
-    module GenerateFromModuleName
+    module GenerateFromClassName
 
       def self.call(module_name)
         ModuleName::StripNamespace.call(module_name)
-          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+          .gsub(/([A-Z]+)([A-Z][a-z])/, %q(\1_\2))
+          .gsub(/([a-z\d])([A-Z])/, %q(\1_\2))
           .downcase
       end
 
-    end # ... GenerateFromModuleName
+    end # ... GenerateFromClassName
   end # ... MethodName
 end # ... AsMethod

data/lib/as_method/method_name/{validate_method_name.rb → validate.rb}

@@ -2,19 +2,19 @@
 
 module AsMethod
   module MethodName
-    module ValidateMethodName
+    module Validate
 
-      REGULAR_NAME_REGEX = /\A[a-z_]+[a-z0-9_]*[?!=]{0,1}\z/
+      REGULAR_NAME_REGEX = /\A[a-z_]+[a-z0-9_]*[?!=]{0,1}\z/.freeze
 
-      SPECIAL_NAMES = %w{[] ! ~ + ** - * / % << >> & | ^ < <= >= > == === != =~ !~ <=>}
+      SPECIAL_NAMES = %w{[] ! ~ + ** - * / % << >> & | ^ < <= >= > == === != =~ !~ <=>}.freeze
 
       def self.call(name)
         return true if name.to_s =~ REGULAR_NAME_REGEX
         return true if SPECIAL_NAMES.include?(name.to_s)
-  
-        false
+
+        fail ArgumentError, "invalid method name #{name.inspect}"
       end
 
-    end # ... ValidateMethodName
+    end # ... Validate
   end # ... MethodName
-end # ... AsMethod
+end # ... AsMethod

data/lib/as_method/module_name/{generate_from_underscored.rb → generate_from_snake_case.rb}

@@ -2,8 +2,7 @@
 
 module AsMethod
   module ModuleName
-    module GenerateFromUnderscored
-
+    module GenerateFromSnakeCase
       REPLACEMENTS = {
         "-" => "_Min",
         "!" => "_Exc",
@@ -25,12 +24,13 @@ module AsMethod
 
       def self.call(string)
         return unless string
-        
+
+        escaped_replacements = REPLACEMENTS.keys.map { Regexp.escape(_1) }
         string.to_s
-          .gsub(/(?:_|(^))([a-z\d]{1})/) { "#{$1}#{$2.capitalize}" }
+          .sub(/^(_|#{escaped_replacements.join('|')})/, "SPECIAL\\1")
+          .gsub(/(^|_)([a-z])/) { ::Regexp.last_match(2).capitalize.to_s }
           .gsub(/[#{Regexp.escape(REPLACEMENTS.keys.join)}]/, REPLACEMENTS)
       end
-
-    end # ... GenerateFromUnderscored
+    end # ... GenerateFromSnakeCase
   end # ... ModuleName
-end # ... AsMethod
+end

data/lib/as_method/module_name/strip_namespace.rb

@@ -4,8 +4,10 @@ module AsMethod
   module ModuleName
     module StripNamespace
 
-      def self.call(module_or_class)
-        module_or_class.to_s.match(/[^:]+\z/)&.to_s
+      def self.call(module_or_class_name)
+        name = String(module_or_class_name)
+        index = name.rindex("::")
+        index ? name[(index + 2)..-1] : name
       end
 
     end # ... StripNamespace

data/lib/as_method/setup.rb

@@ -3,9 +3,10 @@
 # Usage:
 #
 # Require this file to add #as_method class method to all classes:
-#   require 'as_method/setup'
+#   require "as_method/setup"
 #
 
-unless Object.singleton_class.included_modules.include?(AsMethod)
-  Object.extend AsMethod
-end
+require "as_method"
+
+Module.extend(AsMethod::Allow)
+Object.extend(AsMethod::Allow)

data/lib/as_method/validate_service_object.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module AsMethod
+  module ValidateServiceObject
+
+    def self.call(module_or_class)
+      unless module_or_class.is_a?(Module)
+        fail TypeError, "#{module_or_class} must be a Class or a Module"
+      end
+
+      return if module_or_class.respond_to?(:call)
+
+      fail NoMethodError, "Expected #{module_or_class} to respond to #call method"
+    end
+
+  end # ... ValidateServiceObject
+end # ... AsMethod

data/lib/as_method/version.rb

@@ -2,6 +2,6 @@
 
 module AsMethod
 
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 
 end

data/lib/as_method.rb

@@ -1,29 +1,21 @@
 # frozen_string_literal: true
 
 module AsMethod
-  autoload :DefineIncludableModule,         "as_method/define_includable_module"
-  autoload :FindOrDefineIncludableModule,   "as_method/find_or_define_includable_module"
-  autoload :RegistrationMethods,            "as_method/registration_methods"
+  autoload :Allow,                          "as_method/allow"
+  autoload :Helpers,                        "as_method/helpers"
+  autoload :FindOrDefineModule,             "as_method/find_or_define_module"
+  autoload :ValidateServiceObject,          "as_method/validate_service_object"
+  autoload :GetServiceObject,               "as_method/get_service_object"
   autoload :VERSION,                        "as_method/version"
 
   module ModuleName
-    autoload :GenerateForIncludableModule,  "as_method/module_name/generate_for_includable_module"
-    autoload :GenerateFromUnderscored,      "as_method/module_name/generate_from_underscored"
+    autoload :GenerateFromSnakeCase,        "as_method/module_name/generate_from_snake_case"
     autoload :StripNamespace,               "as_method/module_name/strip_namespace"
   end
 
   module MethodName
-    autoload :ValidateMethodName,           "as_method/method_name/validate_method_name"
-    autoload :GenerateFromModuleName,       "as_method/method_name/generate_from_module_name"
+    autoload :Validate,                     "as_method/method_name/validate"
+    autoload :GenerateFromClassName,        "as_method/method_name/generate_from_class_name"
   end
 
-  def as_method(service_object, name: nil)
-    includable_module = FindOrDefineIncludableModule.call(service_object, name)
-    unless self.included_modules.include?(includable_module)
-      includable_module
-    else
-      Kernel # a bit faster
-    end
-    
-  end
 end # ... AsMethod

metadata

@@ -1,44 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: as_method
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Vladimir Gorodulin
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-06 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.2'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
-description: Make callable Service Objects includable as methods
+date: 2024-01-09 00:00:00.000000000 Z
+dependencies: []
+description: Bring Service Objects to your classes as methods.
 email:
 - ru.hostmaster@gmail.com
 executables: []
@@ -49,15 +21,16 @@ files:
 - LICENSE
 - README.md
 - lib/as_method.rb
-- lib/as_method/define_includable_module.rb
-- lib/as_method/find_or_define_includable_module.rb
-- lib/as_method/method_name/generate_from_module_name.rb
-- lib/as_method/method_name/validate_method_name.rb
-- lib/as_method/module_name/generate_for_includable_module.rb
-- lib/as_method/module_name/generate_from_underscored.rb
+- lib/as_method/allow.rb
+- lib/as_method/find_or_define_module.rb
+- lib/as_method/get_service_object.rb
+- lib/as_method/helpers.rb
+- lib/as_method/method_name/generate_from_class_name.rb
+- lib/as_method/method_name/validate.rb
+- lib/as_method/module_name/generate_from_snake_case.rb
 - lib/as_method/module_name/strip_namespace.rb
-- lib/as_method/registration_methods.rb
 - lib/as_method/setup.rb
+- lib/as_method/validate_service_object.rb
 - lib/as_method/version.rb
 homepage: https://github.com/gorodulin/as_method
 licenses:
@@ -74,14 +47,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.0.0
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.22
 signing_key:
 specification_version: 4
 summary: Call Service Objects with ease. Include them to your classes as methods!

data/lib/as_method/define_includable_module.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module AsMethod
-  module DefineIncludableModule
-
-    PASS = if RUBY_VERSION < "2.7"
-      "*args, &block"
-    else
-      "..."
-    end
-
-    def self.call(includable_module_name, service_object_class, method_name)
-      puts "-- DefineIncludableModule #{includable_module_name}"
-      code = <<~RUBY
-        module #{includable_module_name}
-
-          def self.ruby2_keywords(*)
-            puts "-- ruby2_keywords"
-          end if RUBY_VERSION < "2.7"
-
-          ruby2_keywords def #{method_name}(*args, &block)
-            self.class.registered_service_objects[:"#{method_name}"].call(*args, &block)
-          end
-
-          def self.included(base)
-            if base.instance_of?(Module)
-              fail TypeError, "Can't be included into Module \#{base.inspect}"
-            end
-            unless base.included_modules.include?(RegistrationMethods)
-              #puts "-- included #{includable_module_name} into \#{base}"
-              base.include RegistrationMethods
-            end
-            base.register_service_object(:"#{method_name}", ::#{service_object_class})
-          end
-          
-          def self.extended(_base)
-            raise "Do not extend, include!"
-          end
-        end
-      RUBY
-      instance_eval code
-    end
-
-  end # ... DefineIncludableModule
-end # ... AsMethod

data/lib/as_method/find_or_define_includable_module.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module AsMethod
-  class FindOrDefineIncludableModule
-
-    def self.call(service_object, method_name)
-      new.call(service_object, method_name)
-    end
-
-    def call(service_object, method_name)
-      # Note: order matters:
-      self.service_object = service_object
-      self.method_name = method_name
-      self.includable_module_name = generate_includable_module_name(service_object, method_name)
-
-      define_includable_module unless Object.const_defined?(includable_module_name)
-
-      Object.const_get(includable_module_name)
-    end
-
-    private
-
-    attr_accessor :includable_module_name
-    attr_reader :method_name
-    attr_reader :service_object
-
-    def define_includable_module
-      DefineIncludableModule.call(includable_module_name, service_object, method_name)
-    end
-
-    def generate_method_name_from_so_name
-      MethodName::GenerateFromModuleName.call(service_object.name)
-    end
-
-    def generate_includable_module_name(service_object, method_name)
-      ModuleName::GenerateForIncludableModule.call(service_object, method_name)
-    end
-
-    def method_name=(name)
-      validate_method_name!(name.to_s) if name
-
-      @method_name = name&.to_s || generate_method_name_from_so_name
-    end
-
-    def service_object=(module_or_class)
-      unless module_or_class.respond_to?(:call)
-        fail NoMethodError, "Expected #{module_or_class} to respond to #call method"
-      end
-      unless module_or_class.is_a?(Module)
-        fail TypeError, "#{module_or_class} must be a Class or a Module"
-      end
-      @service_object = module_or_class
-    end
-
-    def validate_method_name!(name)
-      return if MethodName::ValidateMethodName.call(name)
-
-      fail NameError, "wrong method name #{name.inspect}"
-    end
-
-  end # ... FindOrDefineIncludableModule
-end # ... AsMethod

data/lib/as_method/module_name/generate_for_includable_module.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module AsMethod
-  module ModuleName
-    module GenerateForIncludableModule
-
-      def self.call(module_or_class, method_name = nil)
-        part = GenerateFromUnderscored.call(method_name) || StripNamespace.call(module_or_class)
-
-        "::#{module_or_class}::As#{part}Method"
-      end
-
-    end # ... GenerateForIncludableModule
-  end # ... ModuleName
-end # ... AsMethod

data/lib/as_method/registration_methods.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module AsMethod
-  module RegistrationMethods
-
-    module ClassMethods
-      def registered_service_objects
-        @registered_service_objects ||= {}
-      end
-      
-      def register_service_objects(hash)
-        hash.each { |name, so| register_service_object(name, so) }
-      end
-
-      def register_service_object(name, so)
-        registered_service_objects[name.to_sym]&.tap do |registered_so|
-          return if so == registered_so
-          raise "#{so} clashes with #{registered_so} in #{self}" if so != registered_so
-        end
-        
-        # puts "--- register #{self.name}##{name} => #{so}#call"
-        registered_service_objects[name.to_sym] = so
-      end
-    end # ... ClassMethods
-
-    def self.included(base)
-      return if base.singleton_class.included_modules.include?(ClassMethods)
-
-      puts "-- #{base.name} extend with RegistrationMethods::ClassMethods"
-      base.extend ClassMethods
-    end
-
-  end # ... RegistrationMethods
-end # ... AsMethod