mushin 0.18.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 51447652084e21f340f0a7b4918bf3ba147f0435
-  data.tar.gz: 3aaa1956e697dddbf8abe10ec5b65aab90a6a05d
+  metadata.gz: a0fb43972864c2456988f71464106b71c234b037
+  data.tar.gz: dcbe3219ab4b0eb6e85f6555a4afb15cd3abf1e8
 SHA512:
-  metadata.gz: 7b79ee28e60ac336b7e24a1ba830c01598dcfd4891bda73f09c070cd24d5c73e7e2dd26bcee4736fa276bc0adeb8290f883d4af794028cd76aae5ee087008722
-  data.tar.gz: 3e8a62c300f941c91e98ec13549a388ddfef538015c062c22da803f4e9d5cfe5bd2c2d85a7ba7ae115b30e439779cac9a6ecb6a6063f8ccdcacc47d06efab0a3
+  metadata.gz: 6787fee036117fed47a8741556104fa2079f5359f3d39005d3cd6e7a2eb90d42e6ef3414f41e169a3a7b6bacf4e6b5ea0e0d57ea7e703c7863433b938ba1d69f
+  data.tar.gz: b5e8b3fb501cb4b00fd1dc516197d8b552669016278e8ba1f32336840099068943b59d1ac9846278cec12b1b6231c4907952a3661ff2c10f556ac1fee47fca49

data/{lib/mushin → hacks}/cqrs/command.rb

@@ -6,18 +6,26 @@ module Mushin
 
 	# attr for a dsl context constructor class
 	attr_accessor :app_dsl_context_klass
+	attr_accessor :constructs
 
 	def initialize context_keyword, &block
+	  dsl_module = Module.new do
+	  end
+	  Mushin.const_set(:DSL, dsl_module)
+	  Mushin::Domain.send :include, Mushin::DSL
+
+	  @constructs = []
+	  #@app_dsl_context_klass = app_dsl_context_access_method_and_klass(context_keyword, dsl_module)
 	  @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
+	  @constructs << 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
+	  $log.debug "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|
@@ -30,27 +38,25 @@ module Mushin
 	      instance_eval &block
 	    end
 	  end
-	  parent_klass.const_set(context_keyword.capitalize, k) #unless parent_klass.const_defined?(context_keyword.capitalize)   
+	  # check if the const is already defined to avoid warnings
+	  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
+	  attr_accessor :context_klass, :construct_klass 
+	  attr_accessor :ext_set
 
 	  def initialize construct_keyword, context_klass, &block
 	    @construct_keyword = construct_keyword
 	    @context_klass = context_klass
-	    $log.info "@ext_set inside #{self} equals []"
-	    $log.info "@ext_set inside #{self} equals []"
-	    $log.info "@ext_set inside #{self} equals []"
-	    $log.info "@ext_set inside #{self} equals []"
-	    $log.info "@ext_set inside #{self} equals []"
+	    $log.debug "@ext_set inside #{self} equals []"
 	    @ext_set = []
 
 	    instance_eval &block
 
-	    $log.info "@ext_set inside #{self} equals #{@ext_set}"
+	    $log.debug "@ext_set inside #{self} equals #{@ext_set}"
 	    @construct_klass = dsl_construct_access_method_and_klass(@construct_keyword, @ext_set, @context_klass)
 	  end
 
@@ -59,10 +65,10 @@ module Mushin
 	  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}"
+	    $log.debug "dynamically building app dsl construct access method for: #{construct_keyword}, inside: #{parent_klass}"
 	    ext_set.reverse!
 
-	    $log.info "ext_set reserved inside #{self} equals #{ext_set}"
+	    $log.debug "ext_set reserved inside #{self} equals #{ext_set}"
 
 	    parent_klass.class_eval do
 	      define_method(construct_keyword) do |args = {}|
@@ -82,7 +88,7 @@ module Mushin
 		    end
 		  end
 		end unless ext[:opts].nil?
-		$log.info ext 
+		$log.debug ext 
 	      end
 
 	      parent_klass.const_get(construct_keyword.capitalize).new args, ext_set
@@ -92,8 +98,8 @@ module Mushin
 	    k = Class.new do
 	      attr_accessor :stack
 	      def initialize args={}, ext_set
-		p "hahahaha"
-		p ext_set
+		$log.debug "hahahaha"
+		$log.debug  ext_set
 		@stack = Mushin::Stack.new
 
 		ext_set.each do |ext|
@@ -105,7 +111,8 @@ module Mushin
 	      end
 	    end
 
-	    parent_klass.const_set(construct_keyword.capitalize, k) #unless parent_klass.const_defined?(construct_keyword.capitalize)
+	    # check if the const is already defined to avoid warnings
+	    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

data/{lib/mushin → hacks}/cqrs/query.rb

@@ -100,7 +100,7 @@ module Mushin
 		ext_set.each do |ext|
 		  @stack.insert_before 0, ext[:ext], ext[:opts], ext[:params]
 		end
-		p "printing the stack value  #{@stack.call}"
+		$log.debug "printing the stack value  #{@stack.call}"
 		return @stack.call
 	      end
 	    end
@@ -114,3 +114,87 @@ module Mushin
     end # end of CQRS module
   end # end of DSLBuilder module
 end # end of Mushin module
+
+#self.class.send :attr_accessor, construct_key
+#instance_eval("@#{construct_key} = 'koko'")
+#send :instance_variable_set, "@#{construct_key}", 'koko'
+#self.singleton_class.send(:attr_accessor, construct_key)
+#self.singleton_class.send :instance_variable_set, "@#{construct_key}", "koko"
+#
+
+=begin
+	      # CQRS query 
+	      def query &query_block 
+		@@dsl_tree.each do |context_set|
+
+		  context_set.each do |context_key, context_value|
+		    p "context_key #{context_key} | context_value #{context_value}"
+		    self.singleton_class.send :define_method, context_key do |&context_block|
+		      context_value.each do |c|
+			c.each do |construct_key, construct_value|
+			  p "construct_key #{construct_key} | construct_value #{construct_value}"
+			  self.singleton_class.send :define_method, construct_key do |data = Hash.new|
+			    p "------data-------"
+			    p data
+			    p data.class
+			    data.each do |k, v|
+			      p  k
+			      p v
+			    end
+			    p "------data-------"
+			    p construct_value.class
+
+			    @stack = Mushin::Stack.new
+			    construct_value.each do |ext|
+			      #p ext_hash
+			      #p ext_hash.keys
+			      ##p ext_hash.values
+			      p ext
+			      p ext[:params]
+			      ext[:params].each do |ext_key, ext_value|
+				p data
+				data.each do |data_key, data_value|
+				  if data_key.to_sym == ext_value then
+				    p data_value
+				    ext[:params][ext_key] = data_value
+				  end
+				end
+			      end unless ext[:params].nil?
+
+			      ext[:opts].each do |key, value|
+				data.each do |data_key, data_value|
+				  if data_key.to_sym == value then
+				    ext[:opts][key] = data_value
+				  end
+				end
+			      end unless ext[:opts].nil?
+			      p "insert_before 0 into stack: #{ext[:ext]}, #{ext[:opts]}, #{ext[:params]}"
+			      @stack.insert_before 0, ext[:ext], ext[:opts], ext[:params]
+			    end
+			    @stack.call
+			  end
+			  #instance_eval("undef :#{construct_key}")
+			end
+		      end
+		      instance_eval &context_block
+
+
+		      context_set[context_key].each do |construct_hash|
+			p "xxxxxx"
+			construct_hash.keys.each do |method_key| 
+			  p method_key
+			  instance_eval("undef :#{method_key}")
+			end
+			p "construct_key #{context_key} is undef-ed"
+		      end
+		    end
+		  end
+		end
+
+		if !query_block.nil? then 
+		  instance_eval &query_block 
+		else
+		  fail "a query_block is required"
+		end
+	      end
+=end

data/hacks/domain.rb

@@ -0,0 +1,35 @@
+require_relative 'dsl_builder'
+module Mushin
+
+  class Domain
+    # offers a virtual datastore for query requests on the domain object
+    #attr_accessor :store, :event_stream
+    #attr_accessor :dparams
+    #attr_accessor :dsl_array
+
+  
+    def self.inherited(subclass)
+      subclass.send :extend, DSLBuilder 
+    end
+
+    def initialize &block
+      #def self.inherited(subclass)
+      #	subclass.send :extend, DSLBuilder 
+      #
+      #	dsl_module = Module.new do
+      #	end
+      #	Mushin.const_set(:DSL, dsl_module)
+      ##	subclass.send :include, DSL 
+      #      end
+
+      #def initialize params={}, &block
+      #@dparams = params
+      #$log.debug "Domain object #{self} is going to instance_eval with dparams of #{@dparams}"
+      #@dsl_array = []
+      instance_eval &block
+      Mushin.send :remove_const, :DSL #, dsl_module)
+    end
+    
+   
+  end
+end

data/hacks/dsl.rb

@@ -0,0 +1,39 @@
+=begin
+module Mushin
+  # DSL module holds one klass and one access method along with 
+  # one neseted klass and one nested access method
+  module DSL
+    def self.inherited(other)
+      $log.debug("#{self} is inherited in #{other}")
+    end
+    def self.method_added(name)
+      $log.debug("method #{name} is added to #{self}")
+    end
+    begin
+      tp = TracePoint.trace(:call) do |tp|                                                                               
+	if tp.method_id == :context then
+	  $log.debug "#{self} #{[tp.lineno, tp.defined_class, tp.method_id, tp.event]}"
+	end
+
+	if tp.method_id == :const_set then 
+	  #puts tp.definedmethods
+	  #puts "constant set" 
+	  #$log.info("#{self} is inherited in #{other}")
+	  #p self
+	  #$log.info "#{self} #{[tp.lineno, tp.defined_class, tp.method_id, tp.event, tp.class]}"
+	  #p "#{self} #{[tp.lineno, tp.defined_class, tp.method_id, tp.event, tp.class]}"
+	  #p self.methods
+	  #p constants
+	  #, :const_defined?
+	  #p tp
+	end 
+	#p "#{self} #{[tp.lineno, tp.defined_class, tp.method_id, tp.event, tp.class]}"
+      end 
+    rescue Exception
+      puts "#{$!} (#{$!.class})"
+      $stdout.flush
+      raise $!
+    end 
+  end
+end
+=end

data/hacks/dsl_builder.rb

@@ -0,0 +1,29 @@
+require_relative 'dsl'
+require_relative 'cqrs/command'
+require_relative 'cqrs/query'
+
+module Mushin
+
+  module DSLBuilder
+
+    @@commands = []
+
+    # The DSLBuilder context access method
+    def context context_keyword, &block
+      $log.debug "printing self from inside DSLBuilder:context #{self}, dsl_array: #{@dsl_array}"
+
+      @@commands << Mushin::DSLBuilder::CQRS::Command.new(context_keyword, &block)
+    end
+
+    def query &block 
+      $log.debug "printing self from inside DSLBuilder:query #{self}"
+      #@@commands << Mushin::DSLBuilder::CQRS::Query.new &block
+      Mushin::DSLBuilder::CQRS::Query.new &block
+    end
+
+    def commands
+      @@commands
+    end
+
+  end # end of DSLBuilder module
+end # end of Mushin

data/lib/mushin/logger.rb

@@ -0,0 +1,119 @@
+# Credits to https://gist.github.com/ab for source: https://gist.github.com/ab/3161648 
+
+# Colorizes the output of the standard library logger, depending on the logger level:
+# To adjust the colors, look at Logger::Colors::SCHEMA and Logger::Colors::constants
+
+require 'logger' 
+require 'date'
+
+module Mushin
+  # Colorizes the output of the standard library logger, depending on the logger level:
+  # To adjust the colors, look at Logger::Colors::SCHEMA and Logger::Colors::constants
+  #
+  # LEVELS
+  #========
+  # 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.
+
+  class Logger < Logger
+    module Colors
+      NOTHING      = '0;0'
+      BLACK        = '0;30'
+      RED          = '0;31'
+      GREEN        = '0;32'
+      BROWN        = '0;33'
+      BLUE         = '0;34'
+      PURPLE       = '0;35'
+      CYAN         = '0;36'
+      LIGHT_GRAY   = '0;37'
+      DARK_GRAY    = '1;30'
+      LIGHT_RED    = '1;31'
+      LIGHT_GREEN  = '1;32'
+      YELLOW       = '1;33'
+      LIGHT_BLUE   = '1;34'
+      LIGHT_PURPLE = '1;35'
+      LIGHT_CYAN   = '1;36'
+      WHITE        = '1;37'
+
+      SCHEMA = {
+	STDOUT => %w[nothing green brown red purple cyan],
+	#STDERR => %w[nothing green yellow light_red light_purple light_cyan],
+	STDERR => %w[dark_gray nothing yellow light_red light_purple light_cyan],
+      }
+    end
+
+
+    alias format_message_colorless format_message
+
+    def format_message(level, *args)
+      if self.class::Colors::SCHEMA[@logdev.dev] && @logdev.dev.tty?
+	begin
+	  index = self.class.const_get(level.sub('ANY','UNKNOWN'))
+	  color_name = self.class::Colors::SCHEMA[@logdev.dev][index]
+	  color = self.class::Colors.const_get(color_name.to_s.upcase)
+	rescue NameError
+	  color = '0;0'
+	end
+	"\e[#{color}m#{format_message_colorless(level, *args)}\e[0;0m"
+      else
+	format_message_colorless(level, *args)
+      end
+    end
+
+    def rainbow(*args)
+      SEV_LABEL.each_with_index do |level, i|
+	add(i, *args)
+      end
+    end
+  end
+
+ 
+  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 = Mushin::Logger.new("| tee " + file.path, shift_age)
+    @log.datetime_format = datetime_format
+    #@log.progname = 'eventstream'
+    
+    #@log.format_message 'DEBUG', 
+
+    @log.info "Mushin Log Levels: DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN" 
+    return @log
+  end
+
+end
+=begin
+  def black;          "\e[30m#{self}\e[0m" end
+  def red;            "\e[31m#{self}\e[0m" end
+  def green;          "\e[32m#{self}\e[0m" end
+  def brown;          "\e[33m#{self}\e[0m" end
+  def blue;           "\e[34m#{self}\e[0m" end
+  def magenta;        "\e[35m#{self}\e[0m" end
+  def cyan;           "\e[36m#{self}\e[0m" end
+  def gray;           "\e[37m#{self}\e[0m" end
+
+  def bg_black;       "\e[40m#{self}\e[0m" end
+  def bg_red;         "\e[41m#{self}\e[0m" end
+  def bg_green;       "\e[42m#{self}\e[0m" end
+  def bg_brown;       "\e[43m#{self}\e[0m" end
+  def bg_blue;        "\e[44m#{self}\e[0m" end
+  def bg_magenta;     "\e[45m#{self}\e[0m" end
+  def bg_cyan;        "\e[46m#{self}\e[0m" end
+  def bg_gray;        "\e[47m#{self}\e[0m" end
+
+  def bold;           "\e[1m#{self}\e[22m" end
+  def italic;         "\e[3m#{self}\e[23m" end
+  def underline;      "\e[4m#{self}\e[24m" end
+  def blink;          "\e[5m#{self}\e[25m" end
+  def reverse_color;  "\e[7m#{self}\e[27m" end
+=end

data/lib/mushin/main.rb

@@ -0,0 +1,146 @@
+require 'set'
+#TODO write fucken tests, move old specs to hacks dir, then select one big good spec
+#TODO write a good generator!
+#TODO release 1.0rc
+
+module Mushin
+  class Store < Mushin::Test::Sample::Ext
+    def initialize(ext, opts = {}, params= {})
+      @ext 	= ext 
+      @opts    	= opts 
+      @params  	= params 
+    end
+
+    def call(env)
+      env ||= Hash.new 
+      @ext.call(env)
+      return env
+    end
+  end
+
+  module Domain
+    refine Class do 
+      #TODO apply advanced centerlized logging automatically via TracePoint, DEBUG log level
+      #trace = TracePoint.new(:c_call) do |tp| #  p [tp.lineno, tp.defined_class, tp.method_id, tp.event]#end#trace.enable
+      @@dsl_tree = Set.new
+
+      def context keyword, &context_block
+	@context_keyword = keyword
+
+	@context_hash = Hash.new
+	@context_hash[@context_keyword] = []
+
+	def construct keyword, &construct_block
+	  @construct_keyword = keyword
+	  @construct_hash = Hash.new
+	  @construct_hash[@construct_keyword] = []
+	  def use ext: nil, opts: nil, params: nil
+
+	    $log.debug "use #{ext}, #{opts}, #{params}"
+	    @construct_hash[@construct_keyword]  << {ext: ext, opts: opts, params: params}
+
+	    #NOTE defining Domain instance methods in this class_exec block
+	    class_exec do 
+	      def store data_key: nil, data_value: nil
+		if !data_key.nil? && !data_value.nil? then
+		  @data[data_key] = data_value
+		  return @data
+		else
+		  return @data
+		end
+	      end
+
+	      def initialize &domain_block
+		@data = Hash.new #should be a HASH
+
+		# both CQRS command & CQRS query code here as well
+		@@dsl_tree.each do |context_set|
+
+		  context_set.each do |context_key, context_value|
+
+		    self.singleton_class.send :define_method, context_key do |&context_block|
+		      context_value.each do |construct_set|
+
+			construct_set.each do |construct_key, construct_value|
+			  $log.debug "construct_key #{construct_key} | construct_value #{construct_value}"
+
+			  self.singleton_class.send :define_method, construct_key do |data = Hash.new|
+			    query_data = []
+			    @stack = Mushin::Stack.new
+
+			    construct_value.each do |ext|
+			      ext[:params].each do |ext_key, ext_value|
+				data.each do |data_key, data_value|
+				  if data_key.to_sym == ext_value then
+				    $log.debug data_value
+				    ext[:params][ext_key] = data_value
+				  end
+				end
+			      end unless ext[:params].nil?
+
+			      ext[:opts].each do |key, value|
+				data.each do |data_key, data_value|
+				  if data_key.to_sym == value then
+				    ext[:opts][key] = data_value
+				  end
+				end
+			      end unless ext[:opts].nil?
+
+			      $log.debug "insert_before 0 into stack: #{ext[:ext]}, #{ext[:opts]}, #{ext[:params]}"
+			      @stack.insert_before 0, ext[:ext], ext[:opts], ext[:params]
+			    end
+
+			    if context_key == "query" then
+			      $log.debug "construct_key #{construct_key} | construct_value #{construct_value}"
+			      $log.debug "this method returns a Hash of all the requested shit "
+			      @stack.insert_before 0, Mushin::Store, {}, {}
+			      stack_data = @stack.call
+			      store(data_key: construct_key.to_sym, data_value: stack_data)
+			    else
+			      @stack.call
+			    end
+			  end
+			end
+		      end
+		      instance_eval &context_block
+
+		      context_set[context_key].each do |construct_hash|
+			construct_hash.keys.each do |method_key| 
+			  instance_eval("undef :#{method_key}")
+			end
+			$log.debug "construct_key #{context_key} is undef-ed"
+		      end
+		    end
+		  end
+		end
+
+		if !domain_block.nil? then 
+		  instance_eval &domain_block 
+		else
+		  fail "a domain_block is required"
+		end
+	      end
+	    end
+	  end 
+
+	  if !construct_block.nil? then 
+	    instance_eval &construct_block 
+	    @context_hash[@context_keyword] << @construct_hash
+	    undef :use
+	  else
+	    fail "construct_block please"
+	  end
+	end 
+
+	if !context_block.nil? then 
+	  instance_eval &context_block 
+	  @@dsl_tree << @context_hash
+	  undef :construct
+	else
+	  fail "context_block please"
+	end
+
+      end 
+    end
+  end
+end

data/lib/mushin/test_helper.rb

@@ -11,7 +11,7 @@ module Mushin
 	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 "Ext: #{self} is called with the following options: #{@opts} & params: #{@params}; and env: #{env}"
 	  $log.info "-----------------------------------------------------------------------"
 
 	  # Inbound maniuplation

data/lib/mushin/version.rb

@@ -1,3 +1,3 @@
 module Mushin
-  VERSION = "0.18.0"
+  VERSION = "0.19.0"
 end

data/lib/mushin.rb

@@ -1,66 +1,23 @@
 require 'middleware'
-require 'logger'
 
 require_relative "mushin/version"
-#require_relative "mushin/es/event"
-#require_relative "mushin/es/event_stream"
+require_relative "mushin/logger"
 require_relative "mushin/stack"
 require_relative "mushin/ext"
-require_relative "mushin/domain"
-require_relative "mushin/generator"
 require_relative "mushin/test_helper"
-require_relative "mushin/bot"
-
-class String
-  def black;          "\e[30m#{self}\e[0m" end
-  def red;            "\e[31m#{self}\e[0m" end
-  def green;          "\e[32m#{self}\e[0m" end
-  def brown;          "\e[33m#{self}\e[0m" end
-  def blue;           "\e[34m#{self}\e[0m" end
-  def magenta;        "\e[35m#{self}\e[0m" end
-  def cyan;           "\e[36m#{self}\e[0m" end
-  def gray;           "\e[37m#{self}\e[0m" end
-
-  def bg_black;       "\e[40m#{self}\e[0m" end
-  def bg_red;         "\e[41m#{self}\e[0m" end
-  def bg_green;       "\e[42m#{self}\e[0m" end
-  def bg_brown;       "\e[43m#{self}\e[0m" end
-  def bg_blue;        "\e[44m#{self}\e[0m" end
-  def bg_magenta;     "\e[45m#{self}\e[0m" end
-  def bg_cyan;        "\e[46m#{self}\e[0m" end
-  def bg_gray;        "\e[47m#{self}\e[0m" end
+require_relative "mushin/main"
 
-  def bold;           "\e[1m#{self}\e[22m" end
-  def italic;         "\e[3m#{self}\e[23m" end
-  def underline;      "\e[4m#{self}\e[24m" end
-  def blink;          "\e[5m#{self}\e[25m" end
-  def reverse_color;  "\e[7m#{self}\e[27m" end
-end
+#NOTE maybe later
+#require_relative "mushin/es/event"
+#require_relative "mushin/es/event_stream"
+#require_relative "mushin/domain"
+#require_relative "mushin/generator"
+#require_relative "mushin/bot"
 
 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 = Mushin.logger #Logger.new(STDOUT)
 
-  $log = logger #Logger.new(STDOUT)
+  # Set logging level to info 
+  $log.level = Logger::INFO
 end

data/mushin.gemspec

@@ -42,7 +42,10 @@ Gem::Specification.new do |spec|
   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"
+  spec.add_runtime_dependency 'ore' #, '~> 0.3'
+
+  #spec.add_runtime_dependency 'logger-colors', '~> 1.0'
+
 
   #TODO http://guides.rubygems.org/security/
 end

data/samples/sample2.rb

@@ -112,3 +112,135 @@ module Mushin
   module DSL
   end
 end
+
+#self.singleton_class.send :remove_method, construct_key.to_sym
+#self.singleton_class.send :remove_method, context_key.to_sym
+#self.singleton_class.send :undef, context_key.to_sym
+#
+
+
+# tree is a set
+# each context is a set
+# each construct is a hash where construct_name is key, and [ext, params, opts] are array
+#tree = [{:torrent_bots => [{:tpb => [["TPB", "params hash", "opts hash"], ["SSD", "params hash", "opts hash"]}]
+
+
+=begin
+  module DSL
+    refine Class do
+    end
+  end
+
+	    if  Mushin::DSL.const_defined? @context_keyword.capitalize then
+	      Mushin::DSL.const_set "#{@context_keyword.capitalize}", Module.new do 
+		send :define_method, :build_dsl do |dsl_tree= @dsl_tree, &block|
+		  p "passed the tree to the dsl_module #{dsl_tree}"
+		  #p dsl_tree
+		end
+	      end
+	    else
+	      p "prepend the module here"
+	    end
+
+=end
+=begin
+module DSL
+    def self.included base
+      base.class_eval do
+	#attr_accessor :keyword_array 
+	def initialize &block
+	  #@keyword_array = []
+	  instance_eval &block
+	end
+      end
+      minis.each do |m| 
+	p m
+	p m
+	p m
+	p m
+	base.send :include, m
+      end
+    end
+
+    def self.minis
+      constants.collect {|const_name| const_get(const_name)}.select {|const| const.class == Module}
+    end
+    end
+=end
+
+#NOTE can be Module.new("Mushin::DSL" + context_keyword.capitalize) to differeniate the minidsls dynamically added to an object in testing
+#dsl_module = Module.new(Mushin::DSL) do 
+#end
+#p context_keyword = @context_keyword 
+#p construct_keyword = @construct_keyword 
+
+=begin
+def self.included base
+  base.class_eval do
+    attr_accessor :keyword_array 
+    def initialize &block
+      @keyword_array = []
+      instance_eval &block
+    end
+  end
+end
+=end
+
+=begin
+	      #define_method construct_keyword do |&block|
+	      #self.extend dsl
+	      #	instance_eval &block
+	      #      end
+
+	      dsl.send :define_method, construct_keyword do |&block|
+		p "inside the instance construct #{self}"
+		p self
+		p self
+	      end
+
+	      define_method context_keyword do |&block|
+		p "inside the instance context #{self} with context_keyword #{context_keyword}"
+		instance_eval &block # self is the dsl module
+	      end
+=end
+
+#dsl.send :define_method, @context_keyword do |&block|
+#  p self
+#  instance_eval &block
+#end
+
+#dsl.send 
+#self.class.send :define_method, @construct_keyword do |&block|
+#  instance_eval &block
+#end
+
+# alias_method + refinment + dynamically created module that is included(maybe that wouldn't be passed)
+=begin
+  module DSL
+    def self.included base
+      base.class_eval do
+	def initialize &block
+	  instance_eval &block
+	end
+      end
+    end
+  end
+=end
+#define_method @context_keyword do |&block|
+#self.send :include, Mushin::DSL #self.send :prepend, Mushin::DSL
+=begin
+Mushin::DSL.send :define_method, @context_keyword do |&block|
+	    p "inside the domain obj"
+	    #self.class.send :define_method, construct_keyword do |&block|
+	    #end
+	    p self 
+	    p construct_keyword
+	    p "....."
+	    instance_eval &block
+	  end
+=end
+#p "context #{@context_keyword} is defined in Mushin::DSL"
+#Mushin::DSL.send :remove_method, @context_keyword 
+# Foo.instance_eval { undef :color }
+# removed_method removes method of receiver class where as undef_method removed all methods from inherited class including receiver class. 
+#base.send :prepend, DSL

data/samples/sample3.rb

@@ -0,0 +1,132 @@
+require_relative './../lib/mushin'
+
+module Sample
+  class TBP < Mushin::Test::Sample::Ext; end
+  class SSD < Mushin::Test::Sample::Ext; end
+  class SSDS < Mushin::Test::Sample::Ext
+    def initialize(ext, opts = {}, params= {})
+      @ext 	= ext 
+      @opts    	= opts 
+      @params  	= params 
+    end
+
+    def call(env)
+      env ||= Hash.new 
+      env[:SSDS_middlewareEnvKey] = "SSDS"
+      @ext.call(env)
+      #super
+      #return env
+    end
+  end
+
+  class SSDA < Mushin::Test::Sample::Ext
+    def initialize(ext, opts = {}, params= {})
+      @ext 		= ext 
+      @opts    	= opts 
+      @params  	= params 
+    end
+
+    def call(env)
+      env ||= Hash.new 
+      env[:nana] = "nana_what"
+      env[:SSDA_middlewareEnvKey] = "SSDA"
+      @ext.call(env)
+      env[:superman_real_nameB] = "where are you now dada"
+      #return env
+    end
+  end
+
+  class RUTracker < Mushin::Test::Sample::Ext 
+  end
+  class Mongodb < Mushin::Test::Sample::Ext; end
+
+  class Domain
+    using Mushin::Domain
+
+    context "torrent_bots" do
+      construct "tpb" do
+	use ext: Sample::TBP, params: {}, opts: {"search_results" => :search_result_max}
+	use ext: Sample::SSD, params: {}, opts: {"ssd_path"=> :storage_path}
+      end
+
+      construct "rutracker" do
+	use ext: RUTracker, params: {}, opts: {"search_results" => :search_result_max}
+      end
+    end
+
+    context "query" do
+      construct 'xyz' 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 'torrentsC' 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
+
+    #    context "ztorrent_bots" do
+    #      construct "zrutracker" do
+    #	use ext: "zRUTracker", params: "params", opts: "opts" 
+    #      end
+    #      construct "zxy" do
+    #	use ext: "zTPB", params: "params", opts: "opts" 
+    #      end
+    #    end
+  end
+
+  class App
+    mydomain = Domain.new do
+      params = {}
+      params[:secret] = "8888"
+
+      torrent_bots do
+	tpb search_result_max: "20", storage_path:"crazypath_here"
+	rutracker search_result_max: params[:secret]
+      end
+
+      query do
+	xyz keyword: "xyz query that shitxyzxyzxyz", seeders: "30"
+	torrentsC keyword: "torrentsC nononononon", seeders: "30"
+	torrentsB keyword: "torrentsB nononononon", seeders: "30"
+      end
+
+      #=begin 
+      #TODO it 'must only accepts things for that had been defined'
+      #ss do
+      #end
+      #torrent_bots do
+      #TODO it 'must only accepts things for that had been defined'
+      #stpb do
+      #end
+      #tpb "this is good"
+      #  tpb search_result_max: "202", storage_path:"crazypath_here2"
+      #end
+
+      #TODO it 'should be nested correctly"
+      #tpb "this is should be nested and shouldn't be allowed to work"
+
+      #ztorrent_bots do
+      #  zrutracker search_result_max: params[:secret2]
+      #  #zxy "god"
+      #end
+      #=end
+    end
+    #p "inspecting the domain object"
+    #p mydomain.methods
+    #p mydomain.inspect
+    #p mydomain.instance_variable_get("@xyz")
+    #p mydomain.store[:love]
+    #p mydomain.store[:xyz]
+    #p mydomain.store[:torrentsB][:nana]
+    p mydomain.store[:torrentsC]
+    p mydomain.store[:torrentsB]
+    p mydomain.store
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mushin
 version: !ruby/object:Gem::Version
-  version: 0.18.0
+  version: 0.19.0
 platform: ruby
 authors:
 - zotherstupidguy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-04 00:00:00.000000000 Z
+date: 2016-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -173,8 +173,6 @@ 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
@@ -185,23 +183,26 @@ files:
 - bin/console
 - bin/setup
 - exe/mushin
+- hacks/bot.rb
+- hacks/cqrs/command.rb
+- hacks/cqrs/query.rb
+- hacks/domain.rb
+- hacks/dsl.rb
+- hacks/dsl_builder.rb
+- hacks/es/event.rb
+- hacks/es/event_stream.rb
+- hacks/generator.rb
 - 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/logger.rb
+- lib/mushin/main.rb
 - lib/mushin/stack.rb
 - lib/mushin/test_helper.rb
 - lib/mushin/version.rb
 - mushin.gemspec
 - samples/sample1.rb
 - samples/sample2.rb
+- samples/sample3.rb
 homepage: http://mushin-rb.github.io/
 licenses:
 - MIT

data/.ssd/eventstream/11_29_2016.ssd

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

data/.ssd/eventstream/11_30_2016.ssd

@@ -1,9 +0,0 @@
----
-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/domain.rb

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

data/lib/mushin/dsl.rb

@@ -1,10 +0,0 @@
-module Mushin
-  # DSL module holds one klass and one access method along with 
-  # one neseted klass and one nested access method
-  module DSL
-    def self.inherited(other)
-      #p "inherited in #{other}"
-      puts other
-    end
-  end
-end

data/lib/mushin/dsl_builder.rb

@@ -1,23 +0,0 @@
-#require 'mushin'
-require_relative 'dsl'
-require_relative 'cqrs/command'
-require_relative 'cqrs/query'
-
-module Mushin
-
-  module DSLBuilder
-
-    # The DSLBuilder context access method
-    def context context_keyword, &block
-      p "printing self from inside DSLBuilder:context #{self}"
-      Mushin::DSLBuilder::CQRS::Command.new context_keyword, &block
-      #Mushin::DSLBuilder::CQRS::Context
-    end
-
-    def query &block 
-      p "printing self from inside DSLBuilder:query #{self}"
-      Mushin::DSLBuilder::CQRS::Query.new &block
-    end
-
-  end # end of DSLBuilder module
-end