dynamicdudes-speaking-apps 1.1.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 rubyphunk, speakingapps.com
+
+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,47 @@
+= speaking-apps
+
+speaking-apps allows you to add remote logging facilities to your application. It uses the http://speakingapps.com API to store and organize your messages. It works for all Ruby projects but was especially designed to be backed into your Rails app.
+
+Caveats: You will need a http://speakingapps.com account.
+
+== Setup
+
+Github Home: http://github.com/dynamicdudes/speaking-apps/tree/master
+
+Gem:
+  gem install dynamicdudes-speaking-apps --source http://gems.github.com
+  $ irb(main):001:0> require 'speaking_apps'
+
+or with Rails >= 2.1:
+  config.gem "dynamicdudes-speaking-apps", :lib => "speaking_apps", :source => "http://gems.github.com"
+
+== Configuration
+
+Just before you start sending messages to the http://speakingapps.com API you should configure a few essential things:
+  SpeakingApps::Config.token = 'your_super_secret_token'
+  
+If you are on Rails you might want to define which environments should be used for remote logging:
+  SpeakingApps::Config.environments = [ 'staging', 'production' ]
+
+== Usage
+
+speaking-apps gives you two methods for sending messages. A one-liner that takes optional tags:
+  SpeakingApps.log('hello World')
+  SpeakingApps.log('hello World', 'tag1', 'tag2', 'tagx')
+
+and a &block taking version for more readability if you have longer messages:
+  SpeakingApps.log_with_tags('tag1', 'tag2') do
+    msg =  'He'
+    msg << 'llo '
+    msg << 'World'
+  end
+
+
+== More
+
+* Written by rubyphunk (http://rubyphunk.com)
+* For http://speakingapps.com
+* Supported by http://dynamicdudes.com
+
+
+Copyright (c) 2008 rubyphunk, speakingapps.com. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "speaking-apps"
+    s.summary = %Q{The official SpeakingApps Gem}
+    s.email = "treas@dynamicdudes.com"
+    s.homepage = "http://github.com/dynamicdudes/speaking-apps"
+    s.description = "The official SpeakingApps Gem. Allows your Rails app (or every other Ruby project) to chat with the http://speakingapps.com logging service."
+    s.authors = ["rubyphunk", "speakingapps.com"]
+    s.add_dependency 'daemons', '>= 1.0.10'
+    s.add_dependency 'json', '>= 1.1.3'
+    s.add_dependency 'sinatra', '>= 0.9.0.4'
+    s.files = FileList['lib/**/*.rb', 'bin/*', '[A-Z]*', 'spec/**/*', 'rails/*', 'init.rb'].to_a    
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'speaking-apps'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc*')
+  rdoc.rdoc_files.include('LICENSE*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.exclude('spec')
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.libs << 'lib' << 'spec'
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.libs << 'lib' << 'spec'
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.rcov = true
+end
+
+begin
+  require 'cucumber/rake/task'
+  Cucumber::Rake::Task.new(:features)
+rescue LoadError
+  puts "Cucumber is not available. In order to run features, you must: sudo gem install cucumber"
+end
+
+task :default => :spec

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 3
+:major: 1
+:minor: 1

data/bin/speaking-apps

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'daemons'
+require File.join(File.dirname(__FILE__), '..', 'lib/speaking_apps/daemon', 'control')

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/rails/init'

data/lib/speaking_apps.rb

@@ -0,0 +1,70 @@
+require 'timeout'
+require File.dirname(__FILE__) + '/speaking_apps/config'
+require File.dirname(__FILE__) + '/speaking_apps/message_queue'
+
+# This is the place to read about the methods that
+# will help you sending Messages/Logs to the SpeakingApps API Service.
+#
+# Please make sure you set the required SpeakingApps::Config values.
+
+module SpeakingApps
+  class << self
+
+    def init(environment = nil) #:nodoc:
+      unless class_variable_defined?(:@@_message_queue)
+        @@_message_queue = SpeakingApps::MessageQueue.new(environment)
+        ensure_existence_of_service_daemon# if @@_message_queue.environment_valid?
+      end      
+    end
+
+    # Send a Messages. You can optionally assign Tags.
+    #
+    # * <tt>SpeakingApps.log('hello World')</tt>
+    # * <tt>SpeakingApps.log('hello World', 'tag1', 'tag2', 'tagx')</tt>
+    def log(message, *tags)
+      begin
+        message_queue.add(message, tags)
+        true
+      rescue
+        false
+      end
+    end
+
+    # Send a Messages with tags.
+    #
+    # * <tt>SpeakingApps.log_with_tags('tag1', 'tag2') { 'Hello World' }</tt>
+    def log_with_tags(*tags, &block)
+      begin
+        message = yield
+        message_queue.add(message, tags)
+        true
+      rescue
+        false
+      end
+    end
+    
+    def message_queue #:nodoc:
+      @@_message_queue
+    end
+      
+    def ensure_existence_of_service_daemon #:nodoc:
+      begin
+        Timeout::timeout(10) do
+          unless message_queue.ping
+            bin_path = File.expand_path(File.join(File.dirname(__FILE__), '/../bin/speaking-apps'))
+            Kernel.system("#{bin_path} start")
+          end
+          sleep 1
+        end
+        send_to_app "=> SpeakingApps: API service ready."
+      rescue
+        send_to_app "=> SpeakingApps: API service is not available!"
+      end
+    end  
+    
+    def send_to_app(message)
+      $stdout.puts message
+    end
+    
+  end
+end

data/lib/speaking_apps/config.rb

@@ -0,0 +1,58 @@
+module SpeakingApps
+  
+  # Use <b>SpeakingApps::Config</b> to setup your http://SpeakingApps.com API access.
+  #
+  # Please note: You must set the token in order to use the API.
+  # Don't know your token? Login to your account on http://youraccount.speakingapps.com (or get a new one),
+  # select your project and open 'Settings'.
+  #
+  # Place the configuration wherever you want. In a Rails app you would typically add these lines
+  # under <tt>config/environment</tt> or <tt>config/initializers/</tt>.
+  
+  class Config
+    
+    # Configure which Project-Token to use.
+    #
+    # <tt>SpeakingApps::Config.token = 'your-api-token'</tt>
+    def self.token=(new_token)
+      @@_token = new_token
+    end
+    
+    def self.token  #:nodoc:
+      class_variable_defined?(:@@_token) ? @@_token : nil
+    end    
+
+    # Set the environment(s) in which SpeakingApps#log should be active. Defaults to: ['production']
+    #
+    # <tt>SpeakingApps::Config.environments = ['staging', 'production']</tt>
+    def self.environments=(new_environments)
+      @@_environments = new_environments
+    end
+    
+    def self.environments #:nodoc:
+      class_variable_defined?(:@@_environments) ? @@_environments : ['production']
+    end
+  
+    def self.host=(new_host) #:nodoc:
+      @@_host = new_host
+    end
+    
+    def self.host #:nodoc:
+      class_variable_defined?(:@@_host) ? @@_host : 'speakingapps.com'
+    end
+    
+    def self.port=(new_port) #:nodoc:
+      @@_port = new_port
+    end
+    
+    def self.port #:nodoc:
+      class_variable_defined?(:@@_host) ? @@_port : '80'
+    end
+    
+    def self.clear! #:nodoc:
+      class_variables.each do |v|
+        remove_class_variable v.intern rescue true
+      end
+    end
+  end
+end

data/lib/speaking_apps/daemon/control.rb

@@ -0,0 +1,4 @@
+Daemons.run_proc('speaking-apps', { :dir_mode => :normal, :dir => '/tmp', :multiple => false,:monitor => true}) do
+  path = File.expand_path(File.join(File.dirname(__FILE__), 'queue_service.rb'))
+  exec "/usr/bin/env ruby #{path} -p 28128 -- --debug"  
+end

data/lib/speaking_apps/daemon/queue_service.rb

@@ -0,0 +1,98 @@
+require 'rubygems'
+require 'sinatra'
+require 'json'
+
+module SpeakingApps
+  module Daemon    
+    class QueueService
+      attr_accessor :queue
+      attr_accessor :worker
+
+      def initialize
+        $DEBUG_SPEAKING_APPS = ARGV.delete('--debug')
+        self.queue = []
+        init_worker
+        @mutex = Mutex.new
+      end  
+
+      def add_outgoing_message(message_with_options)
+        debug "Scheduling outgoing message.. #{message_with_options['message']} (#{message_with_options['token']})"
+        self.queue << message_with_options
+        self.worker.wakeup
+        true
+      end
+      
+      def ping
+        'pong'
+      end
+    
+      protected
+
+      def init_worker
+        self.worker = Thread.new do
+          loop do
+            if @queue.empty?
+              debug "Putting Thread #{Thread.current} to sleep. No waiting items"
+              Thread.stop
+            else
+              debug "Putting Thread #{Thread.current} to sleep for 5 seconds. Waiting messages: #{@queue.size}"
+              sleep 5
+            end
+            
+            execute_queue
+          end
+        end
+        debug "Worker initialized.. #{self.worker} #{self.worker.status}"       
+      end
+
+      def execute_queue
+        @mutex.synchronize do
+          retry_list = []
+          until @queue.empty?
+            item = @queue.shift           
+            api_response =  SpeakingApps::Daemon::Remote.upload_message_with_tags(item)
+            if api_response == SpeakingApps::Daemon::Remote::API_RESPONSE_NETWORK_FAILURE
+              retry_list << item
+            end
+          end
+          @queue += retry_list
+        end
+      end
+      
+    end    
+  end
+end
+
+
+def log(message, mode = :info)
+  return if mode == :debug && !$DEBUG_SPEAKING_APPS
+  puts "[#{Time.now}] #{message}"
+end      
+
+def debug(message)
+  log(message, :debug)
+end
+
+
+# Init Queue Service
+configure do
+  require File.join(File.dirname(__FILE__), 'remote')
+  @@queue_service = SpeakingApps::Daemon::QueueService.new
+  debug "SpeakingApps: Activated Debugging Mode"
+  log "SpeakingApps: Ready."
+end
+
+# Sinatra Resources
+get '/ping' do
+  'pong'
+end
+
+post '/messages' do
+  begin
+    json_request = JSON.parse(request.env["rack.input"].read)
+    @@queue_service.add_outgoing_message(json_request)
+    '201 Created'
+  rescue => error
+    "500 Error: #{error}"
+  end
+end

data/lib/speaking_apps/daemon/remote.rb

@@ -0,0 +1,61 @@
+require 'net/http'
+require 'net/https'
+require 'erb'
+
+module SpeakingApps
+  module Daemon
+    class Remote
+    
+      API_RESPONSE_SUCCESS = 0
+      API_RESPONSE_ERROR = 1
+      API_RESPONSE_NETWORK_FAILURE = 2
+    
+      def self.upload_message_with_tags(message_hash)
+        begin
+          encoded_data = encode_message_hash(message_hash)
+          uri = generate_uri(message_hash)
+          return post_to_remote(uri, encoded_data)
+        rescue => e
+          log "SpeakingApps Error: #{e}"
+        end
+      end
+    
+      def self.encode_message_hash(hash)
+        post_data = []
+        post_data << [ "message=#{ ERB::Util.url_encode(hash['message']) }" ]
+        post_data << [ "tags=#{ ERB::Util.url_encode(hash['tags'].join(', ')) }"] if hash['tags']
+        post_data << [ "environment=#{ ERB::Util.url_encode(hash['environment']) }"] if hash['environment']
+        post_data.join('&')
+      end
+        
+      def self.generate_uri(message_hash)
+        token, host, port = message_hash['token'], message_hash['host'], message_hash['port']
+        "http://#{host}:#{port}/api/v1/#{token}/messages"
+      end
+
+      def self.post_to_remote(uri, encoded_post_data)
+        uri = URI.parse(uri)      
+      
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = false
+        
+        api_response = begin
+          http.post(uri.path, encoded_post_data, { 'Content-type'  => 'application/x-www-form-urlencoded' })
+        rescue => error
+          log "Error while contacting the SpeakingApps API HQ: #{error}"
+          return API_RESPONSE_NETWORK_FAILURE
+        end
+        
+        case api_response
+        when Net::HTTPCreated
+          debug "Send message: '#{encoded_post_data}' to #{uri.host}"
+          return API_RESPONSE_SUCCESS
+        else
+          log "SpeakingApps Error: #{ api_response.body if api_response.respond_to?(:body) }"
+          return API_RESPONSE_ERROR          
+        end                
+      end        
+      
+    end
+  end  
+end

data/lib/speaking_apps/message_queue.rb

@@ -0,0 +1,57 @@
+require 'net/http'
+require 'uri'
+require 'timeout'
+
+module SpeakingApps
+  class MessageQueue
+    attr_accessor :remote_queue
+    attr_accessor :environment
+    
+    def initialize(environment = nil)
+      @environment = environment
+    end    
+    
+    def add(message, *attr)
+      if environment_valid?
+        store_in_remote_service_queue({
+          :message => message, 
+          :tags => attr, 
+          :environment => @environment,
+          :token => SpeakingApps::Config.token,
+          :host => SpeakingApps::Config.host,
+          :port => SpeakingApps::Config.port
+        })
+      end
+    end    
+
+    def ping
+      begin
+        Timeout::timeout(2) do
+          hub_url = URI.parse('http://127.0.0.1:28128/ping')
+          response = Net::HTTP.start(hub_url.host, hub_url.port) { |http| http.get(hub_url.path) }
+          return response.body == 'pong'
+        end
+      rescue => error
+        return false
+      end
+    end
+
+    def store_in_remote_service_queue(message_with_options = {})
+#      begin
+        Timeout::timeout(2) do
+          hub_url = URI.parse('http://127.0.0.1:28128/messages')
+          response = Net::HTTP.start(hub_url.host, hub_url.port) do |http| 
+            http.post(hub_url.path, message_with_options.to_json)
+          end
+          return response == Net::HTTPCreated
+       end        
+      # rescue => error
+      #   return false
+      # end
+    end
+    
+    def environment_valid? #:nodoc#
+      @environment.nil? || ::SpeakingApps::Config.environments.include?(@environment)
+    end    
+  end
+end 

data/rails/init.rb

@@ -0,0 +1 @@
+SpeakingApps.init(RAILS_ENV)

data/spec/lib/speaking_apps/config_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'lib/speaking_apps/config'
+
+describe SpeakingApps::Config do
+  before(:each) do
+    SpeakingApps::Config.clear!
+  end
+  
+  it 'should allow setting the token' do
+    SpeakingApps::Config.token = 'test'
+    SpeakingApps::Config.token.should eql('test')
+  end
+  
+  it 'should allow defining environments' do
+    SpeakingApps::Config.environments = ['development', 'production']
+    SpeakingApps::Config.environments.should eql(['development', 'production'])
+  end
+  
+  it 'should use the default environment "production" if nothing was set' do
+    SpeakingApps::Config.environments.should eql(['production'])
+  end
+end

data/spec/lib/speaking_apps/daemon/queue_service_spec.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/../../../../lib/speaking_apps/daemon/queue_service'
+
+describe SpeakingApps::Daemon::QueueService do
+  before(:each) do
+    @queue = SpeakingApps::Daemon::QueueService.new    
+  end
+  
+  it 'should have a ping-back method' do
+    @queue.ping.should eql('pong')
+  end
+end

data/spec/lib/speaking_apps/daemon/remote_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/../../../../lib/speaking_apps/daemon/remote'
+
+describe SpeakingApps::Daemon::Remote do
+  
+  context '#self.upload_message_with_tags' do
+    before(:each) do
+      SpeakingApps::Daemon::Remote.stub!(:post_to_remote)      
+    end
+    
+    it 'should encode the message_hash' do
+      SpeakingApps::Daemon::Remote.should_receive(:encode_message_hash)
+      SpeakingApps::Daemon::Remote.upload_message_with_tags({ 'message' => 'Test', 'tags' => ['peter', 'Hallo welt'] })
+    end
+    
+    it 'should generate the uri to post to' do
+      SpeakingApps::Daemon::Remote.should_receive(:generate_uri)
+      SpeakingApps::Daemon::Remote.upload_message_with_tags({ 'message' => 'Test' })
+    end
+    
+    it 'should upload a message' do
+      SpeakingApps::Daemon::Remote.should_receive(:post_to_remote)
+      SpeakingApps::Daemon::Remote.upload_message_with_tags({ 'message' => 'Test' })
+    end
+  end
+  
+  context '#self.encode_message_hash' do
+    it 'should encode the hash into a postable string object' do
+      result = SpeakingApps::Daemon::Remote.encode_message_hash( {'message' => 'test', 'tags' => ['hallo welt', 'peter']} )
+      result.should eql('message=test&tags=hallo%20welt%2C%20peter')
+    end
+  end
+  
+  context '#self.generate_uri' do
+    it 'should construct the uri including the project token' do
+      uri = SpeakingApps::Daemon::Remote.generate_uri({ 'token' => '_token_', 'host' => 'localhost', 'port' => '3000'})
+      uri.should eql('http://localhost:3000/api/v1/_token_/messages')
+    end
+  end
+end

data/spec/lib/speaking_apps/message_queue_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'lib/speaking_apps/config'
+require 'lib/speaking_apps/message_queue'
+
+describe 'SpeakingApps::MessageQueue' do
+  before(:each) do    
+    SpeakingApps::Config.stub!(:token).and_return(nil)
+
+    @message_queue = SpeakingApps::MessageQueue.new
+    @message_queue.environment = 'test'
+    @message_queue.stub!(:environment_valid?).and_return(true)    
+  end
+
+  context 'adding items' do
+    before(:each) do
+      @mock_http = mock('HTTP')
+      Net::HTTP.stub!(:start).and_yield(@mock_http)
+    end
+    
+    it 'should store items in the remote queue' do
+      @mock_http.should_receive(:post).with("/messages", message_hash(:message => 'test').to_json)
+      @message_queue.add('test')
+    end
+
+    it 'should accept optional tags' do
+      @mock_http.should_receive(:post).with("/messages", message_hash(:message => 'test', :tags => ['Ruby Cool', 'Defected']).to_json)
+      @message_queue.add('test', 'Ruby Cool', 'Defected')
+    end
+    
+    it 'should not store items if the current environment is not in the list of allowed environments' do
+      @message_queue.stub!(:environment_valid?).and_return(false)          
+      @message_queue.should_not_receive(:store_in_remote_service_queue)
+      @message_queue.add('test')
+    end
+  end
+
+  context 'pinging the service' do
+    it 'should return true if the service is available' do
+      Net::HTTP.stub!(:start).and_return(mock('Request', :body => 'pong'))
+      @message_queue.ping.should be_true
+    end
+    
+    it 'should return false if the service is not available' do
+      Net::HTTP.stub!(:start).and_return(mock('Request', :body => ''))
+      @message_queue.ping.should be_false
+    end
+  end
+  
+  def message_hash(opts = {})
+    { :environment=>"test", :host=>"speakingapps.com", :port=>"80", :tags=>[], :message=>"", :token=>nil }.merge(opts)
+  end
+end

data/spec/lib/speaking_apps_spec.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'lib/speaking_apps'
+
+describe SpeakingApps do
+  before(:each) do
+    @mock_message_queue = mock('MessageQueue')
+    @mock_message_queue.stub!(:add)
+    SpeakingApps.stub!(:message_queue).and_return(@mock_message_queue)
+  end
+  
+  describe '#init' do
+    it 'should try to load the service daemon' do
+      SpeakingApps.stub!(:class_variable_defined?).and_return(false)
+      @mock_message_queue.stub!(:environment_valid?).and_return(true)
+      SpeakingApps.should_receive(:ensure_existence_of_service_daemon)
+      SpeakingApps.init
+    end
+  end
+  
+  describe '#log' do
+    it 'should have a log method' do
+      SpeakingApps.should respond_to(:log)
+    end
+
+    it 'should accept a message for loggin' do
+      SpeakingApps.log('hello world').should be_true
+    end
+
+    it 'should add a message to the MessageQueue' do
+      @mock_message_queue.should_receive(:add).with('Hello World', [])
+      SpeakingApps.log('Hello World')
+    end
+
+    it 'should add optional tags to the MessageQueue' do
+      @mock_message_queue.should_receive(:add).with('test', ['tag', 'tag2'])
+      SpeakingApps.log('test', 'tag', 'tag2')
+    end
+
+    it 'should allow adding tags and provide the message as block' do
+      @mock_message_queue.should_receive(:add).with('Hello World', ['tag1', 'tag2'])
+      SpeakingApps.log_with_tags('tag1', 'tag2') do
+        'Hello World'
+      end
+    end    
+  end
+  
+  describe '#ensure_existence_of_service_daemon' do
+    it 'should load the daemon' do
+      @mock_message_queue.stub!(:ping).and_return(false)
+      Kernel.should_receive(:system).with(File.expand_path(File.join(File.dirname(__FILE__), '/../../bin/speaking-apps start')))
+      SpeakingApps.ensure_existence_of_service_daemon
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rubygems'
+require 'spec'
+require 'json'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__), 'lib')
+$TEST_ENV = true
+
+Spec::Runner.configure do |config|
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: dynamicdudes-speaking-apps
+version: !ruby/object:Gem::Version 
+  version: 1.1.3
+platform: ruby
+authors: 
+- rubyphunk
+- speakingapps.com
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-02-25 00:00:00 -08:00
+default_executable: speaking-apps
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: daemons
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.10
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.1.3
+    version: 
+description: The official SpeakingApps Gem. Allows your Rails app (or every other Ruby project) to chat with the http://speakingapps.com logging service.
+email: treas@dynamicdudes.com
+executables: 
+- speaking-apps
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/speaking_apps/config.rb
+- lib/speaking_apps/daemon/control.rb
+- lib/speaking_apps/daemon/queue_service.rb
+- lib/speaking_apps/daemon/remote.rb
+- lib/speaking_apps/message_queue.rb
+- lib/speaking_apps.rb
+- bin/speaking-apps
+- LICENSE
+- Rakefile
+- README.rdoc
+- VERSION.yml
+- spec/lib
+- spec/lib/speaking_apps
+- spec/lib/speaking_apps/config_spec.rb
+- spec/lib/speaking_apps/daemon
+- spec/lib/speaking_apps/daemon/queue_service_spec.rb
+- spec/lib/speaking_apps/daemon/remote_spec.rb
+- spec/lib/speaking_apps/message_queue_spec.rb
+- spec/lib/speaking_apps_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- rails/init.rb
+- init.rb
+has_rdoc: true
+homepage: http://github.com/dynamicdudes/speaking-apps
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: The official SpeakingApps Gem
+test_files: []
+