graft 0.2.0 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4127a179ba1dd78b8575fac807051f3072a4fed22ec5f1521afe25626d3432a5
+  data.tar.gz: 4cfe831c87a9b0b2be7b2a37945825a6329d15fbcf5d037ea08c492855f26f68
+SHA512:
+  metadata.gz: cdbab8db3916a2f8f62d2563a0c2da6a3a4391573ee77277f6f381f4daf1b8af3185341a3c94efd9d3fbc63e03047b5e2b2dddeb0ef859e3f3af1bc9e97d523a
+  data.tar.gz: 7becc0d2ae1f84fcb34057005b43ec6cfb40bbe2069e735e263c22c15cea5b383c828ceabb9e88c87b64cd8bdc4c5c7e55b7dda0cc136df2e6369cb1103dd9cc

data/lib/graft/callback.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Graft
+  class Callback
+    attr_reader :name
+
+    # NOTE: opts is not used in the current implementation
+    def initialize(name = nil, opts = {}, &block)
+      @name = name
+      @opts = opts
+      @block = block
+      @enabled = true
+    end
+
+    if RUBY_VERSION < "3.0"
+      def call(*args, &block)
+        return unless enabled?
+
+        @block.call(*args, &block)
+      end
+    else
+      def call(*args, **kwargs, &block)
+        return unless enabled?
+
+        @block.call(*args, **kwargs, &block)
+      end
+    end
+
+    def disable
+      @enabled = false
+    end
+
+    def enable
+      @enabled = true
+    end
+
+    def enabled?
+      @enabled
+    end
+  end
+end

data/lib/graft/hook.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative "stack"
+require_relative "callback"
+require_relative "hook_point"
+
+module Graft
+  class Hook
+    DEFAULT_STRATEGY = HookPoint::DEFAULT_STRATEGY
+
+    @hooks = {}
+
+    def self.[](hook_point, strategy = DEFAULT_STRATEGY)
+      @hooks[hook_point] ||= new(hook_point, nil, strategy)
+    end
+
+    def self.add(hook_point, strategy = DEFAULT_STRATEGY, &block)
+      self[hook_point, strategy].add(&block)
+    end
+
+    def self.ignore
+      Thread.current[:hook_entered] = true
+      yield
+    ensure
+      Thread.current[:hook_entered] = false
+    end
+
+    attr_reader :point, :stack
+
+    def initialize(hook_point, dependency_test = nil, strategy = DEFAULT_STRATEGY)
+      @disabled = false
+      @point = hook_point.is_a?(HookPoint) ? hook_point : HookPoint.new(hook_point, strategy)
+      @dependency_test = dependency_test || proc { point.exist? }
+      @stack = Stack.new
+    end
+
+    def dependency?
+      return true if @dependency_test.nil?
+
+      @dependency_test.call
+    end
+
+    def add(&block)
+      tap { instance_eval(&block) }
+    end
+
+    def callback_name(tag = nil)
+      point.to_s << (tag ? ":#{tag}" : "")
+    end
+
+    def append(tag = nil, opts = {}, &block)
+      @stack << Callback.new(callback_name(tag), opts, &block)
+    end
+
+    def unshift(tag = nil, opts = {}, &block)
+      @stack.unshift Callback.new(callback_name(tag), opts, &block)
+    end
+
+    def before(tag = nil, opts = {}, &block)
+      # TODO
+    end
+
+    def after(tag = nil, opts = {}, &block)
+      # TODO
+    end
+
+    def depends_on(&block)
+      @dependency_test = block
+    end
+
+    def enable
+      @disabled = false
+    end
+
+    def disable
+      @disabled = true
+    end
+
+    def disabled?
+      @disabled
+    end
+
+    def install
+      return unless point.exist?
+
+      point.install("hook", &Hook.wrapper(self))
+    end
+
+    def uninstall
+      return unless point.exist?
+
+      point.uninstall("hook")
+    end
+
+    class << self
+      if RUBY_VERSION < "3.0"
+        def wrapper(hook)
+          proc do |*args, &block|
+            env = {
+              self: self,
+              args: args,
+              block: block
+            }
+            supa = proc { |*args, &block| super(*args, &block) }
+            mid = proc { |_, env| {return: supa.call(*env[:args], &env[:block])} }
+            stack = hook.stack.dup
+            stack << mid
+
+            stack.call(env)
+          end
+        end
+      else
+        def wrapper(hook)
+          proc do |*args, **kwargs, &block|
+            env = {
+              receiver: self,
+              method: hook.point.method_name,
+              kind: hook.point.method_kind,
+              strategy: hook.point.instance_variable_get(:@strategy),
+              args: args,
+              kwargs: kwargs,
+              block: block
+            }
+
+            supa = proc { |*args, **kwargs, &block| super(*args, **kwargs, &block) }
+            mid = proc { |_, env| {return: supa.call(*env[:args], **env[:kwargs], &env[:block])} }
+            stack = hook.stack.dup
+            stack << mid
+
+            stack.call(env)[:return]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graft/hook_point.rb

@@ -0,0 +1,410 @@
+# frozen_string_literal: true
+
+module Graft
+  class HookPointError < StandardError; end
+
+  class HookModule < Module
+    def initialize(key)
+      super()
+
+      @key = key
+    end
+
+    attr_reader :key
+
+    def inspect
+      "#<#{self.class.name}: #{@key.inspect}>"
+    end
+  end
+
+  class HookPoint
+    DEFAULT_STRATEGY = Module.respond_to?(:prepend) ? :prepend : :chain
+
+    class << self
+      def parse(hook_point)
+        klass_name, separator, method_name = hook_point.split(/(\#|\.)/, 2)
+
+        raise ArgumentError, hook_point if klass_name.nil? || separator.nil? || method_name.nil?
+        raise ArgumentError, hook_point unless [".", "#"].include?(separator)
+
+        method_kind = (separator == ".") ? :klass_method : :instance_method
+
+        [klass_name.to_sym, method_kind, method_name.to_sym]
+      end
+
+      def const_exist?(name)
+        resolve_const(name) && true
+      rescue NameError, ArgumentError
+        false
+      end
+
+      def resolve_const(name)
+        raise ArgumentError, "const not found: #{name}" if name.nil? || name.empty?
+
+        name.to_s.split("::").inject(Object) { |a, e| a.const_get(e, false) }
+      end
+
+      def resolve_module(name)
+        const = resolve_const(name)
+
+        raise ArgumentError, "not a Module: #{name}" unless const.is_a?(Module)
+
+        const
+      end
+
+      def strategy_module(strategy)
+        case strategy
+        when :prepend then Prepend
+        when :chain then Chain
+        else
+          raise HookPointError, "unknown strategy: #{strategy.inspect}"
+        end
+      end
+    end
+
+    attr_reader :klass_name, :method_kind, :method_name
+
+    def initialize(hook_point, strategy = DEFAULT_STRATEGY)
+      @klass_name, @method_kind, @method_name = HookPoint.parse(hook_point)
+      @strategy = strategy
+
+      extend HookPoint.strategy_module(strategy)
+    end
+
+    def to_s
+      @to_s ||= "#{@klass_name}#{(@method_kind == :instance_method) ? "#" : "."}#{@method_name}"
+    end
+
+    def exist?
+      return false unless HookPoint.const_exist?(@klass_name)
+
+      if klass_method?
+        (
+          klass.singleton_class.public_instance_methods(false) +
+          klass.singleton_class.protected_instance_methods(false) +
+          klass.singleton_class.private_instance_methods(false)
+        ).include?(@method_name)
+      elsif instance_method?
+        (
+          klass.public_instance_methods(false) +
+          klass.protected_instance_methods(false) +
+          klass.private_instance_methods(false)
+        ).include?(@method_name)
+      else
+        raise HookPointError, "#{self} unknown hook point kind"
+      end
+    end
+
+    def klass
+      HookPoint.resolve_module(@klass_name)
+    end
+
+    def klass_method?
+      @method_kind == :klass_method
+    end
+
+    def instance_method?
+      @method_kind == :instance_method
+    end
+
+    def private_method?
+      if klass_method?
+        klass.private_methods.include?(@method_name)
+      elsif instance_method?
+        klass.private_instance_methods.include?(@method_name)
+      else
+        raise HookPointError, "#{self} unknown hook point kind"
+      end
+    end
+
+    def protected_method?
+      if klass_method?
+        klass.protected_methods.include?(@method_name)
+      elsif instance_method?
+        klass.protected_instance_methods.include?(@method_name)
+      else
+        raise HookPointError, "#{self} unknown hook point kind"
+      end
+    end
+
+    def installed?(key) # rubocop:disable Lint/UselessMethodDefinition
+      super
+    end
+
+    def install(key, &block)
+      return unless exist?
+
+      return if installed?(key)
+
+      super
+    end
+
+    def uninstall(key)
+      return unless exist?
+
+      return unless installed?(key)
+
+      super
+    end
+
+    def enable(key) # rubocop:disable Lint/UselessMethodDefinition
+      super
+    end
+
+    def disable(key) # rubocop:disable Lint/UselessMethodDefinition
+      super
+    end
+
+    def disabled?(key) # rubocop:disable Lint/UselessMethodDefinition
+      super
+    end
+
+    module Prepend
+      def installed?(key)
+        prepended?(key) && overridden?(key)
+      end
+
+      def install(key, &block)
+        prepend(key)
+        override(key, &block)
+      end
+
+      def uninstall(key)
+        unoverride(key) if overridden?(key)
+      end
+
+      def enable(key)
+        raise HookPointError, "enable(#{key.inspect}) with prepend strategy"
+      end
+
+      def disable(key)
+        unoverride(key)
+      end
+
+      def disabled?(key)
+        !overridden?(key)
+      end
+
+      private
+
+      def hook_module(key)
+        target = klass_method? ? klass.singleton_class : klass
+
+        mod = target.ancestors.each do |e|
+          break if e == target
+          break(e) if e.instance_of?(HookModule) && e.key == key
+        end
+
+        raise HookPointError, "Inconsistency detected: #{target} missing from its own ancestors" if mod.is_a?(Array)
+
+        [target, mod]
+      end
+
+      def prepend(key)
+        target, mod = hook_module(key)
+
+        mod ||= HookModule.new(key)
+
+        target.prepend(mod)
+      end
+
+      def prepended?(key)
+        _, mod = hook_module(key)
+
+        mod != nil
+      end
+
+      def overridden?(key)
+        _, mod = hook_module(key)
+
+        (
+          mod.instance_methods(false) +
+          mod.protected_instance_methods(false) +
+          mod.private_instance_methods(false)
+        ).include?(method_name)
+      end
+
+      def override(key, &block)
+        hook_point = self
+        method_name = @method_name
+
+        _, mod = hook_module(key)
+
+        mod.instance_eval do
+          if hook_point.private_method?
+            private
+          elsif hook_point.protected_method?
+            protected
+          else
+            public
+          end
+
+          define_method(:"#{method_name}", &block)
+        end
+      end
+
+      def unoverride(key)
+        method_name = @method_name
+
+        _, mod = hook_module(key)
+
+        mod.instance_eval { remove_method(method_name) }
+      end
+    end
+
+    module Chain
+      def installed?(key)
+        defined(key)
+      end
+
+      def install(key, &block)
+        define(key, &block)
+        chain(key)
+      end
+
+      def uninstall(key)
+        disable(key)
+        remove(key)
+      end
+
+      def enable(key)
+        chain(key)
+      end
+
+      def disable(key)
+        unchain(key)
+      end
+
+      def disabled?(key)
+        !chained?(key)
+      end
+
+      private
+
+      def defined(suffix)
+        if klass_method?
+          (
+            klass.methods +
+            klass.protected_methods +
+            klass.private_methods
+          ).include?(:"#{method_name}_with_#{suffix}")
+        elsif instance_method?
+          (
+            klass.instance_methods +
+            klass.protected_instance_methods +
+            klass.private_instance_methods
+          ).include?(:"#{method_name}_with_#{suffix}")
+        else
+          raise HookPointError, "#{self} unknown hook point kind"
+        end
+      end
+
+      def define(suffix, &block)
+        hook_point = self
+        method_name = @method_name
+
+        if klass_method?
+          klass.singleton_class.instance_eval do
+            if hook_point.private_method?
+              private
+            elsif hook_point.protected_method?
+              protected
+            else
+              public
+            end
+
+            define_method(:"#{method_name}_with_#{suffix}", &block)
+          end
+        elsif instance_method?
+          klass.class_eval do
+            if hook_point.private_method?
+              private
+            elsif hook_point.protected_method?
+              protected
+            else
+              public
+            end
+
+            define_method(:"#{method_name}_with_#{suffix}", &block)
+          end
+        else
+          raise HookPointError, "unknown hook point kind"
+        end
+      end
+
+      def remove(suffix)
+        method_name = @method_name
+
+        if klass_method?
+          klass.singleton_class.instance_eval do
+            remove_method(:"#{method_name}_with_#{suffix}")
+          end
+        elsif instance_method?
+          klass.class_eval do
+            remove_method(:"#{method_name}_with_#{suffix}")
+          end
+        else
+          raise HookPointError, "unknown hook point kind"
+        end
+      end
+
+      def chained?(suffix)
+        method_name = @method_name
+
+        if klass_method?
+          klass.singleton_class.instance_eval do
+            instance_method(:"#{method_name}").original_name == :"#{method_name}_with_#{suffix}"
+          end
+        elsif instance_method?
+          klass.class_eval do
+            instance_method(:"#{method_name}").original_name == :"#{method_name}_with_#{suffix}"
+          end
+        else
+          raise HookPointError, "unknown hook point kind"
+        end
+      end
+
+      def chain(suffix)
+        method_name = @method_name
+
+        if klass_method?
+          klass.singleton_class.instance_eval do
+            alias_method :"#{method_name}_without_#{suffix}", :"#{method_name}"
+            alias_method :"#{method_name}", :"#{method_name}_with_#{suffix}"
+          end
+        elsif instance_method?
+          klass.class_eval do
+            alias_method :"#{method_name}_without_#{suffix}", :"#{method_name}"
+            alias_method :"#{method_name}", :"#{method_name}_with_#{suffix}"
+          end
+        else
+          raise HookPointError, "unknown hook point kind"
+        end
+      end
+
+      def unchain(suffix)
+        method_name = @method_name
+
+        if klass_method?
+          klass.singleton_class.instance_eval do
+            alias_method :"#{method_name}", :"#{method_name}_without_#{suffix}"
+          end
+        elsif instance_method?
+          klass.class_eval do
+            alias_method :"#{method_name}", :"#{method_name}_without_#{suffix}"
+          end
+        end
+      end
+
+      if RUBY_VERSION < "3.0"
+        def apply(obj, suffix, *args, &block)
+          obj.send(:"#{method_name}_without_#{suffix}", *args, &block)
+        end
+      else
+        def apply(obj, suffix, *args, **kwargs, &block)
+          obj.send(:"#{method_name}_without_#{suffix}", *args, **kwargs, &block)
+        end
+      end
+    end
+  end
+end

data/lib/graft/stack.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Graft
+  class Stack < Array
+    def call(env = {})
+      head.call(tail, env)
+    end
+
+    def head
+      # TODO: raise EmptyStackError?
+
+      first
+    end
+
+    def tail
+      tail = self[1..size]
+
+      # TODO: raise EmptyStackError?
+      return Stack.new if tail.nil?
+
+      Stack.new(tail)
+    end
+  end
+end

data/lib/graft.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "graft/hook"
+
+module Graft; end