mushin 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f0e88288b1562a69301bdd27ce84b1ebbf34669d
-  data.tar.gz: 6223db5afb53ab8a6dc8cd2b32e94a5739166685
+  metadata.gz: 23e3c79e4ed8304e6e27e3b29073604aa3e58290
+  data.tar.gz: 4c61d824c7d4e1877eb39bb4b0aeec0eda9a6faa
 SHA512:
-  metadata.gz: 88d3ef94d3cd205f21764a498729d8b8f21e87a8308ff34e55e0b77af00f5a470a93927232a6eee564a2a5b1844c80e5af9d82481a26db992b6b6d6c3577bbf7
-  data.tar.gz: ac7e906db31d0be0c154dd26d90638195cf76727470c4167bc777f81aff26c75534d11eee3874eeb1cfcc401e78dd90802d8bfb28eee912ecaa0599797c5bc7f
+  metadata.gz: 9d229890262a4ea1cb220319299beb18c23a10f05c08f587da1abb8dcbc46117360923f8e7f1fd867f0b6b197c8d3f4f2cafe074837093fe467a9824e2b09577
+  data.tar.gz: 0ce71e1931452f3ac0ac3922179dc5b63ab2efed0cf4e20e1a10bd1d768b96850736f9fbef6a2d52b6a2426f9e7601ef2f5c893e6d1f6f8246b618a82e51ad81

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/mygem
+*.swp

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -1,4 +1,4 @@
 source 'https://rubygems.org'
-ruby "2.3.1"
 
+# Specify your gem's dependencies in mushin.gemspec
 gemspec

data/README.md

@@ -1,96 +1,41 @@
-What is Mushin
-===============
-Mushin is a Domain-specific Framework Generator
+# Mushin
 
-How to use Mushin
-=================
-Directly via
+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.
 
-Mushin::Stack.new do 
- use DomainSpecificExtA, opts, params
- use DomainSpecificExtB, opts, params
- use DomainSpecificExtC, opts, params
-end
+TODO: Delete this and the text above, and describe your gem
 
-Indirectly via generating a domain-specific framework and using it instead to generate domain-specific Extentions.
+## Installation
 
-Generate the framework via
-```
-mushin roll domainframeworkXYZ
-```
-then after installing the framework gem in your system, generate extentions via 
-```
-domainframeworkXYZ ext extentionXYZ
-```
-```ruby
-DomainframeworkXYZ::Stack.new do 
- use extentionXYZ1, opts, params
- use extentionXYZ2, opts, params
- use extentionXYZ3, opts, params
-end
-```
+Add this line to your application's Gemfile:
 
-Domain-specfic Extentions duck types to the following interface:
 ```ruby
-class ExtensionXYZ 
- def initialize(app); end
- def call(env); end
-end
+gem 'mushin'
 ```
 
-######################################################################
-Mushin Books uses declarative DSL for describing what an expert want to do.
-https://www.netguru.co/blog/imperative-vs-declarative
-
-
-Mushin previously had crazy bugs as due to mutable objects, this is tend to be 
-avoided in the current implementation.
+And then execute:
 
-=== What is Mushin?
-Mushin is a specification interface between your ruby application and domain-specific frameworks.
-It provides generation capabilities to kick start developing your own domain-specific framework based on the interface, thats the Mushin way.
-Following the Mushin way, new developers can easily start using your new domain-specific framework in their applications. as they expect it to behave similarlar to other mushin-based frameworks.
+    $ bundle
 
-Mushin is a spec describing how an application should implement a domian-specifc rules and actions, similar in the sense that rack is a spec describing how webservers and webframeworks should implement a webrequest and webresponse, following this anology a webrequest the equvilant to a mushin rule, and a webresponse the equivlant of mushin response. and mushin rules engine is similar to rails routecontroller, except that mushin rules engine may activate a number of actions for each rule invoked. 
+Or install it yourself as:
 
-=== Mushin Goal
-Mushin goal is to be in service for preventing every ruby application from complecting different domain knolwedge, in the sense that via following the mushin way, each domain knoweldge is mature in isolation with its own middlewares, in the realm of its own domain-specific framework.
+    $ gem install mushin
 
-=== What Mushin do?
-Mushin do to a ruby application and domain-specific frameworks, what rack does to webservers and webframeworks. Except that rack doesn't offer code generation capabilities for webframework developers. Note: in a general sense a webframework is a domains-specific framework for the 'web' domain, see TheMetal project for the future of rack and how the ruby community been trying to further enahnce rack.
+## Usage
 
-=== Mushin TDD
+TODO: Write usage instructions here
 
-=== Writing Mushin Middleware
-It is a good practice to isolate the middleware from the logic, in the sense that that the logic code inside the call method of your middleware should only be concrned with descion flow and passing variables to your logic methods that typically will reside on its own classes.
+## Development
 
-===== Example writing a Redis DataStore Middleware
-- first we start by writing the specs for our middleware which is typical and can be gernated in the future via mushin
-mushin_middleware_spec.rb
-- then we move own to write the actual middleware
-##### this is a mushin middlware
-class redis
-	def app(env)
-	end
-	def call(env)
-		# here add your if, case statmetents
-  	end
-end
-- then we write the spec for our logic class that contain the methods for our logic
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-- and finally we write the actually logic class that make the spec pass
-#####  this is a logic file for the middleware of mushin
-class RedisDS
-#####  here each function is used and tested in as a spec in isolation
-end
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-=== Mushin testing
+## Contributing
 
-##### TODO Mushin::MockRequest, similar to rack's stack let(:request) { Rack::MockRequest.new(stack) }
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/mushin. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 
-=== Mushin Generation capabilities
-each new version of mushin contains a blue print of the domain-speicifc framework, it copies those files into a destenation directory and then uses grep to replace various code snippet 
+## License
 
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
 
-=== Virtual Currency Domain Framework, that includes middlewares for different client apis and gems to work with virtualcurrencies

data/Rakefile

@@ -1,79 +1,10 @@
-require "rake"
-require 'rake/testtask'
-#require 'logger'
+require "bundler/gem_tasks"
+require "rake/testtask"
 
-#$logger = Logger.new(STDOUT)
-
-task 'clear_screen' do 
-  `clear`
-end
-
-Rake::TestTask.new 'env_spec' do |t|
-  #libs = ["lib/env.rb"]
-  #t.warning = true
-  #t.verbose = true
-  t.test_files = FileList['spec/env_spec.rb']
-end
-
-
-Rake::TestTask.new 'engine_spec' => ['clear_screen'] do |t|
-  libs = ["lib/engine.rb"]
-  #t.warning = true
-  #t.verbose = true
-  t.test_files = FileList['spec/engine_spec.rb']
-end
-
-=begin
-Rake::TestTask.new 'ds_spec' => ['clear_screen'] do |t|
-  libs = ["lib/ds/ds.rb"]
-  t.warning = true
-  t.verbose = true
-  t.test_files = FileList['spec/ds/ds_spec.rb']
-end
-
-Rake::TestTask.new 'redis_spec' => ['clear_screen'] do |t|
-  libs = ["lib/ds/redis.rb"]
-  #t.warning = true
-  #t.verbose = true
-  t.test_files = FileList['spec/ds/redis_spec.rb']
-end
-# task :default => :complete_test
-# compelte test depends on flushin db then expecting a certain space upcoming events run the test
-
-#task 'db:flush' do
-#  `redis-cli flushall`
-#  $logger.info("Redis got a flushall")
-#end
-desc 'Complete clean test, should depend on other stuff'
-task :complete do
-  #ENV['Somevariable'] = 'true'
-  Rake::Task['db:info'].execute
-  Rake::Task['db:flush'].invoke
-  Rake::Task['test'].invoke
-end
-
-task 'db:monitor' do 
-  `redis-cli monitor`
-end
-
-task 'db:info' do
-  `redis-cli INFO`
-end
-=end
-=begin
-Rake::TestTask.new 'test' => ['db:flush'] do 
-  libs = ["lib"]
-  warning = true
-  verbose = true
-  test_files = FileList['spec/*_spec.rb']
-end
-=end
-=begin
-Rake::TestTask.new 'test'  => ['clear_screen', 'db:flush'] do |t|
-  t.libs = ["lib"]
-  t.warning = true
-  t.verbose = true
-  t.test_files = FileList['spec/*_spec.rb']
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
 end
-=end
 
+task :default => :test

data/about.md

@@ -0,0 +1,108 @@
+#TODO 
+mushin itselef needs to be remade as a bundler generated gem to be able to run `bundle exec rake release` and similar, must use --exec too for adding mushin executables.
+
+What is Mushin
+===============
+Mushin is a Domain-specific Framework Generator
+
+What Mushin does?
+=================
+Mushin generates:
+1) domain gems
+2) domain extenstion gems
+
+resource: bundle exec rake release
+resource: bundle gem --help
+
+How to use Mushin
+=================
+Directly via
+
+Mushin::Stack.new do 
+ use DomainSpecificExtA, opts, params
+ use DomainSpecificExtB, opts, params
+ use DomainSpecificExtC, opts, params
+end
+
+Indirectly via generating a domain-specific framework and using it instead to generate domain-specific Extentions.
+
+Generate the framework via
+```
+mushin roll domainframeworkXYZ
+```
+then after installing the framework gem in your system, generate extentions via 
+```
+domainframeworkXYZ ext extentionXYZ
+```
+```ruby
+DomainframeworkXYZ::Stack.new do 
+ use extentionXYZ1, opts, params
+ use extentionXYZ2, opts, params
+ use extentionXYZ3, opts, params
+end
+```
+
+Domain-specfic Extentions duck types to the following interface:
+```ruby
+class ExtensionXYZ 
+ def initialize(app); end
+ def call(env); end
+end
+```
+
+######################################################################
+Mushin Books uses declarative DSL for describing what an expert want to do.
+https://www.netguru.co/blog/imperative-vs-declarative
+
+
+Mushin previously had crazy bugs as due to mutable objects, this is tend to be 
+avoided in the current implementation.
+
+=== What is Mushin?
+Mushin is a specification interface between your ruby application and domain-specific frameworks.
+It provides generation capabilities to kick start developing your own domain-specific framework based on the interface, thats the Mushin way.
+Following the Mushin way, new developers can easily start using your new domain-specific framework in their applications. as they expect it to behave similarlar to other mushin-based frameworks.
+
+Mushin is a spec describing how an application should implement a domian-specifc rules and actions, similar in the sense that rack is a spec describing how webservers and webframeworks should implement a webrequest and webresponse, following this anology a webrequest the equvilant to a mushin rule, and a webresponse the equivlant of mushin response. and mushin rules engine is similar to rails routecontroller, except that mushin rules engine may activate a number of actions for each rule invoked. 
+
+=== Mushin Goal
+Mushin goal is to be in service for preventing every ruby application from complecting different domain knolwedge, in the sense that via following the mushin way, each domain knoweldge is mature in isolation with its own middlewares, in the realm of its own domain-specific framework.
+
+=== What Mushin do?
+Mushin do to a ruby application and domain-specific frameworks, what rack does to webservers and webframeworks. Except that rack doesn't offer code generation capabilities for webframework developers. Note: in a general sense a webframework is a domains-specific framework for the 'web' domain, see TheMetal project for the future of rack and how the ruby community been trying to further enahnce rack.
+
+=== Mushin TDD
+
+=== Writing Mushin Middleware
+It is a good practice to isolate the middleware from the logic, in the sense that that the logic code inside the call method of your middleware should only be concrned with descion flow and passing variables to your logic methods that typically will reside on its own classes.
+
+===== Example writing a Redis DataStore Middleware
+- first we start by writing the specs for our middleware which is typical and can be gernated in the future via mushin
+mushin_middleware_spec.rb
+- then we move own to write the actual middleware
+##### this is a mushin middlware
+class redis
+	def app(env)
+	end
+	def call(env)
+		# here add your if, case statmetents
+  	end
+end
+- then we write the spec for our logic class that contain the methods for our logic
+
+- and finally we write the actually logic class that make the spec pass
+#####  this is a logic file for the middleware of mushin
+class RedisDS
+#####  here each function is used and tested in as a spec in isolation
+end
+
+=== Mushin testing
+
+##### TODO Mushin::MockRequest, similar to rack's stack let(:request) { Rack::MockRequest.new(stack) }
+
+
+=== Mushin Generation capabilities
+each new version of mushin contains a blue print of the domain-speicifc framework, it copies those files into a destenation directory and then uses grep to replace various code snippet 
+
+
+=== Virtual Currency Domain Framework, that includes middlewares for different client apis and gems to work with virtualcurrencies

data/exe/mushin

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+require "mushin"
+
+module Mushin
+  class CLI < Thor
+    #include Utter::Tips
+
+    no_commands do 
+      def seprator
+	puts(" ")
+	puts("-------------------------------------------------------------------------------")
+	puts(" ")
+      end
+
+      def done
+	message   = set_color "  DONE  ", :green, :on_white, :bold
+	motive = set_color " You're Awesome!" + " ", :yellow
+	say(message + motive)
+      end
+
+      def mushin_banner
+	message   = set_color "  Mushin  ", :green, :on_white, :bold
+	motive = set_color " 'in the beginner\'s mind there are many possibilities, in the expert\'s there are few.'" + " ", :yellow
+	say(message + motive)
+      end
+    end
+
+    desc "new", "Generate new a domain-specific framework \ domain extenstion"
+    def new command, params = {}
+      mushin_banner
+      if params.empty? then
+	case command
+	when "domain"
+
+	  seprator
+
+	  info = set_color("  INFO  ", :green, :on_white, :bold)
+	  message = " choose if your domain is standalone or nested "
+	  puts (info + message)
+
+	  #domain_name 		= ask(set_color("Domain Name, e.g. 'gamification': ", :bold))
+	  gem_name 		= ask(set_color(" Enter a domain gem name: ", :bold))
+	  gem_type 		= "domain"
+	  gem_context 		= ask(set_color(" domain gem context? 'project' or 'standalone' ", :bold))
+	  gem_editor 		= nil #ask(set_color(" gemspec editor? 'vim', 'emacs', etc. ", :bold))
+
+	  seprator
+
+	  params = {:gem_name => gem_name, :gem_type => gem_type, :gem_context => gem_context, :editor => gem_editor}
+
+	  Mushin::Generator.new.gem params 
+
+	  done # Says Done you are awesome!	  
+	when "extension", "ext"
+	  seprator
+
+	  #TODO should search rubygems for for the given keywords and suggest a relevant Domain-specific Framework to use
+	  #domain_framework_name 	= ask(set_color("Domain-specific Framework name, e.g. 'GameOn': ", :bold))
+	  #domain_keywords 		= ask(set_color("Domain keywords, e.g. 'gamification': ", :bold))
+	  ext_name 			= ask(set_color("Extension Name, e.g. 'badges': ",:bold))
+
+	  p params = {:ext_name => ext_name}
+	  #generator = Utter::Generators::Ext.new
+	  #generator.create_ext params
+	else
+	  p "not known"
+	end 
+      else
+	#if params is not empty then use direct mode (good for piping from other programs)
+      end
+    end
+
+    desc "package", "Pacakges a domain\domain-extension as a gem and releases it to a gem server"
+    def package
+      `bundle exec rake release`
+    end
+
+  end
+end
+
+Mushin::CLI.start

data/lib/mushin/generator.rb

@@ -0,0 +1,68 @@
+require 'thor'
+
+module Mushin
+  class Generator  < Thor::Group
+    include Thor::Actions
+
+    def gem params
+      @params 	= params 
+
+      #params = {:gem_name => gem_name, :gem_type => gem_type, :gem_context => gem_context, :editor => @editor}
+
+      @name 	= @params[:gem_name]
+      @type 	= @params[:gem_type]
+      @context 	= @params[:gem_context]
+      @editor 	= @params[:gem_editor]
+      #{:name => @name, :type =>type, :context => @context, :editor => @editor}
+
+      #clean the previous gem if it exists? 
+      system("rm -rf #{@name}") 
+
+      case @type
+      when "domain"
+	if @context == "project"
+	  p "creating a domain inside a project"
+	  #system "bundle gem #{@name.downcase} --test minitest --coc  --edit=#{@editor}" 
+	  system "bundle gem #{@name.downcase} --test minitest --mit --exe --coc" 
+	  minitest_spec
+	  system "mv #{@name.downcase} domain"
+	  @name = "domain"
+	  system "mkdir #{@name.downcase}/ext"
+	  #system "#{@editor} #{@name.downcase}/#{@name.downcase}.gemspec" 
+	  #system "cd #{@name.downcase} && bundle install" 
+	elsif @context == "standalone"
+	  p "creating a standalone domain"
+	  system "bundle gem #{@name.downcase} --test minitest --coc  --edit=#{@editor}" 
+	  system "cd #{@name.downcase} && bundle install" 
+	else
+	  p "context value must either be project or standalone"
+	end
+      when "ext"
+	p "ext............"
+      end
+    end
+
+    def minitest_spec
+      system("cd #{@name} && mv test spec && mv spec/#{@name.downcase}_test.rb spec/#{@name.downcase}_spec.rb && mv spec/test_helper.rb spec/spec_helper.rb")
+
+      #p "change directory test to spec"
+      #system("cd #{@name} && mv test spec") 
+
+      #p "change file name from test/#{@name.downcase}_test.rb to spec/#{@name.downcase}_spec.rb"
+      #system("cd #{@name} && mv spec/#{@name.downcase}_test.rb spec/#{@name.downcase}_spec.rb") 
+
+      #p "change file name from test/test_helper.rb to spec/spec_helper.rb"
+      #system("cd #{@name} && mv spec/test_helper.rb spec/spec_helper.rb")
+
+      append_to_file "#{@name}/spec/spec_helper.rb" do
+	"require 'minitest/autorun'"
+	"require 'minitest/spec'"
+	"require 'minitest/pride'"
+      end
+
+      #system("cd #{@name} && mv test spec") 
+      #require_relative "./../spec_helper"
+    end
+  end
+end
+

data/lib/mushin/version.rb

@@ -0,0 +1,3 @@
+module Mushin
+  VERSION = "0.2.0"
+end

data/lib/mushin.rb

@@ -1,14 +1,11 @@
-#require_relative './internals/env'
-#require_relative './internals/engine'
-#require_relative './internals/book'
-
+require_relative "mushin/version"
+require_relative "mushin/generator"
 require 'middleware'
 require 'logger' 
-$logger = Logger.new(STDOUT)
 
+$logger = Logger.new(STDOUT)
 
 module Mushin
-  VERSION = "0.1.0" 
   class Stack < Middleware::Builder
     def initialize &block 
       # let's use `super` to instance_eval inside Middleware::Builder scope

data/mushin.gemspec

@@ -1,9 +1,7 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
-p lib
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
-require_relative "lib/mushin"
+require 'mushin/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "mushin"
@@ -11,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["zotherstupidguy"]
   spec.email         = ["zotherstupidguy@gmail.com"]
 
-  spec.summary       = %q{Mushin is a Domain-specific Frameworks Generator.}
-  spec.description   = %q{Mushin is a Domain-specific Frameworks Generator}
+  spec.summary       = %q{mushin is a domain-specific framwork generator}
+  spec.description   = %q{mushin allows you to generate domain-specific frameworks and domain extenstions.}
   spec.homepage      = "http://mushin-rb.github.io/"
   spec.license       = "MIT"
 
@@ -36,5 +34,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "ibsciss-middleware", "~> 0.3"
   spec.add_runtime_dependency "ibsciss-middleware", "~> 0.3"
 
+  spec.add_development_dependency "thor" #, "~> 0.3"
+  spec.add_runtime_dependency "thor" #, "~> 0.3"
+
   #TODO http://guides.rubygems.org/security/
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mushin
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - zotherstupidguy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-02 00:00:00.000000000 Z
+date: 2016-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,29 +80,56 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.3'
-description: Mushin is a Domain-specific Frameworks Generator
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  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: []
+executables:
+- mushin
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
+- about.md
 - bin/console
 - bin/setup
-- lib/internals/book.rb
-- lib/internals/ds/ds.rb
-- lib/internals/ds/redis.rb
-- lib/internals/ds/secure_ds.rb
-- lib/internals/engine.rb
-- lib/internals/env.rb
-- lib/internals/wongi.rb
+- exe/mushin
 - lib/mushin.rb
+- lib/mushin/generator.rb
+- lib/mushin/version.rb
 - mushin.gemspec
 homepage: http://mushin-rb.github.io/
 licenses:
@@ -127,5 +154,5 @@ rubyforge_project:
 rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
-summary: Mushin is a Domain-specific Frameworks Generator.
+summary: mushin is a domain-specific framwork generator
 test_files: []

data/Gemfile.lock

@@ -1,28 +0,0 @@
-PATH
-  remote: .
-  specs:
-    mushin (0.1.0)
-      ibsciss-middleware (~> 0.3)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    ibsciss-middleware (0.4.1)
-    minitest (5.8.2)
-    rake (10.4.2)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (~> 1.12)
-  ibsciss-middleware (~> 0.3)
-  minitest (~> 5.0)
-  mushin!
-  rake (~> 10.0)
-
-RUBY VERSION
-   ruby 2.3.1p112
-
-BUNDLED WITH
-   1.12.5

data/lib/internals/book.rb

@@ -1,47 +0,0 @@
-require 'logger' 
-$logger = Logger.new(STDOUT)
-
-module Mushin
-  module Book
-    def rule &block
-      @rule 		= {}
-      @rule[:conditions] = []
-      @rule[:actions] 	= []
-      def condition c
-	@rule[:conditions] << c
-	$l.info "condition #{c} is added"
-      end
-      def action a
-	@rule[:actions] << a
-	$l.info "action #{a} is added"
-      end
-      yield
-      $logger.info "this rule is #{@rule}"
-      Mushin::Engine.add_rule @rule
-    end
-  end
-end
-
-module MyCookBook
-  extend Mushin::Book
-
-  rule do
-    condition [:subject_a, :predicate_a, :object_a]
-    condition :b_condition
-    condition :c_condition
-
-    action :a_action
-    action :b_action
-    action :c_action
-  end
-
-  rule do
-    condition :d_condition
-    condition :e_condition
-    condition :f_condition
-
-    action :d_action
-    action :e_action
-    action :f_action
-  end
-end

data/lib/internals/ds/ds.rb

@@ -1,31 +0,0 @@
-require_relative './redis'
-
-module Mushin 
-  module Persistence
-    class DS 
-
-      def initialize(app, opts={}, params={})
-	@app = app
-	@opts = opts
-	@params = params
-	@redis_ds = Mushin::Persistence::RedisDS.new
-      end
-
-      def call(env)
-	@id = env[:id]
-	if @redis_ds.exists? @id 
-	  env[:id] = @redis_ds.get(@id)[:id]
-	  env[:data] = @redis_ds.get(@id)[:data]
-	  $logger.info("domain env object exists in the database") 
-	else 
-	  @redis_ds.set(@id, env[:data])
-	  $logger.info("domain env object DOESNOT exist in the database") 
-	end
-	@app.call(env) # calls up the stack
-	@redis_ds.set(@id, env)
-	env
-      end
-
-    end
-  end
-end

data/lib/internals/ds/redis.rb

@@ -1,31 +0,0 @@
-require "redis"
-
-module Mushin 
-  module Persistence
-    class RedisDS
-      attr_accessor :id, :value_obj
-      def initialize(opts={}, params={})
-	#@id = params[:id]
-	#@value_obj = params[:value_obj]
-	@redis = Redis.new #opts to take a different redis server
-      end
-
-      def set(id = @id, value_obj = @value_obj) 
-	@redis.set(id, Marshal.dump(value_obj))
-      end
-
-      def get(id = @id)
-	Marshal.load(@redis.get(id))
-	#@redis.get(id)
-      end
-
-      def exists?(id)
-	if @redis.get(id).nil? then
-	  return false
-	else 
-	  return true
-	end
-      end
-    end
-  end
-end

data/lib/internals/ds/secure_ds.rb

@@ -1,101 +0,0 @@
-#!/usr/bin/env ruby
-require "openssl"
-require 'digest/sha2'
-require 'base64'
-
-# We use the AES 256 bit cipher-block chaining symetric encryption
-alg = "AES-256-CBC"
-
-# We want a 256 bit key symetric key based on some passphrase
-digest = Digest::SHA256.new
-digest.update("fouad is cool symetric key")
-key = digest.digest
-# We could also have just created a random key
-# key = OpenSSL::Cipher::Cipher.new(alg).random_key
-
-# For security as part of the encryption algorithm, we create a random
-# initialization vector.
-iv = OpenSSL::Cipher::Cipher.new(alg).random_iv
-#iv = OpenSSL::Cipher::Cipher.new(alg).key = "dfsdfasfsafasfaffouad"
-#p OpenSSL::Cipher::Cipher.new(alg).methods
-
-# Example, we debug output our key in various formats
-puts "Our key: #{key}"
-
-# Base64 the key
-key64 = [key].pack('m')
-puts "Our key base 64: #{key64}"
-
-# Base64 decode the key
-raise 'Key Error' if(key.nil? or key.size != 32)
-puts "Our key retrieved from base64: #{key64.unpack('m')[0]}"
-
-# Now we do the actual setup of the cipher
-aes = OpenSSL::Cipher::Cipher.new(alg)
-aes.encrypt
-aes.key = key
-aes.iv = iv
-
-=begin
-# Now we go ahead and encrypt our plain text.
-cipher = aes.update("This is line 1\n")
-cipher << aes.update("This is some other string without linebreak.")
-cipher << aes.update("This follows immediately after period.")
-cipher << aes.update("Same with this final sentence")
-cipher << aes.final
-=end
-class Env
-  def initialize(str)
-    @str = str
-  end
-  def say_hello
-    @str
-  end
-end
-
-#o = Env.new("hello\n")
-#data = Marshal.dump(o)
-#obj = Marshal.load(data)
-#obj.say_hello  #=> "hello\n"
-
-o = Env.new("hello\n")
-#cipher = Marshal.dump(Env.new("hello"))
-#cipher = Marshal.dump(o)
-cipher = "fouad" 
-
-puts "Our Encrypted data in base64"
-cipher64 = [cipher].pack('m')
-puts cipher64
-
-decode_cipher = OpenSSL::Cipher::Cipher.new(alg)
-decode_cipher.decrypt
-decode_cipher.key = key
-decode_cipher.iv = iv
-plain = decode_cipher.update(cipher64.unpack('m')[0])
-p plain
-#p decode_cipher.final
-#plain << decode_cipher.final
-#puts "Decrypted Text"
-#puts plain
-#p plain
-obj = Marshal.load(plain)
-p obj.say_hello  #=> "hello\n"
-
-
-=begin
-'
-# aes encode a file into another file.
-File.open("foo.enc","w") do |enc|
-   File.open("foo") do |f|
-     loop do
-       r = f.read(4096)
-       break unless r
-       cipher = aes.update(r)
-       enc << cipher
-     end
-   end
-
-   enc << aes.final
-end
-'
-=end

data/lib/internals/engine.rb

@@ -1,44 +0,0 @@
-module Mushin
-  class Engine
-
-    @@book_rules = []
-
-    def self.add_rule rule
-      @@book_rules << rule
-    end
-
-    def self.get_rules
-      # load or require_relative certain ruby books, done to be least invasive 
-      @@book_rules
-    end
-
-    def initialize env, book
-      @env_id 		= env[:id]
-      @env_rules 	= env[:rules]
-      @book_rules	= book[:rules]
-      match 
-    end
-
-    def match
-      @@book_rules.each do |rule|
-	if rule[:conditions] == "my provided conditions" then 
-	  # apply rule[:actions]
-	end
-      end
-      @book_rules[@env_rules.to_sym]
-    end
-
-    #def self.set_rules
-    # loads or require certain ruby books
-    # book ||= {:rules => {:some_data => "some rules(conditions and actions)", :x => "dfdf", :y => "dfdf"}}
-    # Book.new("location of the book file") will return an array or hash of the rules
-    #end
-
-    def self.run env
-      env[:book_rules] = get_rules
-      new(env, @@rules)
-    end
-  end
-end 
-
-#Mushin::Engine.run({:id => "myid", :rules => "some_data"})

data/lib/internals/env.rb

@@ -1,98 +0,0 @@
-module Mushin
-  class Env
-
-    attr_accessor :id, :rule , :env
-
-    def initialize id, &block
-      @env	 	= {}
-      @env[:rules] 	= []
-      @id 		= id
-      @env[:id] 	= @id
-      instance_eval &block if block_given? 
-    end
-
-    def rule(conditions = [])
-      @env[:rules] << conditions
-    end
-
-    def self.set id, &block
-      domain_instance = Mushin::Env.new id, &block
-      Mushin::Engine.run domain_instance
-    end
-
-    # run engine, give the env to the engine, 
-    # engine will return the env_instance after it hit all the middlewares including the database middleware.
-    # because domain_instance.env[:rules] is empty as there is no block; the Engine stack will only be of one middleware
-    # , the Mushin::Presistance::DS middleware
-    # Mushin::Engine.run domain_instance 
-    def self.get id
-      domain_instance = Mushin::Env.new id
-      Mushin::Engine.run domain_instance
-    end
-
-  end
-end
-
-=begin
-    def self.set id
-      self.new id
-      #Mushin::Persistence::RedisDS.new.set @id 
-    end
-    def self.get id
-      self.new id
-      #Mushin::Persistence::RedisDS.new.get @id 
-    end
-=end
-=begin
-# Each Domain Framework got its own Env object in the application space. 
-# In this manner the application can easily set and get enviroment objects
-#
-module Mushin
-  class Env
-
-    attr_accessor :id, :current_context_title, :activities
-
-    def initialize
-      @id 			= ''
-      @current_context_title 	= ''
-      @activities 		= []
-    end
-
-    def set id, &block
-      @id = id.to_s + 'mushin'
-      def context current_context_title, &block
-	@current_context_title 	= current_context_title  
-	@activities 		= []  
-	def activity current_activity_title
-	  @activities << current_activity_title 
-	end
-	instance_eval(&block)
-      end
-      instance_eval(&block)
-      #@activities.uniq.each do |current_activity_title| 
-      @activities.each do |current_activity_title| 
-	#GameOn::Engine.run @id, @current_context_title, current_activity_title 
-	$logger.info("Domain Framework Engine.run: #{@id}, #{@current_context_title}, #{current_activity_title}") 
-      end
-      @activities = [] # reset the activities 
-      return Mushin::Persistence::DS.load @id 
-    end
-
-    def get id
-      @id = id.to_s + 'mushin' 
-      #TODO make a git issue for some encryption method based on a configurable app key
-      Mushin::Persistence::DS.load @id 
-    end
-
-    def self.set id, &block
-      e = Env.new
-      e.set id, &block
-    end
-
-    def self.get id
-      e = Env.new
-      e.get id
-    end
-  end
-end
-=end

data/lib/internals/wongi.rb

@@ -1,38 +0,0 @@
-require 'wongi-engine'
-
-include Wongi::Engine
-
-@ds = Network.new
-
-person = Hash.new
-person[:name] = "mohamed"
-person[:age]  = "31"
-
-
-def all
-  #  puts "Enumerate all:"
-  #@ds.each do |wme|
-  #  puts wme
-  #end
-end
-
-#puts "Mismatching pattern:"
-#@ds.each :_, "foe", :_ do |wme|
-#  puts wme
-#ekd
-
-#{:subject=>{:name=>"mohamed", :age=>"31"}, :predicate=>"friend", :object=>"Bob"}
-def run subject, predicate, object 
-  @ds << WME.new( subject, predicate, object)
-
-  #puts "Enumerate by pattern:"
-  @ds.each  do |wme|
-    #ds.each :_, "friend", :_ do |wme|
-    puts wme
-    puts wme.to_h #methods
-    puts "use MushinFrameworkName::MiddlewareName, opts, params #{wme.to_h[:subject]}"
-  end
-end
-
-run person, "mypredicate", Random.new_seed 
-run person, "mypredicate", Random.new_seed