mushin 0.0.0.pre49 → 0.0.0.pre50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a63764b427445373262282b040f8c646b380cb4
-  data.tar.gz: 05c29784839d0464d4f7372b7626c2952402df37
+  metadata.gz: cabcee365ccfdc8afe6f1ed6f8a7481c15c577d5
+  data.tar.gz: fd105bd186c500e080b50aefcc29dc741ce83ebb
 SHA512:
-  metadata.gz: 0d5253a813e17ba821880d6e4eb2c07cc06564d27e684efc9007d66b82fc28a45a002f1cf2e6586ee819c691952b94b8bd29d4437d51ee92bc04e6dd8ee0003c
-  data.tar.gz: f6c44c59d8ef4e5c1bf803959bbc5069d1e9bf09306c365d827142db2d9530bd9bc82a78dd513d22433cd1554b816a3caa524f936f07ceeb399509f343f37ebe
+  metadata.gz: bf159f32f2a2c960e69cb333fddbda306331e6569ada708914adc8dd861049820bb363506bbb9a19e150481c5f6d876c976a49540a75a57b03619e361d7bd7ff
+  data.tar.gz: 988a31cdc58a19e19f53e912f3861895917c53c42ab68cb5a15764b810af18d138802e2a12ce1f71557fa42493435011adb6edc767305f5dac4fbf943feecb4b

data/lib/mushin/base.rb

@@ -19,31 +19,32 @@ module Mushin # Domain Frameworks Generator
       raise "Domain Framework must impelment get"
     end
   end
-
-  module Mushin::Middleware 
-    class << self
-      attr_accessor :opts, :params
-      def opts
-	@opts ||= {}
-      end
-      def params
-	@params ||= {}
-      end
-    end
-    module Opts
-      def self.[] key 
-	Mushin::Middleware.opts[key] 
-      end
-      def self.[]= key, value
-	Mushin::Middleware.opts.merge! Hash[key, value]
+  module Domain
+    module Mushin::Domain::Middleware 
+      class << self
+	attr_accessor :opts, :params
+	def opts
+	  @opts ||= {}
+	end
+	def params
+	  @params ||= {}
+	end
       end
-    end
-    module Params
-      def self.[] key 
-	Mushin::Middleware.params[key] 
+      module Opts
+	def self.[] key 
+	  Mushin::Domain::Middleware.opts[key] 
+	end
+	def self.[]= key, value
+	  Mushin::Domain::Middleware.opts.merge! Hash[key, value]
+	end
       end
-      def self.[]= key, value
-	Mushin::Middleware.params.merge! Hash[key, value]
+      module Params
+	def self.[] key 
+	  Mushin::Domain::Middleware.params[key] 
+	end
+	def self.[]= key, value
+	  Mushin::Domain::Middleware.params.merge! Hash[key, value]
+	end
       end
     end
   end

data/lib/mushin/middleware/builder.rb

@@ -1,137 +1,139 @@
-module Middleware
-  # This provides a DSL for building up a stack of middlewares.
-  #
-  # This code is based heavily off of `Rack::Builder` and
-  # `ActionDispatch::MiddlewareStack` in Rack and Rails, respectively.
-  #
-  # # Usage
-  #
-  # Building a middleware stack is very easy:
-  #
-  #     app = Middleware::Builder.new do
-  #       use A
-  #       use B
-  #     end
-  #
-  #     # Call the middleware
-  #     app.call(7)
-  #
-  class Builder
-    # Initializes the builder. An optional block can be passed which
-    # will be evaluated in the context of the instance.
+module Mushin
+  module Middleware
+    # This provides a DSL for building up a stack of middlewares.
     #
-    # Example:
+    # This code is based heavily off of `Rack::Builder` and
+    # `ActionDispatch::MiddlewareStack` in Rack and Rails, respectively.
     #
-    #     Builder.new do
+    # # Usage
+    #
+    # Building a middleware stack is very easy:
+    #
+    #     app = Middleware::Builder.new do
     #       use A
     #       use B
     #     end
     #
-    # @param [Hash] opts Options hash
-    # @option opts [Class] :runner_class The class to wrap the middleware stack
-    #   in which knows how to run them.
-    # @yield [] Evaluated in this instance which allows you to use methods
-    #   like {#use} and such.
-    #def game name, *dyx, &block  
-    def initialize(opts=nil, &block)
-      opts ||= {}
-      @runner_class = opts[:runner_class] || Runner
-      instance_eval(&block) if block_given?
-    end
+    #     # Call the middleware
+    #     app.call(7)
+    #
+    class Builder
+      # Initializes the builder. An optional block can be passed which
+      # will be evaluated in the context of the instance.
+      #
+      # Example:
+      #
+      #     Builder.new do
+      #       use A
+      #       use B
+      #     end
+      #
+      # @param [Hash] opts Options hash
+      # @option opts [Class] :runner_class The class to wrap the middleware stack
+      #   in which knows how to run them.
+      # @yield [] Evaluated in this instance which allows you to use methods
+      #   like {#use} and such.
+      #def game name, *dyx, &block  
+      def initialize(opts=nil, &block)
+	opts ||= {}
+	@runner_class = opts[:runner_class] || Runner
+	instance_eval(&block) if block_given?
+      end
 
-    # Returns a mergeable version of the builder. If `use` is called with
-    # the return value of this method, then the stack will merge, instead
-    # of being treated as a separate single middleware.
-    def flatten
-      lambda do |env|
-        self.call(env)
+      # Returns a mergeable version of the builder. If `use` is called with
+      # the return value of this method, then the stack will merge, instead
+      # of being treated as a separate single middleware.
+      def flatten
+	lambda do |env|
+	  self.call(env)
+	end
       end
-    end
 
-    # Adds a middleware class to the middleware stack. Any additional
-    # args and a block, if given, are saved and passed to the initializer
-    # of the middleware.
-    #
-    # @param [Class] middleware The middleware class
-    def use(middleware, *args, &block)
-      if middleware.kind_of?(Builder)
-        # Merge in the other builder's stack into our own
-        self.stack.concat(middleware.stack)
-      else
-        self.stack << [middleware, args, block]
+      # Adds a middleware class to the middleware stack. Any additional
+      # args and a block, if given, are saved and passed to the initializer
+      # of the middleware.
+      #
+      # @param [Class] middleware The middleware class
+      def use(middleware, *args, &block)
+	if middleware.kind_of?(Builder)
+	  # Merge in the other builder's stack into our own
+	  self.stack.concat(middleware.stack)
+	else
+	  self.stack << [middleware, args, block]
+	end
+
+	self
       end
 
-      self
-    end
+      # Inserts a middleware at the given index or directly before the
+      # given middleware object.
+      def insert(index, middleware, *args, &block)
+	index = self.index(index) unless index.is_a?(Integer)
+	raise "no such middleware to insert before: #{index.inspect}" unless index
+	stack.insert(index, [middleware, args, block])
+      end
 
-    # Inserts a middleware at the given index or directly before the
-    # given middleware object.
-    def insert(index, middleware, *args, &block)
-      index = self.index(index) unless index.is_a?(Integer)
-      raise "no such middleware to insert before: #{index.inspect}" unless index
-      stack.insert(index, [middleware, args, block])
-    end
+      alias_method :insert_before, :insert
 
-    alias_method :insert_before, :insert
+      # Inserts a middleware after the given index or middleware object.
+      def insert_after(index, middleware, *args, &block)
+	index = self.index(index) unless index.is_a?(Integer)
+	raise "no such middleware to insert after: #{index.inspect}" unless index
+	insert(index + 1, middleware, *args, &block)
+      end
 
-    # Inserts a middleware after the given index or middleware object.
-    def insert_after(index, middleware, *args, &block)
-      index = self.index(index) unless index.is_a?(Integer)
-      raise "no such middleware to insert after: #{index.inspect}" unless index
-      insert(index + 1, middleware, *args, &block)
-    end
+      # Replaces the given middleware object or index with the new
+      # middleware.
+      def replace(index, middleware, *args, &block)
+	if index.is_a?(Integer)
+	  delete(index)
+	  insert(index, middleware, *args, &block)
+	else
+	  insert_before(index, middleware, *args, &block)
+	  delete(index)
+	end
+      end
 
-    # Replaces the given middleware object or index with the new
-    # middleware.
-    def replace(index, middleware, *args, &block)
-      if index.is_a?(Integer)
-        delete(index)
-        insert(index, middleware, *args, &block)
-      else
-        insert_before(index, middleware, *args, &block)
-        delete(index)
+      # Deletes the given middleware object or index
+      def delete(index)
+	index = self.index(index) unless index.is_a?(Integer)
+	stack.delete_at(index)
       end
-    end
 
-    # Deletes the given middleware object or index
-    def delete(index)
-      index = self.index(index) unless index.is_a?(Integer)
-      stack.delete_at(index)
-    end
+      # Runs the builder stack with the given environment.
+      def call(env = Hash.new)
+	#def call(env=nil)
+	to_app.call(env)
+      end
 
-    # Runs the builder stack with the given environment.
-    def call(env = Hash.new)
-    #def call(env=nil)
-      to_app.call(env)
-    end
+      protected
 
-    protected
+      # Returns the numeric index for the given middleware object.
+      #
+      # @param [Object] object The item to find the index for
+      # @return [Integer]
+      def index(object)
+	stack.each_with_index do |item, i|
+	  return i if item[0] == object
+	end
 
-    # Returns the numeric index for the given middleware object.
-    #
-    # @param [Object] object The item to find the index for
-    # @return [Integer]
-    def index(object)
-      stack.each_with_index do |item, i|
-        return i if item[0] == object
+	nil
       end
 
-      nil
-    end
-
-    # Returns the current stack of middlewares. You probably won't
-    # need to use this directly, and it's recommended that you don't.
-    #
-    # @return [Array]
-    def stack
-      @stack ||= []
-    end
+      # Returns the current stack of middlewares. You probably won't
+      # need to use this directly, and it's recommended that you don't.
+      #
+      # @return [Array]
+      def stack
+	@stack ||= []
+      end
 
-    # Converts the builder stack to a runnable action sequence.
-    #
-    # @return [Object] A callable object
-    def to_app
-      @runner_class.new(stack.dup)
+      # Converts the builder stack to a runnable action sequence.
+      #
+      # @return [Object] A callable object
+      def to_app
+	@runner_class.new(stack.dup)
+      end
     end
   end
 end

data/lib/mushin/middleware/runner.rb

@@ -1,68 +1,70 @@
-module Middleware
-  # This is a basic runner for middleware stacks. This runner does
-  # the default expected behavior of running the middleware stacks
-  # in order, then reversing the order.
-  class Runner
-    # A middleware which does nothing
-    EMPTY_MIDDLEWARE = lambda { |env| }
+module Mushin
+  module Middleware
+    # This is a basic runner for middleware stacks. This runner does
+    # the default expected behavior of running the middleware stacks
+    # in order, then reversing the order.
+    class Runner
+      # A middleware which does nothing
+      EMPTY_MIDDLEWARE = lambda { |env| }
 
-    # Build a new middleware runner with the given middleware
-    # stack.
-    #
-    # Note: This class usually doesn't need to be used directly.
-    # Instead, take a look at using the {Builder} class, which is
-    # a much friendlier way to build up a middleware stack.
-    #
-    # @param [Array] stack An array of the middleware to run.
-    def initialize(stack)
-      # We need to take the stack of middleware and initialize them
-      # all so they call the proper next middleware.
-      @kickoff = build_call_chain(stack)
-    end
+      # Build a new middleware runner with the given middleware
+      # stack.
+      #
+      # Note: This class usually doesn't need to be used directly.
+      # Instead, take a look at using the {Builder} class, which is
+      # a much friendlier way to build up a middleware stack.
+      #
+      # @param [Array] stack An array of the middleware to run.
+      def initialize(stack)
+	# We need to take the stack of middleware and initialize them
+	# all so they call the proper next middleware.
+	@kickoff = build_call_chain(stack)
+      end
 
-    # Run the middleware stack with the given state bag.
-    #
-    # @param [Object] env The state to pass into as the initial
-    #   environment data. This is usual a hash of some sort.
-    def call(env)
-      # We just call the kickoff middleware, which is responsible
-      # for properly calling the next middleware, and so on and so
-      # forth.
-      @kickoff.call(env)
-    end
+      # Run the middleware stack with the given state bag.
+      #
+      # @param [Object] env The state to pass into as the initial
+      #   environment data. This is usual a hash of some sort.
+      def call(env)
+	# We just call the kickoff middleware, which is responsible
+	# for properly calling the next middleware, and so on and so
+	# forth.
+	@kickoff.call(env)
+      end
 
-    protected
+      protected
 
-    # This takes a stack of middlewares and initializes them in a way
-    # that each middleware properly calls the next middleware.
-    def build_call_chain(stack)
-      # We need to instantiate the middleware stack in reverse
-      # order so that each middleware can have a reference to
-      # the next middleware it has to call. The final middleware
-      # is always the empty middleware, which does nothing but return.
-      stack.reverse.inject(EMPTY_MIDDLEWARE) do |next_middleware, current_middleware|
-        # Unpack the actual item
-        klass, args, block = current_middleware
+      # This takes a stack of middlewares and initializes them in a way
+      # that each middleware properly calls the next middleware.
+      def build_call_chain(stack)
+	# We need to instantiate the middleware stack in reverse
+	# order so that each middleware can have a reference to
+	# the next middleware it has to call. The final middleware
+	# is always the empty middleware, which does nothing but return.
+	stack.reverse.inject(EMPTY_MIDDLEWARE) do |next_middleware, current_middleware|
+	  # Unpack the actual item
+	  klass, args, block = current_middleware
 
-        # Default the arguments to an empty array. Otherwise in Ruby 1.8
-        # a `nil` args will actually pass `nil` into the class. Not what
-        # we want!
-        args ||= []
+	  # Default the arguments to an empty array. Otherwise in Ruby 1.8
+	  # a `nil` args will actually pass `nil` into the class. Not what
+	  # we want!
+	  args ||= []
 
-        if klass.is_a?(Class)
-          # If the klass actually is a class, then instantiate it with
-          # the app and any other arguments given.
-          klass.new(next_middleware, *args, &block)
-        elsif klass.respond_to?(:call)
-          # Make it a lambda which calls the item then forwards up
-          # the chain.
-          lambda do |env|
-            klass.call(env)
-            next_middleware.call(env)
-          end
-        else
-          raise "Invalid middleware, doesn't respond to `call`: #{action.inspect}"
-        end
+	  if klass.is_a?(Class)
+	    # If the klass actually is a class, then instantiate it with
+	    # the app and any other arguments given.
+	    klass.new(next_middleware, *args, &block)
+	  elsif klass.respond_to?(:call)
+	    # Make it a lambda which calls the item then forwards up
+	    # the chain.
+	    lambda do |env|
+	      klass.call(env)
+	      next_middleware.call(env)
+	    end
+	  else
+	    raise "Invalid middleware, doesn't respond to `call`: #{action.inspect}"
+	  end
+	end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mushin
 version: !ruby/object:Gem::Version
-  version: 0.0.0.pre49
+  version: 0.0.0.pre50
 platform: ruby
 authors:
 - theotherstupidguy