mushin 0.0.0.pre94 → 0.1.0

data/lib/mushin/base.rb

@@ -1,107 +0,0 @@
-module Mushin # Domain Frameworks Generator
-  module Errors  
-    exceptions = %w[ UnkownDSLConstruct UnkownUse UnknownOption ]  
-    exceptions.each { |e| const_set(e, Class.new(StandardError)) }  
-  end
-
-  module Env
-    def register &block
-      module_eval &block
-    end
-
-    def set id, &block
-      raise "Domain Framework must impelment set"
-    end
-    def get id
-      raise "Domain Framework must impelment get"
-    end
-  end
-  module Domain
-    module Mushin::Domain::Middleware 
-      class << self
-	attr_accessor :opts, :params
-	def opts
-	  #@opts ||= {}
-	  @opts = Hash.new
-	end
-	def params
-	  #@params ||= {}
-	  @params = Hash.new
-	end
-      end
-      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
-      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
-
-  module DSL
-    class Context
-      attr_accessor :title, :activities
-      def initialize title
-	@title = title
-	@activities = []
-      end
-    end
-    class Activity 
-      attr_accessor :title, :uses
-      def initialize title 
-	@title = title
-	@uses = []
-      end
-    end
-    class Use 
-      attr_accessor :name, :opts, :params
-      def initialize name, opts={}, params={} 
-	@name = name 
-	@opts = opts
-	@params = params
-      end
-    end
-
-    class << self
-      attr_accessor :contexts, :middlewares
-    end
-    Mushin::DSL.contexts = []
-    def context title, &block
-      @context = Mushin::DSL::Context.new title 
-      def activity activity=[], &block
-	@activity = Mushin::DSL::Activity.new activity 
-	def use name, opts={}, params={}
-	  if !@activity.uses.bsearch {|x| x == [name,opts,params]} #TODO I think bsearch should be commented out as there are certain sequential logics that requires the use of a certain middleware more than once in a single activity
-
-	    @use = Mushin::DSL::Use.new name, opts, params
-	    @activity.uses << @use
-	  end
-	end
-	yield
-	@context.activities << @activity
-      end
-      yield
-     Mushin::DSL.contexts << @context #TODO can't deal with class variables, needs to initialize this? or the DSL will be the same for all users? I think the DSL will be the same for all users so no need to worry about this being class variable on the application level. 
-    end
-  end
-
-  module Engine
-    require_relative './middleware/builder'
-    require_relative './middleware/runner'
-
-    attr_reader :setup_middlewares # set it through the setup method and then read it no need for attr_accessor :setup_middlewares
-    def setup before_stack = [] 
-      @setup_middlewares = before_stack
-    end
-  end
-end

data/lib/mushin/middleware/builder.rb

@@ -1,139 +0,0 @@
-module Mushin
-  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.
-      #
-      # 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)
-	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]
-	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
-
-      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
-
-      # 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
-
-      # 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
-
-      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
-
-	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
-
-      # 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,71 +0,0 @@
-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
-
-      # 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
-
-      # 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 ||= []
-
-	  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
-end