cw 0.2.4 → 0.3.0

data/lib/cw/cw_encoding.rb

@@ -1,80 +1,74 @@
-  # encoding: utf-8
+# encoding: utf-8
+
+module CWG
 
   class CwEncoding
 
+    ENCODINGS = {
+      'a' => [:dot, :dash],
+      'b' => [:dash, :dot, :dot, :dot],
+      'c' => [:dash, :dot, :dash, :dot],
+      'd' => [:dash, :dot, :dot],
+      'e' => [:dot],
+      'f' => [:dot, :dot, :dash, :dot],
+      'g' => [:dash, :dash, :dot],
+      'h' => [:dot, :dot, :dot, :dot],
+      'i' => [:dot, :dot],
+      'j' => [:dot, :dash, :dash, :dash],
+      'k' => [:dash, :dot, :dash],
+      'l' => [:dot, :dash, :dot, :dot],
+      'm' => [:dash, :dash],
+      'n' => [:dash, :dot],
+      'o' => [:dash, :dash, :dash],
+      'p' => [:dot, :dash, :dash, :dot],
+      'q' => [:dash, :dash, :dot, :dash],
+      'r' => [:dot, :dash, :dot],
+      's' => [:dot, :dot, :dot],
+      't' => [:dash],
+      'u' => [:dot, :dot, :dash],
+      'v' => [:dot, :dot, :dot, :dash],
+      'w' => [:dot, :dash, :dash],
+      'x' => [:dash, :dot, :dot, :dash],
+      'y' => [:dash, :dot, :dash, :dash],
+      'z' => [:dash, :dash, :dot, :dot],
+      '1' => [:dot, :dash, :dash, :dash, :dash],
+      '2' => [:dot, :dot, :dash, :dash, :dash],
+      '3' => [:dot, :dot, :dot, :dash, :dash],
+      '4' => [:dot, :dot, :dot, :dot, :dash],
+      '5' => [:dot, :dot, :dot, :dot, :dot],
+      '6' => [:dash, :dot, :dot, :dot, :dot],
+      '7' => [:dash, :dash, :dot, :dot, :dot],
+      '8' => [:dash, :dash, :dash, :dot, :dot],
+      '9' => [:dash, :dash, :dash, :dash, :dot],
+      '0' => [:dash, :dash, :dash, :dash, :dash],
+      '.' => [:dot, :dash, :dot, :dash, :dot, :dash],
+      ',' => [:dash, :dash, :dot, :dot, :dash, :dash],
+      '=' => [:dash, :dot, :dot,:dot, :dash],
+      '!' => [:dot, :dot, :dash, :dash, :dot],
+      '/' => [:dash, :dot, :dot, :dash, :dot],
+      '?' => [:dot, :dot, :dash, :dash, :dot, :dot],
+      ' ' => []
+    }
+
     def fetch char
-      encode(char)
+      ENCODINGS[char]
     end
 
     def encodings
-      @encodings ||= construct_encodings
-    end
-
-    def construct_encodings
-      @encodings = encode_a_n().merge(encode_0_2);
-      @encodings.merge!(encode_3_space)
-    end
-
-    def encode char
-      encodings[char]
+      ENCODINGS
     end
 
-    def encode_a_n
-      {
-        'a' => [:dot, :dash],
-        'b' => [:dash, :dot, :dot, :dot],
-        'c' => [:dash, :dot, :dash, :dot],
-        'd' => [:dash, :dot, :dot],
-        'e' => [:dot],
-        'f' => [:dot, :dot, :dash, :dot],
-        'g' => [:dash, :dash, :dot],
-        'h' => [:dot, :dot, :dot, :dot],
-        'i' => [:dot, :dot],
-        'j' => [:dot, :dash, :dash, :dash],
-        'k' => [:dash, :dot, :dash],
-        'l' => [:dot, :dash, :dot, :dot],
-        'm' => [:dash, :dash],
-        'n' => [:dash, :dot]
-      }
+    def match_elements arg
+      chars = []
+      ENCODINGS.each_pair do |key, value|
+        chars << key unless value.include?(:dot) if arg[0]  == :dashes
+        chars << key unless value.include?(:dash) if arg[0] == :dots
+        chars << key if (value.size < arg[1] )if arg[0]     == :less_than
+        chars << key if (value.size > arg[1] )if arg[0]     == :greater_than
+        chars << key if (value.size == arg[1] )if arg[0]    == :size
+        chars.delete(' ')
+      end
+      chars
     end
-
-    def encode_0_2
-      {
-        'o' => [:dash, :dash, :dash],
-        'p' => [:dot, :dash, :dash, :dot],
-        'q' => [:dash, :dash, :dot, :dash],
-        'r' => [:dot, :dash, :dot],
-        's' => [:dot, :dot, :dot],
-        't' => [:dash],
-        'u' => [:dot, :dot, :dash],
-        'v' => [:dot, :dot, :dot, :dash],
-        'w' => [:dot, :dash, :dash],
-        'x' => [:dash, :dot, :dot, :dash],
-        'y' => [:dash, :dot, :dash, :dash],
-        'z' => [:dash, :dash, :dot, :dot],
-        '1' => [:dot, :dash, :dash, :dash, :dash],
-        '2' => [:dot, :dot, :dash, :dash, :dash]
-      }
-    end
-
-    def encode_3_space
-      {
-        '3' => [:dot, :dot, :dot, :dash, :dash],
-        '4' => [:dot, :dot, :dot, :dot, :dash],
-        '5' => [:dot, :dot, :dot, :dot, :dot],
-        '6' => [:dash, :dot, :dot, :dot, :dot],
-        '7' => [:dash, :dash, :dot, :dot, :dot],
-        '8' => [:dash, :dash, :dash, :dot, :dot],
-        '9' => [:dash, :dash, :dash, :dash, :dot],
-        '0' => [:dash, :dash, :dash, :dash, :dash],
-        '.' => [:dot, :dash, :dot, :dash, :dot, :dash],
-        ',' => [:dash, :dash, :dot, :dot, :dash, :dash],
-        '=' => [:dash, :dot, :dot,:dot, :dash],
-        '!' => [:dot, :dot, :dash, :dash, :dot],
-        '/' => [:dash, :dot, :dot, :dash, :dot],
-        '?' => [:dot, :dot, :dash, :dash, :dot, :dot],
-        ' ' => []
-      }
-    end
-
   end
+end

data/lib/cw/cw_stream.rb

@@ -1,107 +1,111 @@
 # encoding: utf-8
 
-class CwStream
+module CWG
 
-  include Element
+  class CwStream
 
-  attr_accessor :active_region
-  attr_accessor   :stream
+    include Element
 
-  def initialize
-    @active_region = 6
-    empty
-  end
+    attr_accessor :active_region
+    attr_accessor   :stream
 
-  def empty
-    @stream, @success, @first_element, @last_element = {},{}, 0, 0
-  end
+    def initialize
+      @active_region = 6
+      empty
+    end
 
-  def add_word word
-    @stream[@last_element] = word.strip
-    @success[@last_element] = nil
-    inc_last_element
-  end
+    def empty
+      @stream, @success, @first_element, @last_element = {},{}, 0, 0
+    end
 
-  def add_char char
-    @stream[@last_element] = char
-    @success[@last_element] = nil
-    inc_last_element
-  end
+    def push word
+      @stream[@last_element] = word.strip
+      @success[@last_element] = nil
+      inc_last_element
+    end
 
-  def mark(element, type)
-    @success[element] = type
-  end
+    def add_char char
+      @stream[@last_element] = char
+      @success[@last_element] = nil
+      inc_last_element
+    end
 
-  def mark_success element
-    mark element, true
-  end
+    def mark(element, type)
+      @success[element] = type
+    end
 
-  def mark_fail element
-    mark element, false
-  end
+    def mark_success element
+      mark element, true
+    end
 
-  def stream_empty?
-    @first_element == @last_element
-  end
+    def mark_fail element
+      mark element, false
+    end
 
-  def inactive_region
-    stream_empty? ? nil : @last_element - @active_region - 1
-  end
+    def stream_empty?
+      @first_element == @last_element
+    end
+
+    def inactive_region
+      stream_empty? ? nil : @last_element - @active_region - 1
+    end
 
-  def fail_unmarked_inactive_elements
-    if(( ! stream_empty?) && (count > @active_region))
-      @first_element.upto(inactive_region) do |count|
-        @success[count] = false unless @success[count] == true
+    def fail_unmarked_inactive_elements
+      if(( ! stream_empty?) && (count > @active_region))
+        @first_element.upto(inactive_region) do |count|
+          @success[count] = false unless @success[count] == true
+        end
       end
     end
-  end
 
-  def first
-    @stream[@first_element]
-  end
+    def first
+      @stream[@first_element]
+    end
 
-  def pop
-    unless stream_empty?
-      ele = @first_element
-      inc_first_element
-      success = @success.delete(ele)
-      success = success == nil ? false : success
-      { :value => @stream.delete(ele),
-        :success => success
-      }
-    else
-      nil
+    def pop
+      unless stream_empty?
+        ele = @first_element
+        inc_first_element
+        success = @success.delete(ele)
+        success = success == nil ? false : success
+        { :value => @stream.delete(ele),
+          :success => success
+        }
+      else
+        nil
+      end
     end
-  end
 
-#  def pop_marked
-#    return_val = {}
-#    fail_unmarked_inactive_elements
-#    @first_element.upto(@last_element) do |ele|
-#      unless stream_empty?
-#        if(ele < inactive_region)
-#          val = pop
-#
-#          return_val[ele] = {pop => @success[ele]}
-#        elsif(@success[ele] == true || @success[ele] == false)
-#          return_val[ele] = {pop => @success[ele]}
-#        else
-#          break
-#        end
-#      end
-#    end
-#    return_val == {} ? nil : return_val
-#  end
-
-  def pop_next_marked
-    fail_unmarked_inactive_elements
-    unless stream_empty?
-      if(@first_element < inactive_region)
-        pop
-      elsif(@success[@first_element] == true || @success[@first_element] == false)
-        pop
+    #  def pop_marked
+    #    return_val = {}
+    #    fail_unmarked_inactive_elements
+    #    @first_element.upto(@last_element) do |ele|
+    #      unless stream_empty?
+    #        if(ele < inactive_region)
+    #          val = pop
+    #
+    #          return_val[ele] = {pop => @success[ele]}
+    #        elsif(@success[ele] == true || @success[ele] == false)
+    #          return_val[ele] = {pop => @success[ele]}
+    #        else
+    #          break
+    #        end
+    #      end
+    #    end
+    #    return_val == {} ? nil : return_val
+    #  end
+
+    def pop_next_marked
+      fail_unmarked_inactive_elements
+      unless stream_empty?
+        if(@first_element < inactive_region)
+          pop
+        elsif(@success[@first_element] == true || @success[@first_element] == false)
+          pop
+        end
       end
     end
+
   end
 
 end

data/lib/cw/cw_threads.rb

@@ -1,36 +1,146 @@
 # encoding: utf-8
 
-class CWThreads
+module CWG
 
-  attr_accessor :threads
+  class CWThreads
 
-  def initialize context, processes
-    @context = context
-    @processes = processes
-  end
+    attr_reader :threads
+
+    def initialize context, processes
+      @context = context
+      @processes = processes
+    end
 
-  def kill
-    sleep 0.2
-    if @threads.is_a?(Array)
-      @threads.each do |th|
-        th.exit if th.is_a? Thread
+    def start_threads
+      @threads = @processes.collect do |th|
+        {:thread =>
+         Thread.new do
+           @context.send th
+         end,
+         :name => th
+        }
       end
     end
-  end
 
-  def start_threads
-    @threads = @processes.collect do |th|
-      Thread.new{@context.send th}
+    def monitor_threads
+      exiting = false
+      loop do
+        sleep 0.5
+        @threads.each do |th|
+          if thread_false_or_nil?(th)
+            exiting = true
+            unless Cfg.config["exit"]
+#              puts "** #{th[:name].to_s.gsub('_',' ')} quit unexpectedly!**"
+              if th[:thread].backtrace
+                STDERR.puts th[:thread].backtrace.join("\n    \\_ ")
+              end
+            end
+          end
+        end
+        # print_threads_status
+        exiting = true if(Cfg.config["exit"])
+        break if exiting
+      end
+      close_threads if exiting
     end
-  end
 
-  def wait_for_threads
-    @threads.each { |th| th.join }
-  end
+    def kill_thread thread
+      thread[:thread].kill
+    end
+
+    def kill_open_threads
+      @threads.each do |thread|
+        unless thread_false_or_nil?(thread)
+          kill_thread thread
+        end
+      end
+    end
+
+    def thread_false_or_nil? th
+      if(th[:thread].status == false)
+        return true
+      end
+
+      if(th[:thread].status.nil?)
+        return true
+      end
+    end
+
+    def wait_for_threads
+      Cfg.config.params["exit"] = false
+      loop do
+        alive = false
+        sleep 0.1
+        @threads.each { |th|
+          if  thread_false_or_nil? th
+          elsif th[:name] != :monitor_keys_thread
+            alive = true
+          end
+        }
+        break unless alive
+      end
+      threads.each {|th|
+        if(th[:name] == :monitor_keys_thread)
+          kill_thread th
+        end
+        sleep 0.1
+      }
+    end
+
+    def print_threads_status
+      @threads.each do |thread|
+        puts "\r"
+        print "#{thread[:name]} = "
+        p thread[:thread].status
+      end
+    end
+
+    def kill_monitor_keys_thread_maybe thread
+      kill_thread(thread) unless thread_false_or_nil?(thread)
+    end
+
+    def any_thread_open?
+      @threads.each do |thread|
+#        print "status "
+#            p thread
+        if(thread[:name] == :monitor_keys_thread)
+          kill_monitor_keys_thread_maybe thread
+        else
+          unless thread_false_or_nil?(thread)
+            return true
+          end
+        end
+      end
+      nil
+    end
+
+    def force_kill
+      puts "exiting"
+#      puts "Forcing kill!\r"
+      kill_open_threads
+      # print_threads_status
+      system("stty -raw echo")
+      sleep 0.2
+      exit(1)
+    end
+
+    def close_threads
+      await_termination_count = 0
+      loop do
+        sleep 0.1
+        break unless any_thread_open?()
+#         print_threads_status
+        await_termination_count += 1
+        force_kill if(await_termination_count >= 30)
+      end
+    end
+
+    def run
+      start_threads
+      monitor_threads
+      system("stty -raw echo")
+    end
 
-  def run
-    start_threads
-    wait_for_threads
   end
 
 end