plugins 0.2.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 95e5717b6ed8f94cb9b10852dd0ffe859694411c
+  data.tar.gz: 38b115995d982f05f361b66724af2b7b24e4f514
+SHA512:
+  metadata.gz: 96d3f53560dcb1f37190b5ac7bd093de98b164a7238ea09cdd5cc5eae98bcb3d53aff42d72aa9c4f1f83b35452ae68d1fc8ac604797f40f9b090d5e02e064708
+  data.tar.gz: 14322d806fa42ab7f954b5393eeffc5a6a5fcfaddf3fd7bb256b326051a1d001e926ea149a2b17c49ecea617feea711ba351f5b5c6889c43e74ad798c0096254

data/lib/ribbon/plugins/around_stack.rb

@@ -0,0 +1,105 @@
+class Ribbon::Plugins
+  class AroundStack
+    attr_reader :subject
+    attr_accessor :scope
+
+    def initialize(subject, scope=nil)
+      @subject = subject.to_sym
+      @scope = scope
+      @_stack = []
+    end
+
+    def push(&block)
+      raise Errors::Error, "Must pass block" unless block_given?
+
+      AroundWrapper.new(self, subject, &block).tap { |wrapper|
+        @_stack.push(wrapper)
+      }
+    end
+
+    def dup
+      AroundStack.new(subject, scope).tap { |stack|
+        @_stack.each { |wrapper|
+          stack.push(&wrapper.block)
+        }
+      }
+    end
+
+    def call(*args, &block)
+      raise Errors::Error, "Must pass block" unless block_given?
+      call_stack = @_stack.dup
+
+      inner_most = WrappedBlock.new(&block)
+      call_stack.unshift(inner_most)
+
+      outer_most = call_stack.pop
+      outer_most.call(call_stack, *args)
+
+      # This shouldn't happen unless the AroundStack isn't functioning properly.
+      raise Errors::Error, "Block passed was not called!" unless inner_most.called?
+
+      inner_most.retval
+    end
+
+    class AroundWrapper
+      attr_reader :stack, :subject, :block
+
+      def initialize(stack, subject, &block)
+        @stack = stack
+        @subject = subject
+        @block = block
+      end
+
+      def scope
+        stack.scope
+      end
+
+      def method_missing(meth, *args, &block)
+        super unless scope
+        scope.send(meth, *args, &block)
+      end
+
+      def call(call_stack, *args)
+        wrapped = call_stack.pop
+        raise Errors::Error, 'call stack too short' unless wrapped
+
+        define_singleton_method("perform_#{subject}") { |*new_args|
+          args = new_args unless new_args.empty?
+          wrapped.call(call_stack, *args)
+        }
+
+        singleton_class.instance_exec(subject) { |subject|
+          alias_method subject, "perform_#{subject}"
+
+          # Don't allow these to be overriden
+          attr_reader :stack, :subject, :block
+        }
+
+        instance_exec(*args, &block)
+      end
+    end
+
+    class WrappedBlock
+      attr_reader :block
+      attr_reader :retval
+
+      def initialize(&block)
+        @block = block
+      end
+
+      def called?
+        !!@_called
+      end
+
+      ##
+      # Call the wrapped block, ignoring the scope and call_stack arguments.
+      def call(call_stack, *args)
+        raise Errors::Error, 'receiving non-empty call stack' unless call_stack.empty?
+        block.call(*args).tap { |retval|
+          @retval = retval
+          @_called = true
+        }
+      end
+    end
+  end # AroundStack
+end # Ribbon::Plugins

data/lib/ribbon/plugins/block_stack.rb

@@ -0,0 +1,30 @@
+class Ribbon::Plugins
+  class BlockStack
+    attr_accessor :scope
+
+    def initialize(scope=nil)
+      @scope = scope
+      @_stack = []
+    end
+
+    def dup
+      BlockStack.new.tap { |stack|
+        @_stack.each { |block| stack.push(&block) }
+      }
+    end
+
+    def push(&block)
+      @_stack.push(block)
+    end
+
+    def call(*args)
+      @_stack.reverse_each { |block|
+        if scope
+          scope.instance_exec(*args, &block)
+        else
+          block.call(*args)
+        end
+      }
+    end
+  end
+end

data/lib/ribbon/plugins/component_mixin.rb

@@ -0,0 +1,47 @@
+module Ribbon
+  class Plugins
+    ##
+    # Intended to be mixed into any class utilizing the plugins functionality.
+    module ComponentMixin
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        ##
+        # Get or define the plugin loader.
+        #
+        # This block will be used to load a plugin given the value passed to the
+        # +plugin+ instance method. It's the responsibility of this block to
+        # translate the inputted value into either a Class that extends Plugin
+        # or a Proc.
+        #
+        # If for a particular value you wish to not perform any translation,
+        # return falsey.
+        def plugin_loader(&block)
+          if block_given?
+            @_plugin_loader = block
+          else
+            @_plugin_loader
+          end
+        end
+      end
+
+      ###
+      # Instance Methods
+      ###
+
+      ##
+      # Reference to the Plugins instance for the component.
+      def plugins
+        @plugins ||= Plugins.new(self, &self.class.plugin_loader)
+      end
+
+      ##
+      # Add a plugin.
+      def plugin(*args, &block)
+        plugins.add(*args, &block)
+      end
+    end
+  end
+end

data/lib/ribbon/plugins/errors.rb

@@ -0,0 +1,6 @@
+class Ribbon::Plugins
+  module Errors
+    class Error < StandardError; end
+    class LoadError < Error; end
+  end
+end

data/lib/ribbon/plugins/plugin.rb

@@ -0,0 +1,62 @@
+class Ribbon::Plugins
+  class Plugin
+    class << self
+      def create(&block)
+        Class.new(Plugin).tap { |k| k.class_eval(&block) if block }
+      end
+
+      def method_missing(meth, *args, &block)
+        if /^(before|after|around)_(\w+)$/.match(meth.to_s)
+          _define_callback($1, $2, &block)
+        else
+          super
+        end
+      end
+
+      def _define_callback(type, subject, &block)
+        _callbacks(type, subject).push(&block)
+      end
+
+      def _callbacks(type, subject)
+        ((@__callbacks ||= {})[type.to_sym] ||= {})[subject.to_sym] ||= _empty_stack_for(type, subject)
+      end
+
+      def _empty_stack_for(type, subject)
+        case type.to_sym
+        when :before, :after
+          BlockStack.new
+        when :around
+          AroundStack.new(subject)
+        else
+          raise Errors::Error, "Invalid type: #{type}"
+        end
+      end
+    end
+
+    attr_reader :plugins
+
+    def initialize(plugins=nil)
+      @plugins = plugins
+    end
+
+    def before(subject, *args)
+      _callbacks(:before, subject).call(*args)
+    end
+
+    def after(subject, *args)
+      _callbacks(:after, subject).call(*args)
+    end
+
+    def around(subject, *args, &block)
+      _callbacks(:around, subject).call(*args, &block)
+    end
+
+    private
+    def _callbacks(type, subject)
+      ((@_callbacks ||= {})[type.to_sym] ||= {})[subject.to_sym] ||=
+        self.class._callbacks(type, subject).dup.tap { |stack|
+          stack.scope = self
+        }
+    end
+  end # Plugin
+end # Ribbon::Plugins

data/lib/ribbon/plugins/version.rb

@@ -0,0 +1,5 @@
+module Ribbon
+  class Plugins
+    VERSION = "0.2.4"
+  end
+end

data/lib/ribbon/plugins.rb

@@ -0,0 +1,97 @@
+require 'ribbon/plugins/version'
+
+module Ribbon
+  class Plugins
+    autoload(:Errors,         'ribbon/plugins/errors')
+    autoload(:Plugin,         'ribbon/plugins/plugin')
+    autoload(:AroundStack,    'ribbon/plugins/around_stack')
+    autoload(:BlockStack,     'ribbon/plugins/block_stack')
+    autoload(:ComponentMixin, 'ribbon/plugins/component_mixin')
+
+    attr_reader :component, :plugin_loader
+
+    def initialize(component=nil, &block)
+      @component = component
+      @plugin_loader = block
+    end
+
+    def add(plugin=nil, *args, &block)
+      plugin = _load(plugin, &block)
+      _add_plugin(plugin.new(self, *args))
+    end
+
+    def clear
+      @_plugins = nil
+      @_around_stack = nil
+    end
+
+    def before(subject, *args)
+      _plugins.reverse_each { |plugin| plugin.before(subject, *args) }
+    end
+
+    def after(subject, *args)
+      _plugins.reverse_each { |plugin| plugin.after(subject, *args) }
+    end
+
+    def around(subject, *args, &block)
+      _around_stack.call(subject, *args) { |subject, *args| block.call(*args) }
+    end
+
+    def perform(subject, *args, &block)
+      before(subject, *args)
+      retval = around(subject, *args, &block)
+      after(subject, *args)
+
+      retval
+    end
+
+    private
+    def _plugins
+      @_plugins ||= []
+    end
+
+    def _around_stack
+      @_around_stack ||= AroundStack.new(:block, self)
+    end
+
+    def _add_plugin(plugin)
+      _plugins.push(plugin)
+
+      _around_stack.push { |subject, *args|
+        plugin.around(subject, *args) { |*args|
+          perform_block(subject, *args)
+        }
+      }
+
+      plugin
+    end
+
+    def _load(plugin, &block)
+      if plugin
+        _load_plugin(plugin)
+      elsif block_given?
+        Plugin.create(&block)
+      else
+        raise Errors::LoadError, 'No plugin information provided'
+      end
+    end
+
+    def _load_plugin(plugin)
+      _call_plugin_loader(plugin).tap { |p| plugin = p if p }
+
+      case plugin
+      when Class
+        plugin < Plugin && plugin or
+          raise Errors::LoadError, "Invalid plugin class: #{plugin.inspect} Must extend Plugin."
+      when Proc
+        Plugin.create(&plugin)
+      else
+        raise Errors::LoadError, "Invalid plugin identifier: #{plugin.inspect}"
+      end
+    end
+
+    def _call_plugin_loader(plugin)
+      plugin_loader && component.instance_exec(plugin, &plugin_loader)
+    end
+  end # Plugins
+end # Ribbon

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: plugins
+version: !ruby/object:Gem::Version
+  version: 0.2.4
+platform: ruby
+authors:
+- Robert Honer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-05 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'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+description: A flexible plugins framework.
+email:
+- robert@ribbonpayments.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ribbon/plugins.rb
+- lib/ribbon/plugins/around_stack.rb
+- lib/ribbon/plugins/block_stack.rb
+- lib/ribbon/plugins/component_mixin.rb
+- lib/ribbon/plugins/errors.rb
+- lib/ribbon/plugins/plugin.rb
+- lib/ribbon/plugins/version.rb
+homepage: http://github.com/ribbon/plugins
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: A flexible plugins framework.
+test_files: []