explainer-rmb-rails 0.0.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Ken Burgett
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,7 @@
+= rmb-rails
+
+Description goes here.
+
+== Copyright
+
+Copyright (c) 2009 Ken Burgett. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rmb-rails"
+    gem.summary = %Q{RESTful Message Beans for Rails}
+    gem.email = "keburgett@gmail.com"
+    gem.homepage = "http://github.com/explainer/rmb-rails"
+    gem.authors = ["Ken Burgett"]
+    gem.rubyforge_project = "rmb-rails"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+  Jeweler::RubyforgeTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "rmb-rails #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1 @@
+0.0.4

data/lib/listener_client.rb

@@ -0,0 +1,58 @@
+module RMB
+
+  #
+  # This code is called from the client application.  It starts/stops the daemon controller script
+  #
+  class ListenerClient
+  
+    def initialize(hash)
+      @hash = hash
+    end
+    
+    def start
+      control('start')
+    end
+  
+    def stop
+      control('stop')
+    end
+    
+    def control(action)
+      setup
+      control_script = "ruby #{File.dirname(__FILE__)}/#{LD}control.rb #{action}"
+      control_params = "#{@hash[:working_dir]} #{@hash[:key]}"
+      system("#{control_script} #{control_params} -- #{control_params}")
+    end
+    
+    def app_name
+      @hash[:daemon_options][:app_name]
+    end
+
+    def properties=(hash)
+      @hash=hash
+    end
+
+    def properties
+      @hash
+    end
+
+private
+
+    def setup
+      # add derived values to the daemon_options hash
+      @hash[:daemon_options][:app_name] = "#{LD}#{@hash[:key]}"
+      @hash[:daemon_options][:dir] = File.join("#{@hash[:working_dir]}", "tmp", "pids")
+      # Ensure the properties folder is present
+      properties_dir = File.join("#{@hash[:working_dir]}", "tmp", "properties")
+      if !File.directory?(properties_dir)
+        Dir.mkdir(properties_dir)
+      end
+      # dump the properties to a tmp file
+      File.open(File.join("#{properties_dir}", "#{app_name}.properties"), "w+") do |f|
+        Marshal.dump(@hash, f)
+      end
+    end
+    
+  end
+  
+end

data/lib/listener_daemon.rb

@@ -0,0 +1,19 @@
+#
+# Listener Daemon main program
+#
+
+# Value of ARGV[0] => RAILS_ROOT
+# Value of ARGV[1] => key
+
+require 'rubygems'
+require 'logger'
+require 'rmb-rails'
+
+#
+# start the daemon worker code...
+#
+  listener = RMB::ListenerMain.new(ARGV[0], ARGV[1])
+# ...and listen forever
+  listener.run
+
+

data/lib/listener_daemon_control.rb

@@ -0,0 +1,70 @@
+require 'rubygems'
+#
+# Listener Daemon Control Program
+#
+require 'logger'
+require 'daemons'
+require 'rmb-rails'
+#
+#  This ruby script is invoked by the ListenerClient.control method to start and stop the daemon
+#
+=begin rdoc
++app_name+	      The name of the application. This will be used to contruct the name of the pid files and log files. 
+                 Defaults to the basename of the script.
++ARGV+	          An array of strings containing parameters and switches for Daemons. This includes both parameters for Daemons 
+                 itself and the controlling script. These are assumed to be separated by an array element ’—’, 
+                 e.g. [‘start’, ‘f’, ’—’, ‘param1_for_script’, ‘param2_for_script’].
+                 If not given, ARGV (the parameters given to the Ruby process) will be used.
++dir_mode+	      Either 
+    +script      (the directory for writing the pid files to given by +dir is interpreted relative to the script location given by script)  
+    +normal      (the directory given by +dir is interpreted as a (absolute or relative) path)
+    +system      (/var/run is used as the pid file directory)
++dir+	          Used in combination with +dir_mode (description above)
++multiple+	      Specifies whether multiple instances of the same script are allowed to run at the same time
++ontop+	        When given (i.e. set to true), stay on top, i.e. do not daemonize the application 
+                 (but the pid-file and other things are written as usual)
++mode+	
+   +load         Load the script with Kernel.load; 
+   +exec         Execute the script file with Kernel.exec
++backtrace+	    Write a backtrace of the last exceptions to the file ’[app_name].log’ in the pid-file 
+                 directory if the application exits due to an uncaught exception
++monitor+	      Monitor the programs and restart crashed instances
++log_output+	    When given (i.e. set to true), redirect both STDOUT and STDERR to a logfile named ’[app_name].output’ in the pid-file directory
++keep_pid_files+	When given do not delete lingering pid-files (files for which the process is no longer running).
++hard_exit+	    When given use exit! to end a daemons instead of exit (this will for example not call at_exit handlers). 
+=end
+# Value of ARGV[0] => action (start|stop)
+# Value of ARGV[1] => RAILS_ROOT
+
+# Value of ARGV[2] => listener key
+    key = ARGV[2]
+    daemon_name = "listener_daemon_#{key}"
+# Value of ARGV[2] => --
+# Value of ARGV[3] => listener key
+
+    messages_dir = File.join("#{ARGV[1]}", "tmp", "messages")
+    if !File.directory?(messages_dir)
+      Dir.mkdir(messages_dir)
+    end
+    logger = Logger.new("#{ARGV[1]}/log/listener_daemon_control.log")
+    logger.info "Starting the #{File.basename(__FILE__)}..."
+    0.upto ARGV.length-1 do |i| 
+      logger.info "Value of ARGV[#{i}] => #{ARGV[i]}" 
+    end
+
+    # load an instance of the ListenerMain in order to get the options hash
+    l = RMB::ListenerMain.new(ARGV[1], ARGV[2])
+    options = l.hash[:daemon_options]
+    options.each do |key, value|
+      logger.info "options[#{key}] => #{value}"
+    end
+
+    # launch the daemon file from the same directory as this program file.
+    target = File.join(File.dirname(__FILE__), "listener_daemon.rb")
+    logger.info "Launching #{target}...\n"
+    begin
+      Daemons.run(target, options)
+    rescue Exception
+      logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+      raise
+    end

data/lib/listener_main.rb

@@ -0,0 +1,83 @@
+module RMB
+  #
+  # This is the class that gets instantiated from the listener daemon
+  # It contains the worker code of the daemon
+  #
+  class ListenerMain
+    attr_accessor :submitter, :subscriber, :logger, :hash
+=begin rdoc
++initialize+  Given root (the working directory or RAILS_ROOT) and key (the unique identifier that denotes a 
+particular Listener instance), the initialize method sets up the entire daemon.  
+* The daemon name is created from the key
+* A logger object is instantiated for the use of the daemon components
+* A hash of properties is read from a properties file, whose name is also derived from the root and key.
+* An instance of a subclass of Subscriber is created to act as the front end of the daemon, listening on a topic or queue for the arrival of a message
+* An instance of a subclass of Submitter is created to send messages on to a parent rails app, using RESTful techniques to send the message to a rails controller.
+=end    
+    def initialize(root, key)
+      @key = key
+      @logger = Logger.new("#{root}/log/#{app_name}.log")
+      @logger.info "\nStarting #{File.basename(__FILE__)} --> #{app_name}..."
+      @hash = nil
+      # load the marshalled hash of properties
+      f = File.join("#{root}", "tmp", "properties", "#{app_name}.properties")
+      File.open(f) do |props|
+        @hash = Marshal.load(props)
+      end
+      @hash[:logger] = @logger
+      # instantiate the two objects that comprise the front-end and the back-end of 
+      # this listener daemon
+      front = @hash[:subscriber]
+      @subscriber = Kernel.eval "#{front[:class_name]}.new"
+      @subscriber.properties=@hash
+      back = @hash[:submitter]
+      @submitter = Kernel.eval "#{back[:class_name]}.new"
+      @submitter.properties=@hash
+    end
+=begin rdoc
++run+ 
+* The subscriber is connected to a message broker, 
+* the submitter is connected to the rails controller,
+* then an infinite loop is entered
+* subscriber waits to receive a message
+* when a message arrives, it is sent to the rails controller via the submitter
+* ...and loop forever
+=end
+    def run
+      begin
+        subscriber.connect
+        logger.info "subscriber connected."
+      rescue Exception
+        logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+        raise
+      end
+      begin
+        submitter.connect
+        logger.info "submitter logged in."
+      rescue Exception
+        logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+        raise
+      end
+      logger.info "Waiting for messages in #{subscriber.url}."
+      loop do
+        begin
+          message = subscriber.receive
+        rescue
+          logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+          raise
+        end
+        begin
+          submitter.send(message)
+        rescue Exception
+          logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+          raise
+        end
+      end
+    end
+    
+    def app_name
+      "#{LD}#{@key}"
+    end
+  end
+
+end

data/lib/mechanize_submitter.rb

@@ -0,0 +1,83 @@
+require 'mechanize'
+require 'submitter'
+
+module RMB
+  
+  class MechanizeSubmitter < Submitter
+    attr_accessor :user, :password, :login_url, :delivery_url, :agent, :logger, :agent, :daemon_name
+=begin rdoc
++properties=(hash)+ Accepts a hash object containing all of the configuration properties required. These properties are copied into instance variables.
+=end  
+    def properties=(hash)
+      super
+      @hash = hash
+      @daemon_name = "#{LD}#{hash[:key]}"
+      submitter = hash[:submitter]
+      @user = submitter[:user] || ""
+      @password = submitter[:password] || ""
+      @login_url = submitter[:login_url] || ""
+      @delivery_url = submitter[:delivery_url] || ""
+      begin
+        @agent = WWW::Mechanize.new 
+        @agent.user_agent_alias = 'Linux Mozilla'
+      rescue Exception
+        logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+        raise
+      end
+    end
+=begin rdoc
++connect+ Uses the login_url property, along with the user and password properties, to log in to the rails app.
+=end  
+    def connect
+      super
+      #this code requires completion of the User controller in the main app
+    end
+=begin rdoc
++marshal_message_body+ Extracts the message body from the rest of the message, and marshals it into a file.  The name of this file will be submitted to the rails app, along with other message attributes.
+=end  
+    def marshal_message_body(message)
+      file = File.join("#{@hash[:working_dir]}", "tmp", "messages", "#{daemon_name}_#{message.headers["timestamp"]}.message")
+      File.open(file, "w+") do |f|
+        Marshal.dump(message.body, f)
+      end
+      file
+    end
+=begin rdoc
++send+ This method uses the +delivery_url+ property to issue a get request to retrieve the <tt>new document</tt> form from the rails app.  The form is filled in with message attributes and submitted to the rails app for processing.
+=end    
+    def send(message)
+      super
+      file = marshal_message_body(message)
+      begin
+        page = agent.get(delivery_url)
+      rescue Exception
+        logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+        raise
+      end
+      form = page.forms.first
+      
+      # I can't seem to make the Mechanize code recognize fields as attributes, so
+      # I am forced to treat them as an array
+      form.fields[1].value = @hash[:key]
+      form.fields[2].value = message.headers["destination"]
+      form.fields[3].value = message.headers["message-id"]
+      form.fields[4].value = message.headers["content-type"]
+      form.fields[5].value = message.headers["priority"]
+      form.fields[6].value = message.headers["content-length"]
+      form.fields[7].value = message.headers["timestamp"]
+      form.fields[8].value = message.headers["expires"]
+      form.fields[9].value = file
+      
+      #logger.info "final form: #{form.inspect}"
+      
+      #submit the form
+      begin
+        page = agent.submit(form)
+      rescue Exception
+        logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+        raise
+      end
+    end
+  end
+  
+end

data/lib/rmb-rails.rb

@@ -0,0 +1,51 @@
+require 'stomp'
+require 'subscriber'
+
+module RMB
+
+class StompSubscriber < Subscriber
+    attr_accessor :url, :host, :port, :user, :password, :connection, :logger
+=begin rdoc
++connect+ Opens a connection with the message broker, and then subscribes on the url 
+=end   
+    def connect
+      super
+      begin
+        @connection = Stomp::Connection.open(user, password, host, port)
+        @connection.subscribe url, { :ack => 'auto' } 
+      rescue Exception
+        logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+        raise
+      end
+      logger.info "Waiting for messages in #{url}."
+    end
+=begin rdoc
++properties=(hash)+ Accepts a hash object containing all of the configuration properties required. These properties are copied into instance variables.
+=end  
+    def properties=(hash)
+      subscriber = hash[:subscriber]
+      @url = subscriber[:url] || "/queue/something"
+      @host = subscriber[:host] || ""
+      @port = subscriber[:port] || 61613
+      @user = subscriber[:user] || ""
+      @password = subscriber[:password] || ""
+      @connection = nil
+      super
+    end
+=begin rdoc
++receive+ Executes a receive on the connection, thus blocking the daemon until a message arrives.  Then answers the message.
+=end    
+    def receive
+      super
+      begin
+        message = @connection.receive
+      rescue Exception
+        logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+        raise
+      end
+      logger.info "Received message: #{message.inspect}"
+      message
+    end
+  end
+
+end

data/lib/rmb2.rb

@@ -0,0 +1,69 @@
+#
+# = RESTful-Message-Beans module
+#
+# Abstraction which wraps the daemon scripts and
+# handles the setup.
+#
+require 'listener_client'
+require 'listener_main'
+require 'mechanize_submitter'
+require 'stomp_subscriber'
+require 'submitter'
+require 'subscriber'
+
+module RMB
+# This multi-level hash contains the initial set of properties needed to launch a Listener daemon.  
+#* Make a writable copy of this hash
+#* Fill in the areas denoted by <<fill>> with your values
+#* Add additional properties required by the Subscriber and Submitter classes used
+#* Pass this has as the sole parameter in listener_client = ListenerClient.new(hash) to set up the daemon
+#* Call listener_client.start to start the daemon.
+  RMB_Properties = {
+                      :key => "<<fill>>",                               
+                      :subscriber => {
+                                       :class_name => "<<fill>>"   #set this to selected subclass of Subscriber
+                                                                   # <== add more properties for your Subscriber here
+                                     },
+                      :submitter  => {
+                                       :class_name => "<<fill>>"   #set this to selected subclass of Submitter
+                                                                   # <== add more properties for your Submitter here
+                                     },
+                      :working_dir => "<<fill>>",                  #set this to the RAILS_ROOT directory
+                      
+                      :daemon_options => { #these options are passed directly to the class method Daemons.run(target, options)
+                                              :app_name       => "",                        #custom name for this daemon, set by ListenerClient#initialize
+                                              :ARGV           => nil,                       #use the program defaults
+                                              :dir_mode       => :normal,                   #requires absolute path
+                                              :dir            => "<<fill>>",                #this is set to "#{working_dir}/tmp/pids" by ListenerClient#setup
+                                              :multiple       => false,                     #this will allow multiple daemons to run
+                                              :ontop          => false,                     #
+                                              :mode           => :load,
+                                              :backtrace      => false,
+                                              :monitor        => false,
+                                              :log_output     => true,
+                                              :keep_pid_files => true,
+                                              :hard_exit      => true
+                                            }
+                   }
+                
+  LD = "listener_daemon_"   #prefix for all listener_daemon artifacts produced: pids, log files, property files, and message files
+    
+end  
+
+if __FILE__ == $0
+  hash = RMB::ListenerClient.properties('inventory', RAILS_ROOT, 'StompSubscriber', 'MechanizeSubmitter')
+  hash[:daemon_options][:dir] = File.join("#{hash[:working_dir]}", "tmp", "pids")
+  front = hash[:subscriber]
+  front[:url] = '/topic/inventory'
+  front[:host] = 'localhost'
+  front[:port] = 61613
+  front[:user] = nil
+  front[:password] = nil
+
+  back = hash[:submitter]
+  back[:login_url] = 'http://localhost:3000/login'
+  back[:delivery_url] = 'http://localhost:3000/documents/new'
+  lc = RMB::ListenerClient.new(hash)
+  puts lc.inspect
+  lc.start
+end

data/lib/stomp_subscriber.rb

@@ -0,0 +1,51 @@
+require 'stomp'
+require 'subscriber'
+
+module RMB
+
+class StompSubscriber < Subscriber
+    attr_accessor :url, :host, :port, :user, :password, :connection, :logger
+=begin rdoc
++connect+ Opens a connection with the message broker, and then subscribes on the url 
+=end   
+    def connect
+      super
+      begin
+        @connection = Stomp::Connection.open(user, password, host, port)
+        @connection.subscribe url, { :ack => 'auto' } 
+      rescue Exception
+        logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+        raise
+      end
+      logger.info "Waiting for messages in #{url}."
+    end
+=begin rdoc
++properties=(hash)+ Accepts a hash object containing all of the configuration properties required. These properties are copied into instance variables.
+=end  
+    def properties=(hash)
+      subscriber = hash[:subscriber]
+      @url = subscriber[:url] || "/queue/something"
+      @host = subscriber[:host] || ""
+      @port = subscriber[:port] || 61613
+      @user = subscriber[:user] || ""
+      @password = subscriber[:password] || ""
+      @connection = nil
+      super
+    end
+=begin rdoc
++receive+ Executes a receive on the connection, thus blocking the daemon until a message arrives.  Then answers the message.
+=end    
+    def receive
+      super
+      begin
+        message = @connection.receive
+      rescue Exception
+        logger.fatal "#{__FILE__}:#{__LINE__} Exception #{$!}"
+        raise
+      end
+      logger.info "Received message: #{message.inspect}"
+      message
+    end
+  end
+
+end

data/lib/submitter.rb

@@ -0,0 +1,22 @@
+module RMB
+
+  class Submitter
+=begin rdoc
++properties=(hash)+ This method establishes the logger for the subclass.
+=end  
+    def properties=(hash)
+      @logger = hash[:logger]
+    end
+=begin rdoc
++connect+ This is an abstract method, intended to be implemented by a subclass.
+=end 
+    def connect
+    end
+=begin rdoc
++connect+ This is an abstract method, intended to be implemented by a subclass.
+=end
+    def send(message)
+    end
+  end
+  
+end

data/lib/subscriber.rb

@@ -0,0 +1,22 @@
+module RMB
+
+class Subscriber
+=begin rdoc
++connect+ This is an abstract method, intended to be implemented by a subclass.
+=end 
+    def connect
+    end
+=begin rdoc
++receive+ This is an abstract method, intended to be implemented by a subclass.
+=end  
+    def receive
+    end
+=begin rdoc
++properties=(hash)+ This method establishes the logger for the subclass.
+=end  
+    def properties=(hash)
+      @logger = hash[:logger]
+    end
+  end
+  
+end

data/rmb-rails.gemspec

@@ -0,0 +1,57 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{rmb-rails}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ken Burgett"]
+  s.date = %q{2009-07-21}
+  s.email = %q{keburgett@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "lib/listener_client.rb",
+     "lib/listener_daemon.rb",
+     "lib/listener_daemon_control.rb",
+     "lib/listener_main.rb",
+     "lib/mechanize_submitter.rb",
+     "lib/rmb-rails.rb",
+     "lib/rmb2.rb",
+     "lib/stomp_subscriber.rb",
+     "lib/submitter.rb",
+     "lib/subscriber.rb",
+     "rmb-rails.gemspec",
+     "test/rmb-rails_test.rb",
+     "test/test_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/explainer/rmb-rails}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{rmb-rails}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{RESTful Message Beans for Rails}
+  s.test_files = [
+    "test/test_helper.rb",
+     "test/rmb-rails_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/test/rmb-rails_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class RmbRailsTest < Test::Unit::TestCase
+  def test_something_for_real
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rmb-rails'
+
+class Test::Unit::TestCase
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: explainer-rmb-rails
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Ken Burgett
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-21 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: keburgett@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/listener_client.rb
+- lib/listener_daemon.rb
+- lib/listener_daemon_control.rb
+- lib/listener_main.rb
+- lib/mechanize_submitter.rb
+- lib/rmb-rails.rb
+- lib/rmb2.rb
+- lib/stomp_subscriber.rb
+- lib/submitter.rb
+- lib/subscriber.rb
+- rmb-rails.gemspec
+- test/rmb-rails_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/explainer/rmb-rails
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: "0"
+  version: 
+requirements: []
+
+rubyforge_project: rmb-rails
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: RESTful Message Beans for Rails
+test_files: 
+- test/test_helper.rb
+- test/rmb-rails_test.rb