simrb 1.0.4 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08d0b17242e8c909cfb0bf359a32384261911518
-  data.tar.gz: d933bcb7a53af6c263580ae9102ffc531ad5783e
+  metadata.gz: f7878b2a1a7e363b08799171e6153e01aba6f50b
+  data.tar.gz: e1c2104346c1b3b1ab527d29ce9dbfec531235e2
 SHA512:
-  metadata.gz: a8f309668d5e1f668c3a9d6c6f93bbc6f7f173e58c5d7fd51d45509914258b0ad9c8cf7cf8a2df3f493ad2a2bb32e376c4feda16235a86d8d74d76966218f5f5
-  data.tar.gz: 6b6f9a11dd06d04b141bcd59b7fe4bb7ad2fea8aa57339d6942284d9969f62db65cf78d4229f90e6cacb89bec1e706cacf48ccb1eaaba8fc8bde7f2568e6b62c
+  metadata.gz: 82258cd78ad586d504d984e473405f8d53094766967ad499d4ffdd509807a27a07bf93beb9766505b572b845f8eaea3fe8305990b3d4f9a7b4608e92d22445af
+  data.tar.gz: 11796bc82ccc3d168e5cf35d511f5e6d544f9a811e5a9c6ee3d1c10a75c889d48d7b6d4eb988f972841357e21b2971fb07cdce65be2ec436f3bc800ccd827397

data/lib/simrb/base.rb

@@ -0,0 +1,244 @@
+# 
+# definition to the base methods, and default configuration options
+# and the modules that would be loaded
+#
+
+Sroot = Dir.pwd + '/'
+Sdocs = {}
+
+require "simrb/scfg"
+
+module Simrb
+	class << self
+
+		def yaml_read path
+			require 'yaml'
+			YAML.load_file path
+		rescue
+			[]
+		end
+
+		def yaml_write path, data
+			require "yaml"
+			File.open(path, 'w+') do | f |
+				f.write data.to_yaml
+			end
+		end
+
+		def p args, action = nil
+			res = ""
+
+			if args.class.to_s == 'Array'
+				res = args.join("\n")
+			elsif args.class.to_s == 'Hash'
+				args.each do | k, v |
+					if action == :write
+						res << "#{k.to_s.ljust(7)} -- #{v}\n"
+					else
+						res << "#{k.to_s.ljust(15)} => #{v}\n"
+					end
+				end
+				res = res.chomp "\n"
+			else
+				res = args.to_s
+			end
+
+# 			puts "="*30 + "\n" + res + "\n" + "="*30
+			puts res
+			exit if action == :exit
+		end
+
+		# return an hash that stores the modules that consists of local directory and repository
+		#
+		# == Example
+		#
+		# 	Simrb.module_load
+		#
+		# assuming the :requrie_module option of Scfg file that is set as 'system', 
+		# and two modules demo, demo2 in your local directory of project,
+		# so, the result as below
+		#
+		# 	{
+		# 		'system'	=>	'/your_repo_dir/system',
+		# 		'demo'		=>	'/your_project_dir/modules/demo',
+		# 		'demo2'		=>	'/your_project_dir/modules/demo2',
+		# 	}
+		#
+		def module_load
+			module_dirs = {}
+			module_ds 	= {}
+
+			# load modules from local repository
+			Spath[:repo_dirs].map{|m| m + '*'}.each do | dir |
+				Dir[dir].each do | path |
+					name = path.split("/").last
+					module_dirs[name] = File.expand_path(path) if Scfg[:module_require].include? name
+				end
+			end
+
+			# load modules from project directory
+			Dir["#{Spath[:module]}*"].each do | path |
+				name = path.split("/").last
+				module_dirs[name] = File.expand_path("#{Spath[:module]}#{name}") unless Scfg[:module_disable].include? name
+			end
+
+			# load the info of module
+			module_dirs.each do | name, path |
+				path 	= "#{path}#{Spath[:modinfo]}"
+				res 	= Simrb.yaml_read path
+				if res[0] and res[0]["name"] and res[0]["name"] == name
+					module_ds[name] = (res[0]["order"] || 99)
+				else
+					Simrb.p "Loading error of module info, please check #{path}", :exit
+				end
+			end
+
+			# sort module by order field of module
+			res 		= {}
+			module_ds	= module_ds.sort_by { |k, v| v }
+			module_ds.each do | name, order |
+				res[name] = module_dirs[name]
+			end
+			res
+		end
+
+		# initialize a path whatever it is a dir or file
+		#
+		# == Example
+		#
+		# new a file, or with the additional content
+		#
+		# 	path_write "myfile"
+		# 	path_write "myfile", "file content"
+		# 	path_write "myfile", "file content", "w+"
+		#
+		# create the dir
+		#
+		#	path_write "newdir/"
+		#	path_write "newdir/newdir2/"
+		#
+		# create the dir and file at the same time
+		#
+		#	path_write "newdir/newdir2/myfile"
+		#
+		def path_write path, content = "", mode = "a+"
+			if File.exist?(path)
+				File.open(path, mode){|f| f.write content} unless path[-1] == '/'
+			else
+				arrs	= path.split('/')
+				count	= arrs.count - 1
+				prve	= ""
+
+ 				if arrs[0] == ""
+ 					arrs.delete("")
+					prve = "/"
+ 				end
+
+				(0..count).each do | i |
+					sub_path = prve + arrs[0..i].join("/")
+					unless File.exist? sub_path
+						sub_path == path ? File.open(path, mode){|f| f.write content} : Dir.mkdir(sub_path)
+					end
+				end
+			end
+		end
+
+		def root_dir_force
+			# check the required module is that existing
+			Scfg[:module_require].each do | name |
+				unless Smods.keys.include? name
+					puts "Warning: the required module #{name} is not existing, wherever in local dir or repository"
+				end
+			end
+
+			# check the file that is necessary to be loaded
+			unless File.exist?(Sroot + Scfg[:name])
+				Simrb.p "Current command only allow to be used under root directory of project", :exit
+			end
+		end
+
+		# format the input argument from an array to two item, 
+		# first item is orgin array, last is an hash option
+		#
+		# == Example
+		#
+		# 	args, opts = Simrb.input_format ["test", "test2", "--test", "--name=test2", "-n=test3"]
+		#
+		# the above is same as
+		#
+		# 	args, opts = Simrb.input_format ["--test", "test", "test2", "--name=test2", "-n=test3"]
+		# 	
+		# the options that starts with "-" you can write any positions of argument
+		#
+		# output
+		#
+		#	args = ["test", "test2"]
+		#	opts = {test: true, name: test2, n:test3}
+		# 	
+		def input_format args = []
+			resa = [] # return an array
+			resh = {} # return an hash
+			unless args.empty?
+				args.each do | item |
+
+					if item[0] == "-"
+						new_item = item.split("-").uniq.last
+						if new_item.index "="
+							key, val = new_item.split "="
+							resh[key.to_sym] = val
+						else
+							resh[new_item.to_sym] = true
+						end
+					else
+						resa << item
+					end
+
+				end
+			end
+			[resa, resh]
+		end
+
+		def help args = []
+			res 		= []
+			i 			= 0
+			docs_key 	= {}
+			docs_val 	= {}
+			Sdocs.each do | key, val |
+				docs_key[i] = key
+				docs_val[i] = val
+				i = i + 1
+			end
+
+			if args.empty?
+				res << 'Please select the number before the list to see detials'
+				docs_key.each do | i, key |
+					res << "#{i.to_s}, #{key}"
+				end
+			else
+				args.each do | i |
+					res << (docs_val.include?(i.to_i) ? docs_val[i.to_i] : 'no document')
+				end
+			end
+			Simrb.p res
+		end
+
+		def addslash path
+			path[-1] == '/' ? path : "#{path}/"
+		end
+
+		def random size = 12
+			charset = ('a'..'z').to_a + ('0'..'9').to_a + ('A'..'Z').to_a
+			(0...size).map{charset.to_a[rand(charset.size)]}.join
+		end
+
+	end
+end
+
+# load config file
+if File.exist?(Sroot + Scfg[:name])
+	require (Sroot + Scfg[:name])
+end
+
+# load modules
+Smods = Simrb.module_load
+

data/lib/simrb/comd.rb

@@ -1,22 +1,29 @@
 # 
 # the file defines the base functionality of commands
-# that let you initializing a project, create an empty directory of module, or clone
+# that let you initializing a project, create an empty directory of module, or get
 # from remote repository, show the info of this software version, help document, and so on
 #
 
 module Simrb
 	class Scommand
 
+		# run the command
+		#
+		# == Example
+		#
+		# sapp = Simrb::Scommand.new
+		# sapp.run ARGV
+		#
 		def run args = []
-			@output = []
-			cmd 	= args.empty? ? '' : args.shift
+			cmd = args.empty? ? '' : args.shift
 			if Scommand.private_method_defined? cmd
 				self.send(cmd, args)
+			elsif cmd == "help"
+				require 'simrb/docs'
+				Simrb.help args
 			else
-				@output << ">> WARNING: No #{cmd} command found >>"
-				help
+				puts "No command called #{cmd}, please try `$ simrb help`"
 			end
-			Simrb.p(@output.empty? ? 'Implemented complete' : @output)
 		end
 
 		private
@@ -29,35 +36,40 @@ module Simrb
 			#
 			# or, initialize directory and module at the same time with more arguments,
 			# the simrb/system is from remote, the blog is generated by local,
-			# details see the new and clone method
+			# details see the new and get method
 			#
 			# 	$ simrb init myapp simrb/system blog
 			#
 			def init args
 				app_name = args.empty? ? 'myapp' : args.shift 
+# 				app_name = File.expand_path "./#{app_name}"
+
+				# initialize the repositories
+				Spath[:repo_dirs].each do | path |
+					Simrb.path_write Simrb.addslash(path)
+				end
 
 				# generate module directories and files
-				Dir.mkdir app_name
+				Dir.mkdir app_name unless File.exist? app_name
 				Dir.chdir app_name
 
+				# generate project directories
 				Scfg[:init_root_path].each do | item |
 					path = "#{Spath[item]}"
-					Simrb::path_init path
+					Simrb.path_write path
 				end
 
-				# initialize scfg file
-				data = {}
-				Scfg[:init_scfg_item].each do | item |
-					data[item] = Scfg[item]
-				end
-				Simrb.yaml_write('scfg', data)
+				# initialize config file
+				data = File.read(File.dirname(__FILE__) + Scfg[:name_overwrite])
+				data << "\nScfg[:key]\t\t\t\t= '#{Simrb.random(16)}'\n"
+				Simrb.path_write(Scfg[:name], data)
 
 				# create module if it is given,
 				# get module from remote repository if it has the backslash,
 				# other is created at local
 				unless args.empty?
 					args.each do | name |
-						name.index("/") ? clone(args) : new(args)
+						name.index("/") ? get(args) : new(args)
 					end
 				end
 
@@ -68,7 +80,7 @@ module Simrb
 # 				end
 # 				system("bundle install --gemfile=#{@app_name}/apps/#{@module_name}#{@gemfile_path} --without=#{mode}")
 
-				@output << "Initialized project complete"
+				puts "Initialized completely"
 			end
 
 			# create a module, initialize default paths of file and directory
@@ -83,61 +95,101 @@ module Simrb
 			#
 			def new args
 				Simrb.root_dir_force
+				puts "Starting to create module directories"
 
 				args.each do | name |
-					if Smodules.include? name
-						@output << "The module #{name} is existing, not new it"
+					if Smods.keys.include? name
+						puts "The module #{name} is existing, hasn't new it"
 					else
 						# create root dir of module
-						Simrb::path_init "#{Spath[:module]}#{name}/"
+						Simrb.path_write "#{Spath[:module]}#{name}/"
 
 						Dir.chdir "."
 
 						# create sub dir of module 
 						Scfg[:init_module_path].each do | item |
 							path = "#{Spath[:module]}#{name}#{Spath[item]}"
-							Simrb::path_init path
+							Simrb.path_write path
+							Simrb.p({created: path}, :write)
 						end
 
 						# write the content of module info
-						text = [{ 'name' => name, 'author' => 'unknown', 'version' => '1.0.0' }]
-						Simrb.yaml_write "#{Spath[:module]}#{name}#{Spath[:modinfo]}", text
+						res = Scfg[:init_module_field].merge({'name' => name})
+						path = "#{Spath[:module]}#{name}#{Spath[:modinfo]}"
+						Simrb.yaml_write path, [res]
+						Simrb.p({wrote: path}, :write)
 
 						# write the content of .gitignore
 						path = "#{Spath[:module]}#{name}#{Spath[:gitignore]}"
 						File.open(path, "w+") do | f |
-							f.write "*.swp\n*.gem\n*~"
+							f.write Scfg[:init_gitinore_item].join("\n")
 						end
+						Simrb.p({wrote: path}, :write)
 					end
 				end
 
-				@output << "Initialized module complete"
+				puts "Initializing module completed"
 			end
 
-			# clone a module from remote repository to local
+			# get a module from remote repository to local
+			# autually, this is a clone method of git
 			#
 			# == Example
 			# 
-			# 	$ simrb clone simrb/system
+			# 	$ simrb get system
 			#
 			# or, more than one at same time
 			#
-			# 	$ simrb clone simrb/system simrb/test
+			# 	$ simrb get system test
 			#
-			def clone args
+			def get args
 				Simrb.root_dir_force
 
+				repo_dir = Simrb.addslash(Spath[:repo_dirs][0] + Spath[:repo_mods])
+				Simrb.path_write repo_dir
+
 				args.each do | name |
-					if Smodules.include? name
-						@output << "The module #{name} is existing, not clone from remote"
+					if Smods.keys.include? name
+						puts "The module #{name} is existing at local repository, hasn't got from remote"
 					else
-						path = "#{Scfg[:repo_source]}#{name[0]}.git"
-						name = "#{Spath[:module]}#{name[0].split('/').last}"
-						system("git clone #{path} #{name}")
+						path	= "#{Scfg[:source]}#{name}.git"
+						local	= "#{repo_dir}#{name}"
+						system("git clone #{path} #{local}")
 					end
 				end
 
-				@output << "Cloned module complete"
+				puts "Implemented completely"
+			end
+
+			# pull whole remote repository from github
+			#
+			# == Example
+			#
+			# by default, that will pull the official repo
+			#
+			# 	$ simrb pull
+			#
+			# add the option `-f` force to pulling
+			#
+			# 	$ simrb pull -f
+			#
+			# or, specify the link you need in second parameter
+			#
+			# 	$ simrb pull repo ~/simrb_repo
+			#
+			def pull args = []
+				args, opts	= Simrb.input_format args
+				repo_name	= args[0] ? args[0] : Scfg[:main_repo]
+				from_repo	= Scfg[:source] + repo_name
+				to_repo 	= Simrb.addslash(args[1] ? args[1] : Spath[:repo_dirs][0])
+				ispull		= File.exist?(to_repo + repo_name + "/README.md") ? (opts[:f] ? true : false) : true
+
+				if ispull
+					Simrb.path_write to_repo
+					system("git clone #{from_repo}.git")
+					system("mv #{repo_name} #{to_repo}")
+				end
+				puts "Implemented completely"
 			end
 
 			# kill the current process of Simrb of that is running in background
@@ -153,7 +205,7 @@ module Simrb
 # 				`rm #{Spath[:tmp_dir]}pid`
 
 				system("kill #{s}")
-				@output << "Killed the process #{s} of Simrb"
+				puts "Killed the process #{s} of Simrb"
 			end
 
 			# display the basic inforamtion of current version of Simrb
@@ -164,20 +216,7 @@ module Simrb
 			#
 			def info args = []
 				require 'simrb/info'
-				@output << Simrb::Info
-			end
-
-			# the help document
-			#
-			# == Example
-			#
-			# 	$ simrb help
-			# 	$ simrb help 0
-			#
-			def help args = []
-				require 'simrb/help'
-				require 'simrb/docs'
-				@output << Simrb.help(args)
+				Simrb.p Simrb::Info
 			end
 
 	end

data/lib/simrb/docs.rb

@@ -4,16 +4,10 @@
 
 Sdocs['Preface'] =<<Doc
 
-=== What about the Simrb ?
+This is a project to help you build the web service easily, it let you save more time on front-end developing of various terminal applications under the same background data provider.
 
-Simrb is a framework for building server application. Many years ago, i had tried to find an application to do work of that i want to build something that could be used to run at server, and support the web service, web page, json data, xml data, and varied formats of data.
+The core goal of Simrb is focused on how to process background data and assist the data interaction of between front-end and back-end. It aims to get you a most pure utility, and efficient, modular, focused.
 
-The importance things in using is need to be simple, flexible, comfortable. I couldn't find it, So this is the reason why would i build this software called Simrb.
-
-
-=== What responsibility Simrb does ?
-
-Defining the directory architecture, basic command-line, configuration option, initialize loading workflow, that is all.
 Doc
 
 
@@ -22,37 +16,40 @@ Sdocs['Directory'] =<<Doc
 /home/project
 ├── modules
 │   ├── module_name1
-│   │   ├── boxes                      ───│ ---- DATA LAYER ----
-│   │   │   ├── docs                      │ stores the documents
-│   │   │   ├── tpls                      │ stores the templates, like *.erb
-│   │   │   ├── migrations                │ stores the migration records
-│   │   │   ├── langs                     │ stores the language file, *.en, *.de, *.cn, etc
-│   │   │   │   ├── name.en               │ 
-│   │   │   │   └── name.cn               │
-│   │   │   ├── misc                      │ stores the Gemfile, Gemfile.lock, and others
-│   │   │   │   └── Gemfile               │
-│   │   │   ├── installs                  │ stores the installing file that will be write into database, by
-│   │   │   │   └── _mods                 │ the file name as the table name
-│   │   │   ├── tool.rb                   │ these files will be loaded in command `$ 3s`
-│   │   │   └── ...                       │
-│   │   ├── views                      ───│ ---- VIEW LAYER ----
-│   │   │    ├── assets                   │ assets dir stores the file *.js, *.css, *.jpg, *.png, etc
-│   │   │    │   ├── jqeury.js            │
-│   │   │    │   └── style.css            │
-│   │   │    ├── temp.slim                │ here is stored the template files that will be loaded
-│   │   │    ├── demo.slim                │ when the route file need it
-│   │   │    ├── demo2.slim               │ 
-│   │   │    └── ...                      │ 
-│   │   ├── README.md                  ───│ ---- LOGIC LAYER ----
-│   │   ├── .gitignore                    │ 
-│   │   ├── routes.rb                     │ any files with suffix `rb`, like routes.rb, all will be loaded in
-│   │   ├── demo.rb                       │ startup of web server
-│   │   ├── demo2.rb                      │ 
-│   │   └── ...                        ───│ 
-│   │                                     
-│   ├── module_name2                   ───│ other modules, you add it according to the requirement
-│   ├── module_name3                      │
-│   └── ...                               │
+│   │   ├── store                 ───│ ---- DATA LAYER ----
+│   │   │   ├── docs                 │ stores the documents
+│   │   │   ├── tpls                 │ stores the templates, like *.erb
+│   │   │   ├── migrations           │ stores the migration records
+│   │   │   ├── langs                │ stores the language file, *.en, *.de, *.cn, etc
+│   │   │   │   ├── name.en          │ 
+│   │   │   │   └── name.cn          │
+│   │   │   ├── misc                 │ stores the Gemfile, Gemfile.lock, and others
+│   │   │   │   └── Gemfile          │
+│   │   │   ├── installs             │ stores the installing file that will be write into database, by
+│   │   │   │   └── base_info        │ the file name as the table name
+│   │   │   ├── tool.rb              │ these files will be loaded in command `$ 3s`
+│   │   │   └── ...                  │
+│   │   ├── views                 ───│ ---- VIEW LAYER ----
+│   │   │    ├── assets              │ assets dir stores the file *.js, *.css, *.jpg, *.png, etc
+│   │   │    │   ├── jqeury.js       │
+│   │   │    │   └── style.css       │
+│   │   │    ├── temp.slim           │ here is stored the template files that will be loaded
+│   │   │    ├── demo.slim           │ when the route file need it
+│   │   │    ├── demo2.slim          │ 
+│   │   │    └── ...                 │ 
+│   │   ├── logic                 ───│ ---- LOGIC LAYER ----
+│   │   │    ├── routes.rb           │ 
+│   │   │    └── ...                 │ any files with suffix `rb` under the logic dir, or root dir 
+│   │   ├── README.md                │ like routes.rb, logic/routes.rb, all will be loaded when
+│   │   ├── .gitignore               │ the web server startup
+│   │   ├── routes.rb                │ 
+│   │   ├── demo.rb                  │ 
+│   │   ├── demo2.rb                 │ 
+│   │   └── ...                   ───│ 
+│   │
+│   ├── module_name2              ───│ other modules, you add it according to the requirement
+│   ├── module_name3                 │
+│   └── ...                          │
 │
 ├── db
 │   ├── backup
@@ -63,36 +60,50 @@ Sdocs['Directory'] =<<Doc
 │   └── command_error_log.html
 ├── tmp
 │   └── install.lock
-└── scfg                                   put any options of static configuration here with an hash form
+└── scfg.rb                           put any options of static configuration here with an hash form
+
 Doc
 
+Sdocs['Module'] =<<Doc
 
-Sdocs['Configuration'] =<<Doc
+Here is some core modules that is helpful to common application
+
+	base  - some common methods
+	data  - process data and interact with database
+			provide an hash key-val variable as settings that stores in database
+			provide the tag interface for classifing any datas
+			provide the menu interface for managing the routers of applications
+
+	view  - create shortcut view, generate view template, like form, list, table
+	admin - manage data with build-in view
+
+	file  - provide the file upload, download
+	user  - about user login, logout, register, authorise
+
+the base, data and view are core modules, the admin, file and user are extended modules for common requirement
 
-Simrb has two configuration files that is scfg and spath under the root directory, spath stores all of paths of default directory and file, and the scfg file is for setting options to your project application.
 Doc
 
 
-Sdocs['Modularization'] =<<Doc
+Sdocs['Configuration'] =<<Doc
 
-In Simrb, any functionalities that should be packed into module, whatever you want to do, three ways is there for you: new a module, or clone a module that has the requirement you want from remote repository, modify existed module at local.
+Simrb has two configuration files that are the scfg.rb and spath under the root directory, the spath file stores all of paths of directory and file, scfg.rb file stores the setting options of your project application.
 
-Here is a core [system](https://github.com/simrb/system) module for common application.
 Doc
 
 
 Sdocs['Command-line'] =<<Doc
 
-=== Overview
+== Overview
 
-Simrb includes two commands, `simrb`, `3s`. `simrb` is ran at global, except the `new` and `clone`. The `3s` is only allowed to run under root directory of project. And the functionality of `3s` command could be extended by that file *.rb under the boxes dir
+Simrb includes many commands, `simrb`, `3s`. `simrb` is ran at global, except the `new` and `get`. The `3s` is only allowed to run under root directory of project. And the functionality of `3s` command could be extended by the file *.rb that is under the store dir.
 
 
-=== Description of command simrb
+== Description of command simrb
 
 init    - initialize a project directory
 new     - create a new module
-clone   - clone a module from remote repository
+get     - get a module from remote repository
 help    - show the help documentation
 info    - show the information of current version of Simrb
 start   - boot Simrb up via web server mode
@@ -124,7 +135,7 @@ Command format:
 
 	$ simrb new [module_name] [module_name2] [module_name3] ...
 
-note that this command only be used in root directory that includes the scfg file
+note that this command only be used in root directory that includes the scfg.rb file
 
 Example 1, 
 
@@ -135,17 +146,17 @@ Example 2, new module more than one at the same time
 	$ simrb new test test2 test3
 
 
-clone
+get
 ==================
 Command format:
 
-	$ simrb clone [repo_name/module_name] [repo_name/module_name2] [repo_name/module_name3] ...
+	$ simrb get [repo_name/module_name] [repo_name/module_name2] [repo_name/module_name3] ...
 
 its usage is as same as the new command, but just get the module from remote repository.
 
 Example 1
 
-	$ simrb clone repos_name/module_name repos_name2/module_name2
+	$ simrb get repos_name/module_name repos_name2/module_name2
 
 
 help
@@ -179,6 +190,7 @@ kill
 Command format:
 
 	$ simrb kill
+
 Doc
 
 
@@ -194,7 +206,7 @@ Step 02, new a module called demo
 
 	$ cd myapp && simrb new demo
 
-Step 03, add content to file 
+Step 03, add code to file 
 
 	$ echo 'get "/" do "Hello world" end' > modules/demo/routes.rb
 
@@ -202,6 +214,7 @@ Step 04, start up by web server to see what we have done
 
 	$ simrb start
 
-So, open browser and type the link http://0.0.0.0:3000 to address bar,
-yup, if you see the Hello world is there, welcome you fall in Simrb.
+So, put the default address `http://0.0.0.0:3000` to browser
+yup, if you see the `Hello world` is there, welcome to Simrb.
+
 Doc

data/lib/simrb/info.rb

@@ -8,13 +8,13 @@ module Simrb
 		:name			=>	'simrb',
 		:created		=>	'2014-01-01',
 		:alias_name		=>	'3s',
-		:version		=>	'1.0.4',
+		:version		=>	'1.0.6',
 		:author			=>	'Linyu Deng',
 		:email			=>	'coolesting@gmail.com',
-		:homepage		=>	'https://github.com/simrb/simrb-gem',
+		:homepage		=>	'https://github.com/simrb/simrb-help',
 		:license		=>	'MIT',
-		:summary		=>	'Simrb',
-		:description	=>	'This is a command helper for simrb'
+		:description	=>	'This is a command helper for simrb',
+		:summary		=>	'A utility of simrb',
 	}
 
 end

data/lib/simrb/init.rb

@@ -2,7 +2,7 @@
 # this is a configuration file and loading workflow of application
 #
 
-require 'simrb/config'
+require 'simrb/base'
 
 Simrb.root_dir_force
 
@@ -29,13 +29,13 @@ Sload[:main] 		= []
 Sload[:tool] 		= []
 Sload[:view] 		= []
 
-Smodules.each do | name |
-	Sload[:lang] 	+= Dir["#{Sroot}#{Spath[:module]}#{name}#{Spath[:lang]}*.#{Scfg[:lang]}"]
-	Sload[:tool] 	+= Dir["#{Sroot}#{Spath[:module]}#{name}#{Spath[:store]}*.rb"]
-	Sload[:tool] 	+= Dir["#{Sroot}#{Spath[:module]}#{name}#{Spath[:tool]}*.rb"]
-	Sload[:main] 	+= Dir["#{Sroot}#{Spath[:module]}#{name}/*.rb"]
-	Sload[:main] 	+= Dir["#{Sroot}#{Spath[:module]}#{name}#{Spath[:logic]}*.rb"]
-	Sload[:view]	<< "#{Sroot}#{Spath[:module]}#{name}#{Spath[:view]}".chomp("/")
+Smods.each do | name, path |
+	Sload[:lang] 	+= Dir["#{path}#{Spath[:lang]}*.#{Scfg[:lang]}"]
+	Sload[:tool] 	+= Dir["#{path}#{Spath[:store]}*.rb"]
+	Sload[:tool] 	+= Dir["#{path}#{Spath[:tool]}*.rb"]
+	Sload[:main] 	+= Dir["#{path}/*.rb"]
+	Sload[:main] 	+= Dir["#{path}#{Spath[:logic]}*.rb"]
+	Sload[:view]	<< "#{path}#{Spath[:view]}".chomp("/")
 end
 
 # cache label statement of language

data/lib/simrb/scfg.rb

@@ -0,0 +1,120 @@
+
+# default path of project directory and module
+Spath						= {
+
+	# the required repository 
+	:repo_dirs				=> [(File.expand_path("~/.simrb") + '/')],
+
+	# default directory for saving the pulled module from remote
+	:repo_mods				=> 'simrb-mods/',
+
+	# root directory path of project
+	:module					=> 'modules/',
+	:public					=> 'public/',
+	:db_dir					=> 'db/',
+	:upload_dir				=> 'db/upload/',
+	:backup_dir				=> 'db/backup/',
+	:tmp_dir				=> 'tmp/',
+	:cache_dir				=> 'tmp/cache/simrb/',
+	:install_lock			=> 'tmp/install.lock',
+	:log_dir				=> 'log/',
+	:server_log				=> 'log/thin.log',
+	:command_log			=> 'log/command_error_log.html',
+	:schema					=> 'log/migrations/',
+
+	# module directory path
+	:tool					=> '/tool/',
+	:logic					=> '/logic/',
+	:store					=> '/store/',
+	:lang					=> '/store/langs/',
+	:doc					=> '/store/docs/',
+	:install				=> '/store/installs/',
+	:modinfo				=> '/store/installs/base_info',
+	:tpl					=> '/store/tpls/',
+	:misc					=> '/store/misc/',
+	:gemfile				=> '/store/misc/Gemfile',
+	:view					=> '/views/',
+	:assets					=> '/views/assets/',
+	:gitignore				=> '/.gitignore',
+	:route					=> '/routes.rb',
+	:readme					=> '/README.md',
+
+}
+
+# default setting options
+Scfg						= {
+
+	# disable the modules of current project
+	:module_disable			=> [],
+
+	# require the modules of local repository
+	:module_require			=> [],
+
+	:module_focus			=> nil,
+
+	:user 					=> 'unknown',
+
+	# default config filename
+	:name 					=> 'scfg.rb',
+
+	# overwrite the file Scfg[:name]
+	:name_overwrite			=> "/scfg_copy.rb",
+
+	:encoding				=> 'utf-8',
+	:lang					=> 'en',
+	:install_lock			=> 'yes',
+	:db_connection			=> 'sqlite://db/data.db',
+	:server 				=> 'thin',
+	:bind 					=> '0.0.0.0',
+	:port					=> 3000,
+
+	:source					=> 'https://github.com/simrb/',
+
+	# a default core repository for loading when the server booting
+	:main_repo				=> 'simrb-repo',
+
+	# options: development, production, test
+	:environment 			=> 'development',
+
+	:server_log_mode		=> 'file',
+
+	:field_time				=> ['created', 'changed'],
+	:field_fixnum			=> ['order', 'level'],
+	:field_number 			=> ['Fixnum', 'Integer', 'Float'],
+
+	:alias_fields			=> {
+		int:'Fixnum', str:'String', text:'Text',
+		time:'Time', big:'Bignum', fl:'Float'
+	},
+
+	# command alias name of generating methods
+	:alias_gcmd				=> {
+		'm' => 'migration', 'i' => 'install', 'd' => 'data', 'v' => 'view'
+	},
+
+	:alias_cmd				=> {
+	},
+
+	:init_module_path		=> [
+		:store, :install, :modinfo, :misc, 
+		:gemfile, :view, :assets, :readme, :route
+	],
+
+	:init_root_path			=> [
+		:db_dir, :upload_dir, :backup_dir,
+		:tmp_dir, :log_dir, :module, :schema
+	],
+
+	:init_module_field		=> {
+		'name' => 'unname', 'author' => 'unknown', 'version' => '1.0.0' 
+	},
+
+	:init_gitinore_item		=> [
+		"*.swo", "*.swp", "*.gem", "*~", "*.lock", "*.bak"
+	],
+
+}
+
+# append the children repository
+Spath[:repo_dirs] << (Spath[:repo_dirs][0] + Spath[:repo_mods])
+Spath[:repo_dirs] << (Spath[:repo_dirs][0] + Scfg[:main_repo] + '/')

data/lib/simrb/scfg_copy.rb

@@ -0,0 +1,19 @@
+
+Scfg[:encoding]			= 'utf-8'
+Scfg[:lang]				= 'en'
+Scfg[:install_lock]		= 'yes'
+
+Scfg[:db_connection]	= 'sqlite://db/data.db'
+Scfg[:bind]				= '0.0.0.0'
+Scfg[:port]				= 3000
+
+# options: development, production, test
+Scfg[:environment]		= 'development'
+
+# Scfg[:module_require]	= ['base','data','view','file','admin','user']
+
+# your directory path of local
+# Spath[:repo_dirs][0]	= (File.expand_path("~/.simrb") + '/')
+
+# add repository path like this
+# Spath[:repo_dirs] << "/home/yours"

data/lib/simrb/tool_start.rb

@@ -2,6 +2,7 @@
 # this is an entrance for running the task command in tool box
 #
 
+puts "="*30
 require 'simrb/init'
 
 module Simrb
@@ -12,50 +13,54 @@ end
 Sload[:tool].each do | path |
 	require path
 end
-argv = ARGV.clone
-output = []
+
+argv 	= ARGV.clone
+method	= argv.shift(1)[0]
+method	= Scfg[:alias_cmd][method] if Scfg[:alias_cmd].keys.include? method
+
+# output = []
 
 # command mode
-if argv.count > 0 and Simrb::Stool.method_defined?(argv[0])
-	
+if Simrb::Stool.method_defined?(method)
+
 	helpers do
 		include Simrb::Stool
 	end
 
 	get '/_tools' do
-		method = argv.shift(1)[0]
 		argv.empty? ? eval(method).to_s : eval("#{method} #{argv}").to_s
 	end
 
 	env = {'PATH_INFO' => "/_tools", 'REQUEST_METHOD' => 'GET', 'rack.input' => ''}
 	status, type, body = Sinatra::Application.call env
 	if status == 200
-		body.each do | line |
-			output << line
-		end
+# 		body.each do | line |
+# 			output << line
+# 		end
 	else
 		File.open(Spath[:command_log], 'a+') do | f |
 			f.write "\n#{'='*10}#{Time.now.to_s}\n#{'='*10}\n"
 # 			f.write body
  			f.write (Sinatra::ShowExceptions.new(self).call(env.merge("HTTP_USER_AGENT" => "curl"))[2][0].to_s + "\n")
 		end
-		output << env["sinatra.error"]
+# 		output << env["sinatra.error"]
+		puts env["sinatra.error"]
 	end
 
 # document mode
-else
-
-	require 'simrb/help'
+elsif method == "help"
 
-	Smodules.each do | name |
-		Dir["#{Spath[:module]}#{name}#{Spath[:doc]}*.#{Scfg[:lang]}.rb"].each do | path |
-			require(Sroot + path)
+	Smods.each do | name, path |
+		Dir["#{path}#{Spath[:doc]}*.#{Scfg[:lang]}.rb"].each do | path2 |
+			require(path2)
 		end
 	end
 
-	argv.shift 1 
-	output << Simrb.help(argv)
+# 	argv.shift 1
+	puts Simrb.help(argv)
 
+else
+	puts "No command #{method}, please try $3s help"
 end
 
-Simrb.p output
+puts "="*30

data/lib/simrb.rb

@@ -2,7 +2,7 @@
 # this is an entrance to base command operated
 #
 
-require 'simrb/config'
+require 'simrb/base'
 require 'simrb/comd'
 simrb_app = Simrb::Scommand.new
 simrb_app.run ARGV

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simrb
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.6
 platform: ruby
 authors:
 - Linyu Deng
@@ -30,42 +30,42 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.10.0
+        version: 4.15.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 4.10.0
+        version: 4.15.0
 - !ruby/object:Gem::Dependency
   name: slim
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2.0.2
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: thin
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.6.2
+        version: 1.6.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.6.2
+        version: 1.6.3
 description: This is a command helper for simrb
 email: coolesting@gmail.com
 executables:
@@ -77,16 +77,17 @@ files:
 - bin/3s
 - bin/simrb
 - lib/simrb.rb
+- lib/simrb/base.rb
 - lib/simrb/comd.rb
-- lib/simrb/config.rb
 - lib/simrb/docs.rb
-- lib/simrb/help.rb
 - lib/simrb/hook.rb
 - lib/simrb/info.rb
 - lib/simrb/init.rb
+- lib/simrb/scfg.rb
+- lib/simrb/scfg_copy.rb
 - lib/simrb/thin_start.rb
 - lib/simrb/tool_start.rb
-homepage: https://github.com/simrb/simrb-gem
+homepage: https://github.com/simrb/simrb-help
 licenses:
 - MIT
 metadata: {}
@@ -109,5 +110,5 @@ rubyforge_project: simrb
 rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
-summary: Simrb
+summary: A utility of simrb
 test_files: []

data/lib/simrb/config.rb

@@ -1,212 +0,0 @@
-# 
-# definition to the base methods, and default configuration options
-# and the modules that would be loaded
-#
-
-Sroot = Dir.pwd + '/'
-module Simrb
-
-	# common methods
-	class << self
-
-		def yaml_read path
-			require 'yaml'
-			YAML.load_file path
-		rescue
-			[]
-		end
-
-		def yaml_write path, data
-			require "yaml"
-			File.open(path, 'w+') do | f |
-				f.write data.to_yaml
-			end
-		end
-
-		def p args
-			res = ""
-
-			if args.class.to_s == 'Array'
-				res = args.join("\n")
-			elsif args.class.to_s == 'Hash'
-				args.each do | k, v |
-					res << "#{k.to_s.ljust(15)} => #{v}\n"
-				end
-				res = res.chomp "\n"
-			else
-				res = args.to_s
-			end
-
-			puts "="*30 + "\n" + res + "\n" + "="*30
-		end
-
-		def module_load
-			dirs 		= []
-			module_ds 	= {}
-
-			# get the path of module
-			if Scfg[:only_enable_modules].empty?
-				dirs = Dir["#{Spath[:module]}*"]
-			else
-				Scfg[:only_enable_modules].each do | name |
-					path = "#{Spath[:module]}#{name}"
-					dirs << path if File.exist?(path)
-				end
-			end
-
-			# load the info of module
-			dirs.each do | path |
-				path 	= "#{path}#{Spath[:modinfo]}"
-				content = Simrb.yaml_read path
-				name	= content[0]["name"]
-				order	= (content[0]["order"] || 99)
-				module_ds[name] = order unless Scfg[:disable_modules].include?(name.to_s)
-			end
-
-			# sort the module by order field
-			res 		= []
-			module_ds	= module_ds.sort_by { |k, v| v }
-			module_ds.each do | item |
-				res << item[0]
-			end
-			res
-		end
-
-		def path_init path, content = ""
-			unless File.exist?(path)
-				path[-1] == '/' ? Dir.mkdir(path) : File.open(path, 'w+') {|f| f.write content}
-			end
-		end
-
-		def root_dir_force
-			unless File.exist? 'scfg'
-				Simrb.p "Current command only allow to be used under root directory of project"
-				exit
-			end
-		end
-
-		# format the input argument from an array to two item, 
-		# first item is orgin array, last is an hash option
-		#
-		# == Example
-		#
-		# 	args, opts = Simrb.input_format ["test", "test2", "--test", "--name=test2", "-n=test3"]
-		#
-		# the above is same as
-		#
-		# 	args, opts = Simrb.input_format ["--test", "test", "test2", "--name=test2", "-n=test3"]
-		# 	
-		# the options that starts with "-" you can write any positions of argument
-		#
-		# output
-		#
-		#	args = ["test", "test2"]
-		#	opts = {test: true, name: test2, n:test3}
-		# 	
-		def input_format args = []
-			resa = [] # return an array
-			resh = {} # return an hash
-			unless args.empty?
-				args.each do | item |
-
-					if item[0] == "-"
-						new_item = item.split("-").uniq.last
-						if new_item.index "="
-							key, val = new_item.split "="
-							resh[key.to_sym] = val
-						else
-							resh[new_item.to_sym] = true
-						end
-					else
-						resa << item
-					end
-
-				end
-			end
-			[resa, resh]
-		end
-
-	end
-
-	# basic path definition
-	Spath						= {
-		# root path of project
-		:module					=> 'modules/',
-		:public					=> 'public/',
-		:db_dir					=> 'db/',
-		:upload_dir				=> 'db/upload/',
-		:backup_dir				=> 'db/backup/',
-		:tmp_dir				=> 'tmp/',
-		:cache_dir				=> 'tmp/cache/simrb/',
-		:install_lock_file		=> 'tmp/install.lock',
-		:log_dir				=> 'log/',
-		:server_log				=> 'log/thin.log',
-		:command_log			=> 'log/command_error_log.html',
-
-		# sub path under module directory of project
-		:tool					=> '/tool/',
-		:logic					=> '/logic/',
-		:store					=> '/boxes/',
-		:lang					=> '/boxes/langs/',
-		:doc					=> '/boxes/docs/',
-		:schema					=> '/boxes/migrations/',
-		:install				=> '/boxes/installs/',
-		:modinfo				=> '/boxes/installs/_mods',
-		:vars					=> '/boxes/installs/_vars',
-		:menu					=> '/boxes/installs/_menu',
-		:tpl					=> '/boxes/tpls/',
-		:layout_css				=> '/boxes/tpls/layout.css',
-		:common_css				=> '/boxes/tpls/common.css',
-		:misc					=> '/boxes/misc/',
-		:gemfile				=> '/boxes/misc/Gemfile',
-		:view					=> '/views/',
-		:assets					=> '/views/assets/',
-		:gitignore				=> '/.gitignore',
-		:route					=> '/routes.rb',
-		:readme					=> '/README.md',
-	}
-
-	# default settings of scfg file
-	Scfg						= {
-		:time_types				=> ['created', 'changed'],
-		:fixnum_types			=> ['order', 'level'],
-		:number_types 			=> ['Fixnum', 'Integer', 'Float'],
-		:field_alias			=> {int:'Fixnum', str:'String', text:'Text', time:'Time', big:'Bignum', fl:'Float'},
-		:init_module_path		=> [:store, :lang, :schema, :install, :modinfo, :misc, :gemfile, :view, :assets, :readme, :route],
-		:init_root_path			=> [:db_dir, :upload_dir, :backup_dir, :tmp_dir, :log_dir, :module],
-		:environment 			=> 'development',						# or production, test
-		:only_enable_modules	=> [],
-		:disable_modules		=> [],
-		:encoding				=> 'utf-8',
-		:lang					=> 'en',
-		:install_lock			=> 'yes',
-		:db_connection			=> 'sqlite://db/data.db',
-		:server_log_mode		=> 'file',
-		:repo_source			=> 'https://github.com/',
-		:server 				=> 'thin',
-		:bind 					=> '0.0.0.0',
-		:port					=> 3000,
-		:init_scfg_item			=> [:lang, :db_connection, :environment, :bind, :port],
-	}
-
-end
-
-# load config file in shortcut pipe
-Scfg = Simrb::Scfg
-if File.exist? 'scfg'
-	Simrb.yaml_read('scfg').each do | k, v |
-		Scfg[k.to_sym] = v
-	end
-end
-
-# load path in shortcut pipe
-Spath = Simrb::Spath
-if File.exist? 'spath'
-	Simrb.yaml_read('spath').each do | k, v |
-		Spath[k.to_sym] = v
-	end
-end
-
-# load modules
-Smodules = Simrb.module_load
-

data/lib/simrb/help.rb

@@ -1,33 +0,0 @@
-# 
-# a help interface for document
-#
-
-Sdocs = {}
-
-module Simrb
-	
-	def self.help args = []
-		res 		= []
-		i 			= 0
-		docs_key 	= {}
-		docs_val 	= {}
-		Sdocs.each do | key, val |
-			docs_key[i] = key
-			docs_val[i] = val
-			i = i + 1
-		end
-
-		if args.empty?
-			res << 'please select the number before the list to see detials'
-			docs_key.each do | i, key |
-				res << "#{i.to_s}, #{key}"
-			end
-		else
-			args.each do | i |
-				res << (docs_val.include?(i.to_i) ? docs_val[i.to_i] : 'no document')
-			end
-		end
-		res
-	end
-
-end