as_method 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e0e9e993c21de8b7a1d579d9228ee8901f7b18cc892f37a0e0b1f9a6ef6a50a7
+  data.tar.gz: 2f7506bb9f6ed58793c2b4f606035baffc3fb8f608d88d778047ccd9e769c1fe
+SHA512:
+  metadata.gz: b94dd8cc2f9049a71fcbea9bf789ce2794df3d5593b390aa558eeaf7837a12c015c9e8e265898ad1751ccd7effb397e2f43c78eb92d503c628f123747d58f09e
+  data.tar.gz: 98c396c3768c0ca040f25d5d103d18fe71b05baec6571ff3da5396c608a63c3fedf60f226d77325dd1c83ef2c3bc1bc55ec1111abd836ddf9aa62583983f6da5

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.1.0] - 2022-10-06
+
+Initial version

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 V.G.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,54 @@
+# Includable Service Objects
+
+Usage example:
+
+```ruby
+class CreateUser
+  include as_method ValidateUserAttributes, name: :validate!
+  include as_method Generators::GeneratePassword
+  include as_method SaveModel, name: :save
+
+  def call(name, email)
+    @name = name
+    @email = email
+    user = User.new(attributes)
+    validate!(user)
+    save(user)
+  end
+
+  private
+
+  def attributes
+    {
+      name: @name,
+      email: @email,
+      password: generate_password(length: 30),
+    }
+  end
+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;
+
+## Compatibility
+
+Tested on Ruby v2.4 .. v3.1, but it is expected to work on all 2.x versions.
+
+## Installation
+
+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:
+
+```ruby
+require "as_method/setup"
+```

data/lib/as_method/define_includable_module.rb

@@ -0,0 +1,45 @@
+# 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

@@ -0,0 +1,62 @@
+# 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/method_name/generate_from_module_name.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module AsMethod
+  module MethodName
+    module GenerateFromModuleName
+
+      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')
+          .downcase
+      end
+
+    end # ... GenerateFromModuleName
+  end # ... MethodName
+end # ... AsMethod

data/lib/as_method/method_name/validate_method_name.rb

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

data/lib/as_method/module_name/generate_for_includable_module.rb

@@ -0,0 +1,15 @@
+# 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/module_name/generate_from_underscored.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module AsMethod
+  module ModuleName
+    module GenerateFromUnderscored
+
+      REPLACEMENTS = {
+        "-" => "_Min",
+        "!" => "_Exc",
+        "?" => "_Que",
+        "[" => "_Sbl",
+        "]" => "_Sbr",
+        "*" => "_Ast",
+        "/" => "_Sla",
+        "&" => "_Amp",
+        "%" => "_Pct",
+        "^" => "_Pwr",
+        "+" => "_Plu",
+        "<" => "_Lst",
+        "=" => "_Eql",
+        ">" => "_Gtt",
+        "|" => "_Vbr",
+        "~" => "_Til",
+      }.freeze
+
+      def self.call(string)
+        return unless string
+        
+        string.to_s
+          .gsub(/(?:_|(^))([a-z\d]{1})/) { "#{$1}#{$2.capitalize}" }
+          .gsub(/[#{Regexp.escape(REPLACEMENTS.keys.join)}]/, REPLACEMENTS)
+      end
+
+    end # ... GenerateFromUnderscored
+  end # ... ModuleName
+end # ... AsMethod

data/lib/as_method/module_name/strip_namespace.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module AsMethod
+  module ModuleName
+    module StripNamespace
+
+      def self.call(module_or_class)
+        module_or_class.to_s.match(/[^:]+\z/)&.to_s
+      end
+
+    end # ... StripNamespace
+  end # ... ModuleName
+end # ... AsMethod

data/lib/as_method/registration_methods.rb

@@ -0,0 +1,34 @@
+# 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

data/lib/as_method/setup.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Usage:
+#
+# Require this file to add #as_method class method to all classes:
+#   require 'as_method/setup'
+#
+
+unless Object.singleton_class.included_modules.include?(AsMethod)
+  Object.extend AsMethod
+end

data/lib/as_method/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module AsMethod
+
+  VERSION = "0.1.0"
+
+end

data/lib/as_method.rb

@@ -0,0 +1,29 @@
+# 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 :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 :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"
+  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

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: as_method
+version: !ruby/object:Gem::Version
+  version: 0.1.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
+email:
+- ru.hostmaster@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- 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/module_name/strip_namespace.rb
+- lib/as_method/registration_methods.rb
+- lib/as_method/setup.rb
+- lib/as_method/version.rb
+homepage: https://github.com/gorodulin/as_method
+licenses:
+- MIT
+metadata:
+  changelog_uri: https://github.com/gorodulin/as_method/CHANGELOG.md
+  homepage_uri: https://github.com/gorodulin/as_method
+  source_code_uri: https://github.com/gorodulin/as_method
+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.1.6
+signing_key:
+specification_version: 4
+summary: Call Service Objects with ease. Include them to your classes as methods!
+test_files: []