short_bus 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bffed4e5f3b30116df68c93687d47a3169a9b429
+  data.tar.gz: a027b9b56200688d754b5172fd04a0f4cb17cfb4
+SHA512:
+  metadata.gz: 3d5951e107d3cb9591a010f1ef1a250e40ed24ff1e2f706072514bb1542d5512e275f0b9ac988523203d0389459e2a9b6cad7de011c374607e9950437e1914e2
+  data.tar.gz: e2a8c52a1e1adbce728eed8cecca069ed2008ba398cebbe8d11f89430fccf5eeb603888237947a4088b666be48da250b8e97ba241632d604caa48449f14d412d

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.sw[o-z]
+.*.sw[o-z]

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.0.0
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in short_bus.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Rob Zwissler
+
+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.md

@@ -0,0 +1,138 @@
+# ShortBus
+Easy to use multi-threaded pub-sub message dispatcher for implementing self-contained service-oriented Ruby apps.
+
+## What does it do?
+The goal is to provide a minimal, lightweight message dispatcher/service API, with multi-threaded message publishing and subscription for Ruby closures (Lambdas/Blocks) and Methods.
+
+ShortBus has no dependencies outside of the Ruby Core & Standard Libraries.
+
+## What are the components?
+A service is a participant in the SOA (Service Oriented Architecture) for publishing and/or subscribing to messages. To receive messages, the service subscribes to the Driver (Driver#subscribe); and is run as a callback in a dedicated thread or thread pool.
+
+A message (as simple as a String, but ultimately converted to a ShortBus::Message object) is what is received, routed and sent to the recipient services by the Driver. A message can have an optional payload object, and subscribers can return values directly back to the publisher by using the Message object as a Queue (see "Message return values" below).
+
+The Driver (ShortBus::Driver) is the brains of the operation. Once instantiated, a dedicated thread monitors the incoming queue, converts and routes the messages to the appropriate subscribers based on the message\_spec(s) supplied at the time of subscription.
+
+## What does a message and a message\_spec look like?
+In it's simplest form, a message can be a simple String like `'shutdown'`, but typically a more flexible, component based format is used, delimited by `::`, like `'OwnerService::Action::Argument'`.  The Driver will convert the message String into a ShortBus::Message object before routing.
+
+A message\_spec can be supplied when subscribing in order to select which messages are received (ie: run the callback). A message\_spec can be a String (`'shutdown'`), a wildcard String (`'OwnerService::**'`), a Regexp, or even an Array or Set of multiple Strings and/or Regexps.
+
+#### Wildcard String?
+To simplify filtering, a message\_spec String can contain a `*` or a `**` wildcard. A `*` wildcard matches just one field between `::` delimiters. A `**` wildcard matches one or more.
+
+`'Service::*'` matches `'Service::Start'`, but not `'Service::Start::Now'`
+
+`'Service::**'` matches both `'Service::Start'` and `'Service::Start::Now'`
+
+Wilcard Strings are turned into Regexps by the Driver.
+
+## Message return values (Message as a Queue)
+Typically speaking, services participating in a SOA do not get immediate return values, as an SOA is asynchronous. Since ShortBus generally runs as a monolithic application, we can cheat a bit for convenience, and pass return values back through the Message object (which is an inherited Queue class).
+
+When a new Message is published via the Driver#publish method, the return value is the same Message object that subscribers receive.
+
+The publisher can then #pop from that Message, which will block and wait for one of the subscribers to #push a "return value" into the Message on the other side. To make things more flexible, #pop (and #shift, #deq) has been extended to accept a numeric value, which acts as a timeout in seconds.
+
+```ruby
+return_val = driver.publish('Testing::Message')
+  .pop(3)
+```
+
+If you don't want to use the Message return value functionality, you can ignore it, and Ruby's garbage collection will destroy the Message automatically when all subscriber callbacks have completed.
+
+## How do you use it?
+
+```ruby
+require_relative '../short_bus'
+
+# Instantiate Driver, start message routing thread
+#
+driver = ShortBus::Driver.new
+
+# Subscribes a block to all messages (no filtering)
+#
+driver.subscribe { |message| puts "1. I like all foods, including #{message}" }
+
+# Subscribes a block with a message_spec filtering only some messages
+#   Also, replies back to the driver with a new message.
+#
+driver.subscribe(message_spec: 'Chocolate::**') do |message|
+  puts "2. Did I hear you say Chocolate?  (#{message}). I know what I'm making."
+  'Chocolate::And::Strawberries'
+end
+
+# Subscribes a block with a message_spec filtering only some messages
+#
+driver.subscribe(message_spec: '**::Strawberries') do |message|
+  puts "3. I only care about Strawberries: #{message}"
+  'Strawberries'
+end
+
+# First lets just test it with an unrelated message
+#
+driver.publish 'Cookies::And::Cream'
+sleep 0.1
+puts
+
+# Now lets try some interaction going between services
+#
+driver.publish 'Chocolate::Anything'
+sleep 0.1
+```
+And here's what it looks like when we run it:
+
+```
+1. I like all foods, including Cookies::And::Cream
+
+1. I like all foods, including Chocolate::Anything
+2. Did I hear you say Chocolate?  (Chocolate::Anything). I know what I'm making.
+1. I like all foods, including Chocolate::And::Strawberries
+3. I only care about Strawberries: Chocolate::And::Strawberries
+1. I like all foods, including Strawberries
+```
+
+## TODO
+- HIGH: make mixin for easier integration (provide #driver #publish #register #unregister; callback method -> #subscribe)
+- HIGH: create class for automated benchmarking & testing
+- HIGH: make examples easier to read, smaller, more repeatable
+- MEDIUM: convert all Queue's to SizedQueue's, with reasonable/adjustable limits
+- MEDIUM: cascade block to Service object to avoid block.to\_proc slowdown
+- MEDIUM: document api , make gem, publish
+- LOW: Redis connector with JSON and binary-serialized object passing
+- LOW: class based services (object instantiation on callback -> ?)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'short_bus'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install short_bus
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`rake spec` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/robzr/short_bus.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "short_bus"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/misc_tests

@@ -0,0 +1,56 @@
+#!/usr/bin/env ruby
+
+require 'pp'
+require 'short_bus'
+
+driver = ShortBus::Driver.new(debug: false)
+
+#monitor = ShortBus::Monitor.new driver
+
+driver.subscribe(
+  name: 'lambie',
+  service: lambda { |message|
+    sleep 0.2
+    raise Exception.new 'random explosion' if rand(4) == 0
+    'lambie::response'
+  }
+)
+
+driver.subscribe(
+  debug: false, 
+  name: 'got', 
+  publisher_spec: 'lambie', 
+  thread_count: 2
+) do |msg|
+  sleep 0.3
+  puts "anon-1 #{msg}"
+  nil
+end
+
+driver.subscribe(
+  message_spec: ['h**', '**::hello'],
+  name: 'inline_bob'
+) do |message|
+  puts "inline_bob received: #{message} from #{message.publisher}"
+  puts "            payload: #{message.payload}" if message.payload
+  message << 'arbitrary object sent via Message'
+  message.payload += 1 if message.payload.is_a?(Numeric)
+  message.merge 'new::message'
+end
+
+Thread.new { 
+  5.times do 
+    driver << "publish::thread"
+    sleep 0.15
+  end
+}
+
+first_message = driver << ["hi::bob", 1]
+sleep 0.2
+driver << ["hello::jim", "pot"]
+sleep 0.2
+driver << ["hola::xxx", "stew"]
+
+puts "Shift-back from first message #{first_message.shift(2)}"
+
+sleep 1

data/examples/tutorial_1_basic_intro.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+#
+# First example - basic publishing / subscription
+#
+require_relative '../short_bus'
+
+# Instantiate Driver, start message routing thread
+#
+driver = ShortBus::Driver.new
+
+# Subscribes a block to all messages (no filtering)
+#
+driver.subscribe { |message| puts "1. I like all foods, including #{message}" }
+
+# Subscribes a block with a message_spec filtering only some messages
+#   Also, replies back to the driver with a new message.
+#
+driver.subscribe(message_spec: 'Chocolate::**') do |message|
+  puts "2. Did I hear you say Chocolate?  (#{message}). I know what I'm making."
+  'Chocolate::And::Strawberries'
+end
+
+# Subscribes a block with a message_spec filtering only some messages
+#
+driver.subscribe(message_spec: '**::Strawberries') do |message|
+  puts "3. I only care about Strawberries: #{message}"
+  'Strawberries'
+end
+
+# First lets just test it with an unrelated message
+#
+driver.publish 'Cookies::And::Cream'
+sleep 0.1
+puts
+
+# Now lets try some interaction going between services
+#
+driver.publish 'Chocolate::Anything'
+sleep 0.1

data/examples/tutorial_2_message_return_values.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+#
+# ShortBus example passing return values via Message object
+
+require_relative '../short_bus'
+
+driver = ShortBus::Driver.new
+
+def house_cleaner(message)
+  puts "Lets blow this popsicle stand..." 
+  sleep 0.5
+
+  # Send value back into the Message object
+  message << "I'm working on it!"
+
+  # pause
+  sleep 1
+
+  # and exit the program
+  exit
+end
+
+driver.subscribe(
+  message_spec: '*::Shutdown',
+  service: method(:house_cleaner)
+)
+
+# driver.publish returns the message object we just sent
+our_message = driver.publish('Everyone::Shutdown')
+
+# Since it is inherited from a Queue, we can pop right off it
+return_value = our_message.shift
+
+# And see what the callback wanted to tell us!
+puts "I heard back from the house_cleaner, who says: #{return_value}"
+
+# sleep indefinitely, or until we somehow exit...
+sleep

data/lib/short_bus/debug_message.rb

@@ -0,0 +1,9 @@
+module DebugMessage
+  def debug_message(message)
+    (@debug_message_output_filehandle || STDERR).printf(
+      "%s::%s\n",
+      caller.first.sub(/^.*\/([^:]*).*/, '\1'),
+      message
+    ) if @debug
+  end
+end

data/lib/short_bus/driver.rb

@@ -0,0 +1,92 @@
+require 'pp'
+require 'set'
+
+module ShortBus
+  class Driver
+    include DebugMessage
+
+    attr_reader :services
+    attr_accessor :debug
+
+    DEFAULT_DRIVER_OPTIONS = {
+      debug: false,
+      default_message_spec: nil,
+      default_publisher_spec: nil,
+      default_thread_count: 1,
+      max_message_queue_size: 1_000_000,
+    }
+
+    def initialize(*options)
+      @options = DEFAULT_DRIVER_OPTIONS
+      @options.merge! options[0] if options[0].is_a?(Hash)
+      @debug = @options[:debug]
+
+      @messages = SizedQueue.new(@options[:max_message_queue_size])
+      @services = {}
+      @threads = { message_router: launch_message_router }
+    end
+
+    def subscribe(*args, &block)
+      service_args = {
+        debug: @debug,
+        driver: self,
+        message_spec: @options[:default_message_spec],
+        name: nil,
+        publisher_spec: @options[:default_publisher_spec],
+        service: nil,
+        thread_count: @options[:default_thread_count],
+      }.merge args[0].is_a?(Hash) ? args[0] : { service: args[0] }
+
+      service_args[:service] = block.to_proc if block_given?
+      debug_message("#subscribe service: #{service_args[:service]}")
+      service = Service.new(service_args)
+      @services[service.to_s] = service
+    end
+
+    def publish(publisher=nil, arg)
+      if message = convert_to_message(arg)
+        message.publisher = publisher if publisher
+        @messages.push message
+        message
+      end
+    end
+
+    alias_method :<<, :publish
+
+    def unsubscribe(service)
+      if service.is_a? ShortBus::Service
+        unsubscribe service.to_s
+      elsif @services.has_key? service
+        @services[service].stop
+        @services.delete service
+      end      
+    end
+    
+    private
+
+    def convert_to_message(arg)
+      if arg.is_a? ShortBus::Message
+        arg
+      elsif arg.is_a? String
+        Message.new(arg)
+      elsif arg.is_a?(Array) && arg[0].is_a?(String)
+        Message.new(arg)
+      elsif arg.is_a?(Hash) && arg.has_key?(:message) && arg[:message]
+        publisher = arg.has_key?(:publisher) ? arg[:publisher] : nil
+        payload = arg.has_key?(:payload) ? arg[:payload] : nil
+        Message.new(message: arg[:message], payload: payload, publisher: publisher)
+      end
+    end
+
+    def launch_message_router
+      Thread.new do
+        loop do 
+          message = @messages.shift
+          debug_message "route_message(#{message})"
+          @services.values.each { |service| service.check message }
+        end
+      end
+    end
+  end
+end
+

data/lib/short_bus/message.rb

@@ -0,0 +1,85 @@
+require 'pp'
+require 'timeout'
+
+# Queue, with a few mods
+#  - message (message.to_s) (string)
+#  - optional payload (object)
+#  - publisher (string or nil = anonymous)
+#
+module ShortBus
+  class Message < Queue
+    attr_accessor :publisher
+    attr_reader :payload
+
+    def initialize(*args)
+      @message, @payload, @publisher = nil
+      @semaphore = Mutex.new
+      if populate args
+        super()
+      else
+        raise ArgumentError.new "#Message: Invalid args #{args.pretty_inspect}"
+      end
+    end
+
+    def merge(*args)
+      arg_hash = process_args args
+      if arg_hash[:message] 
+        Message.new(
+          message: arg_hash[:message] || @message,
+          payload: arg_hash.has_key?(:payload) ? arg_hash[:payload] : @payload,
+        )
+      end
+    end
+
+    def payload=(arg)
+      @semaphore.synchronize { @payload = arg }
+    end
+
+    def pop(time_out=nil)
+      if time_out.is_a? Numeric
+        begin
+          Timeout.timeout(time_out) { super() }
+        rescue Timeout::Error
+        end
+      else
+        super(time_out)
+      end
+    end
+
+    alias_method :shift, :pop
+    alias_method :deq, :pop
+
+    def to_s
+      @message
+    end
+
+    private
+
+    def populate(args)
+      arg_hash = process_args args
+      if arg_hash.has_key?(:message)
+        @payload = arg_hash[:payload] if arg_hash.has_key?(:payload)
+        @publisher = arg_hash[:publisher] if arg_hash.has_key?(:publisher)
+        @message = arg_hash[:message]
+      end
+    end
+
+    def process_args(args)
+      if args[0].is_a? Array
+        process_args args[0]
+      else
+        {}.tap do |me|
+          if args[0].is_a? String
+            me[:payload] = args[1] if args.length == 2
+            me[:payload] = args.slice(1..-1) if args.length > 2
+            me[:message] = args[0]
+          elsif args[0].is_a?(Hash) && args[0].has_key?(:message)
+            me[:payload] = args[0][:payload] if args[0].has_key?(:payload)
+            me[:publisher] = args[0][:publisher] if args[0].has_key?(:publisher)
+            me[:message] = args[0][:message]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/short_bus/monitor.rb

@@ -0,0 +1,60 @@
+require 'pp'
+
+module ShortBus
+  class Monitor
+
+    DEFAULT_MONITOR_OPTIONS = {
+      message_spec: nil,
+      name: 'ShortBus::Monitor',
+      suppress_payload: false,
+      suppress_publisher: false,
+      publisher_spec: nil,
+      thread_count: 1
+    }
+
+    def initialize(*args)
+      @options = DEFAULT_MONITOR_OPTIONS.merge(
+        { service: method(:monitor) }
+      )
+      @suppress_payload, @suppress_publisher = nil
+
+      if args[0].is_a?(Hash) && args[0].has_key?(:driver)
+        @options.merge! args[0]
+        @driver = @options[:driver]
+        @options.delete(:driver)
+      elsif args.is_a?(Array) && args.length == 1
+        @driver = args[0]
+      else
+        raise ArgumentError, 'No driver passed.'
+      end
+
+      @suppress_payload = @options.delete(:suppress_payload)
+      @suppress_publisher = @options.delete(:suppress_publisher)
+
+      start
+    end
+
+    def monitor(message)
+      puts "[#{@options[:name]}]  message = #{message}"
+      printf(
+        "  %s  payload = %s\n",
+        @options[:name] ?  ' ' * @options[:name].length : '',
+        message.payload.inspect
+      ) if message.payload && !@suppress_payload
+      printf(
+        "  %spublisher = %s\n",
+        @options[:name] ?  ' ' * @options[:name].length : '',
+        message.publisher ? message.publisher : '*ANONYMOUS*'
+      ) if !@suppress_publisher
+      nil
+    end
+
+    def start
+      @service = @driver.subscribe(@options)
+    end
+
+    def stop
+      @driver.unsubscribe @service
+    end
+  end
+end

data/lib/short_bus/service.rb

@@ -0,0 +1,109 @@
+#require 'observer'
+require 'pp'
+require 'set'
+require 'openssl'
+
+module ShortBus
+  class Service
+    include DebugMessage
+
+    attr_reader :name, :threads
+
+    def initialize(
+      debug: false,
+      driver: nil,
+      max_run_queue_size: 1_000_000,
+      message_spec: nil,
+      name: nil,
+      recursive: false,
+      publisher_spec: nil,
+      service: nil, 
+      suppress_exception: false,
+      thread_count: 1
+    )
+      @debug = debug
+      @driver = driver
+      @message_spec = message_spec ? Spec.new(message_spec) : nil
+      @recursive = recursive
+      @publisher_spec = publisher_spec ? Spec.new(publisher_spec) : nil
+      @service = service
+      @thread_count = thread_count
+
+      @name = name || @service.to_s || OpenSSL::HMAC.new(rand.to_s, 'sha1').to_s
+      @run_queue = SizedQueue.new(max_run_queue_size)
+      @threads = []
+      start
+    end
+    
+    def check(message, dry_run=false)
+      debug_message "[#{@name}]#check(#{message})#{' dry_run' if dry_run}#" 
+      if(
+        (!@message_spec || @message_spec.match(message.to_s)) &&
+        (!@publisher_spec || @publisher_spec.match(message.publisher)) &&
+        (message.publisher != @name || @recursive)
+      )
+        @run_queue << message unless dry_run
+      end
+    end
+
+    # TODO: consider some mechanism to pass Exceptions up to the main thread,
+    #   perhaps with a whitelist, optional logging, something clean.
+    def service_thread
+      Thread.new do 
+        begin
+          run_service @run_queue.shift until Thread.current.key?(:stop) 
+        rescue Exception => exc
+          puts "Service [#{@name}] => #{exc.inspect}" unless @suppress_exception
+          abort if exc.is_a? SystemExit
+          retry unless Thread.current.key?(:stop)
+        end 
+      end 
+    end
+
+    def start
+      @threads << service_thread while @threads.length < @thread_count
+    end
+
+    def stop(when_to_kill=nil)
+      @threads.each do |thread|
+        if when_to_kill.is_a? Numeric
+          begin
+            Timeout.timeout(when_to_kill) { stop }
+          rescue Timeout::Error
+            stop :now
+          end
+        elsif when_to_kill == :now   
+          thread.kill
+        else
+          thread[:stop] = true
+        end
+      end
+      @threads.delete_if { |thread| @threads[index].join }
+    end
+
+    def stop!
+      stop :now
+    end
+
+    def to_s
+      @name
+    end
+
+    private
+
+    def run_service(message)
+      debug_message "[#{@name}]#run_service(#{message}) -> #{@service.class.name} ##{@service.arity}"
+      if @service.is_a?(Proc) || @service.is_a?(Method)
+        if @service.arity == 0
+          @driver.publish(@name, @service.call)
+        elsif [1, -1, -2].include? @service.arity
+          @driver.publish(@name, @service.call(message))
+        else
+          raise ArgumentError, "Service invalid arg count: #{@service.class.name}"
+        end
+      else
+        raise ArgumentError, "Unknown service type: #{@service.class.name}"
+      end
+    end
+  end
+end

data/lib/short_bus/spec.rb

@@ -0,0 +1,58 @@
+require 'pp'
+require 'set'
+
+module ShortBus
+  class Spec
+    attr_reader :specs
+
+    def initialize(spec = nil)
+      @specs = process(spec)
+    end
+
+    def <<(spec)
+      @specs += process(spec)
+    end
+
+    def delete(spec)
+      @specs.delete spec
+    end
+
+    def match(item)
+      @specs.reduce(false) { |acc, spec| acc || match_single(spec, item) }
+    end
+
+    private
+
+    def match_single(spec, item)
+      if spec.is_a? String
+        spec == item
+      elsif spec.is_a? Regexp
+        spec.match item
+      end
+    end
+
+    def process(spec, to_set = true)
+      if spec.is_a? Array
+        process spec.flatten.to_set
+      elsif spec.is_a? Regexp
+        to_set ? [spec].to_set : spec
+      elsif spec.is_a? Set
+        spec.flatten
+          .map { |spec| process(spec, false) }
+          .to_set
+      elsif spec.is_a? String
+        to_set ? [string_to_regexp(spec)].to_set : string_to_regexp(spec)
+      elsif spec.is_a? NilClass
+        [/.*/].to_set
+      end
+    end
+
+    def string_to_regexp(spec)
+      if spec.include? '*'
+        /^#{spec.gsub(/\*+/, '*' => '[^:]*', '**' => '.*')}/
+      else
+        spec
+      end
+    end
+  end
+end

data/lib/short_bus/version.rb

@@ -0,0 +1,3 @@
+module ShortBus
+  VERSION = "0.1.0"
+end

data/lib/short_bus.rb

@@ -0,0 +1,11 @@
+require 'short_bus/debug_message'
+require 'short_bus/driver'
+require 'short_bus/spec'
+require 'short_bus/message'
+require 'short_bus/monitor'
+require 'short_bus/service'
+require "short_bus/version"
+
+module ShortBus
+  # Your code goes here...
+end

data/short_bus.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'short_bus/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "short_bus"
+  spec.version       = ShortBus::VERSION
+  spec.authors       = ["Rob Zwissler"]
+  spec.email         = ["rob@zwissler.org"]
+
+  spec.summary       = %q{Lightweight multi-threaded pub-sub message dispatcher for self-contained service-oriented Ruby apps.}
+
+  spec.description   = %q{Small, lightweight, easy to implement multi-threaded publish/subscribe style message dispatcher for quickly creating self-contained service-oriented Ruby apps.}
+  spec.homepage      = "https://github.com/robzr/short_bus"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: short_bus
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rob Zwissler
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Small, lightweight, easy to implement multi-threaded publish/subscribe
+  style message dispatcher for quickly creating self-contained service-oriented Ruby
+  apps.
+email:
+- rob@zwissler.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/misc_tests
+- examples/tutorial_1_basic_intro.rb
+- examples/tutorial_2_message_return_values.rb
+- lib/short_bus.rb
+- lib/short_bus/debug_message.rb
+- lib/short_bus/driver.rb
+- lib/short_bus/message.rb
+- lib/short_bus/monitor.rb
+- lib/short_bus/service.rb
+- lib/short_bus/spec.rb
+- lib/short_bus/version.rb
+- short_bus.gemspec
+homepage: https://github.com/robzr/short_bus
+licenses:
+- MIT
+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.0.14.1
+signing_key: 
+specification_version: 4
+summary: Lightweight multi-threaded pub-sub message dispatcher for self-contained
+  service-oriented Ruby apps.
+test_files: []