mushin 0.25.0 → 0.26.0

data/{samples → showcases}/sample3.rb

@@ -43,7 +43,10 @@ module Sample
   class Mongodb < Mushin::Test::Sample::Ext; end
 
   class Domain
+   include Mushin::Domain
+    #extend Mushin::Domain
     using Mushin::Domain
+    #extend Mushin::Main
 
     context "torrent_bots" do
       construct "tpb" do
@@ -74,13 +77,13 @@ module Sample
       params[:secret] = "8888"
 
       torrent_bots do
-	tpb search_result_max: "20", storage_path:"crazypath_here"
+	tpb search_result_max: "20", storage_path:"crazypath_here", store: "ssd"
 	rutracker search_result_max: params[:secret]
       end
 
       query do
-	torrentsA  path_valueA: "this is a torrentsA pathvalueA", seeders_valueA: "30torrentA", path_valueB: "this is torrentsA pathvalueB", seedersvalueB: "30torrentB"
-	torrentsB  path_value: "this is a torrentsB pathvalue", seeders_value: "30torrentB"
+	torrentsA  path_valueA: "this is a torrentsA pathvalueA", seeders_valueA: "30torrentA", path_valueB: "this is torrentsA pathvalueB", seeders_valueB: "30torrentB"
+	torrentsB  path_valueA: "this is a torrentsB pathvalue", path_valueB: "koko", seeders_valueA: "30torrentA", seeders_valueB: "anna"
 	#torrentsB keyword: "torrentsB nononononon", seeders: "30"
       end
 

data/showcases/torrents_showcase/README.md

@@ -0,0 +1,6 @@
+This directory contains:
+
+- FetchTorrentz: a sample mushin domain-specific framework for searching torrent websites 
+- TPB: a sample built-in mushin extenstion for FetchTorrentz to search ThePirateBay 
+- RUTracker: a sample standalone mushin extenstion for FetchTorrentz 
+- SampleApp: a sample application using FetchTorrentz framework

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mushin
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.26.0
 platform: ruby
 authors:
 - zotherstupidguy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-09 00:00:00.000000000 Z
+date: 2016-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,10 +108,25 @@ dependencies:
     - - ">="
       - !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'
 description: mushin allows you to generate domain-specific frameworks and domain extenstions.
 email:
 - zotherstupidguy@gmail.com
 executables:
+- generator.rb
 - mushin
 extensions: []
 extra_rdoc_files: []
@@ -126,27 +141,30 @@ files:
 - about.md
 - bin/console
 - bin/setup
+- exe/generator.rb
 - 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/builtin/ssd/ssd.rb
+- lib/mushin/domain.rb
 - lib/mushin/ext.rb
 - lib/mushin/logger.rb
-- lib/mushin/main.rb
+- lib/mushin/service.rb
 - lib/mushin/stack.rb
+- lib/mushin/store.rb
 - lib/mushin/test_helper.rb
 - lib/mushin/version.rb
 - mushin.gemspec
-- samples/sample1.rb
-- samples/sample2.rb
-- samples/sample3.rb
+- showcases/gamification_showcase/README.md
+- showcases/gamification_showcase/gameon/lib/gameon.rb
+- showcases/gamification_showcase/gameon/lib/gameon/builtin/badges.rb
+- showcases/gamification_showcase/gameon/lib/gameon/version.rb
+- showcases/gamification_showcase/points/points.rb
+- showcases/gamification_showcase/sample_app/app.rb
+- showcases/gamification_showcase/sample_app/ext/levels/levels.rb
+- showcases/sample1.rb
+- showcases/sample2.rb
+- showcases/sample3.rb
+- showcases/torrents_showcase/README.md
 homepage: http://mushin-rb.github.io/
 licenses:
 - MIT

data/hacks/bot.rb

@@ -1,236 +0,0 @@
-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/hacks/cqrs/command.rb

@@ -1,123 +0,0 @@
-module Mushin
-  module DSLBuilder
-    module CQRS
-
-      class Command 
-
-	# 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
-	  @constructs << Construct.new(construct_keyword, @app_dsl_context_klass, &block)
-	end
-
-	def app_dsl_context_access_method_and_klass(context_keyword, parent_klass)
-	  $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|
-	      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
-	  # 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 
-	  attr_accessor :ext_set
-
-	  def initialize construct_keyword, context_klass, &block
-	    @construct_keyword = construct_keyword
-	    @context_klass = context_klass
-	    $log.debug "@ext_set inside #{self} equals []"
-	    @ext_set = []
-
-	    instance_eval &block
-
-	    $log.debug "@ext_set inside #{self} equals #{@ext_set}"
-	    @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.debug "dynamically building app dsl construct access method for: #{construct_keyword}, inside: #{parent_klass}"
-	    ext_set.reverse!
-
-	    $log.debug "ext_set reserved inside #{self} equals #{ext_set}"
-
-	    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.debug 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
-		$log.debug "hahahaha"
-		$log.debug  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
-
-	    # 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
-	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/hacks/cqrs/query.rb

@@ -1,200 +0,0 @@
-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
-		$log.debug "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
-
-#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