rulesio 0.9.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# dependencies are in rulesio.gemspec
+gemspec

data/README.md

@@ -0,0 +1,154 @@
+rulesio gem for rules.io
+=========
+
+[rules.io](http://rules.io) is a rules engine that reacts to things users do or experience in your software, and makes things happen in 3rd party SaaS APIs -- without your having to write any code. Rather than implementing the most rapidly evolving parts of your application's business logic in code, your team can use the rules.io web app to specify "when", "how", and "who", with rules like these:
+
+* when a user gets a form validation error three times in an hour, send an email to Frank
+* when a premium customer hasn't logged in for a month, flag them in your CRM
+* when a user gets a 500 response, create a ticket in Zendesk
+* when a user invites ten friends, add them to the "well-connected" segment in MailChimp
+
+This gem contains Rack middleware that automatically generates two event streams, one about exceptions and the other about user activity (pageviews, errors, attempts to save invalid models), that can be used to trigger rules in rules.io. You can also send more specific events manually.
+
+Setup
+-----
+
+In your Gemfile:
+
+    gem 'rulesio'
+
+###For Ruby on Rails
+
+You should create two incoming channels (event streams) in rules.io, and configure their tokens in `config/rulesio.rb` (the available options are explained below). You may want to create additional channels to use in other environments, eg for staging.
+
+    token 'CHANNEL_TOKEN'          # default channel (for user-centric events)
+    middleware :users              # automatically generate events about user activity
+    middleware :exceptions do      # automatically generate events for exceptions
+      token 'ERROR_CHANNEL_TOKEN'  # separate channel for error-centric events
+    end
+    
+###As general-purpose Rack middleware, with or without Rails
+
+    config.middleware.insert 0, 'RulesIO::Rack', :token => 'CHANNEL_TOKEN'
+    config.middleware.use 'RulesIO::Users'
+    config.middleware.use 'RulesIO::Exceptions', :token => 'ERROR_CHANNEL_TOKEN'
+
+The current user
+----------------
+
+rules.io can take advantage of knowing about the user behind each event, which is supplied by the \_actor field. This gem employs some to determine the current user, but you can also help it out (the default value is `current_user.to_param`). If, for example, you want to use current_user.id as the \_actor for every event (and 0 for the logged out user), you could do this via:
+
+    controller_data '{:_actor => current_user.try(:id) || 0}'
+
+The string will be evaluated in the context of your controller.
+
+Sending other events
+--------------------
+
+Every event must contain the \_actor, \_timestamp, \_domain and \_name fields. Beyond those fields, you can include any additional data you choose. See [docs](http://rules.io/docs) for more details.
+
+To manually send an event when a user upgrades to a "premium" account:
+
+    RulesIO.send_event(
+      :_actor => current_user.unique_id,
+      :_timestamp => Time.now.to_f,
+      :_domain => 'account',
+      :_name => 'upgrade',
+      :user_email => current_user.email,
+      :plan => 'premium' )
+
+Using girl_friday for asynchronous communication and persistence
+-----------------
+
+By default this gem sends a batch of events to the rules.io service synchronously, at the end of each request to your application. This means that each request to your app will be slowed down by the time it takes to do that communication. While this is fine for development or for low-volume sites, for those who wish to avoid this delay rulesio supports the use of the [girl_friday](https://github.com/mperham/girl_friday) gem, which you can enable in your rulesio.rb file:
+
+    queue RulesIO::GirlFridayQueue
+
+Using the GirlFridayQueue also ensures that events are not lost should the rules.io service be temporarily unavailable.
+
+You can also pass options to girl_friday. To avoid losing events when your app server instances restart, you can tell girl_friday to use Redis. In order to use the Redis backend, you must use the [connection_pool](https://github.com/mperham/connection_pool) gem to share a set of Redis connections with other threads and the GirlFriday queue. If you are not already using Redis in your application, add
+
+    gem 'connection_pool'
+    gem 'redis'
+
+to your Gemfile, and add something like this to `config/rulesio.rb`:
+
+    require 'connection_pool'
+    
+    redis_pool = ConnectionPool.new(:size => 5, :timeout => 5) { ::Redis.new }
+    queue RulesIO::GirlFridayQueue, 
+      :store => GirlFriday::Store::Redis, :store_config => { :pool => redis_pool }
+
+See the [girl_friday wiki](https://github.com/mperham/girl_friday/wiki) for more information on how to use girl_friday.
+
+Options
+-------
+
+RulesIO::Rack accepts these options:
+
+* `token` -- the token for a rules.io channel
+* `webhook_url` -- defaults to 'http://www.rules.io/events'
+* `middleware` -- takes the symbol for a middleware and a block, configuring it
+* `queue` -- takes the class used for queuing (default: RulesIO::MemoryQueue), and an optional hash; see the section on girl_friday for examples
+* `controller_data` -- a string evaluated in the context of the Rails controller (if any) handling the request; it should return a hash to be merged into every event (both automatically generated and manually triggered events)
+
+The `exceptions` middleware accepts these options:
+
+* `token` -- the token for a rules.io error channel
+* `ignore_exceptions` -- an array of exception class names, defaults to ['ActiveRecord::RecordNotFound', 'AbstractController::ActionNotFound', 'ActionController::RoutingError']
+* `ignore_crawlers` -- an array of strings to match against the user agent, includes a number of webcrawlers by default; matching requests do not generate events
+* `ignore_if` -- this proc is passed env and an exception; if it returns true, the exception is not reported to rules.io
+* `custom_data` -- this proc is passed env, and should return a hash to be merged into each automatically generated exception event
+
+The `users` middleware accepts these options:
+
+* `ignore_crawlers` -- an array of strings to match against the user agent, includes a number of webcrawlers by default; matching requests do not generate events
+* `ignore_if` -- this proc is passed env; if it returns true, no automatic events are reported to rules.io for this request
+* `ignore_if_controller` -- a string to be evaluated in the context of the Rails controller instance; if it evaluates to true, no automatic events are reported to rules.io for this request
+* `custom_data` -- this proc is passed env, and should return a hash to be merged into each automatically generated event
+
+The RulesIO::Users middleware uses the same token as RulesIO::Rack.
+
+Here's an example of how to skip sending any user events for all requests to the SillyController:
+
+    middleware :users do
+      ignore_if lambda { |env| env['action_controller.instance'].is_a? SillyController }
+    end
+
+To make life easier in the case where you want a condition evaluated in the context of a Rails controller, you can do the same thing like this. (Only the users middleware supports ignore_if_controller.)
+
+    middleware :users do
+      ignore_if_controller 'self.is_a?(EventsController)'
+    end
+
+Or if you want to skip sending pageview events for requests from pingdom.com:
+
+    middleware :users do
+      ignore_crawlers RulesIO.default_ignored_crawlers + ['Pingdom.com_bot']
+    end
+
+Use Cases
+---------
+
+### Example rule triggers
+
+* whenever a `UserIsHavingAVeryBadDay` exception is raised
+* the first time any particular exception occurs
+* whenever a request takes more than 20 seconds to process
+* whenever someone upgrades their account
+* whenever someone does comment#create more than 10 times in a day
+* whenever someone tagged 'active' doesn't login for a week
+
+### Example rule actions
+
+* send yourself an email or a mobile push message
+* send a user an email or a mobile push message
+* create a ticket in your ticketing system
+* add a data point to a Librato or StatsMix graph
+* tag a user in rules.io, or in your CRM
+* segment a user in your email campaign tool
+
+Compatibility
+-------------
+
+This gem can be used without Rails, but when used with Rails it depends on Rails 3 (we've tested with Rails 3.1 and 3.2). If you want to use girl_friday, you must use Ruby 1.9.2 or greater, JRuby, or Rubinius.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rulesio/active_record_extension.rb

@@ -0,0 +1,29 @@
+module ActiveRecord
+  module RulesIOExtension
+    def save(*)
+      result = super
+      send_invalid_model_event if result == false
+      result
+    end
+
+    def save!(*)
+      begin
+        super
+      rescue ::ActiveRecord::RecordNotSaved
+        send_invalid_model_event
+        raise ::ActiveRecord::RecordNotSaved
+      end
+    end
+
+    private
+    def send_invalid_model_event
+      event = {
+        :_domain => 'invalid_model',
+        :_name => self.class.name,
+        :attributes => self.attributes,
+        :errors => self.errors.full_messages.to_sentence
+      }
+      RulesIO.send_event event
+    end
+  end
+end

data/lib/rulesio/exceptions.rb

@@ -0,0 +1,79 @@
+# With inspiration from
+#   https://github.com/smartinez87/exception_notification
+#   http://sharagoz.com/posts/1-rolling-your-own-exception-handler-in-rails-3
+
+require 'action_dispatch'
+
+module RulesIO
+  class Exceptions
+    include RulesIO::Helpers
+
+    def self.default_ignored_exceptions
+      [].tap do |exceptions|
+        exceptions << 'ActiveRecord::RecordNotFound'
+        exceptions << 'AbstractController::ActionNotFound'
+        exceptions << 'ActionController::RoutingError'
+      end
+    end
+
+    def initialize(app, options={})
+      @app, @options = app, options
+      @options[:ignore_exceptions] ||= self.class.default_ignored_exceptions
+      @options[:ignore_crawlers]   ||= RulesIO.default_ignored_crawlers
+      @options[:ignore_if]         ||= lambda { |env, e| false }
+      @options[:token]             ||= RulesIO.token
+      @options[:custom_data]       ||= lambda { |env| {} }
+    end
+
+    def call(env)
+      begin
+        @app.call(env)
+      rescue Exception => exception
+        env['rulesio.exception'] = exception
+        send_event_now event(env, exception), @options[:token], env unless should_be_ignored(env, exception)
+        raise exception
+      end
+    end
+
+  private
+    def send_event_now(event, token, env)
+      prep = RulesIO.prepare_event(event, env)
+      RulesIO.post_payload_to_token prep, token
+    end
+
+    def should_be_ignored(env, exception)
+      ignored_exception(@options[:ignore_exceptions], exception)       ||
+      from_crawler(@options[:ignore_crawlers], env['HTTP_USER_AGENT']) ||
+      conditionally_ignored(@options[:ignore_if], env, exception)
+    end
+
+    def ignored_exception(ignore_array, exception)
+      Array.wrap(ignore_array).map(&:to_s).include?(exception.class.name)
+    end
+
+    def conditionally_ignored(ignore_proc, env, exception)
+      ignore_proc.call(env, exception)
+    rescue Exception => ex
+      false
+    end
+
+    def event(env, exception)
+      backtrace = clean_backtrace(exception)
+      event = {
+        :_actor => actor_for_exception(exception),
+        :_from => '',
+        :_domain => exception.class.to_s,
+        :_name => fileline(exception),
+        :_message => exception.to_s,
+        :exception => exception.class.to_s,
+        :file => fileline(exception),
+        :backtrace => backtrace.join("\n")
+      }.with_indifferent_access
+      useractor = RulesIO.current_actor(env)
+      event[:_xactor] = useractor if useractor
+      event.merge!(@options[:custom_data].call(env))
+      event
+    end
+
+  end
+end

data/lib/rulesio/girl_friday_queue.rb

@@ -0,0 +1,34 @@
+require 'singleton'
+require 'girl_friday'
+
+module RulesIO
+  class GirlFridayQueue < GirlFriday::WorkQueue
+
+    include Singleton
+  
+    def initialize
+      super(:rulesio, {:size => 1}.merge(RulesIO.queue_options)) do |msg|
+        retries = 0
+        begin
+          RulesIO.post_payload_to_token msg[:payload], RulesIO.token
+        rescue Exception => e
+          if (retries += 1) % 6 == 5
+            RulesIO.logger.warn "RulesIO having trouble sending events; #{retries} attempts so far."
+          end
+          sleep [5, retries].max
+          retry
+        end
+        RulesIO.logger.warn "RulesIO resuming service after #{retries} retries." unless retries == 0
+      end
+    end
+
+    def self.push *args
+      instance.push *args
+    end
+
+    def self.status
+      instance.status
+    end
+
+  end
+end

data/lib/rulesio/helpers.rb

@@ -0,0 +1,27 @@
+module RulesIO
+  module Helpers
+    def from_crawler(ignore_array, agent)
+      ignore_array.each do |crawler|
+        return true if (agent =~ /\b(#{crawler})\b/i)
+      end unless ignore_array.blank?
+      false
+    end
+
+    def clean_backtrace(exception)
+      if defined?(Rails) && Rails.respond_to?(:backtrace_cleaner)
+        Rails.backtrace_cleaner.send(:filter, exception.backtrace)
+      else
+        exception.backtrace
+      end
+    end
+
+    def fileline(exception)
+      fl = clean_backtrace(exception).first.match(/^(.*:.*):/)[1] rescue @app.to_s
+      fl.gsub(/ \((.*)\) /, '-\1-')
+    end
+
+    def actor_for_exception(exception)
+      "#{exception.class.to_s}:#{fileline(exception)}"
+    end
+  end
+end

data/lib/rulesio/memory_queue.rb

@@ -0,0 +1,11 @@
+require 'girl_friday'
+
+module RulesIO
+  class MemoryQueue
+
+    def self.push(hash)
+      RulesIO.post_payload_to_token hash[:payload], RulesIO.token
+    end
+
+  end
+end

data/lib/rulesio/railtie.rb

@@ -0,0 +1,97 @@
+require 'rails/railtie'
+require 'active_record'
+
+module RulesIO
+  class RailsConfigurator
+    attr_accessor :token, :webhook_url, :middlewares, :queue, :controller_data, :queue_options
+    def initialize
+      @webhook_url = 'http://www.rules.io/events/'
+      @middlewares = {}
+    end
+
+    def token(token)
+      @token = token
+    end
+
+    def webhook_url(webhook_url)
+      @webhook_url = webhook_url
+    end
+
+    def middleware(middleware, &block)
+      @middlewares[middleware] = MiddlewareConfigurator.apply(&block)
+    end
+    
+    def queue(queue, options)
+      @queue = queue
+      @queue_options = options
+    end
+
+    def controller_data(data)
+      @controller_data = data
+    end
+
+    def girl_friday_options(options)
+      @girl_friday_options = options
+    end
+  end
+
+  class MiddlewareConfigurator
+    attr_accessor :configuration
+
+    def self.apply(&block)
+      x = new
+      x.configure(&block) if block_given?
+      x
+    end
+
+    def initialize
+      @configuration = {}
+    end
+
+    def configure(&block)
+      instance_eval &block
+    end
+
+    def method_missing(mid, *args, &block)
+      mname = mid.id2name
+      if block_given?
+        @configuration[mname.to_sym] = *block
+      else
+        if args.size == 1
+          @configuration[mname.to_sym] = args.first
+        else
+          @configuration[mname.to_sym] = args
+        end
+      end
+    end
+  end
+
+  class Railtie < Rails::Railtie
+    initializer :rulesio do |app|
+      filename = Rails.root.join('config/rulesio.rb')
+      if File.exists?(filename)
+        RulesIO::RailsConfigurator.new.instance_eval do
+          eval IO.read(filename), binding, filename.to_s, 1
+          if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
+            ::Rails.configuration.middleware.insert_after 'ActionDispatch::Static', 'RulesIO::Rack',
+                :webhook_url => @webhook_url,
+                :token => @token,
+                :queue => @queue,
+                :queue_options => @queue_options,
+                :controller_data => @controller_data
+            ::Rails.configuration.middleware.use('RulesIO::Users', @middlewares[:users].configuration) if @middlewares.has_key?(:users)
+            ::Rails.configuration.middleware.use('RulesIO::Users', @middlewares[:pageviews].configuration) if @middlewares.has_key?(:pageviews)
+            ::Rails.configuration.middleware.use('RulesIO::Exceptions', @middlewares[:exceptions].configuration) if @middlewares.has_key?(:exceptions)
+          end
+        end
+      end
+    end
+
+    config.after_initialize do
+      ActiveSupport.on_load(:active_record) do
+        require 'rulesio/active_record_extension'
+        include ActiveRecord::RulesIOExtension
+      end
+    end
+  end
+end

data/lib/rulesio/users.rb

@@ -0,0 +1,67 @@
+# With inspiration from
+#   https://github.com/smartinez87/exception_notification
+#   http://sharagoz.com/posts/1-rolling-your-own-exception-handler-in-rails-3
+
+require 'action_dispatch'
+
+module RulesIO
+  class Users
+    include RulesIO::Helpers
+
+    def initialize(app, options={})
+      @app, @options = app, options
+      @options[:ignore_crawlers]      ||= RulesIO.default_ignored_crawlers
+      @options[:ignore_if]            ||= lambda { |env| false }
+      @options[:ignore_if_controller] ||= 'false'
+      @options[:custom_data]          ||= lambda { |env| {} }
+    end
+
+    def call(env)
+      before = Time.now
+      status, headers, response = @app.call(env)
+      [status, headers, response]
+    rescue Exception => e
+      status = 500
+      raise e
+    ensure
+      after = Time.now
+      RulesIO.send_event event(env, status, after - before) unless should_be_ignored(env)
+    end
+
+  private
+    def rails_asset_request?(env)
+      defined?(Rails) && env['action_controller.instance'].nil?
+    end
+
+    def should_be_ignored(env)
+      rails_asset_request?(env) ||
+      from_crawler(@options[:ignore_crawlers], env['HTTP_USER_AGENT']) ||
+      conditionally_ignored(@options[:ignore_if], env) ||
+      conditionally_ignored_controller(@options[:ignore_if_controller], env)
+    end
+
+    def conditionally_ignored_controller(condition, env)
+      controller = env['action_controller.instance']
+      controller.instance_eval condition
+    end
+
+    def conditionally_ignored(ignore_proc, env)
+      ignore_proc.call(env)
+    end
+
+    def event(env, status, duration)
+      event = {
+        :_domain => (status.to_i >= 400) ? 'pageerror' : 'pageview',
+        :status => status,
+        :duration => "%.2f" % (duration * 1000)
+      }
+      if exception = env['rulesio.exception']
+        event[:_xactor] = actor_for_exception(exception)
+        event[:_message] = exception.to_s
+      end
+      event.merge!(@options[:custom_data].call(env))
+      event
+    end
+
+  end
+end

data/lib/rulesio/version.rb

@@ -0,0 +1,3 @@
+module RulesIO
+  VERSION = '0.9.2'
+end

data/lib/rulesio.rb

@@ -0,0 +1,137 @@
+require 'rulesio/version'
+require 'rulesio/helpers'
+require 'rulesio/exceptions'
+require 'rulesio/users'
+require 'rulesio/girl_friday_queue'
+require 'rulesio/memory_queue'
+require 'net/http'
+require 'uri'
+require 'logger'
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module RulesIO
+  mattr_accessor :filter_parameters, :buffer, :token, :webhook_url, :queue, :queue_options, :controller_data, :logger
+
+  def self.default_ignored_crawlers
+    %w(Baidu Gigabot Googlebot libwww-perl lwp-trivial msnbot SiteUptime Slurp WordPress ZIBB ZyBorg Yandex Jyxobot Huaweisymantecspider ApptusBot NewRelicPinger)
+  end
+
+  def self.send_event(event)
+    buffer << event
+  end
+
+  def self.flush(env={})
+    return if (events = RulesIO.buffer).empty?
+    RulesIO.buffer = []
+    RulesIO.queue.push(:payload => events.map {|event| RulesIO.prepare_event(event, env)})
+    # RulesIO.post_payload_to_token events.to_json, RulesIO.token
+  end
+  
+  def self.post_payload_to_token(payload, token)
+    uri = URI(RulesIO.webhook_url + token)
+    req = Net::HTTP::Post.new(uri.path)
+    req.body = payload.to_json
+    req.content_type = 'application/json'
+    Net::HTTP.start(uri.host, uri.port) do |http|
+      http.request(req)
+    end
+  end
+
+  def self.current_user(env)
+    if controller = env['action_controller.instance']
+      controller.instance_variable_get('@current_user') || controller.instance_eval('current_user')
+    end
+  rescue
+    nil
+  end
+  
+  def self.current_actor(env)
+    if controller = env['action_controller.instance']
+      begin
+        data = controller.instance_eval(RulesIO.controller_data)
+        data = data.with_indifferent_access
+        return data[:_actor] if data[:_actor]
+      rescue
+      end
+
+      user = controller.instance_variable_get('@current_user') || controller.instance_eval('current_user')
+      [:to_param, :id].each do |method|
+        return user.send(method) if user && user.respond_to?(method)
+      end
+    end
+    nil
+  end
+
+  private
+  def self.page_event_name(request, params)
+    if params && params['controller']
+      "#{params['controller']}##{params['action']}"
+    else
+      request.path.gsub('/', '-')[1..-1]
+    end
+  end
+
+  def self.prepare_event(event, env)
+    event = event.with_indifferent_access
+
+    if controller = env['action_controller.instance']
+      begin
+        data = controller.instance_eval(RulesIO.controller_data).with_indifferent_access
+        event = data.merge(event)
+      rescue
+      end
+    end
+
+    current_user = current_user(env)
+    actor = current_actor(env)
+
+    event[:_actor] = actor || 'anonymous' unless event[:_actor].present?
+    event[:_timestamp] ||= Time.now.to_f
+    event[:rails_env] = Rails.env if defined?(Rails)
+
+    unless env.empty?
+      env['rack.input'].rewind
+      request = defined?(Rails) ? ActionDispatch::Request.new(env) : ::Rack::Request.new(env)
+      params = request.params
+      action = page_event_name(request, params)
+      
+      event[:_name] ||= action
+      event[:_from] ||= current_user.email if current_user && current_user.respond_to?(:email) && current_user.email != event[:_actor]
+      event[:action] = action
+      event[:request_url] = env['rulesio.request_url']
+      event[:request_method] = request.request_method
+      event[:user_agent] = request.user_agent
+      event[:referer_url] = request.referer
+      event[:params] = params.except(*RulesIO.filter_parameters)
+      event[:session] = request.session
+    end
+
+    event.reject! {|k, v| v.to_s.blank?}
+    event
+  end
+
+  class Rack
+    def initialize(app, options={})
+      @app = app
+      RulesIO.logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+      RulesIO.webhook_url = options[:webhook_url] || 'http://www.rules.io/events/'
+      RulesIO.buffer = []
+      RulesIO.filter_parameters = defined?(Rails) ? Rails.application.config.filter_parameters : []
+      RulesIO.token = options[:token]
+      RulesIO.queue = options[:queue] || RulesIO::MemoryQueue
+      RulesIO.queue_options = options[:queue_options] || {}
+      RulesIO.controller_data = options[:controller_data] || '{}'
+    end
+
+    def call(env)
+      RulesIO.buffer = []
+      env['rulesio.request_url'] = ::Rack::Request.new(env).url
+      @app.call(env)
+    ensure
+      RulesIO.flush(env)
+    end
+  end
+end
+
+require 'rulesio/railtie' if defined?(Rails)

data/rulesio.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'rulesio/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'rulesio'
+  s.version     = RulesIO::VERSION
+  s.authors     = ['David Anderson', 'Chris Weis']
+  s.email       = ['david@alpinegizmo.com']
+  s.homepage    = 'https://github.com/rulesio/rulesio'
+  s.summary     = %q{Rack middleware for connecting to rules.io}
+  s.description = %q{Rack middleware for connecting Rack applications to rules.io, with extensions for Rails 3 applications.}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency 'activesupport'
+  s.add_runtime_dependency 'actionpack'
+  s.add_runtime_dependency 'girl_friday', '~> 0.10.0'
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: rulesio
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 9
+  - 2
+  version: 0.9.2
+platform: ruby
+authors: 
+- David Anderson
+- Chris Weis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-08-28 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: actionpack
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: girl_friday
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 10
+        - 0
+        version: 0.10.0
+  type: :runtime
+  version_requirements: *id003
+description: Rack middleware for connecting Rack applications to rules.io, with extensions for Rails 3 applications.
+email: 
+- david@alpinegizmo.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/rulesio.rb
+- lib/rulesio/active_record_extension.rb
+- lib/rulesio/exceptions.rb
+- lib/rulesio/girl_friday_queue.rb
+- lib/rulesio/helpers.rb
+- lib/rulesio/memory_queue.rb
+- lib/rulesio/railtie.rb
+- lib/rulesio/users.rb
+- lib/rulesio/version.rb
+- rulesio.gemspec
+has_rdoc: true
+homepage: https://github.com/rulesio/rulesio
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Rack middleware for connecting to rules.io
+test_files: []
+