mushin 0.10.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4e482e039424a90b36604479ab7e79e4d58d332
-  data.tar.gz: 8cfb989787405f60f65f0100bf007def425df761
+  metadata.gz: 791ed6577d3d1449a3909a83c6b8908a2034069c
+  data.tar.gz: 67d81b8451b9fa51bb7565eea0234701ef644481
 SHA512:
-  metadata.gz: fa3f9d1a7747a0bc12290c2f03ba0882ba41b3a0d73a2327af806fca9efe3eab115568a1227911256ca5612dc75a6fcc70bc460230c483946b86d953a018f609
-  data.tar.gz: 9bdbc1eb80b200515d3f37b58c2f3ef231f7b0779291f51e648c558700a5ccd3cc78befe1c164370a9baa248ab44f5343e4a74a9050e6034ad1616f933ef5f57
+  metadata.gz: 7d4ed1678810aa2faa3906160b968180b7c9df1fa0299a2dd0ef55a952585e6db888fc8500533e0bffad6d1d7f5d8dedd57f19d164cc360f84bf18d6f9774188
+  data.tar.gz: b5c8762676a8d304babf5b82e94109a00efce457d0d8dc39b5c9fbfde40aebdac006230454412244c088727f520010e4c6d85b17f51d27ab514de06e82503e08

data/.gitignore

@@ -9,3 +9,5 @@
 /tmp/
 /mygem
 *.swp
+*.log
+*.ssd

data/.ssd/eventstream/11_29_2016.ssd

@@ -0,0 +1,2 @@
+---
+2016-11-29 21:26:31 UTC_11_29_2016: "#<Mushin::ES::Event:0x00000002262828>"

data/.ssd/eventstream/11_30_2016.ssd

@@ -0,0 +1,9 @@
+---
+2016-11-30 08:05:58 UTC_11_30_2016: !ruby/object:Mushin::ES::Event {}
+2016-11-30 08:06:25 UTC_11_30_2016: !ruby/object:Mushin::ES::Event {}
+2016-11-30 08:06:29 UTC_11_30_2016: !ruby/object:Mushin::ES::Event {}
+2016-11-30 08:06:31 UTC_11_30_2016: !ruby/object:Mushin::ES::Event {}
+2016-11-30 08:06:32 UTC_11_30_2016: !ruby/object:Mushin::ES::Event {}
+2016-11-30 08:53:50 UTC_11_30_2016: !ruby/object:Mushin::ES::Event {}
+2016-11-30 09:01:43 UTC_11_30_2016: !ruby/object:Mushin::ES::Event {}
+2016-11-30 10:03:04 UTC_11_30_2016: !ruby/object:Mushin::ES::Event {}

data/lib/mushin/bot.rb

@@ -0,0 +1,236 @@
+require 'sinatra/base'
+require 'rss'
+require 'cinch'
+require 'singleton'
+
+module Mushin
+  # Mushin speaks via eventsourcing, Mushin::Bot allows Mushin to be heard on IRC, RSS, etc.!
+  module Bot 
+
+    #    def self.config irc_server: nil, irc_channel: nil
+    #      self.irc_server 	= irc_server
+    #      self.irc_channel 	= irc_channel
+    #    end
+
+    #    class << self
+    #      attr_accessor :irc_server
+    #      attr_accessor :irc_channel
+    #    end
+
+    #def initialize  &block
+    #  instance_eval &block
+    #end
+
+    #    def irc message: nil, &block
+    #      IRC.new(message).instance_eval &block
+    #    end
+
+    # C&C and allows communication among a number of microservies over a number of context specific #channels
+    # A Distrubted Rule-based system where each node has its rules-engine and post on a channel and get conditions from the channel, continously adopting to the most recent state of the system.
+    class IRC
+      include Singleton
+
+      attr_accessor :bot, :server, :channels, :nick
+
+      def initialize
+	@bot = Cinch::Bot.new 
+	@server 	= ""
+	@channels 	= []
+	@nick 		= "mushin_botapp_name"
+      end
+
+      def self.config &block
+      end
+
+      def log message: nil
+	@bot.configure do |c|
+	  c.server 	= @server #Mushin::Bot.irc_server #"irc.freenode.org"
+	  c.channels 	= @channels #[Mushin::Bot.irc_channel] #["#cinch-bots"]
+	end
+
+	@bot.on :connect do |m|
+
+	end
+
+	@bot.on :join do |m|
+	  m.reply "Hello, #{message}"
+	end
+
+	@bot.on :message, "hello" do |m|
+	  m.reply "Hello, #{m.user.nick}"
+	end
+
+	@bot.on :exit do |m|
+	  m.reply "goodbye, #{m.user.nick}"
+	end
+
+	@bot.start
+	Thread.new do 
+	end
+      end
+    end
+
+    
+    #TODO from console `mushin publish /path/to/event/stream`
+    class RSS 
+      def initialize path: nil, key: nil, url: "/", port: 9999
+	rss url: url, port: port
+	@data = SSD.dump path, key unless path.nil? || key.nil?
+      end
+      def rss url: "/", port: "9494"
+	server = Class.new(Sinatra::Base) do 
+	  set :port, port
+	  get "#{url}" do
+	    "yay"
+	  end
+	end
+	server.run!
+      end
+    end
+
+  end
+end
+
+#stream = Mushin::EventStream.new
+#stream.rss url: "/eventstream", port: 9999
+
+=begin
+x = "crazy"
+get "/" do
+  rss = RSS::Maker.make("atom") do |maker|
+    maker.channel.author = "matz"
+    maker.channel.updated = Time.now.to_s
+    maker.channel.about = "http://www.ruby-lang.org/en/feeds/news.rss"
+    maker.channel.title = "upjoystream::v1::bots"
+    maker.channel.description = "upjoystream::v1::bots logsdfssfdasfasfasfasdfasdflasdfsafasfasf"
+
+    maker.items.new_item do |item|
+      item.link = "http://www.ruby-lang.org/en/news/2010/12/25/ruby-1-9-2-p136-is-released/"
+      item.title = "ass"
+      item.updated = Time.now.to_s
+    end
+
+    maker.items.image_item do |item|
+      item.link = "http://www.ruby-lang.org/en/news/2010/12/25/ruby-1-9-2-p136-is-released/"
+      item.title = "shitssssssssss"
+      item.updated = Time.now.to_s
+      p item.methods
+      item.link  = "/home/zotherstupidguy/Pictures/10923261.jpg"
+      #item.image_item = "/home/zotherstupidguy/Pictures/10923261.jpg"
+      item.description = "this is a json turned into xml to be viewed here like shit or maybe stayed as json upjoystream::v1::bots logsdfssfdasfasfasfasdfasdflasdfsafasfasf"
+    end
+
+  end
+  p rss.methods
+  return rss.to_s
+end
+require 'date'
+require 'logger'
+require 'rss'
+require 'open-uri'
+
+# UNKNOWN: An unknown message that should always be logged.
+# FATAL: An unhandleable error that results in a program crash.
+# ERROR: A handleable error condition.
+# WARN: A warning.
+# INFO: Generic (useful) information about system operation.
+# DEBUG: Low-level information for developers.
+def self.logger(shift_age: 'daily',
+		datetime_format: '%Y-%m-%d %H:%M:%S',
+		log_dir: 'logs'
+	       )
+  Dir.mkdir(log_dir) unless File.exists?(log_dir)
+  logger_file = "#{log_dir}/#{DateTime.now.strftime('%m_%d_%Y')}.log"
+  file = File.open(logger_file, File::WRONLY | File::APPEND | File::CREAT)
+  @log = Logger.new("| tee " + file.path, shift_age)
+  @log.datetime_format = datetime_format
+  @log.info "Utter Log Levels: DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN"
+  return @log
+end
+
+rss = RSS::Maker.make("atom") do |maker|
+  maker.channel.author = "matz"
+  maker.channel.updated = Time.now.to_s
+  maker.channel.about = "http://www.ruby-lang.org/en/feeds/news.rss"
+  maker.channel.title = "Example Feed"
+
+  maker.items.new_item do |item|
+    item.link = "http://www.ruby-lang.org/en/news/2010/12/25/ruby-1-9-2-p136-is-released/"
+    item.title = "Ruby 1.9.2-p136 is released"
+    item.updated = Time.now.to_s
+  end
+end
+
+puts rss
+
+$log = logger
+class Domain
+  attr :store
+  attr :query
+  attr :log
+  def initialize id
+    p id
+  end
+  def query params={}
+  end
+  def log params={}
+  end
+end
+
+d = Domain.new 'id' do
+  store = "sss"
+end
+p $log
+$log.info d
+
+#===========
+id = "all the kings men"
+d =  Domain.new do 
+end
+
+class Domain
+  def initialize
+  end
+
+  def command 
+    torrent_bots do
+      tpb query: id
+    end
+  end
+
+  def query 'id' 
+    mongodb path: "xx"
+    ssd
+    redis
+  end
+
+  def log
+  end
+end
+
+Domain.log.publish("url")
+#===========
+
+#p d.to_xml
+# In mushin, event sourcing is to capture all changes to an a domain state as a sequence of events."
+# Mushin separates business logic(domain logic) into Commands and Queries
+# state transitions are important part of our problem space and should be modeled within our domain.
+
+# Event Sourcing persists each domain object as a sequence of events, which are replayed to reconstruct the current state.
+#
+#
+# ideaA
+result = d.store  		# returns the a complete hash thing from what was stored via the command domain object process
+result = d.query tpb: "ss" 	# returns a selection from the whole thing of the store
+
+# seperate microservice for read, and seperate microservice for writes and both communicate via the log regardless of the databases they use.
+#
+result = d.log 			# 
+result = d.log tpb: "ss" 	# returns the latest log state
+
+# ideaB
+#result = Domain.query torrent_bots: "ss"
+#result = Domain.query tpb: "ss"
+#result = Domain.query context: "torrent_bots"
+#result = Domain.query construct: "tpb"
+=end

data/lib/mushin/cqrs/command.rb

@@ -0,0 +1,106 @@
+module Mushin
+  module DSLBuilder
+    module CQRS
+
+      class Command 
+
+	# attr for a dsl context constructor class
+	attr_accessor :app_dsl_context_klass
+
+	def initialize context_keyword, &block
+	  @app_dsl_context_klass = app_dsl_context_access_method_and_klass(context_keyword, Mushin::DSL)
+	  instance_eval &block
+	end
+
+	def construct construct_keyword, &block
+	  Construct.new construct_keyword, @app_dsl_context_klass, &block
+	end
+
+	def app_dsl_context_access_method_and_klass(context_keyword, parent_klass)
+	  $log.info "dynamically building app dsl context access method for: #{context_keyword}, inside: #{parent_klass}".reverse_color
+
+	  parent_klass.class_eval do
+	    define_method(context_keyword) do |&block|
+	      parent_klass.const_get(context_keyword.capitalize).new &block #if block_given?
+	    end
+	  end
+
+	  k = Class.new do
+	    def initialize &block
+	      instance_eval &block
+	    end
+	  end
+	  parent_klass.const_set(context_keyword.capitalize, k) unless parent_klass.const_defined?(context_keyword.capitalize)   
+
+	  return parent_klass.const_get(context_keyword.capitalize)
+	end
+
+	class Construct
+	  attr_accessor :context_klass, :construct_klass, :ext_set
+
+	  def initialize construct_keyword, context_klass, &block
+	    @construct_keyword = construct_keyword
+	    @context_klass = context_klass
+	    @ext_set = []
+
+	    instance_eval &block
+
+	    @construct_klass = dsl_construct_access_method_and_klass(@construct_keyword, @ext_set, @context_klass)
+	  end
+
+	  def use args = {}
+	    @ext_set << args
+	  end
+
+	  def dsl_construct_access_method_and_klass(construct_keyword, ext_set, parent_klass)
+	    $log.info "dynamically building app dsl construct access method for: #{construct_keyword}, inside: #{parent_klass}"
+	    ext_set.reverse!
+	    parent_klass.class_eval do
+	      define_method(construct_keyword) do |args = {}|
+		ext_set.each do |ext|
+		ext[:params].each do |key, value|
+		  args.each do |env_key, env_value|
+		    if env_key.to_sym == value then
+		      ext[:params][key] = env_value
+		    end
+		  end
+		end unless ext[:params].nil?
+
+		ext[:opts].each do |key, value|
+		  args.each do |env_key, env_value|
+		    if env_key.to_sym == value then
+		      ext[:opts][key] = env_value
+		    end
+		  end
+		end unless ext[:opts].nil?
+		$log.info ext 
+	      end
+
+	      parent_klass.const_get(construct_keyword.capitalize).new args, ext_set
+	      end
+	    end
+
+	    k = Class.new do
+	      attr_accessor :stack
+	      def initialize args={}, ext_set
+		p ext_set
+		@stack = Mushin::Stack.new
+
+		ext_set.each do |ext|
+		  @stack.insert_before 0, ext[:ext], ext[:opts], ext[:params]
+		  #@stack.insert_after_each (Mushin::ES::EventStream) 
+		end
+
+		@stack.call
+	      end
+	    end
+
+	    parent_klass.const_set(construct_keyword.capitalize, k) unless parent_klass.const_defined?(construct_keyword.capitalize)
+
+	    return parent_klass.const_get(construct_keyword.capitalize)
+	  end
+	end # end of Construct klass
+      end # end of Command klass (Context klass)
+    end # end of CQRS module
+  end # end of DSLBuilder module
+end # end of Mushin module

data/lib/mushin/cqrs/query.rb

@@ -0,0 +1,116 @@
+module Mushin
+  module DSLBuilder
+    module CQRS 
+      class Query
+
+	def initialize &block
+	  @app_dsl_query_klass = app_dsl_query_access_method_and_klass("query", Mushin::DSL)
+	  instance_eval &block
+	end
+
+	def construct construct_keyword, &block
+	 Construct.new construct_keyword, @app_dsl_query_klass, &block
+	end
+
+	def app_dsl_query_access_method_and_klass(query_keyword, parent_klass)
+	  $log.info "Query  for: #{query_keyword}, inside: #{parent_klass}"
+
+	  parent_klass.class_eval do
+	    define_method(query_keyword) do |&block|
+	      parent_klass.const_get(query_keyword.capitalize).new &block #if block_given?
+	    end
+	  end
+
+	  k = Class.new do
+	    def initialize &block
+	      instance_eval &block
+	    end
+	  end
+	  parent_klass.const_set(query_keyword.capitalize, k) unless parent_klass.const_defined?(query_keyword.capitalize)   
+	  return parent_klass.const_get(query_keyword.capitalize)
+	end
+
+	class Construct
+	  attr_accessor :context_klass, :construct_klass, :ext_set
+
+	  def initialize construct_keyword, context_klass, &block
+
+	    
+	    @construct_keyword = construct_keyword
+	    @context_klass = context_klass
+	    @ext_set = []
+
+	    instance_eval &block
+
+	    @construct_klass = dsl_construct_access_method_and_klass(@construct_keyword, @ext_set, @context_klass)
+	  end
+
+	  def use args = {}
+	    @ext_set << args
+	  end
+
+	  def dsl_construct_access_method_and_klass(construct_keyword, ext_set, parent_klass)
+
+
+	    $log.info "Query  for: #{construct_keyword}, inside: #{parent_klass}"
+	    ext_set.reverse!
+	    parent_klass.class_eval do
+	      define_method(construct_keyword) do |args = {}|
+
+
+		ext_set.each do |ext|
+		ext[:params].each do |key, value|
+		  args.each do |env_key, env_value|
+		    if env_key.to_sym == value then
+		      ext[:params][key] = env_value
+		    end
+		  end
+		end unless ext[:params].nil?
+
+		ext[:opts].each do |key, value|
+		  args.each do |env_key, env_value|
+		    if env_key.to_sym == value then
+		      ext[:opts][key] = env_value
+		    end
+		  end
+		end unless ext[:opts].nil?
+		$log.info ext 
+	      end
+
+	      obj = parent_klass.const_get(construct_keyword.capitalize).new args, ext_set
+
+	      Mushin::DSL.class_eval do
+		define_method(construct_keyword) do |&block| 
+		  #p "need to get this #{construct_keyword} and create a method of it inside Mushin::DSL, with the value of obj: #{obj.stack.call}"
+		  #$log.info "Query  for: #{construct_keyword}, inside: #{parent_klass}"
+		  #return "get the value from @stack.call, some freakin how!!!"
+		  return obj.stack.call
+		end
+	      end 
+
+	      end
+	    end
+
+	    k = Class.new do
+	      attr_accessor :stack
+	      def initialize args={}, ext_set
+		p ext_set
+		@stack = Mushin::Stack.new
+
+		ext_set.each do |ext|
+		  @stack.insert_before 0, ext[:ext], ext[:opts], ext[:params]
+		end
+		p "printing the stack value  #{@stack.call}"
+		return @stack.call
+	      end
+	    end
+
+	    parent_klass.const_set(construct_keyword.capitalize, k) unless parent_klass.const_defined?(construct_keyword.capitalize)
+
+	    return parent_klass.const_get(construct_keyword.capitalize)
+	  end
+	end # end of Construct klass
+      end # end of Query klass 
+    end # end of CQRS module
+  end # end of DSLBuilder module
+end # end of Mushin module

data/lib/mushin/domain.rb

@@ -2,13 +2,17 @@ require_relative 'dsl_builder'
 module Mushin
 
   class Domain
+    # offers a virtual datastore for query requests on the domain object
+    attr_accessor :store, :event_stream
+
     def self.inherited(subclass)
-      subclass.send :extend, DSLBuilder
+      subclass.send :extend, DSLBuilder 
       subclass.send :include, DSL 
     end
 
     def initialize &block
       $log.info "Domain object #{self} is going to instance_eval"
+      #TODO obj.send("#{prop_name}=", query_value)
       instance_eval &block
     end
   end

data/lib/mushin/dsl.rb

@@ -3,6 +3,7 @@ module Mushin
   # one neseted klass and one nested access method
   module DSL
     def self.inherited(other)
+      #p "inherited in #{other}"
       puts other
     end
   end

data/lib/mushin/dsl_builder.rb

@@ -1,5 +1,7 @@
-require 'mushin'
+#require 'mushin'
 require_relative 'dsl'
+require_relative 'cqrs/command'
+require_relative 'cqrs/query'
 
 module Mushin
 
@@ -7,114 +9,15 @@ module Mushin
 
     # The DSLBuilder context access method
     def context context_keyword, &block
-      Context.new context_keyword, &block
+      p "printing self from inside DSLBuilder:context #{self}"
+      Mushin::DSLBuilder::CQRS::Command.new context_keyword, &block
+      #Mushin::DSLBuilder::CQRS::Context
     end
 
-    class Context
-
-      # attr for a dsl context constructor class
-      attr_accessor :app_dsl_context_klass
-
-      def initialize context_keyword, &block
-	@app_dsl_context_klass = app_dsl_context_access_method_and_klass(context_keyword, Mushin::DSL)
-	instance_eval &block
-      end
-
-      def construct construct_keyword, &block
-	Construct.new construct_keyword, @app_dsl_context_klass, &block
-      end
-
-      def app_dsl_context_access_method_and_klass(context_keyword, parent_klass)
-	$log.info "dynamically building app dsl context access method for: #{context_keyword}, inside: #{parent_klass}".reverse_color
-	parent_klass.class_eval do
-	  define_method(context_keyword) do |&block|
-	    p context_keyword
-	    parent_klass.const_get(context_keyword.capitalize).new &block #if block_given?
-	  end
-	end
-
-	k = Class.new do
-	  def initialize &block
-	    instance_eval &block
-	    p "shit in klass #{self}"
-	  end
-	end
-	parent_klass.const_set(context_keyword.capitalize, k) unless parent_klass.const_defined?(context_keyword.capitalize)   
-
-	return parent_klass.const_get(context_keyword.capitalize)
-      end
-
-      class Construct
-	attr_accessor :context_klass, :construct_klass, :ext_set
-
-	def initialize construct_keyword, context_klass, &block
-	  @construct_keyword = construct_keyword
-	  @context_klass = context_klass
-	  @ext_set = []
-	  instance_eval &block
-
-
-	  @construct_klass = dsl_construct_access_method_and_klass(@construct_keyword, @ext_set, @context_klass)
-	  #konstructor = @construct_klass.new
-
-	end
-
-	def use args = {}
-	  p "**********************"
-	  p args
-	  p "************will replace with actual values from konstuctor object args**********"
-	  @ext_set << args
-	end
-
-	def dsl_construct_access_method_and_klass(construct_keyword, ext_set, parent_klass)
-	  $log.info "dynamically building app dsl construct access method for: #{construct_keyword}, inside: #{parent_klass}"
-	  ext_set.reverse!
-	  parent_klass.class_eval do
-	    define_method(construct_keyword) do |args = {}|
-	      p "here replace :symbols with values"
-	      p args.class
-	      ext_set.each do |ext|
-		ext[:params].each do |key, value|
-		  args.each do |env_key, env_value|
-		    if env_key.to_sym == value then
-		      ext[:params][key] = env_value
-		    end
-		  end
-		end unless ext[:params].nil?
-
-		ext[:opts].each do |key, value|
-		  args.each do |env_key, env_value|
-		    if env_key.to_sym == value then
-		      ext[:opts][key] = env_value
-		    end
-		  end
-		end unless ext[:opts].nil?
-		$log.info ext 
-	      end
-
-	      parent_klass.const_get(construct_keyword.capitalize).new args, ext_set
-	    end
-	  end
-
-	  k = Class.new do
-	    attr_accessor :stack
-	    def initialize args={}, ext_set
-	      p "construct dynamic klass"
-	      @stack = Mushin::Stack.new
-	      ext_set.each do |ext|
-		p "inside the stack"
-		p ext
-		@stack.insert_before 0, ext[:ext], ext[:opts], ext[:params]
-	      end
-	      @stack.call
-	    end
-	  end
-	  parent_klass.const_set(construct_keyword.capitalize, k) unless parent_klass.const_defined?(construct_keyword.capitalize)   
-
+    def query &block 
+      p "printing self from inside DSLBuilder:query #{self}"
+      Mushin::DSLBuilder::CQRS::Query.new &block
+    end
 
-	  return parent_klass.const_get(construct_keyword.capitalize)
-	end
-      end # end of Construct klass
-    end # end of Context klass
   end # end of DSLBuilder module
 end

data/lib/mushin/es/event.rb

@@ -0,0 +1,18 @@
+module Mushin
+  module ES
+    # A domain event is an object that defines an event (something that happens). 
+    # A domain event is an event that domain experts care about.
+    class Event
+      attr_accessor :id
+      attr_accessor :timestamp
+      attr_accessor :version
+      attr_accessor :type
+      attr_accessor :title
+      attr_accessor :data
+      def initialize &block
+	instance_eval &block if block_given?
+	Mushin::ES::EventStream.instance.add self
+      end
+    end
+  end
+end

data/lib/mushin/es/event_stream.rb

@@ -0,0 +1,33 @@
+require 'date'
+require 'open-uri'
+require 'singleton'
+
+module Mushin
+  module ES
+
+    #TODO from the console `mushin eventstream path/to/event/stream` this will populate the application with all the events logged in the specified eventstream, meaning all the databases that the system used will populate it as well. looks like migration mechanism.
+    #TODO event stream(s) maybe used via a rule-engine(sitting on IRC chatrooms as a bot) to determine some general actions. The rule-engine bot takes in events as conditions from a number of microservices and sends should be applied actions to the chat room.
+    class EventStream 
+      include Singleton
+
+      def initialize
+      end
+
+      # When an event is added to the strea, it is streamed first then stored to a datastore
+      def add event
+	# Stream to IRC 
+	Mushin::Bot::IRC.instance.log message: event
+
+
+	#irc server: "irc.freenode.net", channel: "hackspree", nick: "testingasshole"
+	#rss server: "irc.freenode.net", channel: "hackspree", nick: "testingasshole"
+	# store the event
+	Mushin::ES::Store.write dir: "eventstream", name: DateTime.now.strftime('%m_%d_%Y'), data: event
+      end
+
+      def replay
+      end
+
+    end
+  end
+end

data/lib/mushin/test_helper.rb

@@ -9,18 +9,25 @@ module Mushin
 	end
 
 	def call(env)
+	  env ||= Hash.new #if env.nil?
 	  $log.info "-----------------------------------------------------------------------"
 	  $log.info "Ext: #{self} is called with the following options: #{@opts} & params: #{@params}; and env: #{env}".red 
 	  $log.info "-----------------------------------------------------------------------"
 
 	  # Inbound maniuplation
-	  env = Hash.new if env.nil?
+
+	  env[:events] ||= []
 
 	  $log.info  env[:var] = "#{self} new_value_inbound"
+
+	  $log.info  env[:events] << "#{self} new_event_inbound"
+
 	  @ext.call(env)
 
 	  #Outbound maniuplation
-	  $log.info env[:var] = "#{self} new_value_outbound"
+	  $log.info  env[:var] = "#{self} new_value_outbound"
+
+	  $log.info env[:events] << "#{self} new_event_outbound"
 	end
       end
     end

data/lib/mushin/version.rb

@@ -1,3 +1,3 @@
 module Mushin
-  VERSION = "0.10.0"
+  VERSION = "0.12.0"
 end

data/lib/mushin.rb

@@ -1,14 +1,15 @@
 require 'middleware'
-require 'logger' 
+require 'logger'
 
 require_relative "mushin/version"
+#require_relative "mushin/es/event"
+#require_relative "mushin/es/event_stream"
 require_relative "mushin/stack"
 require_relative "mushin/ext"
 require_relative "mushin/domain"
 require_relative "mushin/generator"
 require_relative "mushin/test_helper"
-
-$log = Logger.new(STDOUT)
+require_relative "mushin/bot"
 
 class String
   def black;          "\e[30m#{self}\e[0m" end
@@ -35,3 +36,31 @@ class String
   def blink;          "\e[5m#{self}\e[25m" end
   def reverse_color;  "\e[7m#{self}\e[27m" end
 end
+
+module Mushin
+  private
+  # UNKNOWN: 	An unknown message that should always be logged.
+  # FATAL: 	An unhandleable error that results in a program crash.
+  # ERROR: 	A handleable error condition.
+  # WARN: 	A warning.
+  # INFO: 	Generic (useful) information about system operation.
+  # DEBUG: 	Low-level information for developers.
+  def self.logger(shift_age: 'daily',
+	     datetime_format: '%Y-%m-%d %H:%M:%S',
+	     log_dir: 'log'
+	    )
+    Dir.mkdir(log_dir) unless File.exists?(log_dir)
+    logger_file = "#{log_dir}/#{DateTime.now.strftime('%m_%d_%Y')}.log"
+    file = File.open(logger_file, File::APPEND | File::WRONLY | File::CREAT)
+    file.sync = true
+    #file = File.open(logger_file, File::WRONLY | File::APPEND) 
+    @log = Logger.new("| tee " + file.path, shift_age)
+    @log.datetime_format = datetime_format
+    #@log.progname = 'eventstream'
+
+    #@log.info "Mushin Log Levels: DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN"
+    return @log
+  end
+
+  $log = logger #Logger.new(STDOUT)
+end

data/mushin.gemspec

@@ -37,5 +37,12 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "thor" #, "~> 0.3"
   spec.add_runtime_dependency "thor" #, "~> 0.3"
 
+  spec.add_runtime_dependency "sinatra" #, "~> 0.3"
+  spec.add_runtime_dependency "ssd" #, "~> 0.3"
+  spec.add_runtime_dependency "cinch" #, "~> 0.3"
+
+  # favouring ore for gem generation over bundler, as it providers a fine-grained customization
+  spec.add_runtime_dependency "ore" #, "~> 0.3"
+
   #TODO http://guides.rubygems.org/security/
 end

data/samples/sample1.rb

@@ -1,16 +1,35 @@
-require 'mushin'
-
+#require 'mushin'
+require_relative './../lib/mushin'
 #$log.level = Logger::WARN
 module Sample
 
   class TBP < Mushin::Test::Sample::Ext; end
   class SSD < Mushin::Test::Sample::Ext; end
+  class SSDS < Mushin::Test::Sample::Ext
+    def call(env)
+      env ||= Hash.new 
+      env[:shit] = "coool"
+      super
+      return env
+    end
+  end
+
+  class SSDA < Mushin::Test::Sample::Ext
+    def call(env)
+      env ||= Hash.new 
+      env[:nana] = "nana_what"
+      super
+      return env
+    end
+  end
+
 
   class RUTracker < Mushin::Test::Sample::Ext; end
   class Mongodb < Mushin::Test::Sample::Ext; end
 
 
   class Domain < Mushin::Domain
+    # execution model 
     context 'torrent_bots' do 
       construct 'tpb' do
 	use ext: Sample::TBP, params: {}, opts: {"search_results" => :search_result_max}
@@ -19,21 +38,50 @@ module Sample
 	use ext: Sample::SSD, params: {}, opts: {"ssd_path"=> :storage_path}
       end
       construct 'rutracker' do
-      	use ext: Sample::RUTracker, params: {"search_results" => :search_result_max}
-      	use ext: Sample::Mongodb, params: {"search_results" => :search_result_max}
+	use ext: Sample::RUTracker, params: {"search_results" => :search_result_max}
+	use ext: Sample::Mongodb, params: {"search_results" => :search_result_max}
       end
     end
+
+    # query model 
+    query do
+      construct 'torrents' do
+	use ext: Sample::SSDS, params: {"seeders" => :seeders}, opts: {"ssd_path"=> :keyword}
+	use ext: Sample::SSDA, params: {"seeders" => :seeders}, opts: {"ssd_path"=> :keyword}
+      end
+
+      construct 'torrentsB' do
+	use ext: Sample::SSDS, params: {"seeders" => :seeders}, opts: {"ssd_path"=> :keyword}
+	use ext: Sample::SSDA, params: {"seeders" => :seeders}, opts: {"ssd_path"=> :keyword}
+      end
+
+    end
   end
 
   class App
     def initialize
-      s = "8888"
-      Domain.new do 
+      params = {}
+      params[:secret] = "8888"
+
+      domain = Domain.new do
 	torrent_bots do
 	  tpb search_result_max: "20", storage_path:"crazypath_here"
-	  rutracker search_result_max: "s"
+	  rutracker search_result_max: params[:secret]
 	end
+
+	query do 
+	  torrents keyword: "shit", seeders: "30"
+	  torrentsB keyword: "nononononon", seeders: "30"
+	end
+
       end
+
+      p domain.torrents 
+      p domain.torrentsB
+      p "kil"
+
+      #return domain.query :some_key # query somthing specific from the virtual domain datastore
+      return domain.store # returns the whole virtual domain datastore
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mushin
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.12.0
 platform: ruby
 authors:
 - zotherstupidguy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-24 00:00:00.000000000 Z
+date: 2016-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,62 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ssd
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cinch
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ore
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: mushin allows you to generate domain-specific frameworks and domain extenstions.
 email:
 - zotherstupidguy@gmail.com
@@ -117,6 +173,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ssd/eventstream/11_29_2016.ssd"
+- ".ssd/eventstream/11_30_2016.ssd"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -128,9 +186,14 @@ files:
 - bin/setup
 - exe/mushin
 - lib/mushin.rb
+- lib/mushin/bot.rb
+- lib/mushin/cqrs/command.rb
+- lib/mushin/cqrs/query.rb
 - lib/mushin/domain.rb
 - lib/mushin/dsl.rb
 - lib/mushin/dsl_builder.rb
+- lib/mushin/es/event.rb
+- lib/mushin/es/event_stream.rb
 - lib/mushin/ext.rb
 - lib/mushin/generator.rb
 - lib/mushin/stack.rb