cw 0.0.1

data/lib/cw/repeat_word.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+class RepeatWord < FileDetails
+
+  include Tester
+
+  def initialize
+    super
+    @repeat_word = true
+  end
+
+  #overloaded #todo
+
+  def print_failed_exit_words
+    until stream.stream_empty?
+      word = stream.pop[:value]
+      print.prn_red word + ' ' unless @repeat_word
+    end
+  end
+
+  def print_words words
+    timing.init_char_timer
+    (words.to_s + space).each_char do |letr|
+      process_letter letr
+      loop do
+        process_space_maybe letr
+        process_word_maybe
+        break if timing.char_delay_timeout?
+      end
+      print.prn letr if print_letters?
+      break if quit?
+    end
+  end
+
+  def process_input_word_maybe
+    if @word_to_process
+      stream.match_last_active_element @process_input_word.strip
+      @process_input_word = @word_to_process = nil
+    end
+  end
+
+  def build_word_maybe
+    @input_word ||= empty_string
+    @input_word << key_chr if is_relevant_char?
+    move_word_to_process if complete_word?
+  end
+
+  def process_letter letr
+    current_word.process_letter letr
+    sleep_char_delay letr
+  end
+
+  def print_marked_maybe
+    @popped = stream.pop_next_marked
+    print.results(@popped, :pass_only) if(@popped && ! print_letters?)
+  end
+
+  #overloaded #todo
+
+  def play_words_thread
+    play_words_until_quit
+    print "\n\rplay has quit " if @debug
+  end
+
+  def double_words words
+    temp = []
+    words.each do |wrd|
+      2.times { temp.push wrd }
+    end
+    words = temp
+  end
+
+  def run words
+    temp_words = words.all
+    temp_words = double_words temp_words if Params.double_words
+    temp_words.each do |word|
+      loop do
+        @input_word, @words = '', Words.new
+        @quit, @failed = nil, nil
+        @words.add [word]
+        @threads = CWThreads.new(self, thread_processes)
+        @threads.run
+        break unless @failed
+        break if global_quit?
+      end
+      break if global_quit?
+    end
+    reset_stdin
+    print.newline
+  end
+end

data/lib/cw/rss.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+
+#class Rss
+
+class Rss
+
+  def sources
+    {
+      bbc:        'http://feeds.bbci.co.uk/news/rss.xml',
+      reuters:    'http://feeds.reuters.com/Reuters/worldNews?format=xml',
+      guardian:   'http://www.theguardian.com/world/rss',
+      quotations: 'http://feeds.feedburner.com/quotationspage/qotd'
+    }
+  end
+
+  def source src
+    sources.has_key?(src) ? sources[src] : sources[:quotations]
+  end
+
+  def read_rss(src, show_count = 3)
+    require 'feedjira'
+    require "htmlentities"
+    require 'sanitize'
+    coder = HTMLEntities.new
+    url   = source(src)
+    feed  = Feedjira::Feed.fetch_and_parse url # returns a Hash, with each url having a Feedjira::Feed object
+    entry_count = 0
+    @rss_articles = []
+    entry = feed.entries.each do |entry|
+      title = entry.title
+      unless(title.include?('VIDEO:') ||
+             title.include?('In pictures:') ||
+             title.include?('Morning business round-up'))
+        words = entry.summary
+        entry_count += 1
+      end
+      @rss_articles << (Sanitize.clean coder.decode words).split(',')
+      break if entry_count >= show_count
+    end
+    @rss_flag = true
+  end
+
+  def inc_article_index
+    @article_index += 1
+  end
+
+  def article_index
+    @article_index || @article_index = 0
+  end
+
+  def cw_chars chr
+    chr.tr('^a-z0-9\.\,+', '')
+  end
+
+  def exclude_non_cw_chars word
+    temp = ''
+    word.split.each do |chr|
+      temp += chr if letter(chr)
+    end
+    temp
+  end
+
+  def next_article
+    temp = @rss_articles[article_index]
+    return unless temp
+    inc_article_index
+    quote = ''
+    temp.map { |i| quote += i }
+    (quote.split.collect { |article| cw_chars(article.strip.gsub("\"", '').downcase)})
+  end
+end

data/lib/cw/sentence.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+class Sentence
+
+  attr_accessor :index #todo
+
+  def text              ; @text ||= String.new   ; end
+  def all               ; @sentences             ; end
+  def next              ; @next = true           ; end
+  def next?             ; @next                  ; end
+  def forward           ; @index += 1            ; end
+  def previous?         ; @previous              ; end
+  def repeat?           ; @repeat                ; end
+  def change?           ; next? || previous?     ; end
+  def change_or_repeat? ; change? || repeat?     ; end
+  def current           ; @sentences[@index]     ; end
+  def next_sentence     ; @sentences[@index + 1] ; end
+
+  def change
+    forward if next?
+    rewind if previous?
+  end
+
+  def rewind
+    @index = @index <= 1 ? 0 : @index - 1
+  end
+
+  def read_progress progress_file
+    File.open(progress_file, 'r') {|f| @index = f.readline.to_i}
+  end
+
+  def write_progress progress_file
+    File.open(progress_file, 'w') {|f| f.puts @index.to_s}
+  end
+
+  def read_book book
+    File.open(book, 'r') { |f| text.replace f.readlines(' ').join}
+  end
+
+  def cw_chars chr
+    chr.tr('^a-z0-9\,\=\!\/\?\.', '')
+  end
+
+  def exclude_non_cw_chars word
+    cw_chars(word)
+  end
+
+  def find_all
+    @sentences = []
+    @text.gsub!(/\s+/, ' ').downcase!
+    loop do
+      sentence_end = @text.index('. ')
+      unless sentence_end
+        break
+      end
+      line = @text[0..sentence_end]
+      line = line.split.collect{|word| exclude_non_cw_chars word}.join(' ')
+      @sentences << line
+      @text.replace @text[sentence_end + 2..-1]
+    end
+  end
+
+  def check_sentence_navigation chr
+    @next     = true if(chr == ']')
+    @previous = true if(chr == '[')
+    @repeat   = true if(chr == '-')
+  end
+
+  def reset_flags
+    @next = @previous = @repeat = nil
+  end
+
+  def to_array
+    array = @sentences[@index].split(' ')
+    array.collect {|x| x + ' '}
+  end
+
+end

data/lib/cw/speak.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+#class Numbers provides the Number Testing functionality
+
+class Spoken
+
+  def initialize(options = {})
+    @options = options
+  end
+
+end

data/lib/cw/spoken.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+#class Numbers provides the Number Testing functionality
+
+class Spoken
+
+  def initialize(options = {})
+    @options = options
+  end
+
+end

data/lib/cw/str.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+#class Str
+
+class Str
+
+  def initialize
+    @seperator = ', '
+  end
+
+  def to_s
+    delim  = delim_std_str
+    ["\n#{Params.name}\r",
+     "\n#{delim}",
+     "#{wpm_str}\n",
+     shuffle_str,
+     word_count_str,
+     word_size_str,
+     beginning_str,
+     ending_str,
+     delim].
+      collect{ |prm| prm.to_s }.join
+  end
+
+  def stringify ary
+    ary.join(@seperator)
+  end
+
+  def delim_str size
+    "#{'=' * size}\n\r"
+  end
+
+  def delim_std_str
+    tempsize = Params.name.size
+    delim_str tempsize
+  end
+
+  def shuffle_str
+    shuffle =  Params.shuffle
+    shuffle ? "Shuffle:    #{shuffle ? 'yes' : 'no'}\n\r" : nil
+  end
+
+  def word_count_str
+    wc = Params.word_count
+    wc ? "Word count: #{wc}\n\r" : nil
+  end
+
+  def word_size_str
+    size = Params.size
+    size ? "Word size:  #{size}\n\r" : nil
+  end
+
+  def beginning_str
+    beginning = Params.begin
+    beginning ? "Beginning:  #{stringify beginning}\n\r" : nil
+  end
+
+  def ending_str
+    ending = Params.end
+    ending ? "Ending:     #{stringify ending}\n\r" : nil
+  end
+
+  def wpm_str
+    "WPM:        #{Params.wpm}\n\r"
+  end
+
+end

data/lib/cw/stream.rb

@@ -0,0 +1,161 @@
+# encoding: utf-8
+
+class Stream
+
+  attr_accessor :active_region
+
+  def initialize
+    @active_region = 6
+    empty
+  end
+
+  def empty
+    @stream, @success, @first_element, @last_element = {},{}, 0, 0
+  end
+
+  def count
+    @last_element - @first_element
+  end
+
+  def add_word word
+    @stream[@last_element] = word.strip
+    @success[@last_element] = nil
+    inc_last_element
+  end
+
+  def add_char char
+    @stream[@last_element] = char
+    @success[@last_element] = nil
+    inc_last_element
+  end
+
+  def inc_last_element
+    @last_element += 1
+  end
+
+  def inc_first_element
+    @first_element += 1
+  end
+
+  def mark(element, type)
+    @success[element] = type
+  end
+
+  def mark_success element
+    mark element, true
+  end
+
+  def mark_fail element
+    mark element, false
+  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
+      end
+    end
+  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
+    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
+    return_val = {}
+    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
+    #    return_val == {} ? nil : return_val
+  end
+
+  def element type
+    return @last_element - 1 if type == :last
+    first = @last_element - @active_region - 1
+    first < 0 ? 0 : first
+  end
+
+  def match_first_active_element match
+    if ! stream_empty?
+      found = false
+      first = element(:first)
+      first.upto element(:last) do |ele|
+        if found
+          first.upto found - 1 do |failed|
+            @success[failed] = false # unless @success[ele]
+          end
+          break
+        elsif((@stream[ele] == match) && (! @success[ele]))
+          @success[ele], found = true, ele
+        else
+          @success[first] = false
+        end
+      end
+    end
+  end
+
+  def match_last_active_element match
+    if ! stream_empty?
+      first = @last_element - @active_region - 1
+      first = 0 if(first < 0)
+      last = @last_element - 1
+      found = false
+      last.downto(first) do |ele|
+        if found
+          @success[ele] = false unless @success[ele]
+        elsif((@stream[ele] == match) && (! @success[ele]))
+          @success[ele], found = true, true
+        else
+          @success[first] = false
+        end
+      end
+    end
+  end
+end
+