holywarez-holywarez-mpt 0.1.3

data/CHANGELOG

@@ -0,0 +1,4 @@
+v0.1.3 Wrap helpers support added
+v0.1.2 Instance eval with arguments is now supported for any object
+v0.1.1 Sample sources updated
+v0.1.0 First version of MPT gem

data/Manifest

@@ -0,0 +1,18 @@
+CHANGELOG
+install_gem.bat
+lib/event.rb
+lib/mpt.rb
+lib/system.rb
+lib/wrap.rb
+LICENSE
+Manifest
+mpt.gemspec
+Rakefile
+README
+run_samples.bat
+samples/call_experiment.rb
+samples/declarations.rb
+samples/ordered_subscribers.rb
+samples/run_experiments.rb
+samples/unordered_subscribers.rb
+samples/wrap_method_experiment.rb

data/README

@@ -0,0 +1,2 @@
+= Russian =
+Примеры использования либы можно посмотреть в директории 'samples'

data/Rakefile

@@ -0,0 +1,11 @@
+require "echoe"
+Echoe.new( "holywarez-mpt" ) do |p|
+	p.author = "Anatoly Lapshin"
+	p.summary = "Monkey Patching Toolkit"
+	p.runtime_dependencies = ['activesupport']
+	p.development_dependencies = []
+	p.need_tar_gz = false
+	p.retain_gemspec = true
+	p.gemspec_name = 'mpt.gemspec'
+	p.clean_pattern.push 'lib/*-*'
+end

data/install_gem.bat

@@ -0,0 +1,5 @@
+call rake manifest
+call rake install
+cd pkg
+call gem install holywarez-mpt-0.1.3.gem
+cd ..

data/lib/event.rb

@@ -0,0 +1,69 @@
+
+module MPT
+  class EventContainer
+    attr_accessor :event_object
+
+    def initialize( val = nil )
+      self.event_object = val.dup unless val.nil?
+    end
+    
+  end
+
+  class FilterChain < Array
+    def reorganize
+      index = 0
+      while index < self.size
+        filter = self[index]
+        filter_opts = filter[:options]
+        unless filter_opts[:after].nil?
+          for i in index..self.size-1
+            fo = self[i][:options]
+            unless fo[:as].nil?
+              if fo[:as] == filter_opts[:after]
+                new_chain = []
+                new_chain += self[0..index-1] if index > 0
+                new_chain += [self[i]]
+                new_chain += self[index..i-1]
+                new_chain += self[i+1..self.size-1]
+                self.replace new_chain 
+                index = 0
+                break
+              end # if :as matched with :after
+            end	# unless :as is nil				
+          end # for next items
+        end # unless :after is nil
+        index += 1
+      end # while index < list size
+    end # def reorganize
+  end # filter chain class
+
+  class Event
+    @@mpt_subscribers = {}
+    
+    class << self
+      def subscribe(event_name, options = {}, &block)
+        channel = @@mpt_subscribers[event_name] ||= MPT::FilterChain.new
+        channel << { :options => options, :proc => block }
+        channel.reorganize
+      end
+
+      def trigger_with_object(event_name, object, *args)
+        container = MPT::EventContainer.new(object)
+        channel = @@mpt_subscribers[event_name]
+        if channel.size > 0
+
+          channel.each do |subscriber|
+            container.instance_eval_with_args( subscriber[:proc], *args )
+          end
+        end
+
+        container.event_object
+      end
+
+      def trigger(event_name, *args)
+        trigger_with_object(event_name, nil, *args)
+      end
+    end # end of static section
+  end # end of class Event
+  
+end

data/lib/mpt.rb

@@ -0,0 +1,11 @@
+require "rubygems"
+ 
+gem "activesupport"
+require "activesupport"
+ 
+gem "uuid"
+require "uuid"
+ 
+require "system.rb"
+require "wrap.rb"
+require "event.rb"

data/lib/system.rb

@@ -0,0 +1,10 @@
+
+class Object
+  def instance_eval_with_args(proc, *args, &block)
+    mod = @mpt_injection_module ||= Module.new
+    self.extend mod
+    mod.send :define_method, :mpt_instance_with_args_handler, proc
+    self.mpt_instance_with_args_handler( *args, &block )
+    mod.send :undef_method, :mpt_instance_with_args_handler
+  end
+end

data/lib/wrap.rb

@@ -0,0 +1,140 @@
+
+module MPT
+  class Wrap  
+    @@wrap_variables = {}
+    @@registry = {}
+    class << self
+      def with(var ={}, &block)
+        thread_id = Thread.current.object_id
+        @@wrap_variables[thread_id]||={}
+        temp = @@wrap_variables[thread_id].dup
+        @@wrap_variables[thread_id].merge!(var)
+        yield
+        @@wrap_variables[thread_id] = temp
+      end
+      
+      def get(wrap_name, default = nil)
+        temp = @@wrap_variables[Thread.current.object_id]
+        res = nil
+
+
+        if !temp.blank?
+          res = temp[wrap_name] unless temp[wrap_name].blank?
+        end
+
+        if res.nil? && !default.nil?
+          res = default
+          if default.instance_of?( Proc )
+            res = default.call 
+          end
+        end
+
+        res
+      end
+      
+      def register(value)
+        @@uuid_generator ||= UUID.new
+        key = @@uuid_generator.generate(:urn).to_s
+        @@registry[key] = value
+        key
+      end
+      
+      def get_from_registry(key)
+        @@registry[key]
+      end
+    end
+    
+    class Blank
+      def self.run(*args)
+      end
+    end
+  end
+end
+
+class Class
+  def wrap_it(target, options = { :using => :run, :scope => :before }, &block)
+    return if options[:by].nil? && block.nil?
+    
+    targets = target
+    targets = [target] unless target.instance_of?( Array )
+    targets.each do |tgt|
+      wrap_it_single(tgt, options, &block)
+    end      
+  end
+  
+  def wrap_with(target, options = {})
+    return if options.blank?
+    
+    targets = target
+    targets = [target] unless target.instance_of?( Array )
+    targets.each do |tgt|
+      wrap_with_single(tgt, options)
+    end
+  end
+  
+  private
+  def wrap_it_single(target, options, &block)
+    by_name = options[:by]
+    old_method_name = "#{target.to_s}_without_wrap_it"
+    
+    instance_to_call_code = "self"
+    unless by_name == :self 
+      instance_to_call_code = "MPT::Wrap.get( #{by_name.inspect}, MPT::Wrap::Blank )"
+    end
+    
+    if by_name.nil? && !block.nil? 
+      block_key = MPT::Wrap.register(block)
+      instance_to_call_code = "self.instance_eval( &MPT::Wrap.get_from_registry(#{block_key.inspect}) )"
+    end
+    
+    scope_call_code = "target_instance.#{options[:using]}(*args, &block); #{old_method_name}(*args, &block)"
+    
+    if options[:scope] == :after
+      scope_call_code = "#{old_method_name}(*args, &block); target_instance.#{options[:using]}(*args, &block)"
+    end
+    
+    if options[:scope] == :around
+      scope_call_code = "target_instance.#{options[:using]}(*args) { #{old_method_name}(*args, &block) }"
+    end
+    
+    code_to_eval = <<-EOC
+      def #{target.to_s}_with_wrap_it(*args, &block)
+        target_instance = #{instance_to_call_code}
+        #{scope_call_code}
+      end
+      
+      alias_method_chain #{target.to_sym.inspect}, :wrap_it
+    EOC
+    
+    self.class_eval(code_to_eval, __FILE__, __LINE__)
+  end
+  
+  def wrap_with_single(target, options)
+    key = MPT::Wrap.register(options.dup)
+    code = <<-EOC
+      def #{target.to_s}_with_wrap_options(*args)
+        MPT::Wrap.with MPT::Wrap.get_from_registry(#{key.inspect}) do
+          #{target.to_s}_without_wrap_options(*args)
+        end
+      end
+      
+      alias_method_chain #{target.to_sym.inspect}, :wrap_options
+    EOC
+    
+    self.class_eval(code, __FILE__, __LINE__)
+  end
+end
+
+class Class
+	def wrappable(accessor_name, wrap_name)
+		code = <<-EOS
+		  def #{accessor_name.to_s}_with_wrap_support
+        MPT::Wrap.get("#{wrap_name}", Proc.new { self.send :"#{accessor_name.to_s}_without_wrap_support" })
+		  end
+
+		  alias_method_chain :#{accessor_name.to_s}, :wrap_support
+		EOS
+		
+		class_eval(code, __FILE__, __LINE__)
+	end
+end

data/mpt.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{holywarez-mpt}
+  s.version = "0.1.3"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Anatoly Lapshin"]
+  s.date = %q{2009-07-01}
+  s.description = %q{Monkey Patching Toolkit}
+  s.email = %q{}
+  s.extra_rdoc_files = ["CHANGELOG", "lib/event.rb", "lib/mpt.rb", "lib/system.rb", "lib/wrap.rb", "LICENSE", "README"]
+  s.files = ["CHANGELOG", "install_gem.bat", "lib/event.rb", "lib/mpt.rb", "lib/system.rb", "lib/wrap.rb", "LICENSE", "Manifest", "mpt.gemspec", "Rakefile", "README", "run_samples.bat", "samples/call_experiment.rb", "samples/declarations.rb", "samples/ordered_subscribers.rb", "samples/run_experiments.rb", "samples/unordered_subscribers.rb", "samples/wrap_method_experiment.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Holywarez-mpt", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{holywarez-mpt}
+  s.rubygems_version = %q{1.3.2}
+  s.summary = %q{Monkey Patching Toolkit}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 0"])
+  end
+end

data/run_samples.bat

@@ -0,0 +1,3 @@
+cd samples
+call ruby run_experiments.rb
+cd ..

data/samples/call_experiment.rb

@@ -0,0 +1,15 @@
+module CallExperiment
+  include ::MPT
+  experiment "Call experiment" do
+    controller = Controller.new
+    controller.logic # must be 4
+
+    Wrap.with '/system/services/logic-service' => CustomService.new do
+      controller.logic # must be 96
+      Wrap.with '/system/services/logic-service' => CustomService.new(999) do
+        controller.logic # must be 1998
+      end
+      controller.logic # must be 96 again
+    end
+  end # end of experiment
+end

data/samples/declarations.rb

@@ -0,0 +1,41 @@
+module Kernel  
+  
+  def experiment(title)
+    en = @@experiment_number ||= 1
+    puts "Experiment ##{en}. #{title}\n\n"
+
+    yield
+
+    puts "\nExperiment ##{en} FINISHED!\n\n\n\n"
+    @@experiment_number += 1
+  end
+  
+end
+
+class GeneralService
+	def calculate(input)
+		input * input
+	end
+end
+
+class CustomService < GeneralService
+	def initialize(rate = 48)
+		@rate = rate
+	end
+	
+	def calculate(input)
+		input * @rate
+	end
+end
+
+class Controller
+	def service
+		@service ||= GeneralService.new
+	end
+	
+	def logic
+		puts "Logic result is: #{service.calculate(2)}"
+	end
+	
+	wrappable :service, '/system/services/logic-service'
+end

data/samples/ordered_subscribers.rb

@@ -0,0 +1,34 @@
+module OrderedSubscribersExperiment
+  include ::MPT
+  
+  experiment "Ordered filter chain with event object" do
+    input_object = { :content => "This scintillating new production of Shakespeare's romantic comedy is one of the most accomplished Shakespeare in the Park productions in some time." }
+    
+    Event.subscribe '/filters/count-words', :as => :remove_unimportant_characters do
+      event_object[:content].gsub!( /[\!\.\,\?\:\=\-]|('s)/, '' )
+    end
+    
+    Event.subscribe '/filters/count-words' do
+      # empty filter handler
+    end
+    
+    Event.subscribe '/filters/count-words', :as => :word_counter, :after => :normalizer do
+      word_counts = {}
+      words = event_object[:content].split
+      words.each do |word|
+        word_counts[word] ||= 0
+        word_counts[word] += 1
+      end
+      
+      event_object[:counts] = word_counts
+    end
+    
+    Event.subscribe '/filters/count-words', :as => :normalizer, :after => :remove_unimportant_characters do
+      event_object[:content].downcase!
+    end
+    
+    result_object = Event.trigger_with_object '/filters/count-words', input_object
+    
+    puts "Result is:\n#{result_object[:counts].inspect}"
+  end
+end

data/samples/run_experiments.rb

@@ -0,0 +1,11 @@
+require "rubygems"
+
+gem "holywarez-mpt"
+require "mpt"
+
+
+require "declarations.rb"
+require "call_experiment.rb"
+require "unordered_subscribers.rb"
+require "ordered_subscribers.rb"
+require "wrap_method_experiment.rb"

data/samples/unordered_subscribers.rb

@@ -0,0 +1,16 @@
+module UnorderedSubscribersExperiment
+  include ::MPT
+  
+  experiment "Unordered subscribers with void event object" do
+    Event.subscribe '/system/special-channel' do |parameter|
+      self.event_object = parameter
+    end
+
+    Event.subscribe '/system/special-channel' do |parameter|
+      self.event_object = "#{event_object} AND same shit"
+    end
+
+    result = Event.trigger '/system/special-channel', "XXX"
+    puts "Result is: #{result}"
+  end
+end

data/samples/wrap_method_experiment.rb

@@ -0,0 +1,78 @@
+
+module WrapMethodsExperiment
+  include ::MPT
+  
+  class TargetORM
+    def initialize(name = 'default')
+      @name = 'default'
+    end
+    
+    def execute(sql)
+      puts "#{@name} execute '#{sql}'"
+    end
+    
+    def query(sql)
+      puts "#{@name} query '#{sql}'"
+    end
+    
+    def transaction
+      puts "TRANSACTION BEGIN"
+      yield
+      puts "TRANSACTION COMMIT"
+    end
+  end
+  
+  class TargetController
+    attr_reader :orm
+    wrappable :orm, '/system/orm'
+  
+    def initialize(system_orm)
+      @orm = system_orm
+    end
+    
+    def process
+      orm.execute( "ControllerSQL" )
+    end
+  end
+  
+  class TargetDispatcher
+    def initialize
+      @orm = TargetORM.new
+    end
+    
+    def process
+      @orm.query("dispatcher-sql")
+      
+      controller = TargetController.new(@orm)
+      controller.process
+    end
+  end
+  
+  class MonkeyPatch
+    def run(sql)
+      puts "Patcher run: '#{sql}'"
+    end
+  end
+  
+  experiment "Wrap methods experiment" do
+    TargetORM.wrap_it [:execute, :query], :by => '/patches/monkey-patch', :using => :run, :scope => :before
+    
+    orm = TargetORM.new
+    orm.execute "First SQL"
+    
+    patch = MonkeyPatch.new
+    Wrap.with '/patches/monkey-patch' => patch do
+      orm.execute "Second SQL"
+    end
+    
+  end
+  
+  experiment "Wrap by around methods" do
+    TargetDispatcher.wrap_it( :process, :using => :transaction, :scope => :around ) { @orm }
+    TargetController.wrap_with :process, '/system/orm' => TargetORM.new('custom')
+  
+    dispatcher = TargetDispatcher.new
+    dispatcher.process
+  end
+  
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification 
+name: holywarez-holywarez-mpt
+version: !ruby/object:Gem::Version 
+  version: 0.1.3
+platform: ruby
+authors: 
+- Anatoly Lapshin
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-01 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Monkey Patching Toolkit
+email: ""
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- lib/event.rb
+- lib/mpt.rb
+- lib/system.rb
+- lib/wrap.rb
+- LICENSE
+- README
+files: 
+- CHANGELOG
+- install_gem.bat
+- lib/event.rb
+- lib/mpt.rb
+- lib/system.rb
+- lib/wrap.rb
+- LICENSE
+- Manifest
+- mpt.gemspec
+- Rakefile
+- README
+- run_samples.bat
+- samples/call_experiment.rb
+- samples/declarations.rb
+- samples/ordered_subscribers.rb
+- samples/run_experiments.rb
+- samples/unordered_subscribers.rb
+- samples/wrap_method_experiment.rb
+has_rdoc: true
+homepage: ""
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Holywarez-mpt
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: holywarez-mpt
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Monkey Patching Toolkit
+test_files: []
+