mushin 0.0.0.pre53 → 0.0.0.pre55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ce885be69161e374cfd40f005fc06db0fa5a27d
-  data.tar.gz: 100fb96ad91036e2e5392e502e6a3bc9f78109f0
+  metadata.gz: 884ae94e93a1a1165ce87ea3e14e9f79ce08b504
+  data.tar.gz: ab9b87746c7ef9545d5a0bf104c03584d6393ad9
 SHA512:
-  metadata.gz: 54e7eb81992036afa41a7d3af590b85a8afb9b813f3cf7db9c55e0e22499328a12ba9ec43279effe8fc7b99888248c19c0d9431e0b2f28c8715a12ec78b1c263
-  data.tar.gz: c5a52b00b6508781105f3614fcef8640369e74adb197405bbeb6a5eeb2571fb6c821768af8406e34b57da2031d1c994d9cbad6355d0e6af43683ec9bc64edad2
+  metadata.gz: f9c66cb155dfa1ba03c9b0d076c961caec5f874259f959d6cbc0bb2cc247e898a4b25b54f0750d8f896047f1cd4818692b1273a5a5a8ec459841920c921b62ed
+  data.tar.gz: 3ba4a08ad2bec98a2f4e02dfe17bba3f02fbfa696315353ba63121a873570a5b6d4de4c489e75779b05f366a6233ca81acc383c7b7c3caf26c2ee5f7442d4885

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mushin
 version: !ruby/object:Gem::Version
-  version: 0.0.0.pre53
+  version: 0.0.0.pre55
 platform: ruby
 authors:
 - theotherstupidguy
@@ -20,14 +20,12 @@ extra_rdoc_files: []
 files:
 - bin/mushin
 - lib/mushin.rb
-- lib/mushin/base.rb
-- lib/mushin/middleware/builder.rb
-- lib/mushin/middleware/runner.rb
 homepage: https://github.com/mushin-rb/mushin
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message: |2
+   !    Mushin is kinda Awesome.
 rdoc_options: []
 require_paths:
 - lib

data/lib/mushin/base.rb

@@ -1,102 +0,0 @@
-require_relative './middleware/builder'
-require_relative './middleware/runner'
-
-module Mushin # Domain Frameworks Generator
-  module Errors  
-    exceptions = %w[ UnkownDSLConstruct UnkownActivation 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 ||= {}
-	end
-	def params
-	  @params ||= {}
-	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, :statments
-      def initialize title
-	@title = title
-	@statments = []
-      end
-    end
-    class Statment 
-      attr_accessor :title, :activations
-      def initialize title 
-	@title = title
-	@activations = []
-      end
-    end
-    class Activation 
-      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 statment statment=[], &block
-	@statment = Mushin::DSL::Statment.new statment 
-	def activation name, opts={}, params={}
-	  @activation = Mushin::DSL::Activation.new name, opts, params
-	  @statment.activations << @activation 
-	end
-	yield
-	@context.statments << @statment
-      end
-      yield
-     Mushin::DSL.contexts << @context
-    end
-  end
-
-  module Engine
-    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