mushin 0.0.0.pre4 → 0.0.0.pre5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e5db142fcbe592ac14841d36cf5ac54c3c04d43
-  data.tar.gz: 1b0684e30975a5c690b45648d45dce8daefd2d34
+  metadata.gz: 57d69b4ddf43f86cb77ad4605f6b56c9390f557e
+  data.tar.gz: cbcb2987546f85ba505dc869ad704df8431258d3
 SHA512:
-  metadata.gz: 247097d0563696a53f8bee7202fbf99b0ee4c2c0526b2342b0acd5de389cfe5de530a15d8125b251559eb2d033d49e930e44575b0b743262531f68571016fe80
-  data.tar.gz: 3814c50c06ceabc26affcc17f2357e7420eb3a9f9f3bfb7127cb3c72fff1f6da19ca21ae93d59986f3b7967331911d17052acfbc38ff7b67f2d282e1a9f44711
+  metadata.gz: f03d782e256b51ec7f1a717c2fbfacdae5e7c9dff087eacd3ba0ac34c5719674c1710c8fe408cac8ec4b7551844d8032078711f0f279fd424eaaecba2c0dc4e5
+  data.tar.gz: 540f7ffde560fae05ab43b3df6616ee1276271e87f0dc8011fd2ad727876b8434728df537537acc0dd841d43af30f45b3af6d0cd8e3ff32260d49277cb3b5f62

data/lib/mushin/base.rb

@@ -0,0 +1,125 @@
+require_relative './middleware/builder'
+require_relative './middleware/runner'
+
+module Mushin 
+  module DSL
+    #Usage: 
+    # module GameOn
+    #  module Book
+    #    include Mushin::DSL::Notebook 
+    #    def mybook
+    #      p 'book works' 
+    #    end
+    #  end
+    # end
+    #
+    # module MyDomainBook
+    #  extend GameOn::Book
+    #  mybook
+    #  mynotebook
+    # end
+    module Notebook
+      def self.extended(mod)
+	puts "#{self} extended in #{mod}"
+	#puts "#{self} included in #{mod}"
+	self.send(:include, mod)
+	#mod.send(:extend, self)
+	#TODO Inject somthing useful logging,exceptions, etc.
+	#prepend mod
+      end
+
+      def self.find activity_construct, activity_rule
+	@@middlewares = []
+	@@constructs.each do |construct|
+	  if activity_construct == construct.title
+	    construct.rules.each do |rule|
+	      if activity_rule == rule.title
+		rule.all_dynamix.each do |middleware|
+		  @@middlewares << middleware 
+		end
+	      end
+	    end
+	  end
+	end
+	@@middlewares
+      end
+    end
+
+    class Activities
+      def self.on domain_context, &block 
+	#p construct
+	@@domain_context = domain_context 
+	@@activities = []
+
+	def add activity=[] 
+	  @@activities += [activity] 
+	end
+
+	yield Activities.new
+
+	@@activities.each do |activity| 
+	  p @@domain_context
+	  #p self
+	  self.construction @@domain_context, activity
+	  #Mushin::Engine.run @@construct, activity
+	end 
+      end
+
+      def self.domain_context
+	@@domain_context
+      end
+
+      def self.all
+	@@activities
+      end
+
+      def self.count
+	@@activities.count 
+      end
+    end
+  end
+
+  class Env
+    class << self
+      attr_accessor :id
+    end
+
+    def Env.register &block
+      #instance_eval &block
+      class_eval &block
+    end
+
+    def Env.activate id, &block
+      @id = id
+      yield
+    end
+  end
+
+  module Engine
+    def Engine.setup before_stack = [] 
+      @@setup_middlewares = before_stack
+    end
+
+    def Engine.run domain_context, activity
+      p 'Mushin::Engine is running'
+      @@domain_context = domain_context
+      @@activity = activity
+      #TODO write metaprog code in Mushin::DSL::Gamebooks to figure out the modules that included it via the included(self) and then trigger the find function on it to get its own domain
+      @@middlewares = Mushin::DSL::Notebook.find @@domain_context, @@activity 
+      #p @@middlewares
+      @@stack = Middleware::Builder.new do
+	#use GameOn::Persistence::DS
+	@@middlewares.each do |middleware|
+	  #p "use #{middleware.name}, #{middleware.opts}, #{middleware.params}"
+	  use middleware.name, middleware.opts, middleware.params
+	end
+      end
+      @@setup_middlewares.each do |setup_middleware|
+	#@@stack.insert_before 1, setup_middleware #TODO should be one? 
+	@@stack.insert_before 0, setup_middleware 
+      end
+      @@stack.call
+      #p @@stack.methods
+    end
+  end
+end

data/lib/mushin/middleware/builder.rb

@@ -0,0 +1,137 @@
+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

data/lib/mushin/middleware/runner.rb

@@ -0,0 +1,69 @@
+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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mushin
 version: !ruby/object:Gem::Version
-  version: 0.0.0.pre4
+  version: 0.0.0.pre5
 platform: ruby
 authors:
 - theotherstupidguy
@@ -18,6 +18,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - 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