meddler 0.0.1 → 0.0.2

data/README.rdoc

@@ -9,14 +9,16 @@ This lets you have on_request and on_response wrappers around a builder, and opt
 In your rackup file, do this:
 
   require 'meddler'
-  use Meddler::Builder, :on_request => proc{|req| req.post?} do
+  use Meddler::Builder do
+    on_request {|req| req.post?}
     use MungePostMiddleware
   end
 
 Or, on response
 
   require 'meddler'
-  use Meddler::Builder, :on_response => proc{|resp| resp.status == 200} do
+  use Meddler::Builder do
+    on_response {|resp| resp.status == 200}
     use MiddlewareThatLikesOkThings
   end
 

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/lib/meddler/builder.rb

@@ -3,10 +3,35 @@ class Meddler
 
     def initialize(app, rules = nil, &block)
       @app = app
-      @target = Rack::Builder.new(&block)
-      @meddler = Meddler.new(@app, rules && rules[:on_request], rules && rules[:on_response], @target)
+      @target = Rack::Builder.new{}
+      instance_eval(&block)
+      @meddler = Meddler.new(@app, @on_request, @on_response, @before, @after, @target)
     end
-
+    
+    def method_missing(method, *args, &block)
+      @target.send(method, *args, &block)
+    end
+    
+    def on_request(&block)
+      @on_request ||= []
+      @on_request << block
+    end
+      
+    def on_response(&block)
+      @on_response ||= []
+      @on_response << block
+    end
+      
+    def before(&block)
+      @before ||= []
+      @before << block
+    end
+    
+    def after(&block)
+      @after ||= []
+      @after << block
+    end
+    
     def call(env)
       @meddler.call(env)
     end

data/lib/meddler.rb

@@ -5,13 +5,17 @@ require 'meddler/builder'
 
 class Meddler
 
-  def initialize(app, before_rule, after_rule, wrapped_app)
-    wrapped_app.run(PostInterceptor.new(app, after_rule))
-    @app = PreInterceptor.new(wrapped_app.to_app, app, before_rule)
+  def initialize(app, on_request, on_response, before, after, wrapped_app)
+    wrapped_app.run(PostInterceptor.new(app, on_response, after, signal))
+    @app = PreInterceptor.new(wrapped_app.to_app, app, on_request, before)
+  end
+  
+  def signal
+    self.object_id.to_s.to_sym
   end
   
   def call(env)
-    response = catch(:skipped_middleware) do
+    response = catch(signal) do
       @app.call(env)
     end
     response
@@ -19,33 +23,44 @@ class Meddler
   
 
   class PostInterceptor
-    def initialize(app, rule = nil)
+    attr_reader :app, :rules, :filters, :signal
+    def initialize(app, rules, filters, signal)
       @app = app
-      @rule = rule
+      @rules = rules
+      @filters = filters
+      @signal = signal
     end
     
     def call(env)
-      response = @app.call(env)
-      if @rule.nil? || @rule.call(Rack::Response.new(response))
-        response
+      raw_response = app.call(env)
+      response = Rack::Response.new(raw_response[2], raw_response[0], raw_response[1])
+      if rules.nil? || rules.all?{|r| r.call(response)}
+        filters && filters.each{|f| f.call(response)}
+        response.to_a
       else
-        throw :skipped_middleware, response
+        throw signal, response.to_a
       end
     end
 
   end
-  
+
   class PreInterceptor
-    attr_accessor :skip_app
-    
-    def initialize(app, skip_app, rule = nil)
+    attr_reader :app, :skip_app, :rules, :filters
+    def initialize(app, skip_app, rules, filters)
       @app = app
       @skip_app = skip_app
-      @rule = rule
+      @rules = rules
+      @filters = filters
     end
-    
+
     def call(env)
-      response = @rule.nil? || @rule.call(Rack::Request.new(env)) ? @app.call(env) : @skip_app.call(env)
+      request = Rack::Request.new(env)
+      if rules.nil? || rules.all?{|f| f.call(request)}
+        filters && filters.each{|f| f.call(request)}
+        app.call(env)
+      else
+        skip_app.call(env)
+      end
     end
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: meddler
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Joshua Hull