andromeda 0.1 → 0.1.2

data/lib/andromeda/atom.rb

@@ -0,0 +1,105 @@
+module Andromeda
+
+	module Impl
+
+		class Atom < Atomic
+			include To_S
+
+			def initialize(init_val = nil)
+				super init_val
+			end
+
+			def empty? ; value.nil? end
+			def full? ; ! value.nil? end
+
+			def to_short_s ; "(#{To_S.short_s(value)})" end
+			alias_method :inspect, :to_s
+
+			def wait_while(&test)
+				while test.call(value) ; Thread::pass	end
+			end
+
+			def wait_until_eq(val = nil)
+				raise ArgumentError unless val.kind_of?(Fixnum)
+				wait_while { |v| v != val }
+			end
+
+			def wait_until_ne(val = nil)
+				raise ArgumentError unless val.kind_of?(Fixnum)
+				wait_while { |v| v == val }
+			end
+
+			def wait_until_empty?
+				wait_until_eq nil
+			end
+
+			def wait_until_full?
+				wait_until_ne nil
+			end
+
+			def with_value
+				update { |v| yield v ; v }
+			end
+		end
+
+	end
+
+	module Atom
+
+		class Region
+			include Impl::To_S
+
+			def to_short_s ; "(#{Impl::To_S.short_s(value)})" end
+			alias_method :inspect, :to_s
+
+			def initialize(init_value = 0)
+				init_value = init_value[:init_value].to_i if init_value.kind_of?(Hash)
+				raise ArgumentError unless init_value.kind_of?(Fixnum)
+				@count = Impl::Atom.new init_value
+			end
+
+			alias_method :inspect, :to_s
+
+			def value ; @count.value end
+
+			def enter(amount = 1)
+				raise ArgumentError unless amount.kind_of?(Fixnum)
+				raise ArgumentError unless amount >= 0
+				@count.update { |v| v + amount }
+			end
+
+			def leave(amount = 1)
+				raise ArgumentError unless amount >= 0
+				raise ArgumentError unless amount.kind_of?(Fixnum)
+				@count.update { |v| v - amount }
+			end
+
+			def wait_until_eq(val) ; @count.wait_until_eq(val) end
+		end
+
+		class Var < Impl::Atom
+		end
+
+		class FillOnce < Var
+			def empty! ; super.update nil end
+
+			def update(v)
+				super.update do |o|
+					raise ArgumentError, 'Attempt to refill FillOnce' if o
+					v
+				end
+			end
+		end
+
+		class Combiner < Var
+			attr_reader :combiner
+
+			def update(v)
+				super.update do |o|
+					if combiner then combiner.call o, v else v end
+				end
+			end
+		end
+
+	end
+end

data/lib/andromeda/cmd.rb

@@ -0,0 +1,242 @@
+module Andromeda
+
+	module Cmd
+
+		class Cmd
+			attr_reader :cmd
+			attr_reader :data
+			attr_reader :time
+
+			def initialize(cmd, data = {}, cmd_time = nil)
+				raise ArgumentError unless cmd.kind_of?(Symbol)
+				@cmd     = cmd
+				@data    = data
+				@time    = if cmd_time then cmd_time else Time.now.to_i end
+				@comment = nil
+			end
+
+			def comment ; @comment || ''  end
+			def comment=(str = nil) ;	@comment = str end
+
+			def if_cmd(sym) ; if sym == cmd then yield data else seld end end
+
+			def as_json
+				h = { cmd: cmd, data: (data.as_json rescue data), time: time }
+				c = @comment
+				h[:comment] = c if c
+				h
+			end
+
+			def to_s ; as_json.to_json end
+
+			def with_comment(str = nil)
+				@comment = str
+				self
+			end
+
+			def self.new_input(cmd, data = {}, cmd_time = nil)
+				inner = Cmd.new cmd, data, cmd_time
+				Cmd.new :input, inner, cmd_time
+			end
+
+			def self.from_json(json)
+				Cmd.new json['cmd'].to_sym, json['data'], (json['time'] rescue nil)
+			end
+		end
+
+		class FileCmdPlan < Kit::InlineKeyRouter
+			attr_reader :path
+			attr_reader :mode
+			attr_reader :file
+
+			meth_spot :open
+			meth_spot :sync
+			meth_spot :close
+			meth_spot :input
+
+			signal_spot :open
+			signal_spot :close
+			signal_spot :sync
+
+			def data_map(name, data)
+				if data.is_a?(Cmd) then data else Cmd.new(data) end
+			end
+
+			def data_key(name, data) ; data.cmd  end
+			def data_val(name, data) ; data.data end
+
+			def data_tag(name, key, val, tags_in)
+				tags_out = super
+				if name == :input
+					tags_out[:time]    = val.time
+					tags_out[:comment] = val.comment
+				end
+				tags_out
+			end
+
+			def on_open(key, val)
+				if @file
+					signal_error ArgumentError.new("associated file already open")
+				else
+					@path   = val[:path] if val[:path]
+					@mode   = val[:mode] if val[:mode]
+					@mode ||= init_mode
+					@file = File.open @path, @mode
+				end
+			end
+
+			def on_input(key, val)
+				exit << val if exit
+			end
+
+			def on_sync(key, val)
+				f = @file ;	sync_file f if f
+			end
+
+			def on_close(key, val)
+				if @file
+					begin
+						close_file(@file)
+					ensure
+						@file = nil
+					end
+				else
+					signal_error ArgumentError.new("associated file not open")
+				end
+			end
+
+			protected
+
+			def close_file(f)
+				begin
+					sync_file f
+				ensure
+					f.close
+				end
+			end
+
+			def sync_file(f) ; end
+		end
+
+		class Writer < FileCmdPlan
+
+			def init_mode ; 'w' end
+
+			def on_input(key, val)
+				signal_error ArgumentError.new("associated filed not open") unless file
+				cmd  = val.cmd
+				raise ArgumentError, "invalid cmd" unless cmd.kind_of?(Symbol)
+				data = val.data
+				str  = if data then data.to_json else '' end
+				len  = str.length + 1
+				tim  = val.time if val.time
+				tim  = Time.now unless tim
+				tim  = tim.to_i unless tim.kind_of?(Fixnum)
+				new_str = ''
+				str.each_line { |line| new_str << "... #{line}\n" }
+				str  = nil
+				len  = new_str.length
+				val  = tags[:comment]
+				val.each_line { |line| file.write "\# #{line}\n" } if val
+				file.write "<<< ANDROMEDA START :#{cmd} TIME #{tim} LEN #{len} >>>\n"
+				file.write new_str
+				file.write "<<< ANDROMEDA END :#{cmd} >>>\n"
+				super key, val
+			end
+
+			protected
+
+			def sync_file(f)
+				f.sync
+				f.fsync rescue nil
+			end
+		end
+
+		class Reader < Kit::FileReader
+			attr_reader :start_matcher, :end_matcher, :comment_matcher, :line_matcher
+
+			def initialize(config = {})
+				super config
+				@start_matcher   = /<<< ANDROMEDA START :(\w+) TIME (\d+) LEN (\d+) >>>/
+				@end_matcher     = /<<< ANDROMEDA END :(\w+) >>>/
+				@comment_matcher = /#(.*)/
+				# remember to change the offset for :line, too whenever you change this
+				@line_matcher    = /... (.*)/
+			end
+
+			def match_line(state, line)
+				m = @start_matcher.match line
+				return yield :start, state, ({ cmd: m[1].to_sym, tim: m[2].to_i, len: m[3].to_i }) if m
+				m = @end_matcher.match line
+				return yield :end, state, m[1].to_sym if m
+				m = @comment_matcher.match line
+				return yield :comment, state, m[1] if m
+				m = @line_matcher.match line
+				return yield :line, state, m[1] if m
+				yield :garbage, state, line
+			end
+
+			def on_enter(key, val)
+				super key, val do |file|
+					fst = tags[:first]
+					lst = tags[:last]
+
+					state = { :comment => true, :start => true, :cont => true }
+					while (line = file.gets) && state[:cont]
+						line = line.chomp
+						match_line(state, line) do |token, state, parts|
+							signal_error ArgumentError.new("Skipping unexpected token #{token} in line '#{line}' (state: #{state})") unless state[token]
+							case token
+							when :comment
+								if state[:comment_str]
+									then state[:comment_str] << parts
+									else state[:comment_str]  = parts end
+							when :start
+								state.delete :comment
+								state.delete :start
+								state[:line]    = true
+								state[:end]     = true
+								parts[:data]    = ''
+								state[:len]     = 0
+								state[:cur]     = parts
+								parts[:comment] = state[:comment_str]
+								state.delete :comment_str
+							when :line
+								state[:len] += parts.length + 5
+								state[:cur][:data] << "#{parts}\n"
+							when :end
+								state.delete :line
+								state.delete :end
+								state[:start]   = true
+								state[:comment] = true
+								cur             = state[:cur]
+								data            = cur[:data]
+								signal_error ArgumentError.new("Start (#{cur[:cmd]}) and end (#{parts})cmd mismatch") unless cur[:cmd] == parts
+								signal_error ArgumentError.new("Length mismatch (expected: #{cur[:len]}, found: #{state[:len]})") unless cur[:len] == state[:len]
+								exit << cur if exit
+								state[:cont] = false unless file.pos <= lst
+							else
+								signal_error ArgumentError.new("Garbage encountered (line: '#{line}')")
+								return
+							end
+						end
+					end
+				end
+			end
+
+		end
+
+		class Parser < Plan
+
+			def on_enter(key, val)
+				data = val[:data].chomp
+				data = JSON::parse(data)
+				cmd  = Cmd.new val[:cmd], data, val[:time]
+				rem  = val[:comment] rescue nil
+				cmd.with_comment rem if rem
+				exit << cmd if cmd
+			end
+		end
+
+	end
+end

data/lib/andromeda/copy_clone.rb

@@ -0,0 +1,44 @@
+module Andromeda
+
+  class ::Object
+
+    def identical_copy
+      case clone_to_copy?
+      when false then self
+      when true then clone
+      else clone rescue self end
+    end
+
+    def clone_to_copy? ; cloneable? end
+    def cloneable? ; nil end
+  end
+
+  class ::NilClass
+    def cloneable? ; false end
+  end
+
+  class ::FalseClass
+    def cloneable? ; false end
+  end
+
+  class ::FalseClass
+    def cloneable? ; false end
+  end
+
+  class ::Numeric
+    def cloneable? ; false end
+  end
+
+  class ::Symbol
+    def cloneable? ; false end
+  end
+
+  class ::Thread
+    def cloneable? ; false end
+  end
+
+  class ::Regexp
+    def cloneable? ; false end
+  end
+
+end

data/lib/andromeda/error.rb

@@ -0,0 +1,42 @@
+module Andromeda
+
+  class InfoMsg
+
+    def self.str(msg = '', details = {}, cause_ = nil)
+      details[:cause] = cause_ if cause_
+      (InfoMsg.new msg, details).to_s
+    end
+
+    attr_reader :details
+    attr_reader :cause
+    attr_reader :msg
+
+    def initialize(msg = '', details = {})
+      @msg     = msg
+      @details = details
+      @cause   = details[:cause]
+      details.delete :cause if @cause
+    end
+
+    def to_s
+      out = msg.dup
+      if details && details.length > 0
+        if cause
+          out << " (cause = #{cause}; details = \{"
+        else
+          out << ' (details = {'
+        end
+        details.each_pair { |k,v| out << " #{k}: #{v}" }
+        out << ' })'
+      else
+        out << " (cause = #{cause})" if cause
+      end
+      out << '.'
+      out
+    end
+  end
+
+	class SendError < RuntimeError ; end
+  class ExecError < RuntimeError ; end
+
+end

data/lib/andromeda/guide.rb

@@ -0,0 +1,50 @@
+module Andromeda
+
+  module Guides
+
+  	class Guide
+      def track(spot, key, suggested_track = nil)
+        raise NoMethodError
+      end
+
+      def pack(track, was_suggested = false)
+        return plan.copy if was_suggested
+        if plan.frozen? then plan else plan.copy end
+      end
+  	end
+
+    class Track
+      def follow(*args, &thunk) ; thunk.call *args end
+    end
+
+    class LocalGuide < Guide
+      include Singleton
+
+      def track(spot, key, suggested_track = nil)
+        return suggested_track if suggested_track
+        LocalTrack.instance
+      end
+    end
+
+    class LocalTrack < Track
+      include Singleton
+    end
+
+    class SpawnGuide < Guide
+      include Singleton
+
+      def track(spot, key, suggested_track = nil)
+        SpawnGuide.instance
+      end
+    end
+
+    class SpawnTrack < Track
+      include Singleton
+
+      def follow(*args, &thunk)
+        Thread.new { || thunk.call *args }
+      end
+    end
+
+  end
+end