mushin 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a283c8c960aee0c0485446728dfe43fbe2f3b26
-  data.tar.gz: d3e0a4f65a9fb5292a9063c6e00372d8d07ef495
+  metadata.gz: 1f70e9a7877e3a7c66d3059d6c532475bd46b461
+  data.tar.gz: e6be036dc7da19ad1cf2a6d1a471f0b4fb20109f
 SHA512:
-  metadata.gz: 0861f966361d9c26fa104a026ad0eee4c1bf8cacec62dc011499336724d131fb68758ddac3c986acb0aae8eeaefaac91a9b6f2af0209cf4f992e447d856b1bd7
-  data.tar.gz: 1f403b0bfa9bb450d46ce2dcc06ab8c678241898164f0ff13270153a7fa63367d36490c423fd6ca7ccf32e762f09497da0eebaf4975491ed272733ccf630c5d3
+  metadata.gz: bff8590b02972719c0c6033f05b5acf7ca3c30e93ff5f653604d106b5541cecd856e939ba48938d4c853c620c803ea57c45e77a790ac48c10d643086feb2d7de
+  data.tar.gz: bab6e09ba6ba66ced0efbc732a8406df66df837fe040a99966301cf00f9eff05d9c5c6d5833d3ec1d29e2ca386ca6d703637569e56e52a00110e7e6e87823d6b

data/README.md

@@ -1,8 +1,13 @@
 # Mushin
+In a mushin app there is two DSLs, domain developer DSL (provided via mushin) and app developer DSL(provided via the domain developer)
+
+Context is a place to define a DSL
+A Bounded Context can be considered as a miniature application, containing its own Domain,
+own code and persistence mechanisms. Within a Bounded Context, there should be logical
+consistency; each Bounded Context should be independent of any other Bounded Context.
 
 Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/mushin`. To experiment with that code, run `bin/console` for an interactive prompt.
 
-TODO: Delete this and the text above, and describe your gem
 
 ## Installation
 
@@ -21,8 +26,72 @@ Or install it yourself as:
     $ gem install mushin
 
 ## Usage
+```
+mushin new domain
+```
+This command generates a new domain that consits of a context.rb and an empty directory of ext/
+
+The context.rb requires mushin and require_relative everything in the ext directory. 
+Its initialize &block acts as a simple dsl for all the methods it contains.
+
+```
+require 'mushin'
+Dir['./ext/**/*.rb'].each{ |f| require_relative f }
+
+class Context
+ def initialize &block
+  instance_eval &block
+ end
+end
+```
 
-TODO: Write usage instructions here
+```
+mushin new ext
+```
+This command generates a new domain extension in the ext/ directory 
+
+```
+module Internal
+end
+
+class Main < Mushin::Ext # this raise an error if the inheriting class doens't have :initialize and :call                                                        
+ include Internal
+
+def initialize app=nil, opts={}, params={}
+ @app      = app
+ @opts     = opts
+ @params   = params 
+end
+
+def call env 
+#NOTE Utter Generated Code: used to provide you an env hash variable
+env = Hash.new if env.nil? 
+
+p "#{self} ------ Inbound maniuplation"
+p env
+p @params
+env[:query] = @params[:query]
+# Exception halt the middleware chain that backing out in a reverse order, works really well.
+case
+when env[:query].nil?, env[:query].empty?
+#TODO https://www.sitepoint.com/ruby-error-handling-beyond-basics/
+#TODO http://ieftimov.com/exception-handling-and-testing
+#return raise EmptyQuery
+p "empty is no good"
+else 
+env[:tpbbot] = search(env[:query])
+end
+
+@app.call(env)
+
+p "#{self} ------ Outbound maniuplation"
+p env
+
+end
+
+```
+## Reading list
+[domain-driven design servcies architecture](https://www.thoughtworks.com/insights/blog/domain-driven-design-services-architecture) .
 
 ## Development
 

data/lib/mushin/domain.rb

@@ -0,0 +1,123 @@
+# 1- an access method :context is defined in DSLBuilder(thats a module avialable as class methods to the domain class of the application.
+# 2- the :context takes a name, &block and pass instance_eval it aganist an object created from DSLBuilder::Context
+# 3- DSLBuilder::Context initialize takes a context_name say "torrent_bots" and create an app_context_klass and creates an access method with the :context_name inside DSL 
+#
+module Mushin
+  module DSLBuilder
+    class Context
+      attr_accessor :context_name
+      # defines a DSL::Klass of type Context based on :name
+      # Supplies the defined DSL::Klass with a method of the construct
+      def initialize context_name, &block
+	@context_name = context_name.capitalize
+
+	app_context_klass = Class.new(Object) do
+	  def initialize &block
+	    instance_eval &block
+	  end
+	end
+	# creates a context klass dynamically
+	DSL.const_set(context_name.capitalize, app_context_klass) unless DSL.const_defined?(context_name.capitalize)
+	# creates an access method inside DSL for the dynamically created context klass
+	DSL.send(:define_method, context_name) do |&block|
+	  DSL.const_get(context_name.capitalize).new &block unless context_name.nil?
+	end
+
+	instance_eval &block
+      end
+
+      # access method for DSLBuilder::Construct klass inside a context object &block
+      def construct name, &block
+	app_context_klass = DSL.const_get(@context_name)
+	Construct.new(name, app_context_klass, &block) #.instance_eval &block
+      end
+    end
+
+    class Construct
+      attr_accessor :name, :stack, :app_context_klass
+      def initialize name, app_context_klass, &block
+	@name 	= name.capitalize
+	@middlewares = []
+	@stack 	= Mushin::Stack.new
+	@app_context_klass = app_context_klass
+	
+	instance_eval &block
+	$log.info "middlewares after instance_eval"
+	$log.info  middlewares = @middlewares
+
+	app_construct_klass = Class.new(Object) do
+	  @@stack = Mushin::Stack.new
+	  @@env = {}
+	  @@middlewares = middlewares
+
+	  attr_accessor :env
+	  def initialize env = {}
+	    @env = env
+	    #p "merging #{@@env} with #{env_updates} for the result of #{env_updates.merge @@env}"
+	    #p "domaindsl construct is ready to activate calling the stack with #{env}"
+	  end
+	end # end of app_construct_klass 
+
+	DSL.const_set(name.capitalize, app_construct_klass) unless DSL.const_defined?(name.capitalize)
+	# Reopens most recent context klass and add method `def construct_name params; app_construct_class.new(params)`
+	# access method for DSL::Construct dynamic klass inside a context object &block
+	DSL.const_get(@app_context_klass.to_s).send(:define_method, name) do |env|
+	  # 1. populate :symbols inside opts and params with values from env
+	  @@middlewares.each do |middleware|
+	    middleware[:params].each do |key, value|
+	      env.each do |env_key, env_value|
+		if env_key.to_sym == value then
+		  middleware[:opts][key] = env_value
+		end
+	      end
+	    end
+
+	    middleware[:opts].each do |key, value|
+	      env.each do |env_key, env_value|
+		if env_key.to_sym == value then
+		  middleware[:opts][key] = env_value
+		end
+	      end
+	    end
+	    $log.info middleware
+	  end
+	  # 2. insert 
+	  @@middlewares.each do |middleware|
+	    @@stack.insert_before 0, middleware[:ext], middleware[:opts], middleware[:params]
+	  end
+	  # 3. call the stack
+	  @@stack.call
+
+	  DSL.const_get(name.capitalize).new env
+	end
+	#p DSL.constants
+      end
+
+      def use ext:, opts: {}, params: {}
+	@middlewares << {:ext => ext, :opts => opts, :params => params}
+	#p @middlewares
+	#	@stack.insert_before 0, ext, opts, params
+	#@stack.call
+	#@stack = Use.new(ext, opts, params, @stack)
+      end
+    end
+
+    def context name, &block
+      Context.new(name, &block) #.instance_eval &block
+    end
+  end
+
+  module DSL
+  end
+
+  class Domain
+    def self.inherited(subclass)
+      subclass.send :extend, DSLBuilder
+      subclass.send :include, DSL 
+    end
+
+    def initialize &block
+      instance_eval &block
+    end
+  end
+end

data/lib/mushin/ext.rb

@@ -0,0 +1,10 @@
+module Mushin
+  class Ext  
+    def initialize app
+      raise NotImplementedError, "Mushin Extenstions implement :initialize that takes an app"
+    end 
+    def call env
+      raise NotImplementedError, "Mushin Extenstions implement :call that takes an env"
+    end 
+  end
+end

data/lib/mushin/stack.rb

@@ -0,0 +1,10 @@
+module Mushin
+  class Stack < Middleware::Builder
+    def initialize &block 
+      # let's use `super` to instance_eval inside Middleware::Builder scope
+      super
+      # Run it!
+      call 
+    end
+  end
+end

data/lib/mushin/version.rb

@@ -1,3 +1,3 @@
 module Mushin
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/mushin.rb

@@ -1,26 +1,13 @@
-require_relative "mushin/version"
-require_relative "mushin/generator"
 require 'middleware'
 require 'logger' 
 
-$logger = Logger.new(STDOUT)
+require_relative "mushin/version"
+require_relative "mushin/stack"
+require_relative "mushin/ext"
+require_relative "mushin/domain"
+require_relative "mushin/generator"
 
-module Mushin
-  class Stack < Middleware::Builder
-    def initialize &block 
-      # let's use `super` to instance_eval inside Middleware::Builder scope
-      super
-      # Run it!
-      call 
-    end
-  end
+$log = Logger.new(STDOUT)
 
-  class Ext  
-    def initialize app
-      raise NotImplementedError, "Mushin Extenstions implement :initialize that takes an app"
-    end 
-    def call env
-      raise NotImplementedError, "Mushin Extenstions implement :call that takes an env"
-    end 
-  end
-end
+#module Mushin
+#end

data/samples/sample1.rb

@@ -0,0 +1,168 @@
+require 'mushin'
+
+module Sample
+  class Bot < Mushin::Ext
+    def initialize(app=nil, opts: {}, params: {})
+      @app     = app
+      @opts    = opts 
+      @params  = params 
+    end
+
+    def call(env)
+      # Inbound maniuplation
+      env = Hash.new if env.nil?
+      p env[:var] = "new_value_inbound"
+      @app.call(env)
+      #Outbound maniuplation
+      p env[:var] = "new_value_outbound"
+    end
+  end
+end
+
+module Mushin
+
+  module DSLBuilder
+    def self.context context_name, &block
+      @dsl = Module.new
+      yield
+    end
+    def self.construct construct_name, &block
+      yield
+    end
+
+    def self.use app, opts: {}, params: {}
+    end
+  end
+
+  class Domain
+
+    # Responsible for `executing` the DSL methods
+    def initialize &block
+      instance_eval &block
+    end
+
+    def self.inherited(app_domain_class)
+      # Responsible for `building` the DSL methods
+      app_domain_class.extend Mushin::DSLBuilder 
+      #super # important?
+    end
+  end
+end
+
+module Sample
+  class Domain < Mushin::Domain
+    # creates the context for torrent_bots
+    context :torrent_bots do
+      # creates the construct for tpb, a `mushin construct` is a stack of extenstions
+      # construct :tpb, { max_results: 10 } do
+      p "Sample:Domain: context shit..."
+      construct "tpb" do
+	p "Sample:Domain: construct shit..."
+	# keeps inserting into the domain's @stack object
+	use Bot, opts: {max_results: 10}, params: {}
+	#use "ssd"
+	#use "logger"
+      end
+    end
+  end
+
+  class Service
+    def server
+      Domain.new do
+	torrent_bots do
+	  p "Sample:Service: service dsl inside the torrent_bots"
+	  tpb max_results: 40
+	end
+      end
+    end
+  end
+end
+Sample::Service.new.server
+
+
+
+
+
+
+
+
+
+
+
+
+=begin
+
+      #extend self.class.dsl
+
+    def self.inherited(app_domain_class)
+      # use it if I want to extend the App Domain Class, 
+      # maybe sometimes it will be better to extend the objects itself.
+      #app_domain_class.extend @dsl
+      puts "#{app_domain_class} is ready to be injected with methods"
+      super
+    end
+
+    #attr_accessor :context
+    #
+
+      #@context = @@context.dup
+      # extends 
+      #extend @context.dsl
+
+  class ContextBuilder
+    attr_accessor :context_name
+    attr_accessor :stack, :env
+    attr_accessor :dsl
+
+    def initialize context_name, &block
+      @context_name = context_name
+      instance_eval &block
+    end
+
+    def construct construct_name, args={},  &block
+      @dsl = Module.new 
+      @dsl.send :define_method, construct_name do |&context_block|
+	#define_method @context_name do |&context_block|
+	instance_eval &context_block 
+      end
+
+      p "Mushin::Domain self.construct: #{construct_name.to_sym} is created" 
+      define_method(construct_name.to_sym) do |args={}, &construct_block|
+	p "Mushin::Domain self.construct: #{construct_name.to_sym} is executed" 
+	@env = {}
+	@stack = Mushin::Stack.new
+	#TODO @stack.env = args oorsomthing
+	p @stack.inspect
+	p @env[construct_name] = args
+	instance_eval &construct_block
+	p "calling the stack to execute"
+	@stack.call # call the stack after adding all the middlewares via use
+      end
+      instance_eval &block
+    end
+
+    # takes a app, opts={} and a params={} 
+    def self.use app, opts: {}, params: {}
+      p "Mushin::Domain self.use: #{app}, #{opts}, #{params} is created" 
+      define_method(construct_name.to_sym) do |args={}, &construct_block|
+	"@stack.insert_before 0, app, opts, params"
+	p "@stack.insert_before 0, #{app}, #{opts}, #{params}"
+      end
+      yield
+    end
+  end
+
+  b = Boy.new
+  b.send(define_method :greeting, -> { puts 'Hello!' })
+  dsl = Module.new
+  dsl.send(define_method :super, -> { puts 'i am super' })                                                             
+  b.extend Extras 
+  b.extend dsl 
+
+# Responsible for defining the DSL methods
+    #def self.context context_name, &block
+    #  @context = ContextBuilder.new context_name, &block
+    #  #extend context.dsl
+    #end
+
+=end

data/samples/sample2.rb

@@ -0,0 +1,165 @@
+require 'mushin'
+require 'docile'
+
+module Sample
+  class Bot < Mushin::Ext
+    def initialize(app=nil, opts: {}, params: {})
+      @app     = app
+      @opts    = opts 
+      @params  = params 
+    end
+
+    def call(env)
+      # Inbound maniuplation
+      env = Hash.new if env.nil?
+      p env[:var] = "new_value_inbound"
+
+      @app.call(env)
+
+      #Outbound maniuplation
+      p env[:var] = "new_value_outbound"
+
+    end
+  end
+end
+
+module Mushin
+  class ContextBuilder
+    attr_accessor :context_name
+    attr_accessor :stack, :env
+
+    def initialize context_name, &block
+      @context_name = context_name
+      instance_eval &block
+    end
+
+    def construct construct_name, &block
+      p "Mushin::Domain self.construct: #{construct_name.to_sym} is created" 
+      define_method(construct_name.to_sym) do |args={}, &construct_block|
+	p "Mushin::Domain self.construct: #{construct_name.to_sym} is executed" 
+	@env = {}
+	@stack = Mushin::Stack.new
+	#TODO @stack.env = args oorsomthing
+	p @stack.inspect
+	p @env[construct_name] = args
+	instance_eval &construct_block
+	p "calling the stack to execute"
+	@stack.call # call the stack after adding all the middlewares via use
+      end
+
+      instance_eval &block
+    end
+
+    # takes a app, opts={} and a params={} 
+    def self.use app, opts: {}, params: {}
+      p "Mushin::Domain self.use: #{app}, #{opts}, #{params} is created" 
+      define_method(construct_name.to_sym) do |args={}, &construct_block|
+	"@stack.insert_before 0, app, opts, params"
+	p "@stack.insert_before 0, #{app}, #{opts}, #{params}"
+      end
+      yield
+    end
+  end
+
+  class Domain
+    attr_accessor :context
+
+    def initialize &block
+      instance_eval &block
+    end
+    def self.context context_name, &block
+      #@context = ContextBuilder.new context_name, &block
+      context = Docile.dsl_eval(ContextBuilder.new context_name, &block).build
+    end
+
+  end
+end
+
+module Sample
+  class Domain 
+    #< Mushin::Domain
+    # creates the context for torrent_bots
+    context :torrent_bots do
+      # creates the construct for tpb, a `mushin construct` is a stack of extenstions
+      # construct :tpb, { max_results: 10 } do
+      p "Sample:Domain: context shit..."
+      construct "tpb" do
+	p "Sample:Domain: construct shit..."
+	# keeps inserting into the domain's @stack object
+	use Bot, opts: {max_results: 10}, params: {}
+	#use "ssd"
+	#use "logger"
+      end
+    end
+  end
+  yield @domain
+end
+
+class Service
+  def server
+    Domain.new do
+      torrent_bots do
+	p "Sample:Service: service dsl inside the torrent_bots"
+	tpb max_results: 40
+      end
+    end
+  end
+end
+
+end
+
+Sample::Service.new.server
+
+=begin
+
+    # takes a context_name and a block and dynamically define a :context_name method
+    def self.context context_name #, &block
+      p "Mushin::Domain self.context: #{context_name.to_sym} is created!"
+      define_method(context_name.to_sym) do |args={}, &context_block|
+	p "Mushin::Domain self.context: #{context_name.to_sym} is executed!"
+	instance_exec &context_block
+      end
+      yield
+    end
+
+    # takes a construct_name, args={} and a block and dynamically define a :construct_name method
+    def self.construct construct_name, args = {} , &block
+      DSL.new construct_name, args, &block
+    end
+
+
+	  #tpb max_results: params[:max_results]
+    #TODO do i need that, every construct is basically creating a DSL.new line
+    #def torrent_bots &block
+    #  DSL.new &block
+    #end
+    
+    #Domain.methods
+
+def use app, opts: {}, params: {}
+      p app
+      p opts
+      p params
+    end
+=end
+=begin
+     DSL.new do 
+  context 'xx' do 
+    construct 'yy' do
+      use 'zz' do
+      end
+    end
+  end
+
+  construct 'zz' do
+  end
+end
+  #TODO do i need that, every construct is basically passing params to a stack middleware
+  #class DSL < Mushin::DSL
+  #  def tpb max_results: 
+  #   p "testing tpb #{max_results}, under the hood will be insert this into the stack and at the end of the block will call the stack, use 'XXX' #, params: {'key' => 's'}"
+  #  end
+  #end
+
+
+=end

data/samples/sample3.rb

@@ -0,0 +1,105 @@
+require 'mushin'
+
+module DSLBuilder
+  @@dsl = Module.new do
+    def included mod
+      # determine here if the included is a context_dsl or a construct_dsl 
+      # then make constructs nested inside context until a new context is define and repeat
+      # or somthing similar
+      #.respond_to? :context_name
+      #.respond_to? :construct_name
+    end
+  end
+
+  @@stack = []
+
+  # context keyword
+  def context context_name, &block
+
+    # construct keyword
+    def construct construct_name, &block
+      #@construct_dsl = Module.new
+      # use keyword 
+      def use app, opts: {}, params: {}
+	@@stack << app
+	p "#{app} adding middlewares to the stack"
+	p @@stack
+      end 
+
+      @@dsl.send :define_method, construct_name do |&construct_block|
+	p "inside #{construct_name} context method"
+	instance_eval &construct_block 
+	
+	#remove_method construct_name
+      end
+
+      instance_eval &block 
+
+      # force raise error if use keyword is used outside of a construct block
+      undef :use
+    end 
+
+    @@dsl.send :define_method, context_name do |&context_block|
+      p "inside #{context_name} context method"
+      instance_eval &context_block 
+    end
+
+    instance_eval &block 
+
+    # force raise error if construct keyword is used outside of a context block
+    undef :construct
+  end 
+  def self.app_domain_dsl
+    @@dsl
+  end
+end 
+
+class Domain
+  extend DSLBuilder
+  def initialize &block
+    extend DSLBuilder.app_domain_dsl
+    instance_eval &block 
+  end
+end
+
+class AppDomain < Domain
+  context :torrent_bots do 
+    p "torrent_bots context built"
+    construct :tpb do 
+      p "tpb construct built"
+    end
+    construct :rutracker do 
+      p "rutracker construct built"
+      use "rutrackerbot"
+      use "ssd"
+      use "logger"
+    end
+  end
+
+  context :shit do
+    construct "xxxxxxxxxxxxxxxxxxxxxxxxxxxxlogger" do
+      use "xxxxxxxxxxxxxxxxxxxxxxxxxxxxlogger"
+    end
+  end
+end
+
+params = Hash.new
+params[:max] = "100000000000000"
+#p "from inside love #{x}"
+AppDomain.new do
+  p "AppDomain begins" 
+  torrent_bots do 
+    tpb do
+      p max_results = params[:max]
+      p max_results = params[:max]
+      p max_results = params[:max]
+      p max_results = params[:max]
+    end
+  end
+
+  tpb do
+    p "shit! constructs are its repeateive"
+  end
+
+  p "AppDomain ends"
+end

data/samples/sample4.rb

@@ -0,0 +1,155 @@
+require 'mushin'
+#
+# Thats the module I want to give to the AppDomain class or AppDomain objects
+# Usage: 
+#	dsl = {
+#  	 :a => [
+#    	   :b,
+#    	   :c
+#	  ]
+#	}
+#create_dsl(dsl)
+module DSL
+  def new_method_and_class(x, parent_klass = Object)
+    parent_klass.class_eval do
+      define_method(x) do |&block|
+	p x.to_s
+	parent_klass.const_get(x.capitalize).new.instance_eval &block if block
+      end
+    end
+
+    parent_klass.const_set(x.capitalize, Class.new)
+  end
+
+  def create_dsl(branch,parent_klass = Object)
+    case branch
+    when Symbol, String
+      new_method_and_class(branch,parent_klass)
+    when Array
+      branch.each do |child|
+	create_dsl(child, parent_klass)
+      end
+    when Hash
+      branch.each do |key, value|
+	create_dsl(value, new_method_and_class(key,parent_klass))
+      end
+    end
+  end
+end
+#
+# End of dsl Module
+#    
+
+class Domain
+  extend DSL
+  def self.inherited(subclass)
+
+    #
+    # Mushin DSL
+    #
+    ["context", "construct", "use"].inject(subclass.singleton_class) do |klass, dsl_builder_keyword|
+
+      p "inside inject:: #{subclass} inherited domain self: #{self} -- klass: #{klass} -- dsl_builder_keyword: #{dsl_builder_keyword}"
+
+      # runs class_eval on subclass.singleton_class aka `AppDomain singleton_class`
+      klass.class_eval do #klass.instance_eval do
+
+	# arg not a name
+	define_method(dsl_builder_keyword) do |name, &block|
+
+	  case dsl_builder_keyword
+	  when "context"
+	    p "#{name} context built"
+	    p subclass.singleton_class
+	    #p "context ............"
+	    #p klass.class
+	    #z = klass.const_get(dsl_builder_keyword.capitalize).new.instance_eval &block if block
+	    #p z.class
+	    #p dsl
+	    klass.const_get(dsl_builder_keyword.capitalize).new.instance_eval &block if block
+	    #context_name = name
+	    #dsl.send :define_method, context_name do |&context_block|
+	    #  instance_eval &context_block 
+	    #end
+	    #p dsl.instance_methods
+	    #subclass.send :include, dsl
+	  when "construct"
+	    #p "#{name} construct built"
+	    klass.const_get(dsl_builder_keyword.capitalize).new.instance_eval &block if block
+
+	    #construct_name = name
+	    #dsl.send :define_method, construct_name do |&context_block|
+	    #  instance_eval &context_block 
+	    #end
+	    ##p dsl.instance_methods
+	    #subclass.send :include, dsl
+	  when "use"
+	    #  p "#{name} built"
+	    p "add middleware to stack"
+	    #klass.const_get(dsl_builder_keyword.capitalize).new.instance_eval &block if block
+	  else
+	    p "warning or error: unkown mushin dsl builder keyword"
+	  end
+	end
+	#remove_method dsl_builder_keyword
+      end
+      klass.const_set(dsl_builder_keyword.capitalize, Class.new)
+    end
+    # 
+    # End of Mushin DSL 
+    #
+  end
+
+  def initialize &block
+    instance_eval &block 
+  end
+end
+
+class AppDomain < Domain
+  context :torrent_bots do 
+    #p "torrent_bots context defined"
+    construct :tpb do 
+    end
+    construct :rutracker do 
+      #p "rutracker construct built"
+      use "rutrackerbot"
+      use "ssd"
+      use "logger"
+    end
+  end
+
+  context :shit do
+    construct "xxxxxxxxxxxxxxxxxxxxxxxxxxxxlogger" do
+      use "xxxxxxxxxxxxxxxxxxxxxxxxxxxxlogger"
+    end
+  end
+end
+
+
+=begin testing if it is clean code and only works inside AppDomain
+context do
+  p "outsiiiiiiiiiiiiiiiiiiiiiiide"
+end
+=end
+
+params = Hash.new
+params[:max] = "100000000000000"
+#p "from inside love #{x}"
+
+#=begin
+AppDomain.new do
+  #p "AppDomain begins" 
+  torrent_bots do 
+    tpb do
+      p max_results = params[:max]
+      p max_results = params[:max]
+    end
+  end
+
+  tpb do
+    p "shit! constructs are its repeateive"
+  end
+
+  p "AppDomain ends"
+end
+#=end

data/samples/sample5.rb

@@ -0,0 +1,186 @@
+require 'mushin'
+#
+# Thats the module I want to give to the AppDomain class or AppDomain objects
+# Usage: 
+#	dsl = {
+#  	 :a => [
+#    	   :b,
+#    	   :c
+#	  ]
+#	}
+#create_dsl(dsl)
+class DSL
+  attr_accessor :middlewares, :stack
+
+  def initialize middlewares: [], &block
+    @stack = Mushin::Stack.new
+    #@middlewares.each do |middlewares|
+    # add it to the stack
+    #end
+    #@stack.call run the stack
+    instance_eval &block
+  end
+
+  def new_method_and_class(x, parent_klass = Object)
+    parent_klass.class_eval do
+      define_method(x) do |&block|
+	p x.to_s
+	parent_klass.const_get(x.capitalize).new.instance_eval &block if block
+      end
+    end
+
+    parent_klass.const_set(x.capitalize, Class.new)
+  end
+
+  def create_dsl(branch,parent_klass = Object)
+    case branch
+    when Symbol, String
+      new_method_and_class(branch,parent_klass)
+    when Array
+      branch.each do |child|
+	create_dsl(child, parent_klass)
+      end
+    when Hash
+      branch.each do |key, value|
+	create_dsl(value, new_method_and_class(key,parent_klass))
+      end
+    end
+  end
+end
+#
+# End of dsl Module
+#    
+
+class Domain
+  def self.inherited(subclass)
+    dsl_hash = Hash.new
+    #dsl = {:context_name => [:constructA,:constructB]}
+
+    #
+    # Mushin DSL
+    #
+    ["context", "construct", "use"].inject(subclass.singleton_class) do |klass, dsl_builder_keyword|
+
+      p "inside inject:: #{subclass} inherited domain self: #{self} -- klass: #{klass} -- dsl_builder_keyword: #{dsl_builder_keyword}"
+
+      # runs class_eval on subclass.singleton_class aka `AppDomain singleton_class`
+      klass.class_eval do #klass.instance_eval do
+
+	# arg not a name
+	define_method(dsl_builder_keyword) do |name, &block|
+
+	  p "thats my subclass"
+	  subclass.send(:define_method, :torrent_bots) do #|&block|
+	  end
+
+	  case dsl_builder_keyword
+	  when "context"
+	    p "#{name} context built"
+	    p subclass.singleton_class
+	    klass.const_get(dsl_builder_keyword.capitalize).new.instance_eval &block if block
+	  when "construct"
+	    #p "#{name} construct built"
+	    klass.const_get(dsl_builder_keyword.capitalize).new.instance_eval &block if block
+
+	  when "use"
+	    #  p "#{name} built"
+	    p "add middleware to stack"
+	    #klass.const_get(dsl_builder_keyword.capitalize).new.instance_eval &block if block
+	  else
+	    p "warning or error: unkown mushin dsl builder keyword"
+	  end
+	end
+	#remove_method dsl_builder_keyword
+      end
+      klass.const_set(dsl_builder_keyword.capitalize, Class.new)
+    end
+    # 
+    # End of Mushin DSL 
+    #
+  end
+
+  def initialize &block
+    instance_eval &block
+    #DSL.new &block 
+  end
+end
+
+class AppDomain < Domain
+  context :torrent_bots do
+    #p "torrent_bots context defined"
+    construct :tpb do 
+    end
+    construct :rutracker do 
+      #p "rutracker construct built"
+      use "rutrackerbot"
+      use "ssd"
+      use "logger"
+    end
+  end
+
+  context :shit do
+    construct "xxxxxxxxxxxxxxxxxxxxxxxxxxxxlogger" do
+      use "xxxxxxxxxxxxxxxxxxxxxxxxxxxxlogger"
+    end
+  end
+end
+#=begin
+AppDomain.new do
+  #p "AppDomain begins" 
+  torrent_bots do 
+    p "shit"
+    p "shit"
+    p "shit"
+    tpb do
+      p "crazy"
+      p max_results = params[:max]
+      p max_results = params[:max]
+    end
+  end
+
+  tpb do
+    p "shit! constructs are its repeateive"
+  end
+
+  p "AppDomain ends"
+end
+#=end
+#
+
+
+
+
+### HACKS
+#
+=begin 
+testing if it is clean code and only works inside AppDomain
+	    #p "context ............"
+	    #p klass.class
+	    #z = klass.const_get(dsl_builder_keyword.capitalize).new.instance_eval &block if block
+	    #p z.class
+	    #p dsl
+
+	    #context_name = name
+	    #dsl.send :define_method, context_name do |&context_block|
+	    #  instance_eval &context_block 
+	    #end
+	    #p dsl.instance_methods
+	    #subclass.send :include, dsl
+
+params = Hash.new
+params[:max] = "100000000000000"
+#p "from inside love #{x}"
+
+
+context do
+  p "outsiiiiiiiiiiiiiiiiiiiiiiide"
+end
+=end
+
+#construct_name = name
+#dsl.send :define_method, construct_name do |&context_block|
+#  instance_eval &context_block 
+#end
+##p dsl.instance_methods
+#subclass.send :include, dsl
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mushin
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - zotherstupidguy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-19 00:00:00.000000000 Z
+date: 2016-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,9 +128,17 @@ files:
 - bin/setup
 - exe/mushin
 - lib/mushin.rb
+- lib/mushin/domain.rb
+- lib/mushin/ext.rb
 - lib/mushin/generator.rb
+- lib/mushin/stack.rb
 - lib/mushin/version.rb
 - mushin.gemspec
+- samples/sample1.rb
+- samples/sample2.rb
+- samples/sample3.rb
+- samples/sample4.rb
+- samples/sample5.rb
 homepage: http://mushin-rb.github.io/
 licenses:
 - MIT