andromeda 0.1.2 → 0.1.3

data/lib/andromeda/error.rb

@@ -36,7 +36,7 @@ module Andromeda
     end
   end
 
-	class SendError < RuntimeError ; end
+  class SendError < RuntimeError ; end
   class ExecError < RuntimeError ; end
 
 end

data/lib/andromeda/guide.rb

@@ -2,7 +2,7 @@ module Andromeda
 
   module Guides
 
-  	class Guide
+    class Guide
       def track(spot, key, suggested_track = nil)
         raise NoMethodError
       end
@@ -11,7 +11,7 @@ module Andromeda
         return plan.copy if was_suggested
         if plan.frozen? then plan else plan.copy end
       end
-  	end
+    end
 
     class Track
       def follow(*args, &thunk) ; thunk.call *args end

data/lib/andromeda/guide_track.rb

@@ -1,8 +1,7 @@
 module Andromeda
-
   module Guides
 
-  	class Guide
+    class Guide
       include Andromeda::Impl::To_S
 
       def track(spot, label, suggested_track = nil)
@@ -20,7 +19,7 @@ module Andromeda
         if plan.frozen? then plan else plan.identical_copy end
       end
 
-  	end
+    end
 
     class Track
       include Andromeda::Impl::To_S

data/lib/andromeda/id.rb

@@ -1,19 +1,19 @@
 module Andromeda
 
-	class Id < Impl::XorId
-		# Default length of generated ids
-		DEFAULT_NUM_BYTES = 8
+  class Id < Impl::XorId
+    # Default length of generated ids
+    DEFAULT_NUM_BYTES = 8
 
-	  # @param [Bool] random
-		def initialize(random = true)
-			super DEFAULT_NUM_BYTES, random
-		end
+    # @param [Bool] random
+    def initialize(random = true)
+      super DEFAULT_NUM_BYTES, random
+    end
 
-	  # @return [Id] empty (zero) id
-	  def self.zero
-	  	@id = self.new false unless defined? @id
-	  	@id
-	  end
-	end
+    # @return [Id] empty (zero) id
+    def self.zero
+      @id = self.new false unless defined? @id
+      @id
+    end
+  end
 
 end

data/lib/andromeda/impl/class_attr.rb

@@ -2,7 +2,7 @@ module Andromeda
 
   module Impl
 
-  	module ClassAttr
+    module ClassAttr
 
       protected
 
@@ -24,7 +24,7 @@ module Andromeda
         dest_set = get_attr_set var_name, false
         instance_variable_set var_name, dest_set.union(name_set)
       end
-  	end
+    end
 
   end
 

data/lib/andromeda/impl/id.rb

@@ -0,0 +1,89 @@
+module Andromeda
+
+  module Impl
+
+    # Generator for random xorable ids (used for markers)
+    class XorId
+      include To_S
+
+      protected
+
+      def initialize(len, random = true, init_data = nil)
+        raise ArgumentError unless len.kind_of?(Fixnum)
+        raise ArgumentError unless len >= 0
+
+        @data = if init_data
+          init_data
+        else
+          if random
+            then len.times.map { Id.rnd_byte }
+            else len.times.map { 0 } end
+        end
+      end
+
+      public
+
+      def clone_to_copy? ; false end
+      def identical_copy ; self end
+
+      def length ; @data.length end
+      def zero? ; each { |b| return false unless b == 0 } ; true end
+
+      def [](key) ; @data[key] end
+
+      def same_length?(obj) ; self.length == obj.length end
+
+      def each ; this = self ; 0.upto(length-1).each { |i| yield this[i] } end
+      def each_with_index ; this = self ; 0.upto(length-1).each { |i| yield i, this[i] } end
+
+      # Compare self to b
+      # @param [Id] b
+      def ==(b)
+        return true if self.equal? b
+        return false if b.nil?
+        return false unless b.class.equal? self.class
+        return false unless same_length? b
+        zip_bytes(b) { |i, j| return false if i != j }
+        true
+      end
+
+      def hash ; @data.hash end
+
+      # xor self and b's ids component-wise
+      # @param [Array<Fixnum>] b
+      # @return [Id]
+      def xor(b)
+        r = []
+        zip_bytes(b) { |i,j| r << (i ^ j) }
+        Id.new r.length, false, r
+      end
+
+      def to_short_s
+        r = ''
+        each { |b| r << Id.two_char_hex_str(b.to_s(16)) }
+        r
+      end
+
+      def inspect ; to_s end
+
+      private
+
+      def zip_bytes(b)
+        a = self
+        0.upto(length-1).each { |i| yield a[i], b[i] }
+      end
+
+      def self.rnd_byte ; Random.rand(256) end
+
+      def self.two_char_hex_str(s)
+        case s.length
+          when 0 then '00'
+          when 1 then "0#{s}"
+          else s
+        end
+      end
+    end
+
+  end
+
+end

data/lib/andromeda/impl/proto_plan.rb

@@ -8,21 +8,21 @@ module Andromeda
       extend Impl::ClassAttr
 
       def self.spot_names(inherit = true) ; get_attr_set '@spot_names', inherit end
-      def self.attr_spot_names(inherit = true) ; get_attr_set '@attr_spot_names', inherit end
-      def self.meth_spot_names(inherit = true) ; get_attr_set '@meth_spot_names', inherit end
+      def self.spot_attr_names(inherit = true) ; get_attr_set '@spot_attr_names', inherit end
+      def self.spot_meth_names(inherit = true) ; get_attr_set '@spot_meth_names', inherit end
       def self.name_spot(*names) ; name_attr_set '@spot_names', *names end
 
-      def self.meth_spot(name, opts = {})
+      def self.spot_meth(name, opts = {})
         name_spot name
-        name_attr_set '@meth_spot_names', name
+        name_attr_set '@spot_meth_names', name
         define_method :"#{name}" do ||
           mk_spot name, opts = {}
         end
       end
 
-      def self.attr_spot(*names)
+      def self.spot_attr(*names)
         name_spot *names
-        name_attr_set '@attr_spot_names', *names
+        name_attr_set '@spot_attr_names', *names
         attr_writer *names
         names.each do |name|
           define_method :"#{name}" do ||
@@ -46,7 +46,7 @@ module Andromeda
         @id      = Id.new
         set_from_config init_from_config, config
         @tags  ||= {}
-        @guide ||= init_guide
+        self.guide=(init_guide) unless @guide
       end
 
       def initialize_copy(other)
@@ -54,36 +54,41 @@ module Andromeda
         @tags  ||= {}
       end
 
-      def init_guide ; Guides::DefaultGuide.instance end
+      def init_guide ; Guides.default end
 
       def tags ; @tags end
       def to_short_s ; " id=#{id.to_short_s}t" end
       alias_method :inspect, :to_s
 
       def guide=(new_guide)
-        new_guide = new_guide.instance if new_guide.is_a?(Class) && new_guide.include?(Singleton)
-        @guide    = new_guide
+        @guide = if new_guide.is_a?(Class)
+          if new_guide.include?(Singleton) 
+            then new_guide.instance
+            else new_guide.new end
+        else
+          new_guide
+        end
       end
 
-      # Overload to map all incoming data, default to data
-      def data_map(name, data) ; data end
+      # Override to map all incoming data, default to data
+      def map_data(name, data) ; data end
 
-      # Overload to extract the data key from mapped, incoming data, defaults to name
+      # Override to extract the data key from mapped, incoming data, defaults to name
       def data_key(name, data) ; name end
 
-      # Overload to determine the target spot name from the key, defaults to name
+      # Override to determine the target spot name from the key, defaults to name
       def key_spot(name, key) ; name end
 
-      # Overload to determine the target track label from the key, defaults to ket
+      # Override to determine the target track label from the key, defaults to key
       def key_label(name, key) ; key end
 
-      # Overload to extract the data value from mapped, incoming data, defaults to data
+      # Override to extract the data value from mapped, incoming data, defaults to data
       def data_val(name, data) ; data end
 
-      # Overload to compute additional tags
+      # Override to compute additional tags
       def data_tag(name, key, val, tags_in) ; { name: name } end
 
-      # Overload to filter the data events that should be processed, defaults to true
+      # Override to filter the data events that should be processed, defaults to true
       def selects?(name, key, val, tags_in) ; true end
 
       def post_data(spot_, track_in, data, tags_in = {})
@@ -93,7 +98,7 @@ module Andromeda
         name     = spot_.name
         details  = { name: name, data: data, tags_in: tags_in, spot: spot_ }
         begin
-          data   = data_map name, data
+          data   = map_data name, data
           key    = data_key name, data
           name   = key_spot name, key
 
@@ -133,19 +138,23 @@ module Andromeda
       end
 
       def spot_name?(name) ; spot_names.include? name end
-      def attr_spot_name?(name) ; attr_spot_names.include? name end
-      def meth_spot_name?(name) ; meth_spot_names.include? name end
+      def spot_attr_name?(name) ; spot_attr_names.include? name end
+      def spot_meth_name?(name) ; spot_meth_names.include? name end
       def signal_name?(name) ; signal_names.include? name end
 
       def spot_names ; self.class.spot_names end
-      def attr_spot_names ; self.class.attr_spot_names end
-      def meth_spot_names ; self.class.meth_spot_names end
+      def spot_attr_names ; self.class.spot_attr_names end
+      def spot_meth_names ; self.class.spot_meth_names end
       def signal_names ; self.class.signal_names end
 
       def current_scope ;  tags[:scope] end
       def current_name ;  tags[:name] end
 
-      def >>(spot) ; @emit = spot.entry ; spot.dest end
+      def >>(spot)
+        @emit = spot.entry
+        d     = spot.dest 
+        if d then d else spot end
+      end
 
       def entry ; enter end
       def dest ; emit end
@@ -156,7 +165,7 @@ module Andromeda
 
       protected
 
-      attr_spot :emit
+      spot_attr :emit
 
       def exit ; emit end
 

data/lib/andromeda/impl_base.rb

@@ -0,0 +1,48 @@
+module Andromeda
+
+  module Impl
+
+    module To_S
+
+      def to_s(short = false)
+        if short
+          to_short_s
+        else
+          super_str  = super()
+          class_name = self.class.name.split('::')[-1]
+          obj_id     = object_id.to_s(16)
+          "\#<#{class_name}:0x#{obj_id}#{to_s(true)}>"
+        end
+      end
+
+      def to_short_s ; '' end
+
+      def self.short_s(v = value)
+        return ":#{v}" if v.is_a?(Symbol)
+        return "'#{v}'" if v.is_a?(String)
+        return 'nil' unless v
+        "#{v}"
+      end
+
+    end
+
+    # Shared base class of Spot and Impl::PrePlan
+    class ConnectorBase
+      # @return [Spot] entry.intern nil
+      def start ; entry.intern(nil) end
+
+      # post_to nil, data, tags_in
+      #
+      # @return [self]
+      def post(data, tags_in = {}) ; post_to nil, data, tags_in end
+
+      alias_method :<<, :post
+
+      # post_to LocalTrack.instance, data, tags_in
+      #
+      # @return [self]
+      def post_local(data, tags_in = {}) ; post_to Guides::LocalTrack.instance, data, tags_in end
+    end
+
+  end
+end

data/lib/andromeda/kit.rb

@@ -1,172 +1,172 @@
 module Andromeda
 
-	module Kit
-
-		module Transf
-			attr_accessor :filter
-			attr_accessor :mapper
-
-			def deliver_data(name, meth, key, val, tags_in)
-				if signal_name?(name)
-					super name, meth, key, val, tags_in
-				else
-					filter_ = filter
-					mapper_ = mapper
-					if !(filter_ && filter_.call(val))
-						super name, meth, key, (if mapper_ then mapper_.call(val) else val end), tags_in
-					end
-				end
-			end
-		end
-
-		class Tee < Plan
-			attr_accessor :level
-			attr_accessor :other
-			attr_accessor :delay
-
-			def initialize(config = {})
-				config = { nick: config } unless config.is_a? Hash || config.is_a?(Spot)
-				config = { other: config } unless config.is_a? Hash
-				super config
-
-				@level ||= :info
-			end
-
-			def initialize_copy(other)
-				@level = other.level.identical_copy
-				@delay = other.delay.identical_copy
-			end
-
-			def on_enter(key, val)
-				log_   = log
-				level_ = level
-				sleep delay.to_i if delay
-				if log_ && level_
-					cur_name = current_name
-					key_str  = Andromeda::Impl::To_S.short_s key
-					val_str  = Andromeda::Impl::To_S.short_s val
-					log_str  = "#{to_s}.#{cur_name}(#{key_str}, #{val_str})"
-					tags.each_pair { |k, v|	log_str << " #{k}=#{Andromeda::Impl::To_S.short_s(v)}" }
-					log_str << " tid=0x#{Thread.current.object_id.to_s(16)}"
-					log_.send level, log_str
-				end
-				other_ = other
-				other_ << val if other_
-				super key, val
-			end
-		end
-
-		class Targeting < Plan
-			attr_accessor :targets
-
-			def initialize(config = {})
-				super config
-				@targets ||= {}
-			end
-
-			def target_values ; t = targets ; t.values rescue t end
-		end
-
-		class Broadc < Targeting
-			def on_enter(key, val)
-				target_values { |t| intern(t) << val rescue nil }
-			end
-		end
-
-		class Switch < Targeting
-			def on_enter(key, val)
-				(intern(key) rescue exit) << val rescue nil
-			end
-		end
-
-		class SinglePlan < Plan
-	    def init_guide ; Guides::SinglePoolGuide.new end
-		end
-
-		class InlineKeyRouter < SinglePlan
-			def key_spot(name, key) ; key end
-		end
-
-		class Gatherer < SinglePlan
-			include Transf
-		end
-
-		class Reducer < Gatherer
-			attr_accessor :state
-			attr_accessor :reducer
-
-			attr_spot :new_state
-
-			def on_enter(key, val)
-				reducer_ = reducer
-
-				state_   = state
-				new_     = reducer_.call state_, key, val
-				unless new_ == state_
-					state = new_
-					new_state << state if new_state
-				end
-			end
-		end
-
-		class FileReader < Plan
-			attr_reader :path
-			attr_reader :mode
-
-			def initialize(config = {})
-				super config
-				@mode ||= init_mode
-			end
-
-			def data_tag(name, key, val, tags_in)
-				tags_out         = super
-				tags_out[:first] = val.first rescue 0
-				tags_out[:last]  = val.last rescue -1
-				tags_out
-			end
-
-			def init_mode ; 'r' end
-
-			protected
-
-			def on_enter(key, val)
-				file = File.open path, mode
-				begin
-						file.seek tags[:first]
-						tags[:last] = file.size - 1 if tags[:last] < 0
-						tags[:num]  = tags[:last] - tags[:first]
-						if block_given? then yield file else super key, val end
-				ensure
-					file.close
-				end
-			end
-
-		end
-
-		class FileChunker < FileReader
-			attr_reader :num_chunks
-
-			def initialize(config = {})
-				super config
-				@num_chunks ||= Guides::PoolGuide.num_procs
-			end
-
-			def on_enter(key, val)
-				num_c = num_chunks
-				super key, val do |f|
-					fst = tags[:first]
-					lst = tags[:last]
-					sz  = tags[:num] / num_c rescue 1
-					sz  = 1 if sz < 0
-					while fst <= lst
-						nxt = fst + sz
-						nxt = lst if nxt > lst
-						exit << Range.new(fst, nxt)
-						fst = nxt + 1
-					end
-				end
-			end
-		end
-
-	end
+  module Kit
+
+    module Transf
+      attr_accessor :filter
+      attr_accessor :mapper
+
+      def deliver_data(name, meth, key, val, tags_in)
+        if signal_name?(name)
+          super name, meth, key, val, tags_in
+        else
+          filter_ = filter
+          mapper_ = mapper
+          if !(filter_ && filter_.call(val))
+            super name, meth, key, (if mapper_ then mapper_.call(val) else val end), tags_in
+          end
+        end
+      end
+    end
+
+    class Tee < Plan
+      attr_accessor :level
+      spot_attr :other
+      attr_accessor :delay
+
+      def initialize(config = {})
+        config = { nick: config } unless config.is_a? Hash || config.is_a?(Spot)
+        config = { other: config } unless config.is_a? Hash
+        super config
+
+        @level ||= :info
+      end
+
+      def initialize_copy(other)
+        @level = other.level.identical_copy
+        @delay = other.delay.identical_copy
+      end
+
+      def on_enter(key, val)
+        log_   = log
+        level_ = level
+        sleep delay.to_i if delay
+        if log_ && level_
+          cur_name = current_name
+          key_str  = Andromeda::Impl::To_S.short_s key
+          val_str  = Andromeda::Impl::To_S.short_s val
+          log_str  = "#{to_s}.#{cur_name}(#{key_str}, #{val_str})"
+          tags.each_pair { |k, v| log_str << " #{k}=#{Andromeda::Impl::To_S.short_s(v)}" }
+          log_str << " tid=0x#{Thread.current.object_id.to_s(16)}"
+          log_.send level, log_str
+        end
+        other_ = other
+        other_ << val if other_
+        super key, val
+      end
+    end
+
+    class Targeting < Plan
+      attr_accessor :targets
+
+      def initialize(config = {})
+        super config
+        @targets ||= {}
+      end
+
+      def target_values ; t = targets ; t.values rescue t end
+    end
+
+    class Broadc < Targeting
+      def on_enter(key, val)
+        target_values { |t| intern(t) << val rescue nil }
+      end
+    end
+
+    class Switch < Targeting
+      def on_enter(key, val)
+        (intern(key) rescue exit) << val rescue nil
+      end
+    end
+
+    class SinglePlan < Plan
+      def init_guide ; Guides::SinglePoolGuide.new end
+    end
+
+    class InlineKeyRouter < SinglePlan
+      def key_spot(name, key) ; key end
+    end
+
+    class Gatherer < SinglePlan
+      include Transf
+    end
+
+    class Reducer < Gatherer
+      attr_accessor :state
+      attr_accessor :reducer
+
+      spot_attr :new_state
+
+      def on_enter(key, val)
+        reducer_ = reducer
+
+        state_   = state
+        new_     = reducer_.call state_, key, val
+        unless new_ == state_
+          state = new_
+          new_state << state if new_state
+        end
+      end
+    end
+
+    class FileReader < Plan
+      attr_reader :path
+      attr_reader :mode
+
+      def initialize(config = {})
+        super config
+        @mode ||= init_mode
+      end
+
+      def data_tag(name, key, val, tags_in)
+        tags_out         = super
+        tags_out[:first] = val.first rescue 0
+        tags_out[:last]  = val.last rescue -1
+        tags_out
+      end
+
+      def init_mode ; 'r' end
+
+      protected
+
+      def on_enter(key, val)
+        file = File.open path, mode
+        begin
+            file.seek tags[:first]
+            tags[:last] = file.size - 1 if tags[:last] < 0
+            tags[:num]  = tags[:last] - tags[:first]
+            if block_given? then yield file else super key, val end
+        ensure
+          file.close
+        end
+      end
+
+    end
+
+    class FileChunker < FileReader
+      attr_reader :num_chunks
+
+      def initialize(config = {})
+        super config
+        @num_chunks ||= Guides::PoolGuide.num_procs
+      end
+
+      def on_enter(key, val)
+        num_c = num_chunks
+        super key, val do |f|
+          fst = tags[:first]
+          lst = tags[:last]
+          sz  = tags[:num] / num_c rescue 1
+          sz  = 1 if sz < 0
+          while fst <= lst
+            nxt = fst + sz
+            nxt = lst if nxt > lst
+            exit << Range.new(fst, nxt)
+            fst = nxt + 1
+          end
+        end
+      end
+    end
+
+  end
 end