to_proc_interface 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b73dd7a76c25dc9c9f1fcab7fdc1d3e08f16ae59f506135129b142c92741c7cc
-  data.tar.gz: a8f54245df8216be57aae42e715278caf65edbfb0ebdfa05f61f01528c3347e0
+  metadata.gz: b002618fc6a3b5e2e6d7a7d649a093b4f053fc4d9020ff4a19cb27213ee8f882
+  data.tar.gz: 0d081f67681e258e9ef4d09b7e26f81f688ef8741bda45bda5477813e2a4c99b
 SHA512:
-  metadata.gz: b8be7d648e4033dfcca339b67033e2de7b941ef013675de3fd6033bae2b016bee268b2e7611c818175a0111427da5c734ebb60bf643c04af74a4d4b2cee4cfa4
-  data.tar.gz: 3a1e0c7e8f4820c4857098c46984a319d5c5908659f97c7b158de547bfe3735fb2e914d729b9771c2340361fc0f54a5e5e19aca91ecc89cc052ae0d16a97fde0
+  metadata.gz: 501d9ef19ae6a4051d59838a8fa1b480bb90574a76653e39662c1c78ec9458c9e81e13ca2ee2951bc1fa6c6f2a320c2da9a6c482b947d2a7ba969961cfb307d4
+  data.tar.gz: 923339620dfa4e87a3db869fe20c46d34bafc602e2d4a6b7e50b309be5272421a5e88f185ee36504f2cf1d34651a353aa9ab7eeb426702dd9251ef2a95ddbbab

data/.rubocop.yml

@@ -0,0 +1,19 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 2.7
+  SuggestExtensions: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/AccessModifierDeclarations:
+  EnforcedStyle: inline
+
+Naming/MethodParameterName:
+  MinNameLength: 1
+
+Style/SymbolArray:
+  Enabled: false

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+- 0.2.0
+  - Re-release

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2024 estum
+Copyright (c) 2025 Anton Semenov
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,6 +1,6 @@
 # ToProcInterface
 
-The collection of mixins to make anything responsible to `#call` acts like a `Proc`.
+The collection of mixins that makes your classes or instances act like a `Proc`. In the common way it handles some routines to memoize `#to_proc` method from a `#call` method object and delegates `Proc` instance methods to that proc.
 
 ## Installation
 
@@ -18,7 +18,7 @@ gem install to_proc_interface
 
 ## Usage
 
-TODO: Write usage instructions here
+See docs.
 
 ## Development
 

data/Rakefile

@@ -5,4 +5,8 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task default: %i[spec]
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/to_proc_interface/call_to_maybe.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ToProcInterface
+  # The mixin to use when an instance-level {#call} method returns a monad.
+  module CallToMaybe
+    include ToProcInterface
+
+    # All the arguments passed to initializer.
+    # @see #initialize
+    # @see #call
+    # @return [Dry::Monad::Maybe]
+    def call(...)
+      new(...).call.to_maybe
+    end
+  end
+end

data/lib/to_proc_interface/calling_service.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ToProcInterface
+  # @example Usage
+  #   class Sum < Struct.new(:a, :b, keyword_init: true)
+  #     extend ToProcInterface::CallingService
+  #
+  #     def call
+  #       self.a + self.b
+  #     end
+  #   end
+  #
+  #   [
+  #     { a: 1, b: 2 },
+  #     { a: 3, b: 4 }
+  #   ].map(&Sum) # => [3, 7]
+  module CallingService
+    include ToProcInterface
+
+    # Initializes an object with the given args and invokes it's {#call} method without arguments.
+    # @see #initializer
+    # @see #call
+    def call(...)
+      new(...).call
+    end
+  end
+end

data/lib/to_proc_interface/hooks.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module ToProcInterface
+  # The namespace for hook mixins & the composition mixin.
+  #
+  # @example Usage
+  #   module MyToProcInterface
+  #     include ToProcInterface::Mixin
+  #     include ToProcInterface::Delegations
+  #     extend ToProcInterface::Hooks
+  #   end
+  module Hooks
+    # The mixin contains the {Class.inherited} hook for the proper memoization of {#to_proc} singleton class method.
+    # It is neccessary to use it when extending a singleton class with the interface.
+    # @api private
+    module Inherited
+      # @param subclass [Class]
+      # @return [void]
+      private def inherited(subclass)
+        if subclass.instance_variable_defined?(:@to_proc)
+          subclass.remove_instance_variable(:@to_proc)
+          subclass.to_proc
+        end
+        super
+      end
+    end
+
+    # The mixin hooks the {#extend_object} method that selects
+    # the proper extension.
+    #
+    # @example Usage
+    #   module Extension
+    #     include ToProcInterface
+    #     extend Hooks::Extended
+    #   end
+    #
+    #   class Example
+    #     # @!parse extend ToProcInterface::Hooks::Inherited
+    #     extend Extension
+    #   end
+    #
+    # @api private
+    module Extended
+      # @return [void]
+      #
+      # @overload extend_object(module_object)
+      #   @param module_object [Module]
+      #   Extends the target module {ToProcInterface::Hooks::Included}.
+      #
+      # @overload extend_object(class_object)
+      #   @param class_object [Class]
+      #   Extends the target class with {ToProcInterface::Hooks::Inherited}
+      private def extend_object(object)
+        case object
+        when Class
+          object.extend Inherited
+        when Module
+          object.extend Included
+        end
+        super
+      end
+    end
+
+    # @example Usage
+    #   module Mixin
+    #     # @!parse extend ToProcInterface::Hooks::Included
+    #     include ToProcInterface
+    #   end
+    #
+    #   class Example
+    #     extend Mixin
+    #   end
+    #
+    # @api private
+    module Included
+      # @return [void]
+      #
+      # @overload append_features(module_object)
+      #   @param module_object [Module]
+      #   Extends the target module (unless it is the namespaced {ToProcInterface::Singleton} mixin)
+      #   with {Hooks::Extended}.
+      #
+      # @overload append_features(class_object)
+      #   @param class_object [Class]
+      #   Does nothing if includes to {Class}
+      private def append_features(base)
+        return false if base < self
+
+        case base
+        when Class
+          super
+        when Module
+          super
+          base.extend Extended unless ToProcInterface.const_defined?(:Singleton) && base == Singleton
+        end
+      end
+    end
+
+    include Extended
+    include Included
+  end
+end

data/lib/to_proc_interface/initializer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ToProcInterface
+  # @example Usage
+  #   class Sum < Struct.new(:a, :b, keyword_init: true)
+  #     extend ToProcInterface::Initializer
+  #   end
+  #   [
+  #     { a: 1, b: 2 },
+  #     { a: 3, b: 4 }
+  #   ].map(&Sum) # => [#<struct Sum a=1, b=2>, #<struct Sum a=3, b=4>]
+  module Initializer
+    include ToProcInterface
+
+    # Initializes an object with the given args and invokes it's {#call} method without arguments.
+    # @see #initializer
+    def call(...)
+      new(...)
+    end
+  end
+end

data/lib/to_proc_interface/performing_service.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ToProcInterface
+  # @example Usage
+  #   class Sum < Struct.new(:a, :b, keyword_init: true)
+  #     extend ToProcInterface::PerformingService
+  #
+  #     def perform
+  #       self.a + self.b
+  #     end
+  #   end
+  #
+  #   [
+  #     { a: 1, b: 2 },
+  #     { a: 3, b: 4 }
+  #   ].map(&Sum) # => [3, 7]
+  module PerformingService
+    include ToProcInterface
+
+    # Initializes an object with the given args and invokes it's {#perform} method without arguments.
+    # @see #initializer
+    # @see #perform
+    def call(...)
+      new(...).perform
+    end
+  end
+end

data/lib/to_proc_interface/singleton.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "singleton"
+
+module ToProcInterface
+  # Singleton variation. {#to_proc} & {#call} delegated to {ToProcInterface::Singleton::ClassMethods.instance}
+  #
+  # @example Usage
+  #   require "to_proc_interface/singleton"
+  #
+  #   class Sum
+  #     include ToProcInterface::Singleton
+  #
+  #     def call(a, b)
+  #       a + b
+  #     end
+  #   end
+  #
+  #   Sum.(1, 2) # => 3
+  module Singleton
+    include ToProcInterface
+
+    # @api private
+    def self.included(base)
+      super
+      base.include ::Singleton
+      base.extend ClassMethods
+    end
+
+    # @api private
+    module ClassMethods
+      include Delegations
+
+      # @!attribute [r] instance
+      #   @return [::Singleton]
+
+      # @return [Proc]
+      def to_proc
+        instance.to_proc
+      end
+
+      def call(...)
+        instance.call(...)
+      end
+    end
+  end
+end

data/lib/to_proc_interface/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ToProcInterface
-  VERSION = "0.1.1"
-end
+  VERSION = "0.2.0"
+end

data/lib/to_proc_interface/wrapping_call.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ToProcInterface
+  # @note
+  #   Block passed to class-level {WrappingCall#call}
+  #   will be yield to instance-level #call
+  module WrappingCall
+    include ToProcInterface
+
+    # @!scope class
+
+    def call(...)
+      if block_given?
+        call_safe(...)
+      else
+        call_unsafe(...)
+      end
+    end
+
+    def call_safe(*args, **opts, &block)
+      new(*args, **opts).call_safe(&block)
+    end
+
+    def call_unsafe(...)
+      new(...).call_unsafe
+    end
+  end
+end

data/lib/to_proc_interface.rb

@@ -1,221 +1,126 @@
 # frozen_string_literal: true
 
-require 'singleton'
+require "to_proc_interface/hooks"
+require "zeitwerk"
 
-# @example Usage
-#   class SomeCallableClass
-#     def self.call(*args)
-#       # bla-bla
+# @example Extended to a class
+#   class Sum
+#     extend ToProcInterface
+#
+#     def self.call(a, b)
+#       a + b
 #     end
+#   end
 #
-#     extend ToProcInterface
+#   Sum[1, 2] # => 3
+#
+# @example Included to a class
+#   class Sum
+#     include ToProcInterface
+#
+#     def call(a, b)
+#       a + b
+#     end
+#   end
+#
+#   Sum.new[1, 2] # => 3
+#
+# @example Included to a module
+#   module YieldToInstanceCall
+#     # @!parse extend ToProcInterface::Hooks::Extended
+#     # @!parse extend ToProcInterface::Hooks::Inherited
+#     include ToProcInterface
+#
+#     def call(*args, **opts, &block)
+#       new(*args, **opts).call(&block)
+#     end
+#   end
+#
+#   class BinaryOp
+#     extend YieldToInstanceCall
+#
+#     def initialize(a, b)
+#       @a, @b = a, b
+#     end
+#
+#     def call
+#       yield(@a, @b)
+#     end
 #   end
+#
+#   BinaryOp.(1, 2, &:+) # => 3
 module ToProcInterface
-  # @api private
-  # Mixin module with delegations to {ToProcInterface#to_proc} method to mimic {Proc} behavior.
-  module Delegations
-    class << self
-      @@proc_methods = []
-
-      # @return [Array<Symbol>]
-      def proc_methods
-        @@proc_methods
-      end
+  METHODS = [
+    :parameters,
+    :<<,
+    :yield,
+    :[],
+    :>>,
+    :arity,
+    :lambda?,
+    :binding,
+    :curry,
+    :source_location
+  ].freeze
 
-      @@args_by_arity = [
-        "",
-        "arg",
-        "*args, **opts, &block"
-      ].freeze
-
-      # @!macro [new] delegate_to_proc
-      #   @!method (...)
-      #     @see Proc#
-      #
-      # @param name [Symbol, String]
-      #   method name
-      # @param arity [Integer]
-      #   method arity
-      # @return [Symbol]
-      #   delegated method name
-      #
-      # @example Customize proc-delegated methods
-      #   ToProcInterface::Delegations.delegate_to_proc :custom_proc_method, arity: 1
-      def delegate_to_proc(name, arity: nil)
-        name = name.to_sym
-        arity ||= Proc.instance_method(name).arity
-        args = @@args_by_arity[arity.clamp(-1, 1)]
-
-        class_eval(<<~RUBY, __FILE__, __LINE__ + 1).tap { proc_methods << _1 }
-          def #{name}(#{args})
-            to_proc.#{name}(#{args})
-          end
-        RUBY
-      end
-    end
-
-    delegate_to_proc :parameters, arity: 0
-    delegate_to_proc :arity, arity: 0
-    delegate_to_proc :lambda?, arity: 0
-    delegate_to_proc :binding, arity: 0
-    delegate_to_proc :curry, arity: -1
-    delegate_to_proc :yield, arity: -1
-    delegate_to_proc :[], arity: -1
-    delegate_to_proc :<<, arity: 1
-    delegate_to_proc :>>, arity: 1
-    delegate_to_proc :source_location
-    delegate_to_proc :ruby2_keywords if Proc.method_defined?(:ruby2_keywords)
-  end
-
-  # @api private
-  module Hooks
-    # @example Usage
-    #   extend ToProcInterface::Hooks::Included
-    module Included
-      # @return [void]
-      private def included(base)
-        base.extend Extended if base.is_a?(Module) && !base.is_a?(Class)
-        super if defined?(super)
-      end
-    end
-
-    # @example Usage
-    #   extend ToProcInterface::Hooks::Extended
-    module Extended
-      # Hooks an {Module#extended} callback method to mix in possible singleton class with {Inherited}.
-      # @return [void]
-      private def extended(base)
-        base.extend Inherited if base.is_a?(Class)
-        super if defined?(super)
-      end
-    end
-
-    # @example Usage
-    #   extend ToProcInterface::Hooks::Inherited
-    module Inherited
-      # Hooks an {Class#inherited} method to avoid reusing cached {#to_proc} on inherited classes.
-      # @return [void]
-      private def inherited(subclass)
-        if subclass.instance_variable_defined?(:@to_proc)
-          subclass.remove_instance_variable(:@to_proc)
-          subclass.to_proc
-        end
-        super if defined?(super)
-      end
-    end
-  end
-
-  # @api private
+  # @abstract
   module Mixin
-    extend Hooks::Included
-    include Delegations
-
-    # @return [Proc] built from the {#call} method
+    # @!attribute [r] to_proc
+    #   @return [Proc] built from the {#call} method
     def to_proc
       @to_proc ||= method(:call).to_proc
     end
-  end
-
-  include Mixin
-
-  # Interface with predefined {#call} method which delegates all the given params into class' constructor
-  # and invokes instance's {#call} method.
-  #
-  # @example Usage
-  #   extend ToProcInterface::CallingService
-  module CallingService
-    include Mixin
-
-    # @see #initialize
-    # @see #call
-    def call(*args, **opts, &block)
-      instance = new(*args, **opts, &block)
-      instance.call
-    end
-  end
 
-  # Interface with predefined {#call} method which delegates all the given params into class' constructor
-  # and invokes instance's {#call} method converting a result monad into maybe.
-  #
-  # @abstract
-  #   The instance method `#call` should return a monad-like object responsible to `#to_maybe`.
-  #
-  # @example Usage
-  #   extend ToProcInterface::CallToMaybe
-  module CallToMaybe
-    include Mixin
-
-    # @see #initialize
-    # @see #call
-    # @return [Dry::Monads::Maybe]
-    def call(*args, **opts, &block)
-      instance = new(*args, **opts, &block)
-      result = instance.call
-      result.to_maybe
+    # @abstract
+    def call
+      raise NotImplementedError
     end
   end
 
-  # Interface with predefined {#call} method which delegates all the given params into class' constructor.
-  #
-  # @example Usage
-  #   extend ToProcInterface::Initializer
-  module Initializer
-    include Mixin
+  # The mixin brings all public methods of the {Proc} class to be delegated to the {Mixin#to_proc} method.
+  # @api private
+  module Delegations
+    template, *loc = <<~RUBY, __FILE__, __LINE__ + 1
+      # @see #to_proc
+      # @see Proc#%<name>s
+      def %<name>s(...)
+        to_proc.%<name>s(...)
+      end
+    RUBY
 
-    # @see #initialize
-    # @return [self]
-    def call(*args, **opts, &block)
-      new(*args, **opts, &block)
-    end
+    METHODS.each { module_eval(format(template, name: _1), *loc) }
   end
 
-  # Interface with predefined {#call} method which delegates all the given params into class' constructor
-  # and invokes instance's {#perform} method.
-  #
-  # @example Usage
-  #   extend ToProcInterface::PerformingService
-  module PerformingService
-    include Mixin
+  include Mixin
+  include Delegations
 
-    # @see #initialize
-    # @see #perform
-    def call(*args, **opts, &block)
-      new(*args, **opts, &block).perform
-    end
-  end
+  # @!parse extend Hooks::Extended, Hooks::Included
+  extend Hooks
 
-  # Singleton variation. {#to_proc} & {#call} delegated to {ToProcInterface::Singleton::ClassMethods.instance}
-  #
-  # @example Usage
-  #   include ToProcInterface::Singleton
-  module Singleton
-    include ToProcInterface
+  # rubocop:disable Metrics/MethodLength
 
-    class << self
-      # @api private
-      private def included(base)
-        if base.is_a?(Class)
-          base.include ::Singleton
-          base.extend ClassMethods
+  # @api private
+  def self.loader
+    @loader ||=
+      Zeitwerk::Loader.for_gem.tap do |loader|
+        root = __dir__
+        loader.tag = "to_proc_interface"
+        loader.push_dir root
+        loader.ignore \
+          "#{root}/to_proc_interface/call_to_maybe.rb",
+          "#{root}/to_proc_interface/hooks.rb",
+          "#{root}/to_proc_interface/performing_service.rb",
+          "#{root}/to_proc_interface/singleton.rb",
+          "#{root}/to_proc_interface/wrapping_call.rb"
+
+        if defined?(Pry)
+          loader.log!
+          loader.enable_reloading
         end
-        super if defined?(super)
-      end
-    end
-
-    # @private
-    module ClassMethods
-      # @see ToProcInterface#to_proc
-      # @return [Proc]
-      def to_proc
-        instance.to_proc
       end
+  end
 
-      # @see #call
-      def call(*args, **opts, &block)
-        instance.call(*args, **opts, &block)
-      end
+  # rubocop:enable Metrics/MethodLength
 
-      include Delegations
-    end
-  end
-end
+  loader.setup
+end

metadata

@@ -1,30 +1,30 @@
 --- !ruby/object:Gem::Specification
 name: to_proc_interface
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
-- estum
+- Anton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-12-05 00:00:00.000000000 Z
+date: 2025-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: singleton
+  name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0.1'
-description: Collection of mixins to make anything act like a proc.
+        version: '0'
+description: Collection of mixins that makes your classes & objects act like procs.
 email:
 - anton.estum@gmail.com
 executables: []
@@ -32,21 +32,30 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/to_proc_interface.rb
+- lib/to_proc_interface/call_to_maybe.rb
+- lib/to_proc_interface/calling_service.rb
+- lib/to_proc_interface/hooks.rb
+- lib/to_proc_interface/initializer.rb
+- lib/to_proc_interface/performing_service.rb
+- lib/to_proc_interface/singleton.rb
 - lib/to_proc_interface/version.rb
-- sig/to_proc_interface.rbs
+- lib/to_proc_interface/wrapping_call.rb
 homepage: https://github.com/estum/to_proc_interface
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/estum/to_proc_interface
-  source_code_uri: https://github.com/estum/to_proc_inteface
-  changelog_uri: https://github.com/estum/to_proc_inteface/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/estum/to_proc_interface
+  changelog_uri: https://github.com/estum/to_proc_interface/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -62,8 +71,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.17
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
-summary: "#to_proc mixins."
+summary: Collection of mixins that makes your classes & objects act like procs.
 test_files: []

data/sig/to_proc_interface.rbs

@@ -1,5 +0,0 @@
-module ToProcInterface
-  VERSION: String
-
-  def to_proc: -> Proc
-end