modware 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89d92353fe1c300cb4eab370fa9838b6d104e8a6
-  data.tar.gz: 5d0f202e063fd925a3d57a663e7bcc54548f707b
+  metadata.gz: 3954be9354da6c601d61ef054899259b7fc749c9
+  data.tar.gz: 6840f5fa4aad0fbd2f4a97200133e12a5362bb25
 SHA512:
-  metadata.gz: 24ac95fc4d539362292a322a92f9d7111671d7fd76fcc312f4b9494b27e26c1d113d110286eeb1c8899d835b02cafa61ca189c20ff2069d4b4d2a34aaae1fbd9
-  data.tar.gz: ca9b22dc6012180c1a109ae2713855d5866bc1969ba75b41a4141074b96ac6668f722084bf7d2d36595662668779b282481ccfe88b4d5621f99c418a1fc1fd18
+  metadata.gz: 997889d2b9aed15eabab7ebc41f85f52ba1be4213d2cdcd44ab562ce5245c75c6a3b0d9e87515b02b4387eea34e2305c8c841ee93324c8b76319953f4ab2f803
+  data.tar.gz: 0cfe6a6036f066df4794e96944ac42750f4249d1d4a13da5482412fd63cc9bd051de7e7a7f419cc9c67805cec360ee8eb53bfa104f29c18935c2828599e9887f

data/README.md

@@ -38,7 +38,7 @@ and Modware will define a class that accepts those keys as keyword arguments, an
 
 ### Defining middleware
 
-Middleware is defined as a module that defines one or more middleware methods:
+Define middleware by creating a module that defines one or more of these middleware methods:
 
 ```ruby
 module MyMiddleware
@@ -91,7 +91,36 @@ The execution sequence of the stack is as follows:
 2. Call each middleware `before(env)` method, in the order they were added
 3. Call each middleware `around(env)` method, in the order they were added.  This bottoms out with the last `implement(env)` method to be added, if any, otherwise the base implementation
 4. Call each middleware `after(env)` method, in the order they were added
-5. Return `env`
+5. `stack.start` returns `env`
+
+#### Example: wrapping an existing operation
+
+A common idiom is to wrap a modware stack around an existing operation:
+
+```ruby
+class WrapsOperation < BaseClass
+
+  attr_reader :stack
+
+  def initialized(*args)
+    super
+    @stack = Modware::Stack.new(env: [:time, :place, :result])
+  end
+  
+  def operation(time, place)
+    stack.start(time: time, place: place) { |env|
+      env.result = super env.time, env.place
+    }.result
+  end
+end
+```
+
+Notice in the `operation` wrapper method: 
+
+* The `env` instance gets initialized with the method arguments
+* The base implmenetation of `operation` gets its arguments from the `env` instance, giving clients a chance to modify them in `:before` or `:around` methods.
+* The result of the base implementation gets stored in `env`, giving clients a chance to modify it in `:around` or `:after` methods.
+* When stack execution finishes, it returns `env`, from which the wrapper returns the result.
 
 ### Helpers
 
@@ -101,6 +130,11 @@ The execution sequence of the stack is as follows:
 
 The [middleware](https://rubygems.org/gems/middleware) gem works well, following a [rack](http://rack.github.io/)-like execution model.
 
+## Change Log
+
+* 0.1.1 - Thread safety in Stack#start
+* 0.1.0 - Initial release
+
 ## Contributing
 
 Contributions welcome -- feel free to open issues or submit pull requests.  Thanks!

data/lib/modware/stack.rb

@@ -19,32 +19,31 @@ module Modware
 
     def start(*args, &implementation)
       env = @env_klass.new(*args)
-      @base_implementation = implementation
-      execute_stack(env)
+      execute_stack(env, implementation)
       env
     end
 
     private
 
-    def execute_stack(env)
-      return call_implementation(env) unless @middlewares.any?
+    def execute_stack(env, base_implementation)
+      return call_implementation(env, base_implementation) unless @middlewares.any?
 
       @middlewares.each do |middleware|
         middleware.before env if middleware.respond_to? :before
       end
 
-      @middlewares.first._call(env)
+      @middlewares.first._call(env, base_implementation)
 
       @middlewares.each do |middleware|
         middleware.after env if middleware.respond_to? :after
       end
     end
 
-    def call_implementation(env)
+    def call_implementation(env, base_implementation)
       if middleware = @middlewares.select(&it.respond_to?(:implement)).last
         middleware.implement(env)
-      elsif @base_implementation
-        @base_implementation.call env
+      elsif base_implementation
+        base_implementation.call env
       else
         raise StackError, "No base implementation nor middleware implementation in stack"
       end
@@ -58,21 +57,21 @@ module Modware
         singleton_class.send :include, mod
       end
 
-      def _call(env)
+      def _call(env, base_implementation)
         if respond_to? :around
           around(env) { |env|
-            _continue env
+            _continue env, base_implementation
           }
         else
-          _continue env
+          _continue env, base_implementation
         end
       end
 
-      def _continue(env)
+      def _continue(env, base_implementation)
         if self._next
-          self._next._call(env)
+          self._next._call(env, base_implementation)
         else
-          @stack.send :call_implementation, env
+          @stack.send :call_implementation, env, base_implementation
         end
       end
     end

data/lib/modware/version.rb

@@ -1,3 +1,3 @@
 module Modware
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modware
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - ronen barzel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-09 00:00:00.000000000 Z
+date: 2015-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: key_struct
@@ -179,7 +179,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: A middleware library, featuring a simple interface and "callback" style semantics