rulesio 0.9.10 → 0.10.0

data/lib/rulesio/base.rb

@@ -0,0 +1,33 @@
+module RulesIO
+  class Base
+    # include Singleton
+    attr_accessor :token, :buffer
+
+    def initialize(token)
+      RulesIO.instance = self
+      puts "INSTANCE SET"
+      @token = token
+      @buffer = []
+    end
+
+    def send_event(event)
+      @buffer << prepare_event(event)
+    end
+    
+    def flush
+      return if (events = @buffer).empty?
+      @buffer = []
+      RulesIO.queue.push(:payload => events, :token => @token)
+    end
+
+  private
+    def prepare_event(event)
+      event = event.with_indifferent_access
+
+      event[:_actor] = event[:_actor].to_s
+      event[:_timestamp] ||= Time.now.to_f
+
+      event
+    end
+  end
+end

data/lib/rulesio/exceptions.rb

@@ -3,9 +3,10 @@
 #   http://sharagoz.com/posts/1-rolling-your-own-exception-handler-in-rails-3
 
 require 'action_dispatch'
+require 'rulesio/users'
 
 module RulesIO
-  class Exceptions
+  class Exceptions < RulesIO::Users
     include RulesIO::Helpers
 
     def self.default_ignored_exceptions
@@ -19,7 +20,7 @@ module RulesIO
     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_crawlers]   ||= default_ignored_crawlers
       @options[:ignore_if]         ||= lambda { |env, e| false }
       @options[:token]             ||= RulesIO.token
       @options[:custom_data]       ||= lambda { |env| {} }
@@ -30,17 +31,18 @@ module RulesIO
         @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)
+        send_event event(env, exception), 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
+    
+    def send_event(event, env)
+      prep = prepare_event(event, env)
+      RulesIO.post_payload_to_token prep, @options[:token]
     end
 
+
+  private
     def should_be_ignored(env, exception)
       ignored_exception(@options[:ignore_exceptions], exception)       ||
       from_crawler(@options[:ignore_crawlers], env['HTTP_USER_AGENT']) ||
@@ -69,7 +71,7 @@ module RulesIO
         :file => fileline(exception),
         :backtrace => backtrace.join("\n")
       }.with_indifferent_access
-      useractor = RulesIO.current_actor(env)
+      useractor = current_actor(env)
       event[:_xactor] = useractor if useractor
       event.merge!(@options[:custom_data].call(env))
       event

data/lib/rulesio/girl_friday_queue.rb

@@ -10,7 +10,7 @@ module RulesIO
       super(:rulesio, {:size => 1}.merge(RulesIO.queue_options)) do |msg|
         retries = 0
         begin
-          RulesIO.post_payload_to_token msg[:payload], RulesIO.token
+          RulesIO.post_payload_to_token msg[:payload], msg[:token]
         rescue Exception => e
           if (retries += 1) % 6 == 5
             RulesIO.logger.warn "RulesIO having trouble sending events; #{retries} attempts so far."

data/lib/rulesio/memory_queue.rb

@@ -4,7 +4,7 @@ module RulesIO
   class MemoryQueue
 
     def self.push(hash)
-      RulesIO.post_payload_to_token hash[:payload], RulesIO.token
+      RulesIO.post_payload_to_token hash[:payload], hash[:token]
     end
 
   end

data/lib/rulesio/rack.rb

@@ -0,0 +1,115 @@
+module RulesIO
+  class Rack < Base
+    attr_accessor :filter_parameters, :controller_data, :config_options
+    
+    #cattr_accessor :config_options
+    @@config_options = {}
+    
+    def self.config_options
+      @@config_options
+    end
+    
+    def self.config_options=(opts)
+      @@config_options = opts
+    end
+    
+    def default_ignored_crawlers
+      %w(Baidu Gigabot Googlebot libwww-perl lwp-trivial msnbot SiteUptime Slurp WordPress ZIBB ZyBorg Yandex Jyxobot Huaweisymantecspider ApptusBot NewRelicPinger CopperEgg Pingdom UptimeRobot)
+    end
+    
+    def initialize(app, options={})
+      self.class.config_options = @config_options = (options || {})
+      RulesIO.instance = self
+      @app = app
+      @buffer = []
+      @filter_parameters ||= defined?(Rails) ? Rails.application.config.filter_parameters : []
+      @token = options[:token]
+      @controller_data = options[:controller_data] || '{}'
+    end
+
+    def call(env)
+      @buffer = []
+      request = ::Rack::Request.new(env)
+      env['rulesio.request_url'] = request.url
+      env['rulesio.request_method'] = request.request_method
+      @app.call(env)
+    ensure
+      flush(env)
+    end
+    
+    def send_event(event)
+      @buffer << event
+    end
+    
+    def flush(env={})
+      return if (events = @buffer).empty?
+      @buffer = []
+      RulesIO.queue.push(:token => @token, :payload => events.map {|event| prepare_event(event, env)})
+    end
+  
+  private
+    def prepare_event(event, env)
+      event = event.with_indifferent_access
+
+      current_user = current_user(env) rescue nil
+      actor = current_actor(env) rescue nil
+
+      if controller = env['action_controller.instance']
+        begin
+          data = if RulesIO.controller_data.is_a?(String)
+            controller.instance_eval(RulesIO.controller_data)
+          elsif RulesIO.controller_data.is_a?(Proc) && !RulesIO.controller_data.lambda?
+            controller.instance_eval(&RulesIO.controller_data)
+          else
+            {}
+          end
+          event = data.with_indifferent_access.merge(event)
+        rescue Exception => e
+          RulesIO.logger.warn "RulesIO having trouble with controller_data: #{e}"
+        end
+      end
+
+      event[:_actor] = actor || 'anonymous' unless event[:_actor].present?
+      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[:_domain] = 'JSON' if event[:_domain] == 'pageview' && params['format'] == 'json'
+        event[:_domain] = 'XML' if event[:_domain] == 'pageview' && params['format'] == 'xml'
+        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] = env['rulesio.request_method']
+        event[:user_agent] = request.user_agent
+        event[:referer_url] = request.referer
+        event[:session] = request.session
+        parameter_filter = ::ActionDispatch::Http::ParameterFilter.new(filter_parameters)
+        event[:params] = parameter_filter.filter(params)
+      end
+
+      event.reject! {|k, v| v.to_s.blank?}
+      event
+    end
+
+    def 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 page_event_name(request, params)
+      if params && params['controller']
+        "#{params['controller']}##{params['action']}"
+      else
+        request.path.gsub('/', '-')[1..-1]
+      end
+    end
+  end
+end

data/lib/rulesio/railtie.rb

@@ -19,7 +19,7 @@ module RulesIO
     end
 
     def middleware(middleware, &block)
-      @middlewares[middleware] = MiddlewareConfigurator.apply(&block)
+      @middlewares[middleware] = MiddlewareConfigurator.apply(self, &block)
     end
     
     def queue(queue, options)
@@ -38,13 +38,25 @@ module RulesIO
     def girl_friday_options(options)
       @girl_friday_options = options
     end
+    
+    def configuration
+      {
+        :webhook_url => @webhook_url,
+        :disable_sending_events => @disable,
+        :token => @token,
+        :queue => @queue,
+        :queue_options => @queue_options,
+        :controller_data => @controller_data
+      }
+    end
   end
 
   class MiddlewareConfigurator
-    attr_accessor :configuration
+    attr_accessor :configuration, :root
 
-    def self.apply(&block)
+    def self.apply(root, &block)
       x = new
+      x.root = root
       x.configure(&block) if block_given?
       x
     end
@@ -77,17 +89,16 @@ module RulesIO
       if File.exists?(filename)
         RulesIO::RailsConfigurator.new.instance_eval do
           eval IO.read(filename), binding, filename.to_s, 1
+          RulesIO.logger = Rails.logger
+          RulesIO.webhook_url = @webhook_url || 'https://www.rules.io/events/'
+          RulesIO.queue = @queue || RulesIO::MemoryQueue
+          RulesIO.queue_options = @queue_options || {}
+          RulesIO.disable_sending_events = @disable_sending_events || false
           if defined?(::Rails.configuration) && ::Rails.configuration.respond_to?(:middleware)
-            ::Rails.configuration.middleware.insert 0, 'RulesIO::Rack',
-                :webhook_url => @webhook_url,
-                :disable_sending_events => @disable,
-                :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)
+            ::Rails.configuration.middleware.insert 0, 'RulesIO::Rack', configuration
+            ::Rails.configuration.middleware.use('RulesIO::Users', configuration.merge(@middlewares[:users].configuration)) if @middlewares.has_key?(:users)
+            ::Rails.configuration.middleware.use('RulesIO::Users', configuration.merge(@middlewares[:pageviews].configuration)) if @middlewares.has_key?(:pageviews)
+            ::Rails.configuration.middleware.use('RulesIO::Exceptions', configuration.merge(@middlewares[:exceptions].configuration)) if @middlewares.has_key?(:exceptions)
           end
         end
       else

data/lib/rulesio/users.rb

@@ -1,12 +1,12 @@
 require 'action_dispatch'
 
 module RulesIO
-  class Users
-    include RulesIO::Helpers
-
+  class Users < RulesIO::Rack
+    include Helpers
     def initialize(app, options={})
-      @app, @options = app, options
-      @options[:ignore_crawlers]      ||= RulesIO.default_ignored_crawlers
+      @app, @options = app, RulesIO::Rack.config_options.merge(options)
+      super(@app, @options)
+      @options[:ignore_crawlers]      ||= default_ignored_crawlers
       @options[:ignore_if]            ||= Proc.new { |env| false }
       @options[:ignore_if_controller] ||= 'false'
       @options[:custom_data]          ||= Proc.new { |env| {} }
@@ -73,5 +73,34 @@ module RulesIO
       event
     end
 
+    def current_actor(env)
+      if controller = env['action_controller.instance']
+        begin
+          data = if @controller_data.is_a?(String)
+            controller.instance_eval(@controller_data)
+          elsif @controller_data.is_a?(Proc) && !@controller_data.lambda?
+            controller.instance_eval(&@controller_data)
+          else
+            {}
+          end
+          data = data.with_indifferent_access
+          return data[:_actor] if data[:_actor]
+        rescue Exception => e
+          puts e.message
+          puts e.backtrace.join("\n")
+        end
+
+        begin
+          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
+        rescue Exception => e
+          puts e.message
+          puts e.backtrace.join("\n")
+        end
+      end
+      nil
+    end
   end
 end

data/lib/rulesio/version.rb

@@ -1,3 +1,3 @@
 module RulesIO
-  VERSION = '0.9.10'
+  VERSION = '0.10.0'
 end

data/lib/rulesio.rb

@@ -1,7 +1,9 @@
 require 'rulesio/version'
 require 'rulesio/helpers'
-require 'rulesio/exceptions'
+require 'rulesio/base'
+require 'rulesio/rack'
 require 'rulesio/users'
+require 'rulesio/exceptions'
 require 'rulesio/girl_friday_queue'
 require 'rulesio/memory_queue'
 require 'net/http'
@@ -12,21 +14,16 @@ require 'active_support/core_ext/hash/indifferent_access'
 require 'action_dispatch/http/parameter_filter'
 
 module RulesIO
-  mattr_accessor :filter_parameters, :buffer, :token, :webhook_url, :queue, :queue_options, :controller_data, :logger, :disable_sending_events
-
-  def self.default_ignored_crawlers
-    %w(Baidu Gigabot Googlebot libwww-perl lwp-trivial msnbot SiteUptime Slurp WordPress ZIBB ZyBorg Yandex Jyxobot Huaweisymantecspider ApptusBot NewRelicPinger CopperEgg Pingdom UptimeRobot)
-  end
+  mattr_accessor :webhook_url, :queue, :queue_options, :logger, :disable_sending_events, :instance
 
-  def self.send_event(event)
-    buffer << event
+  @logger = Logger.new(STDOUT)
+  
+  def self.send_event(*args)
+    instance.send_event(*args)
   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
+  
+  def self.flush
+    instance.flush
   end
   
   def self.post_payload_to_token(payload, token)
@@ -41,127 +38,6 @@ module RulesIO
       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 = if RulesIO.controller_data.is_a?(String)
-          controller.instance_eval(RulesIO.controller_data)
-        elsif RulesIO.controller_data.is_a?(Proc) && !RulesIO.controller_data.lambda?
-          controller.instance_eval(&RulesIO.controller_data)
-        else
-          {}
-        end
-        data = data.with_indifferent_access
-        return data[:_actor] if data[:_actor]
-      rescue Exception => e
-        puts e.message
-        puts e.backtrace.join("\n")
-      end
-
-      begin
-        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
-      rescue Exception => e
-        puts e.message
-        puts e.backtrace.join("\n")
-      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
-
-    current_user = current_user(env)
-    actor = current_actor(env)
-
-    if controller = env['action_controller.instance']
-      begin
-        data = if RulesIO.controller_data.is_a?(String)
-          controller.instance_eval(RulesIO.controller_data)
-        elsif RulesIO.controller_data.is_a?(Proc) && !RulesIO.controller_data.lambda?
-          controller.instance_eval(&RulesIO.controller_data)
-        else
-          {}
-        end
-        event = data.with_indifferent_access.merge(event)
-      rescue Exception => e
-        RulesIO.logger.warn "RulesIO having trouble with controller_data: #{e}"
-      end
-    end
-
-    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[:_domain] = 'JSON' if event[:_domain] == 'pageview' && params['format'] == 'json'
-      event[:_domain] = 'XML' if event[:_domain] == 'pageview' && params['format'] == 'xml'
-      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] = env['rulesio.request_method']
-      event[:user_agent] = request.user_agent
-      event[:referer_url] = request.referer
-      event[:session] = request.session
-      parameter_filter = ::ActionDispatch::Http::ParameterFilter.new(RulesIO.filter_parameters)
-      event[:params] = parameter_filter.filter(params)
-    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] || 'https://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] || '{}'
-      RulesIO.disable_sending_events = options[:disable_sending_events] || false
-    end
-
-    def call(env)
-      RulesIO.buffer = []
-      request = ::Rack::Request.new(env)
-      env['rulesio.request_url'] = request.url
-      env['rulesio.request_method'] = request.request_method
-      @app.call(env)
-    ensure
-      RulesIO.flush(env)
-    end
-  end
 end
 
 require 'rulesio/railtie' if defined?(Rails)

data/test/test_configuration.rb

@@ -5,7 +5,7 @@ require "rulesio/girl_friday_queue"
 MockController = Class.new
 
 class TestConfiguration < Test::Unit::TestCase
-  REDIS = Object.new
+  REDIS = APP = Object.new
 
   STRING_CONFIGURATION = <<-CONFIG
   token 'FOOF'
@@ -30,23 +30,23 @@ class TestConfiguration < Test::Unit::TestCase
   PROC_CONFIGURATION = <<-CONFIG
   token 'FOOF'
   queue RulesIO::GirlFridayQueue, :store => GirlFriday::Store::Redis, :store_config => { :pool => TestConfiguration::REDIS }
-  controller_data Proc.new { {:_actor => self.current_user.try(:email) || 'anonymous'} }
+  controller_data proc { {:_actor => self.current_user.try(:email) || 'anonymous'} }
 
   middleware :users do
-    ignore_if_controller Proc.new { self.is_a?(MockController) && ["create", "recent"].include?(params[:action]) }
+    ignore_if_controller proc { self.is_a?(MockController) && ["create", "recent"].include?(params[:action]) }
   end
   CONFIG
 
   setup do
-    Rails.expects(:logger)
-    Rails.expects(:application).returns(mock(:config => mock(:filter_parameters => [])))
+    Rails.stubs(:logger)
+    Rails.stubs(:application).returns(stub(:config => stub(:filter_parameters => [])))
     @rc = RulesIO::RailsConfigurator.new
   end
   
   test "general configuration works" do
-    user_middleware = @rc.instance_eval do
+    rack_middleware, user_middleware = @rc.instance_eval do
       eval TestConfiguration::STRING_CONFIGURATION, binding, __FILE__, __LINE__
-      RulesIO::Rack.new(Object.new,
+      a = RulesIO::Rack.new(APP,
         :webhook_url => @webhook_url,
         :disable_sending_events => @disable,
         :token => @token,
@@ -54,18 +54,18 @@ class TestConfiguration < Test::Unit::TestCase
         :queue_options => @queue_options,
         :controller_data => @controller_data
       )
-      RulesIO::Users.new(Object.new, @middlewares[:users].configuration)
+      b = RulesIO::Users.new(APP, @middlewares[:users].configuration)
+      [a,b]
     end
     assert_not_nil @rc.middlewares
-    assert_equal 'FOOF', RulesIO.token
-    assert_equal RulesIO::GirlFridayQueue, RulesIO.queue
+    assert_equal 'FOOF', rack_middleware.token
     assert_equal 'self.is_a?(MockController) && ["create", "recent"].include?(params[:action])', user_middleware.instance_variable_get(:@options)[:ignore_if_controller]
   end
   
   test "configuring blocks as strings works" do
-    user_middleware = @rc.instance_eval do
+    rack_middleware, user_middleware = @rc.instance_eval do
       eval TestConfiguration::STRING_CONFIGURATION, binding, __FILE__, __LINE__
-      RulesIO::Rack.new(Object.new,
+      a = RulesIO::Rack.new(APP,
         :webhook_url => @webhook_url,
         :disable_sending_events => @disable,
         :token => @token,
@@ -73,7 +73,8 @@ class TestConfiguration < Test::Unit::TestCase
         :queue_options => @queue_options,
         :controller_data => @controller_data
       )
-      RulesIO::Users.new(Object.new, @middlewares[:users].configuration)
+      b = RulesIO::Users.new(APP, @middlewares[:users].configuration)
+      [a,b]
     end
     
     assert @rc.middlewares[:users].configuration[:ignore_if_controller].is_a? String
@@ -83,14 +84,14 @@ class TestConfiguration < Test::Unit::TestCase
     stub_controller_instance = stub(:current_user => stub(:email => 'email@example.com'), :params => {:action => 'update'})
     stub_controller_instance.expects(:is_a?).with(MockController).returns(true)
     env = {'action_controller.instance' => stub_controller_instance}
-    assert_equal 'email@example.com', RulesIO.current_actor(env)
+    assert_equal 'email@example.com', user_middleware.send(:current_actor, env)
     assert_equal false, user_middleware.send(:should_be_ignored, env)
   end
   
   test "configuring blocks as lambdas DOES NOT work" do
-    user_middleware = @rc.instance_eval do
+    rack_middleware, user_middleware = @rc.instance_eval do
       eval TestConfiguration::BLOCK_CONFIGURATION
-      RulesIO::Rack.new(Object.new,
+      a = RulesIO::Rack.new(APP,
         :webhook_url => @webhook_url,
         :disable_sending_events => @disable,
         :token => @token,
@@ -98,7 +99,8 @@ class TestConfiguration < Test::Unit::TestCase
         :queue_options => @queue_options,
         :controller_data => @controller_data
       )
-      RulesIO::Users.new(Object.new, @middlewares[:users].configuration)
+      b = RulesIO::Users.new(APP, @middlewares[:users].configuration)
+      [a,b]
     end
     
     assert @rc.middlewares[:users].configuration[:ignore_if_controller].is_a? Proc
@@ -111,14 +113,14 @@ class TestConfiguration < Test::Unit::TestCase
     stub_controller_instance.expects(:is_a?).never
     env = {'action_controller.instance' => stub_controller_instance}
     # returns nil, because lambda doesn't work right with instance_eval
-    assert_equal nil, RulesIO.current_actor(env)
+    assert_equal nil, user_middleware.send(:current_actor, env)
     assert_equal false, user_middleware.send(:should_be_ignored, env)
   end
   
   test "configuring blocks as Procs works" do
     user_middleware = @rc.instance_eval do
       eval TestConfiguration::PROC_CONFIGURATION, binding, __FILE__, __LINE__
-      RulesIO::Rack.new(Object.new,
+      RulesIO::Rack.new(APP,
         :webhook_url => @webhook_url,
         :disable_sending_events => @disable,
         :token => @token,
@@ -126,7 +128,7 @@ class TestConfiguration < Test::Unit::TestCase
         :queue_options => @queue_options,
         :controller_data => @controller_data
       )
-      RulesIO::Users.new(Object.new, @middlewares[:users].configuration)
+      RulesIO::Users.new(APP, @middlewares[:users].configuration)
     end
     
     assert @rc.middlewares[:users].configuration[:ignore_if_controller].is_a? Proc
@@ -137,7 +139,7 @@ class TestConfiguration < Test::Unit::TestCase
     stub_controller_instance = stub(:current_user => stub(:email => 'email@example.com'), :params => {:action => 'update'})
     stub_controller_instance.expects(:is_a?).with(MockController).returns(true)
     env = {'action_controller.instance' => stub_controller_instance}
-    assert_equal 'email@example.com', RulesIO.current_actor(env)
+    assert_equal 'email@example.com', user_middleware.send(:current_actor, env)
     assert_equal false, user_middleware.send(:should_be_ignored, env)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rulesio
 version: !ruby/object:Gem::Version
-  version: 0.9.10
+  version: 0.10.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-07 00:00:00.000000000 Z
+date: 2013-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -155,10 +155,12 @@ files:
 - Rakefile
 - lib/rulesio.rb
 - lib/rulesio/active_record_extension.rb
+- lib/rulesio/base.rb
 - lib/rulesio/exceptions.rb
 - lib/rulesio/girl_friday_queue.rb
 - lib/rulesio/helpers.rb
 - lib/rulesio/memory_queue.rb
+- lib/rulesio/rack.rb
 - lib/rulesio/railtie.rb
 - lib/rulesio/users.rb
 - lib/rulesio/version.rb