receptacle 0.3.1 → 2.0.0

data/lib/receptacle/method_delegation.rb

@@ -1,136 +0,0 @@
-# frozen_string_literal: true
-require 'receptacle/method_cache'
-require 'receptacle/registration'
-require 'receptacle/errors'
-
-module Receptacle
-  # module which enables a repository to mediate methods dynamically to wrappers and strategy
-  # @api private
-  module MethodDelegation
-    # dynamically build mediation method on first invocation if the method is registered
-    def method_missing(method_name, *arguments, &block)
-      if Registration.repositories[self].methods.include?(method_name)
-        public_send(__build_method(method_name), *arguments, &block)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      Registration.repositories[self].methods.include?(method_name) || super
-    end
-
-    # @param method_name [#to_sym]
-    # @return [void]
-    def __build_method(method_name)
-      method_cache = __build_method_call_cache(method_name)
-      if method_cache.wrappers.nil? || method_cache.wrappers.empty?
-        __define_shortcut_method(method_cache)
-      elsif method_cache.arity.abs > 1
-        __define_full_method_high_arity(method_cache)
-      else
-        __define_full_method(method_cache)
-      end
-    end
-
-    # build method cache for given method name
-    # @param method_name [#to_sym]
-    # @return [MethodCache]
-    def __build_method_call_cache(method_name)
-      config = Registration.repositories[self]
-
-      raise Errors::NotConfigured, repo: self if config.strategy.nil?
-      MethodCache.new(
-        strategy: config.strategy,
-        wrappers: config.wrappers,
-        method_name: method_name
-      )
-    end
-
-    # build lightweight method to mediate method calls to strategy without wrappers
-    # @param method_cache [MethodCache] method_cache of the method to be build
-    # @return [void]
-    def __define_shortcut_method(method_cache)
-      define_singleton_method(method_cache.method_name) do |*args, &inner_block|
-        method_cache.strategy.new.public_send(method_cache.method_name, *args, &inner_block)
-      end
-    end
-
-    # build method to mediate method calls of arity 1 to strategy with full wrapper support
-    # @param method_cache [MethodCache] method_cache of the method to be build
-    # @return [void]
-    def __define_full_method(method_cache)
-      define_singleton_method(method_cache.method_name) do |*args, &inner_block|
-        __run_wrappers(method_cache, *args) do |*call_args|
-          method_cache.strategy.new.public_send(method_cache.method_name, *call_args, &inner_block)
-        end
-      end
-    end
-
-    # build method to mediate method calls of higher arity to strategy with full wrapper support
-    # @param method_cache [MethodCache] method_cache of the method to be build
-    # @return [void]
-    def __define_full_method_high_arity(method_cache)
-      define_singleton_method(method_cache.method_name) do |*args, &inner_block|
-        __run_wrappers(method_cache, args, true) do |*call_args|
-          method_cache.strategy.new.public_send(method_cache.method_name, *call_args, &inner_block)
-        end
-      end
-    end
-
-    # runtime method to call before and after wrapper in correct order
-    # @param method_cache [MethodCache] method_cache for the current method
-    # @param input_args input parameter of the repository method call
-    # @param high_arity [Boolean] if are intended for a higher arity method
-    # @return strategy method return value after all wrappers where applied
-    def __run_wrappers(method_cache, input_args, high_arity = false)
-      wrappers = method_cache.wrappers.map(&:new)
-      args =
-        if method_cache.skip_before_wrappers?
-          input_args
-        else
-          __run_before_wrappers(wrappers, method_cache.before_method_name, input_args, high_arity)
-        end
-      ret = high_arity ? yield(*args) : yield(args)
-      return ret if method_cache.skip_after_wrappers?
-      __run_after_wrappers(wrappers, method_cache.after_method_name, args, ret, high_arity)
-    end
-
-    # runtime method to execute all before wrappers
-    # @param wrappers [Array] all wrapper instances to be executed
-    # @param method_name [Symbol] name of method to be executed on wrappers
-    # @param args input args of the repository method
-    # @param high_arity [Boolean] if are intended for a higher arity method
-    # @return processed method args by before wrappers
-    def __run_before_wrappers(wrappers, method_name, args, high_arity = false)
-      wrappers.each do |wrapper|
-        next unless wrapper.respond_to?(method_name)
-        args = if high_arity
-                 wrapper.public_send(method_name, *args)
-               else
-                 wrapper.public_send(method_name, args)
-               end
-      end
-      args
-    end
-
-    # runtime method to execute all after wrappers
-    # @param wrappers [Array] all wrapper instances to be executed
-    # @param method_name [Symbol] name of method to be executed on wrappers
-    # @param args input args to the strategy method (after processing in before wrappers)
-    # @param return_value return value of strategy method
-    # @param high_arity [Boolean] if are intended for a higher arity method
-    # @return processed return value by all after wrappers
-    def __run_after_wrappers(wrappers, method_name, args, return_value, high_arity = false)
-      wrappers.reverse_each do |wrapper|
-        next unless wrapper.respond_to?(method_name)
-        return_value = if high_arity
-                         wrapper.public_send(method_name, return_value, *args)
-                       else
-                         wrapper.public_send(method_name, return_value, args)
-                       end
-      end
-      return_value
-    end
-  end
-end

data/lib/receptacle/registration.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-require 'singleton'
-require 'set'
-module Receptacle
-  # keeps global state of repositories, the defined strategy, set wrappers and methods to mediate
-  class Registration
-    include Singleton
-    Tuple = Struct.new(:strategy, :wrappers, :methods)
-
-    attr_reader :repositories
-
-    def initialize
-      @repositories = Hash.new do |h, k|
-        h[k] = Tuple.new(nil, [], Set.new)
-      end
-    end
-
-    def self.repositories
-      instance.repositories
-    end
-
-    # {clear_method_cache} removes dynamically defined methods
-    # this is needed to make strategy and wrappers changes inside the codebase possible
-    def self.clear_method_cache(receptacle)
-      instance.repositories[receptacle].methods.each do |method_name|
-        begin
-          receptacle.singleton_class.send(:remove_method, method_name)
-        rescue NameError
-          nil
-        end
-      end
-    end
-  end
-end

data/performance/benchmark.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-require 'bundler/inline'
-
-gemfile false do
-  source 'https://rubygems.org'
-  gem 'benchmark-ips'
-  gem 'receptacle', path: './..'
-end
-
-require_relative 'speed_receptacle'
-
-Speed.strategy(Speed::Strategy::One)
-Speed.wrappers [Speed::Wrappers::W1,
-                Speed::Wrappers::W2,
-                Speed::Wrappers::W3,
-                Speed::Wrappers::W4,
-                Speed::Wrappers::W5,
-                Speed::Wrappers::W6]
-
-print 'w/ wrappers'
-Benchmark.ips do |x|
-  x.warmup = 10 if RUBY_ENGINE == 'jruby'
-  x.report('a: 2x around, 1x before, 1x after') { Speed.a(1) }
-  x.report('b: 1x around, 1x before, 1x after') { Speed.b(1) }
-  x.report('c: 1x before, 1x after') { Speed.c(1) }
-  x.report('d: 1x after') { Speed.d(1) }
-  x.report('e: 1x before') { Speed.e(1) }
-  x.report('f: 1x around') { Speed.f(1) }
-  x.report('g: no wrappers') { Speed.g(1) }
-end
-
-Speed.wrappers []
-print 'method dispatching w/ wrappers'
-Benchmark.ips do |x|
-  x.warmup = 10 if RUBY_ENGINE == 'jruby'
-  x.report('via receptacle') { Speed.a(:foo) }
-  x.report('direct via public_send') { Speed::Strategy::One.new.public_send(:a, :foo) }
-  x.report('direct via method-method') do
-    m = Speed::Strategy::One.new.method(:a)
-    m.call(:foo)
-  end
-  x.report('direct method-call') { Speed::Strategy::One.new.a(:foo) }
-  x.compare!
-end

data/performance/profile.rb

@@ -1,39 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-# run with --profile.api in JRUBY_OPTS
-require 'bundler/inline'
-require 'jruby/profiler'
-PROFILE_NAME = 'receptacle'.freeze
-
-gemfile false do
-  source 'https://rubygems.org'
-  gem 'receptacle', path: './..'
-end
-require_relative 'speed_receptacle'
-
-Speed.strategy(Speed::Strategy::One)
-Speed.wrappers [Speed::Wrappers::W1,
-                Speed::Wrappers::W2,
-                Speed::Wrappers::W3,
-                Speed::Wrappers::W4,
-                Speed::Wrappers::W5,
-                Speed::Wrappers::W6]
-Speed.a(1)
-Speed.b(1)
-Speed.c(1)
-Speed.d(1)
-Speed.e(1)
-Speed.f(1)
-Speed.g(1)
-
-GC.disable
-profile_data = JRuby::Profiler.profile do
-  100_000.times { Speed.a(1) }
-end
-
-profile_printer = JRuby::Profiler::GraphProfilePrinter.new(profile_data)
-profile_printer.printProfile(File.open("#{PROFILE_NAME}.graph.profile", 'w+'))
-profile_printer.printProfile(STDOUT)
-
-profile_printer = JRuby::Profiler::FlatProfilePrinter.new(profile_data)
-profile_printer.printProfile(File.open("#{PROFILE_NAME}.flat.profile", 'w+'))

data/performance/speed_receptacle.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-require 'receptacle'
-module Speed
-  include Receptacle::Repo
-  mediate :a
-  mediate :b
-  mediate :c
-  mediate :d
-  mediate :e
-  mediate :f
-  mediate :g
-  module Strategy
-    class One
-      def a(arg)
-        arg
-      end
-      alias b a
-      alias c a
-      alias d a
-      alias e a
-      alias f a
-      alias g a
-    end
-  end
-
-  module Wrappers
-    class W1
-      def before_a(args)
-        args
-      end
-
-      def after_a(return_values, _)
-        return_values
-      end
-
-      def before_f(args)
-        args
-      end
-
-      def after_f(return_values, _)
-        return_values
-      end
-    end
-
-    class W2
-      # :a
-      def before_a(args)
-        args
-      end
-
-      def after_a(return_values, _)
-        return_values
-      end
-
-      # :b
-      def before_b(args)
-        args
-      end
-
-      def after_b(return_values, _)
-        return_values
-      end
-    end
-    class W3
-      def before_a(args)
-        args
-      end
-
-      def before_c(args)
-        args
-      end
-    end
-
-    class W4
-      def after_a(return_values, _)
-        return_values
-      end
-
-      def after_d(return_value, _)
-        return_value
-      end
-    end
-
-    class W5
-      def before_b(args)
-        args
-      end
-
-      def after_c(return_value, _)
-        return_value
-      end
-    end
-
-    class W6
-      def after_b(return_value, _)
-        return_value
-      end
-
-      def before_e(args)
-        args
-      end
-    end
-  end
-end