rmk-ruby 0.1.0

data/README.md

@@ -0,0 +1,37 @@
+# Rmk
+
+A build tool like make, tup, ninja.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rmk'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rmk
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+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.
+
+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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/pbl-pw/rmk. 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.
+
+## Code of Conduct
+
+Everyone interacting in the Rmk project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rmk/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+	t.libs << "test"
+	t.libs << "lib"
+	t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rmk"
+
+# 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(__FILE__)

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/exe/rmk

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'iniparse'
+require "rmk"
+
+options = {}
+parser = OptionParser.new{ |opts|
+	opts.summary_width = 48
+	opts.banner = 'Usage: rmk [Options] [targets]'
+	opts.separator ''
+	opts.on '-O', '--outdir=dir', 'output root dir,can be absolute or relative to pwd,default _Build' do |dir|
+		options[:outroot] = dir
+	end
+	opts.on '-S', '--srcdir=dir', 'source root dir,can be absolute or relative to output root(start with ..),default ..' do |dir|
+		options[:srcroot] = dir
+	end
+	opts.on '-V', '--variant [x,y,z]', Array, 'variant list to build, empty for build all variants' do |list|
+		options[:variants] = list || []
+	end
+	opts.on '-h', '--help', 'show this help' do
+		puts opts
+		exit
+	end
+	opts.on '-v', '--version', 'show version' do
+		puts 'rmk 0.2.0', ''
+		exit
+	end
+}
+targets = parser.parse(ARGV)
+if options[:variants]
+	raise "variants config file 'variants.rmk' not exist" unless File.exist? 'variants.rmk'
+	inifile = IniParse.open 'variants.rmk'
+	targets = targets.map{|tgt| %|"#{tgt}"|}.join ' '
+	exe = File.join RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name']
+	thrs = []
+	(options[:variants].empty? ? inifile : options[:variants].map!{|vn|
+		variant = inifile[vn]
+		warn "variant '#{vn}' doesn't exist" unless variant
+		variant
+	}).each do |variant|
+		next unless variant
+		thrs << Thread.new{ system %|"#{exe}" "#{__FILE__}" -O"#{variant['outdir']}" -S"#{variant['srcdir']}" #{targets}|}
+	end
+	thrs.each{|thr| thr.join}
+	exit
+end
+if File.exist? 'ini.rmk'
+	inifile = IniParse.open 'ini.rmk'
+	dir, link = inifile['Outdir']['Path'], inifile['Outdir']['LinkTo']
+	if link
+		require 'fileutils'
+		link = link.gsub(/\$(?:(\$)|{(.*?)})/){$1 || ENV[$2]}.gsub! ?\/, ?\\
+		FileUtils.mkpath link unless Dir.exist? link
+		if File.symlink? dir
+			if File.readlink(dir) != link
+				Dir.rmdir dir
+				File.symlink link, dir
+			end
+		elsif Dir.exist?(dir) || File.exist?(dir)
+			raise "need symlink '#{dir}' as outroot, but file(or dir) '#{dir}' already exist"
+		else
+			FileUtils.mkpath File.dirname dir
+			File.symlink link, dir
+		end
+	else
+		FileUtils.mkpath dir
+	end
+	options[:srcroot] ||= inifile['Srcdir']['Path']
+	options[:outroot] ||= dir
+end
+rmk = Rmk.new srcroot:options[:srcroot] || '..', outroot:options[:outroot] || '_Build'
+rmk.parse
+rmk.build *targets

data/lib/rmk/build.rb

@@ -0,0 +1,238 @@
+require_relative 'rmk'
+require_relative 'vdir'
+require_relative 'vfile'
+require 'open3'
+require 'digest'
+
+class Rmk::Build
+	attr_reader :dir, :vars
+	attr_reader :infiles, :depfiles, :orderfiles, :outfiles
+
+	# create Build
+	# @param dir [Rmk::VDir] build's dir
+	# @param rule [Rmk::Rule] build's rule
+	# @param vars [Rmk::Vars] upstream vars
+	# @param input [Array<Rmk::VFile>] input files
+	# @param implicit_input [String, nil] implicit input raw string
+	# @param order_only_input [String, nil] order-only input raw string
+	# @param output [String, nil] output raw string
+	# @param implicit_output [String, nil] implicit output raw string
+	# @param collection [String, nil] collection name
+	def initialize(dir, rule, vars, input, implicit_input, order_only_input, output, implicit_output, collection)
+		@mutex = Thread::Mutex.new
+		@updatedcnt = 0		# input file updated count
+		@runed = false			# build has been runed
+		@input_modified = false	# input file has modified
+
+		@dir = dir
+		@command = rule.command
+		@vars = vars.downstream_new clone_rmk:true
+		rmk_vars = @vars.rmk
+		@infiles = input
+
+		if @infiles.size == 1
+			if FFile === @infiles[0]
+				vname = @infiles[0].vname
+				if vname
+					match = /^((?:[^\/]+\/)*)([^\/]*)$/.match vname
+					rmk_vars['in_dir'], rmk_vars['in_nodir'] = match[1], match[2]
+					match = /^(.*)\.(.*)$/.match match[2]
+					rmk_vars['in_base'], rmk_vars['in_ext'] = match[1], match[2]
+					rmk_vars['in_noext'] = rmk_vars['in_dir'] + rmk_vars['in_base']
+				end
+				rmk_vars['stem'] = @infiles[0].stem if @infiles[0].stem
+				@infiles[0] = @infiles[0].vfile
+			end
+		end
+		rmk_vars['in'] = @infiles.map do |file|
+			file.input_ref_builds << self
+			next file.vpath || file.path unless file.src?
+			file.vpath ? @dir.rmk.join_rto_src_path(file.vpath) : file.path
+		end.join ' '
+
+		@vars.split_str(implicit_input).each do |fn|
+			files = @dir.find_inputfiles fn
+			raise "pattern '#{fn}' not match any file" if files.empty?
+			files.each{|f| f.input_ref_builds << self}
+		end if implicit_input
+
+		@orderfiles = []
+		@vars.split_str(order_only_input).each do |fn|
+			files = @dir.find_inputfiles fn
+			raise "pattern '#{fn}' not match any file" if files.empty?
+			files.each{|f| f.order_ref_builds << self}
+		end if order_only_input
+		raise 'no found any input file' if @infiles.empty? && @orderfiles.empty?
+
+		@outfiles = []
+		regout = proc do |fn|
+			file = @dir.add_out_file fn
+			file.output_ref_build = self
+			@outfiles << file
+		end
+		output = rule['out'] || raise('must have output') unless output
+		@vars.split_str(output).each &regout
+		collection.each{|col| col.concat @outfiles} if collection
+		rmk_vars['out'] = @outfiles.map {|file| file.vpath || file.path}.join ' '
+		rmk_vars['out_noext'] = rmk_vars['out'][/^(.*)\..*$/, 1] if @outfiles.size == 1
+		rule.apply_to @vars	# interpolate rule's vars to self
+		@vars.split_str(implicit_output).each &regout if implicit_output
+		rmk_vars.freeze
+		@depfiles = []
+		@outfiles.each do |file|
+			next unless (fns = @dir.rmk.dep_storage.data![file.path])
+			fns.each {|fn| @dir.rmk.find_inputfiles(fn).each {|f| f.input_ref_builds << self; @depfiles << f}}
+		end
+	end
+
+	def input_updated!(modified, order:false)
+		Rmk::Schedule.new_thread! &method(:run) if @mutex.synchronize do
+			next @runed = :checkskip if @runed == :force
+			next if @runed
+			@updatedcnt += 1
+			@input_modified ||= order ? modified == :create : modified
+			needrun = @updatedcnt >= @infiles.size + @depfiles.size + @orderfiles.size
+			@runed = true if needrun
+			needrun
+		end
+	end
+
+	def order_updated!(modified) input_updated! modified, order:true end
+
+	private def get_command
+		cmd = @vars.interpolate_str @vars['command'] || @command
+		digest = Digest::SHA1.new
+		digest << cmd
+		fdproc = proc{|f| digest << f.vpath || f.path}
+		@infiles.each &fdproc
+		@orderfiles.each &fdproc
+		@depfiles.each {|f| digest << f.path}
+		digest = digest.hexdigest
+		storage = @dir.rmk.cml_storage
+		[cmd, storage.data![@outfiles[0].path] != digest]
+	end
+
+	private def save_digest(fns)
+		digest = Digest::SHA1.new
+		digest << @command
+		fdproc = proc{|f| digest << f.vpath || f.path}
+		@infiles.each &fdproc
+		@orderfiles.each &fdproc
+		fns.each {|f| digest << f} if fns
+		digest = digest.hexdigest
+		storage = @dir.rmk.cml_storage
+		storage.sync{|data| data[@outfiles[0].path] = digest}
+	end
+
+	@output_mutex = Thread::Mutex.new
+	def self.puts(*parms) @output_mutex.synchronize{$stdout.puts *parms} end
+	def self.err_puts(*parms) @output_mutex.synchronize{$stderr.puts *parms} end
+	def self.log_cmd_out(out, err)
+		@output_mutex.synchronize do
+			$stdout.puts out unless out.empty?
+			$stderr.puts err unless err.empty?
+		end
+	end
+
+	def parser_force_run!
+		return if @runed
+		@runed = :force
+		exec = nil
+		@outfiles.each{|file| file.state = File.exist?(file.path) ? :exist : (exec = :create)}
+		@command, changed = get_command
+		unless changed || exec
+			inproc = proc do |file|
+				next file.check_for_parse if file.src?
+				state = file.state
+				raise 'output file not updated when ref as config file build input' unless state
+				state != :exist
+			end
+			exec = @infiles.any? &inproc
+			exec ||= @depfiles.any? &inproc
+			return unless @orderfiles.any? do |file|
+				next if file.src?
+				state = file.state
+				raise 'output file not updated when ref as config file build input' unless state
+				state == :create
+			end unless exec
+		end
+		raise 'config file build fail' unless raw_exec @command
+		@outfiles.each{|file| file.state = :update if file.state == :exist}
+	end
+
+	private def run
+		if @runed == :checkskip
+			@outfiles.each {|file| file.updated! file.state != :exist && file.state}
+			save_digest process_depfile unless @outfiles[0].state == :exist
+		else
+			exec = nil
+			@outfiles.each{|file| file.state = File.exist?(file.path) ? :update : (exec = :create)}
+			@command, changed = get_command
+			return @outfiles.each{|file| file.updated! false} unless changed || @input_modified ||  exec
+			return unless raw_exec @command
+			@outfiles.each {|file| file.updated! file.state}
+			save_digest process_depfile
+		end
+	end
+
+	private def raw_exec(cmd)
+		@vars['depfile'] ||= (@outfiles[0].vpath || @outfiles[0].path) + '.dep' if @vars['deptype']
+		unless /^\s*$/.match? cmd
+			env = {}
+			env['PATH'] = @vars['PATH_prepend'] + ENV['PATH'] if @vars['PATH_prepend']
+			@vars['ENV_export'].split(/\s+/).each{|name| env[name] = @vars[name] if @vars.include? name} if @vars['ENV_export']
+			std, err, result = env.empty? ? Open3.capture3(cmd) : Open3.capture3(env, cmd)
+			std = std.empty? ? @vars['echo'] || "Rmk: run: #{cmd}" : (@vars['echo'] || "Rmk: run: #{cmd}") + ?\n + std
+			if result.exitstatus != 0
+				err = "execute faild: '#{cmd}'" if err.empty?
+				Rmk::Build.log_cmd_out std, err
+				@outfiles.each{|file| File.delete file.path if File.exist? file.path}
+				return false
+			end
+			Rmk::Build.log_cmd_out std, err
+		end
+		true
+	end
+
+	private def process_depfile
+		return unless @vars['deptype']
+		unless File.exist? @vars['depfile']
+			Rmk::Build.err_puts "Rmk: depend file '#{@vars['depfile']}' which must be created by build '#{@vars['out']}' not found"
+		end
+		if @vars['deptype'] == 'make'
+			files = parse_make_depfile @vars['depfile']
+			File.delete @vars['depfile']
+			return Rmk::Build.err_puts "Rmk: syntax of depend file '#{@vars['depfile']}' not support yet" unless files
+			@dir.rmk.dep_storage[@outfiles[0].path] = files
+			files.each do |file|
+				file = File.absolute_path Rmk.normalize_path(file), @dir.rmk.outroot
+				next if @dir.rmk.srcfiles.include?(file) || @dir.rmk.outfiles.include?(file)
+				@dir.rmk.mid_storage.sync{|data| data[file] ||= Rmk::VFile.generate_modified_id(file)}
+			end
+			files
+		else
+			Rmk::Build.err_puts "Rmk: depend type '#{@vars['deptype']}' not support"
+		end
+	end
+
+	def parse_make_depfile(path)
+		lines = IO.readlines path
+		line, lid = lines[0], 0
+		_, _, line = line.partition /(?<!\\)(?:\\\\)*\K:\s+/
+		return unless line
+		files = []
+		while lid < lines.size
+			joinline = line.sub! /(?<!\\)(?:\\\\)*\K\\\n\z/,''
+			parms = line.split /(?<!\\)(?:\\\\)*\K\s+/
+			unless parms.empty?
+				parms.delete_at 0 if parms[0].empty?
+				parms.map!{|parm| File.absolute_path parm.gsub(/\\(.)/, '\1')}
+				files.concat parms
+			end
+			break unless joinline
+			lid += 1
+			line = lines[lid]
+		end
+		files
+	end
+end

data/lib/rmk/rmk.rb

@@ -0,0 +1,197 @@
+require 'rmk/version'
+require_relative 'vars'
+require_relative 'storage'
+
+class Rmk
+	# normalize path, drive letter upcase and path seperator set to '/'
+	# @param path [String]
+	# @return [String]
+	def self.normalize_path(path) path.gsub(?\\, ?/).sub(/^[a-z](?=:)/){|ch|ch.upcase} end
+
+	# create Rmk object
+	# @param srcroot [String] source root dir,can be absolute or relative to output root(start with ..)
+	# @param outroot [String] output root dir,can be absolute or relative to pwd,default pwd
+	def initialize(srcroot:'', outroot:'')
+		@files_mutex = Thread::Mutex.new	# files operate mutex
+
+		srcroot = Rmk.normalize_path srcroot
+		@outroot = File.join Rmk.normalize_path(File.absolute_path outroot), ''
+		@srcroot = File.join File.absolute_path(srcroot, @outroot), ''
+		raise "source path '#{@srcroot}' not exist or not directory" unless ::Dir.exist?(@srcroot)
+		warn 'in-source build' if @outroot == @srcroot
+		@src_relative = srcroot.match?(/^\.\./) && File.join(srcroot, '')
+		Dir.mkdir @outroot unless Dir.exist? @outroot
+		Dir.chdir @outroot
+		Dir.mkdir '.rmk' unless Dir.exist? '.rmk'
+		@mid_storage = Rmk::Storage.new '.rmk/mid', {}
+		@dep_storage = Rmk::Storage.new '.rmk/dep', {}
+		@cml_storage = Rmk::Storage.new '.rmk/cml', {}	# command line text storage
+		@srcfiles = {}
+		@outfiles = {}
+		@defaultfiles = []
+		@vars = {'srcroot'=>@srcroot[0..-2], 'outroot'=>@outroot[0..-2], 'src_rto_root'=>(@src_relative || @srcroot)[0..-2]}.freeze
+		@virtual_root = Rmk::VDir.new self, nil
+	end
+	attr_reader :srcroot, :outroot, :vars, :virtual_root, :srcfiles, :outfiles
+	attr_reader :mid_storage, :dep_storage, :cml_storage
+
+	def join_abs_src_path(path) File.join @srcroot, path end
+
+	# join src file path relative to out root, or absolute src path when not relative src
+	def join_rto_src_path(path) ::File.join @src_relative ? @src_relative : @srcroot, path end
+
+	# split path pattern to dir part and file match regex part
+	# @param pattern [String] absolute path, can include '*' to match any char at last no dir part
+	# when pattern include '*', return [dir part, file(or dir) match regex, post dir part, post file part]
+	# ;otherwise return [origin pattern, nil, nil, nil]
+	def split_path_pattern(pattern)
+		match = /^([a-zA-Z]:\/(?:[^\/*]+\/)*+)([^\/*]*+)(?:\*([^\/*]*+))?(?(3)(\/(?:[^\/*]+\/)*+[^\/*]++)?)$/.match pattern
+		raise "file syntax '#{pattern}' error" unless match
+		dir, prefix, postfix, postpath = *match[1..5]
+		regex = postfix && /#{Regexp.escape prefix}(.*)#{Regexp.escape postfix}$/
+		[regex ? dir : pattern, regex, postpath]
+	end
+
+	# find files which can be build's imput file
+	# @param pattern [String] absolute path to find src and out files which can include '*' to match any char at last no dir part
+	# @param ffile [Boolean] return FFile struct or not
+	# @return [Array<VFile, FFile>] return array of FFile when ffile, otherwise array of VFile
+	def find_inputfiles(pattern, ffile:false)
+		pattern = Rmk.normalize_path pattern
+		path, regex, postpath = split_path_pattern pattern
+		files = []
+		if regex
+			@files_mutex.synchronize do
+				find_outfiles_imp files, path, regex, postpath, ffile:ffile
+				range = postpath ? path.size..-1-postpath.size : path.size..-1
+				Dir[pattern].each do |fn|
+					next if @outfiles.include? fn
+					next files << (ffile ? FFile.new(@srcfiles[fn], nil, fn[range][regex, 1]) : @srcfiles[fn]) if @srcfiles.include? fn
+					file = (@srcfiles[fn] = VFile.new rmk:self, path:fn, is_src:true,
+						vpath:fn.start_with?(@srcroot) && fn[@srcroot.size .. -1])
+					files << (ffile ? FFile.new(file, nil, fn[range][regex, 1]) : file)
+				end
+			end
+		else
+			@files_mutex.synchronize do
+				next files << (ffile ? FFile.new(@outfiles[path]) : @outfiles[path]) if @outfiles.include? path
+				next files << (ffile ? FFile.new(@srcfiles[path]) : @srcfiles[path]) if @srcfiles.include? path
+				next unless File.exist? path
+				file = @srcfiles[path] = VFile.new rmk:self, path:path, is_src:true,
+						vpath:path.start_with?(@srcroot) && path[@srcroot.size .. -1]
+				files << (ffile ? FFile.new(file) : file)
+			end
+		end
+		files
+	end
+
+	# find files which must be build's output
+	# @param pattern [String] absolute path to find out files which can include '*' to match any char at last no dir part
+	# @return [Array<Hash>] return Array of file, and Regex when has '*' pattern
+	def find_outfiles(pattern)
+		path, regex, postpath = split_path_pattern Rmk.normalize_path pattern
+		files = []
+		@files_mutex.synchronize do
+			next (files << @outfiles[path] if @outfiles.include? path) unless regex
+			find_outfiles_imp files, path, regex, postpath
+		end
+		files
+	end
+
+	# find outfiles raw implement(assume all parms valid)
+	# @param files [Array<VFile>] array to store finded files
+	# @param path [String] absolute path, path must be dir(end with '/') or empty
+	# @param regex [Regexp] file match regexp, or dir match regexp when postpath not nil
+	# @param postpath [String, nil] path after dir match regexp
+	# @param ffile [Boolean] return FFile struct or not
+	# @return [Array<VFile, FFile>] return array of FFile when ffile, otherwise array of VFile
+	private def find_outfiles_imp(files, path, regex, postpath, ffile:false)
+		range = postpath ? path.size..-1-postpath.size : path.size..-1
+		return @outfiles.each do |k, v|
+			next unless k.start_with?(path) && k[range].match?(regex)
+			files << (ffile ? FFile.new(v, nil, k[range][regex, 1]) : v)
+		end unless postpath
+		@outfiles.each do |k, v|
+			next unless k.start_with?(path) && k.end_with?(postpath) && k[range].match?(regex)
+			files << (ffile ? FFile.new(v, nil, k[range][regex, 1]) : v)
+		end
+	end
+
+	# register a out file
+	# @param path [String]
+	# @param vpath [String]
+	# @return [Rmk::VFile] return file obj added
+	def add_out_file(path:, vpath:nil)
+		@files_mutex.synchronize do
+			raise "file '#{path}' has been defined" if @outfiles.include? path
+			file = @srcfiles.delete(path).change_to_out! file if @srcfiles.include? path
+			@outfiles[path] = VFile.new rmk:self, path:path, vpath:vpath
+		end
+	end
+
+	# register a src file
+	# @param path [String]
+	# @param vpath [String]
+	# @return [Rmk::VFile] return file obj added
+	def add_src_file(path:, vpath:nil)
+		@files_mutex.synchronize do
+			@outfiles[path] || (@srcfiles[path] ||= VFile.new(rmk:self, path:path, vpath:vpath, is_src:true))
+		end
+	end
+
+	# add default target
+	def add_default(*files) @files_mutex.synchronize{@defaultfiles.concat files} end
+
+	# parse project
+	# @return [self]
+	def parse
+		puts 'Rmk: parse start'
+		@mid_storage.wait_ready
+		@dep_storage.wait_ready
+		@cml_storage.wait_ready
+		@virtual_root.parse
+		puts 'Rmk: parse done'
+		self
+	end
+
+	def build(*tgts)
+		puts 'Rmk: build start'
+		if tgts.empty?
+			files = @defaultfiles
+		else
+			files = tgts.map do |name|
+				file = Rmk.normalize_path name
+				file = @outfiles[File.absolute_path file, @outroot] || @srcfiles[File.absolute_path file, @srcroot]
+				raise "build target '#{name}' not found" unless file
+				file = file.input_ref_builds[0].outfiles[0] if file.src? && file.input_ref_builds.size == 1
+				file
+			end
+		end
+		if files.empty?
+			@srcfiles.each_value{|file| file.check_for_build}
+		else
+			checklist = []
+			checkproc = proc do |fi|
+				next checklist << fi if fi.src?
+				fi.output_ref_build.infiles.each &checkproc
+				fi.output_ref_build.depfiles.each &checkproc
+				fi.output_ref_build.orderfiles.each &checkproc
+			end
+			files.each &checkproc
+			exit puts('found nothing to build') || 0 if checklist.empty?
+			checklist.each {|file| file.check_for_build}
+		end
+		while Thread.list.size > 1
+			thr = Thread.list[-1]
+			thr.join unless thr == Thread.current
+		end
+		puts 'Rmk: build end'
+		@mid_storage.save
+		@dep_storage.data!.each_key {|key| @dep_storage.data!.delete key unless @outfiles.include? key}
+		@dep_storage.save
+		@cml_storage.data!.each_key {|key| @cml_storage.data!.delete key unless @outfiles.include? key}
+		@cml_storage.save
+	end
+
+	class VFile; end
+end

data/lib/rmk/rule.rb

@@ -0,0 +1,30 @@
+require_relative 'rmk'
+
+class Rmk::Rule
+	Var = Struct.new :append?, :value
+
+	# create Rule
+	# @param command [String] exec command template
+	def initialize(command)
+		@command = command
+		@vars = {}
+		@rmk_vars = {'out'=>nil, 'collection'=>nil}
+	end
+	attr_reader :command
+
+	def vars; self end
+
+	def [](name) @rmk_vars[name] end
+
+	# add var define template
+	# @return Array<Var>
+	def []=(name, append = false, value)
+		return @vars[name] = Var.new(append, value) unless @rmk_vars.include? name
+		raise "special var '#{name}' can't be append" if append
+		@rmk_vars[name] = value
+	end
+
+	def apply_to(tgt)
+		@vars.each{|name, var| var.append? ? tgt[name] += var.value : tgt[name] = var.value }
+	end
+end

data/lib/rmk/schedule.rb

@@ -0,0 +1,15 @@
+class Rmk; end
+
+module Rmk::Schedule
+	Thread.abort_on_exception = true
+	@queue = SizedQueue.new 8
+
+	def self.new_thread!(&cmd)
+		Thread.new do
+			@queue.push nil
+			result = cmd.call
+			@queue.pop
+			result
+		end
+	end
+end

data/lib/rmk/storage.rb

@@ -0,0 +1,30 @@
+require_relative 'schedule'
+
+class Rmk::Storage
+	# create
+	# @param file [String] file path
+	# @param iniobj [Object] init inside obj
+	def initialize(file, iniobj)
+		@mutex = Thread::Mutex.new
+		@file = file
+		@data = File.exist?(@file) ? Rmk::Schedule.new_thread!{Marshal.load IO.binread @file} : iniobj
+	end
+
+	# wait for storage ready to read and write
+	# @note before call this method storage is not ready, can't call any follow methods
+	def wait_ready; @mutex.synchronize{@data = @data.value if Thread === @data} end
+
+	# save data to disk file
+	def save; @mutex.synchronize{IO.binwrite @file, Marshal.dump(@data)} end
+
+	# run block in mutex sync protected
+	# @yieldparam data [Hash] inside Hash obj
+	# @return [Object] block's result
+	def sync(&cmd) @mutex.synchronize{cmd.call @data} end
+
+	# get inside Hash obj without sync protected
+	def data!; @data end
+
+	# redirect undef method to inside data obj with sync protected, often used for single operation
+	def method_missing(name, *parms, &cmd) @mutex.synchronize{@data.send name, *parms, &cmd} end
+end