classx-pluggable 0.0.1

data/examples/test_runner/bin/test_runner.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+
+require 'test_runner'
+
+require 'yaml'
+conf = ARGV[0] || File.join(File.dirname(__FILE__), '..', 'conf/config.yaml')
+
+config = nil
+File.open(conf) do |f|
+  config = YAML.load(f.read)
+end
+app = TestRunner.new(config["global"].merge({
+  :test_cases => [:foo, :bar, :baz],
+  :logger => $logger ? $logger : Logger.new($stderr) # FIXME: It's for spec/example_spec.rb
+}))
+app.load_plugins(config["plugins"])
+
+app.run

data/examples/test_runner/conf/config.yaml

@@ -0,0 +1,19 @@
+---
+global:
+  log_level: debug
+  check_events: true
+  events:
+    - BEFORE_EACH
+    - AROUND_ALL
+    - AROUND_EACH
+
+plugins:
+  - module: TestRunner::Plugin::SetupFixture #=> autoloading TestRunner::Plugin::SetupFixture, "test_runner/plugin/setup_fixture"
+  - module: +TestTimer  # same means of TestRunner::Plugin::TestTimer #=> autoloading TestRunner::Plugin::TestTimer, "test_runner/plugin/test_timer"
+  - module: +TestInfo
+    config:
+      template: start test %s
+  - module: +TestInfo
+    config:
+      template: you can also ouput other info for %s
+

data/examples/test_runner/lib/test_runner.rb

@@ -0,0 +1,33 @@
+require 'classx'
+require 'classx/validate'
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '../../../lib')))
+require 'classx/pluggable'
+require 'classx/pluggable/plugin'
+
+class TestRunner
+  include ClassX
+  include ClassX::Role::Logger
+  include ClassX::Pluggable
+
+  module Plugin; end
+
+  has :test_cases
+
+  def run
+    call_event_around(:ALL, :logger => logger) do
+
+      test_cases.each do |tc|
+        _do_test(tc)
+      end
+
+    end
+  end
+
+  # it's dummy
+  def _do_test tc
+    call_event_around(:EACH, :logger => logger, :test => tc) do
+      sleep(0.1)
+    end
+  end
+end
+

data/examples/test_runner/lib/test_runner/plugin/setup_fixture.rb

@@ -0,0 +1,31 @@
+require 'classx'
+require 'classx/validate'
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '../../../../lib')))
+require 'classx/pluggable/plugin'
+
+class TestRunner
+  module Plugin
+    class SetupFixture
+      include ClassX
+      include ClassX::Pluggable::Plugin
+      include ClassX::Pluggable::Plugin::AutoRegister
+
+      # without C::P::P::AutoRegister
+      # you can do followings:
+      #
+      # define_events({
+      #   :AROUND_ALL => :on_around_all,
+      # })
+
+      def on_around_all param
+        param = ClassX::Validate.validate param do
+          has :logger
+        end
+
+        param.logger.info "#{self.class}: Setup Fixture"
+        yield
+        param.logger.info "#{self.class}: Clear Fixture"
+      end
+    end
+  end
+end

data/examples/test_runner/lib/test_runner/plugin/test_info.rb

@@ -0,0 +1,28 @@
+require 'classx'
+require 'classx/validate'
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '../../../../lib')))
+require 'classx/pluggable/plugin'
+
+class TestRunner
+  module Plugin
+    class TestInfo
+      include ClassX
+      include ClassX::Pluggable::Plugin
+      include ClassX::Pluggable::Plugin::AutoRegister
+
+      has :template
+
+      def on_before_each param
+        param = ClassX::Validate.validate param do
+          has :logger
+          has :test
+        end
+
+        info = self.template % [ param.test ]
+        param.logger.info "#{self.class}: #{info}"
+
+        info
+      end
+    end
+  end
+end

data/examples/test_runner/lib/test_runner/plugin/test_timer.rb

@@ -0,0 +1,56 @@
+require 'classx'
+require 'classx/validate'
+$LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), '../../../../lib')))
+require 'classx/pluggable/plugin'
+
+
+class TestRunner
+  module Plugin
+    class TestTimer
+      include ClassX
+      include ClassX::Pluggable::Plugin
+      include ClassX::Pluggable::Plugin::AutoRegister
+
+      # without C::P::P::AutoRegister
+      # you can do followings:
+      #
+      # define_events({
+      #   :AROUND_ALL     => :on_around_all,
+      #   :AROUND_EACH    => :on_arond_each,
+      # })
+
+      def on_around_all param
+        param = ClassX::Validate.validate param do
+          has :logger
+        end
+
+        param.logger.info "#{self.class}: total: start timer"
+        test_suite_timer = Time.now
+
+        yield
+
+        diff = Time.now - test_suite_timer
+        param.logger.info "#{self.class}: total: #{diff.to_f} sec."
+
+        diff
+      end
+
+      def on_around_each param
+        param = ClassX::Validate.validate param do
+          has :logger
+          has :test
+        end
+
+        param.logger.info "#{self.class}: test #{param.test}: start timer"
+        test_timer = Time.now
+        yield
+
+        diff = Time.now - test_timer
+
+        param.logger.info "#{self.class}: test #{param.test}: #{diff.to_f} sec."
+
+        diff
+      end
+    end
+  end
+end

data/lib/classx/pluggable.rb

@@ -0,0 +1,231 @@
+require 'classx'
+require 'ostruct'
+
+module ClassX
+  # in your context class.
+  #
+  #   require 'classx'
+  #   require 'classx/pluggable'
+  #   class YourApp
+  #     include ClassX
+  #     include ClassX::Pluggable
+  #
+  #     def run
+  #       call_event("SETUP", {})
+  #       # you app
+  #       call_event("TEARDOWN", {})
+  #     end
+  #
+  #   end
+  #
+  # in your plugin class
+  #
+  #   require 'classx'
+  #   require 'classx/pluggable'
+  #   class YourApp
+  #     class Plugin
+  #       include ClassX
+  #       include ClassX::Pluggable::Plugin
+  #
+  #       class SomePlugin < Plugin
+  #         def register
+  #           add_event("SETUP", :on_setup)
+  #         end
+  #
+  #         def on_setup param
+  #           # param is Hash
+  #           # hooked setup
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  module Pluggable
+    extend ClassX::Attributes
+    extend ClassX::Role::Logger
+
+    class PluginLoadError < ::Exception; end
+
+    has :__classx_pluggable_events_of,
+        :lazy    => true,
+        :no_cmd_option  => true,
+        :default => proc {|mine| mine.events.inject({}) {|h,event| h[event] = []; h } }
+
+    has :plugin_dir,
+        :optional => true,
+        :kind_of  => Array
+
+    has :check_events,
+      :default  => false,
+      :optional => true,
+      :desc     => "only add events that define before add_event."
+
+    has :events,
+      :lazy => true,
+      :optional => true,
+      :kind_of  => Array,
+      :desc    => "hook point for #{self}'s instance",
+      :default => proc { [] }
+
+    # register plugin and method to hook point.
+    #
+    def add_event name, plugin, meth
+      name = name.to_s
+      if self.check_events && !self.events.include?(name)
+        raise "#{name.inspect} should be declared before call add_event. not in #{self.events.inspect}"
+      else
+        self.__classx_pluggable_events_of[name] ||= []
+      end
+      self.__classx_pluggable_events_of[name] << { :plugin => plugin, :method => meth }
+    end
+
+    # load plugins.
+    #
+    #   app.load_plugins([
+    #     { :module => "YourApp::Plugin::Foo", :confiig => { :some_config => "foo"} },
+    #     { :module => "+Bar", :confiig => { } }, # It's same meaning of YourApp::Plugin::Bar
+    #   ])
+    #
+    def load_plugins plugins
+      load_components("plugin", plugins)
+    end
+
+    # if you customize Plugin name space. you can use this instead of +load_plugins+.
+    #
+    #  app.load_components('engine', [
+    #     { :module => "YourApp::Engine::Foo", :confiig => { :some_config => "foo"} },
+    #     { :module => "+Bar", :confiig => { } }, # It's same meaning of YourApp::Engine::Bar
+    #  ])
+    #
+    def load_components type, components
+      components.each do |component|
+        load_component type, component
+      end
+    end
+
+    def load_component type, hash
+      component = OpenStruct.new(hash.dup)
+      mod = self.class.component_class_get(type, component.module, { :plugin_dir => self.plugin_dir })
+      component.config ||= {}
+      component.config[:context] = self
+      instance = mod.new(component.config)
+      instance.register
+      logger.debug("ClassX::Pluggable: loaded #{type} #{component.module}, config=#{instance.inspect}")
+    end
+
+    # invoke registered event of +name+ with +args+. and return array of result each callback.
+    def call_event name, *args
+      name = name.to_s
+      if events = self.__classx_pluggable_events_of[name]
+        events.map do |event|
+          event[:plugin].__send__(event[:method], *args)
+        end
+      else
+        []
+      end
+    end
+
+    # invoke registered event of BEFORE_xxxx and yield block and invoke hook AFTER_xxxx.
+    def call_event_around name, *args, &block
+      name = name.to_s
+      around_name = "AROUND_#{name}"
+
+      call_event("BEFORE_#{name}", *args)
+      if events = self.__classx_pluggable_events_of[around_name]
+        procs = []
+        procs << block
+        index = 0
+        nested_proc = events.inject(block) {|bl, event| proc { event[:plugin].__send__(event[:method], *args, &bl ) } }
+        nested_proc.call
+      end
+      call_event("AFTER_#{name}", *args)
+    end
+
+    private
+
+    module Util
+      def module2path mod
+        mod.split(/::/).map { |s|
+          s.gsub(/([A-Z][a-z]+)(?=[A-Z][a-z]*?)/, '\1_').gsub(/([A-Z])(?=[A-Z][a-z]+)/, '\1_').downcase
+        }.join(File::SEPARATOR)
+      end
+
+      def nested_const_get mod
+        name_spaces = mod.split(/::/)
+        result = ::Object
+        name_spaces.each do |const|
+          result = result.const_get(const)
+        end
+        return result
+      end
+
+      def nested_autoload mod, path
+        name_spaces = mod.split(/::/)
+        target = name_spaces.pop
+        tmp = ::Object
+        name_spaces.each do |const|
+          tmp = tmp.const_get(const)
+        end
+        tmp.autoload(target, path)
+      end
+
+      module_function :module2path, :nested_const_get, :nested_autoload
+    end
+
+    module ClassMethods
+      include ClassX::Pluggable::Util
+
+      def component_class_get type, name, options={}
+        case name
+        when ::Class
+          return name
+        else
+          mod_name = nil
+          target_name = nil
+          if name =~ /\A\+([\w:]+)\z/
+            target_name = $1
+            mod_name = [ self, type.capitalize, target_name ].join("::")
+          else
+            mod_name = name
+          end
+          begin
+            return nested_const_get(mod_name)
+          rescue NameError => e
+            begin
+              if options[:plugin_dir]
+                options[:plugin_dir].each do |path|
+                  begin
+                    begin
+                      self.const_get(type.capitalize).autoload(name, File.expand_path(File.join(path, module2path(target_name))))
+                    rescue LoadError => e
+                      raise ::ClassX::Pluggable::PluginLoadError, "class: #{mod_name} is not found"
+                    end
+                    return nested_const_get(mod_name)
+                  rescue NameError => e
+                    next
+                  end
+                  raise NameError, "must not happened unless your code is something wrong!!"
+                end
+              else
+                nested_autoload(mod_name, module2path(mod_name))
+                nested_const_get mod_name
+              end
+            rescue LoadError => e
+              raise ::ClassX::Pluggable::PluginLoadError, "class: #{mod_name} is not found."
+            end
+          end
+        end
+      end
+    end
+
+    def self.included klass
+      klass.extend ClassMethods
+    end
+
+    # It's useful for testing.
+    class MockContext
+      include ClassX
+      include ClassX::Pluggable
+    end
+  end
+end

data/lib/classx/pluggable/plugin.rb

@@ -0,0 +1,66 @@
+require 'classx'
+
+module ClassX
+  module Pluggable
+    module Plugin
+      extend ClassX::Attributes
+
+      has :context, :kind_of => ClassX::Pluggable
+
+      module ClassMethods
+        def define_events hash
+          define_method :register do
+            add_events hash
+          end
+        end
+      end
+
+      # Abstract method for calling from context instance automatically that you should implement like followings:
+      #
+      #   def register
+      #     add_event('SOME_EVENT', 'on_some_event')
+      #   end
+      #
+      #   def on_some_event
+      #     # do something.
+      #   end
+      #
+      def register
+        raise NotImprementedError
+      end
+
+      def inspect
+        hash = self.to_hash
+        hash.delete("context")
+        "#{self.class}: #{hash.inspect}"
+      end
+
+      private
+
+      def self.included klass
+        klass.extend(ClassMethods)
+      end
+
+      def add_event name, meth
+        self.context.add_event(name, self, meth)
+      end
+
+      def add_events hash
+        hash.each do |event, meth|
+          add_event(event, meth)
+        end
+      end
+
+      module AutoRegister
+        EVENT_REGEX = /\Aon_(.+)\z/
+
+        def register
+          methods.map {|meth| meth.to_s }.grep(EVENT_REGEX).each do |meth|
+            meth =~ EVENT_REGEX
+            add_event $1.upcase, meth
+          end
+        end
+      end
+    end
+  end
+end