mushin 0.0.0.pre94 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 173b049e2e256622d7aa4445dfcf79ea967b6fbc
-  data.tar.gz: 297aa258200c1c26cbfb2aaef4f197da52306f3d
+  metadata.gz: f0e88288b1562a69301bdd27ce84b1ebbf34669d
+  data.tar.gz: 6223db5afb53ab8a6dc8cd2b32e94a5739166685
 SHA512:
-  metadata.gz: a8ed502492200450ad67c22b93b78aee42e74017ba6d7f80f1a2f0775cd18ff4813131728de1a1b26e7656f4c00e2d5f1620ae9d382e16c8efa3f12a7be12043
-  data.tar.gz: ea16155207c863b948276c159a3c2fc034f85ceacb36a60f9e8da80f6bdf86d8314e6a9e3e5ddf174ce853126cc9d6d5b57f75e3f254b65492147a0d0d32d5fc
+  metadata.gz: 88d3ef94d3cd205f21764a498729d8b8f21e87a8308ff34e55e0b77af00f5a470a93927232a6eee564a2a5b1844c80e5af9d82481a26db992b6b6d6c3577bbf7
+  data.tar.gz: ac7e906db31d0be0c154dd26d90638195cf76727470c4167bc777f81aff26c75534d11eee3874eeb1cfcc401e78dd90802d8bfb28eee912ecaa0599797c5bc7f

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at zotherstupidguy@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+ruby "2.3.1"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,28 @@
+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/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 zotherstupidguy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,96 @@
+What is Mushin
+===============
+Mushin is a Domain-specific Framework Generator
+
+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/Rakefile

@@ -0,0 +1,79 @@
+require "rake"
+require 'rake/testtask'
+#require 'logger'
+
+#$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']
+end
+=end
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mushin"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/internals/book.rb

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,101 @@
+#!/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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,98 @@
+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