cw 0.2.4 → 0.3.0

data/lib/cw/tone_helpers.rb

@@ -1,33 +1,25 @@
 # Module ToneHelpers provides helper methods for ToneGenerator
 
-module ToneHelpers
+module CWG
 
-  TWO_PI           = 2 * Math::PI
-  HERE             = File.dirname(__FILE__) + '/../../'
-  DOT_FILENAME     = HERE + "audio/dot.wav"
-  DASH_FILENAME    = HERE + "audio/dash.wav"
-  SPACE_FILENAME   = HERE + "audio/space.wav"
-  E_SPACE_FILENAME = HERE + "audio/e_space.wav"
+  module ToneHelpers
 
-# :reek: exclude from UtilityFunction
-  def play_filename
-    HERE + "audio/#{Params.audio_filename}"
-  end
+    TWO_PI           = 2 * Math::PI
 
-  def convert_words wrds
-    wrds.to_array.collect{ |wrd| wrd.delete("\n")}
-  end
+    def convert_words wrds
+      wrds.to_array.collect{ |wrd| wrd.delete("\n")}
+    end
 
-  def generate_space number_of_samples
-    [].fill(0.0, 0, number_of_samples)
-  end
+    def generate_space number_of_samples
+      [].fill(0.0, 0, number_of_samples)
+    end
 
-  def space_sample? ele
-    ele == :space || ele == :e_space
-  end
+    def space_sample? ele
+      ele == :space || ele == :e_space
+    end
 
-  def last_element? idx, chr
-    idx == chr.size - 1
+    def last_element? idx, chr
+      idx == chr.size - 1
+    end
   end
-
 end

data/lib/cw/voice.rb

@@ -1,16 +1,20 @@
 # encoding: utf-8
 
-#class Speak speaks with a voice
+module CWG
 
-class Voice
+  #class Speak speaks with a voice
 
-  def initialize(options = {})
-    @options = options
-  end
+  class Voice
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def say words, rate = 300, voice = 'bruce'
+      system("say #{words} -ospoken.wave -r#{rate} -v#{voice}")
+      system("afplay spoken.wave")
+    end
 
-  def say words, rate = 300, voice = 'bruce'
-    system("say #{words} -ospoken.wave -r#{rate} -v#{voice}")
-    system("afplay spoken.wave")
   end
 
 end

data/lib/cw/words.rb

@@ -1,149 +1,179 @@
 # encoding: utf-8
 
-#class Words deals with words
+module CWG
 
-class Words
+  #class Words deals with words
 
-  include TextHelpers
+  class Words
 
-  def load(filename)
-    File.open(filename, 'r') do |file|
-      @words = file.read.split
+    include TextHelpers
+
+    def load args
+      @words = CommonWords.new.read(args)
     end
-  end
 
-  def double_words
-    temp = []
-    @words.each do |wrd|
-      2.times { temp.push wrd }
+    def load_text(filename)
+      File.open(filename, 'r') do |file|
+        @words = file.read.split
+      end
     end
-    @words = temp
-  end
 
-  def shuffle
-    @words.shuffle!
-  end
+    def double_words
+      @words.collect! {|wrd| [wrd] * 2}
+      @words.flatten!
+    end
 
-  def to_array
-    @words
-  end
+    def repeat multiplier
+      @words *= multiplier + 1
+    end
 
-  def all
-    @words
-  end
+    def shuffle
+      @words.shuffle!
+    end
 
-  def to_s
-    @words.join(' ')
-  end
+    def to_array
+      @words
+    end
 
-  def add words
-    @words = words
-  end
+    def all
+      @words
+    end
 
-  def exist?
-    @words
-  end
+    def to_s
+      @words.join(' ')
+    end
 
-  def word_size(size)
-    @words = @words.select{|wrd| wrd.size == size}
-  end
+    def add words
+      @words = words
+    end
 
-  def beginning_with_letter(letr)
-    @words.select{|wrd| wrd.start_with?(letr)}
-  end
+    def exist?
+      @words
+    end
 
-  def beginning_with(* letters)
-    @words = letters.flatten.collect{|letr| beginning_with_letter(letr)}.flatten
-  end
+    def word_size(size)
+      @words = @words.select{|wrd| wrd.size == size}
+    end
 
-  def ending_with_letter(letr)
-    @words.select{|wrd| wrd.end_with?(letr)}
-  end
+    def beginning_with_letter(letr)
+      @words.select{|wrd| wrd.start_with?(letr)}
+    end
 
-  def ending_with(* letters)
-    @words = letters.flatten.collect{|letr| ending_with_letter(letr)}.flatten
-  end
+    def ending_with_letter(letr)
+      @words.select{|wrd| wrd.end_with?(letr)}
+    end
 
-  def count word_count
-    @words = @words.take(word_count)
-  end
+    def beginning_with
+      letter_filter(:beginning_with, Cfg.config["begin"])
+    end
 
-  def including_letter(letr)
-    @words.select{|wrd| wrd.include?(letr)}
-  end
+    def ending_with
+      letter_filter(:ending_with, Cfg.config["end"])
+    end
 
-  def containing(* letters)
-    lets = letters.flatten.join('').split("")
-    found, temp, @words = false, @words, []
-    temp.each do |wrd|
-      wrd_lets = wrd.split("")
-      wrd_lets.each do |wrd_let|
-        if lets.include?(wrd_let)
-          found = true
+    def including
+      letter_filter(:including, Cfg.config["including"])
+    end
+
+    def letter_filter(option,letters)
+      method_name = option.to_s + "_letter"
+      @words = letters.flatten.collect do |letr|
+        if letr.class == Range
+          letr.collect do |let|
+            self.send(method_name, let)
+          end
         else
-          found = false
-          break
+          self.send(method_name, letr)
+        end
+      end.flatten
+    end
+
+    def count word_count
+      @words = @words.take(word_count)
+    end
+
+    def including_letter(letr)
+      @words.select{|wrd| wrd.include?(letr)}
+    end
+
+    def containing
+      letters = Cfg.config["containing"]
+      letters.flatten.collect do |letr|
+        if letr.class == Range
+          letters = letr.collect { |let| let }
         end
       end
-      if found
-        @words.push wrd
+
+      lets = letters.flatten.join('').split("")
+      found, temp, @words = false, @words, []
+      temp.each do |wrd|
+        wrd_lets = wrd.split("")
+        wrd_lets.each do |wrd_let|
+          if lets.include?(wrd_let)
+            found = true
+          else
+            found = false
+            break
+          end
+        end
+        if found
+          @words.push wrd
+        end
       end
+      @words
     end
-    @words
-  end
 
-  def including(* letters)
-    @words = letters.flatten.collect{|letr| including_letter(letr)}.flatten
-  end
+    def no_longer_than(max)
+      @words = @words.select{|wrd| wrd.size <= max}
+    end
 
-  def no_longer_than(max)
-    @words = @words.select{|wrd| wrd.size <= max}
-  end
+    def no_shorter_than(min)
+      @words = @words.select{|wrd| wrd.size >= min}
+    end
 
-  def no_shorter_than(min)
-    @words = @words.select{|wrd| wrd.size >= min}
-  end
+    def assign(words)
+      words.kind_of?(String) ?
+        @words = words.split(/\s+/) :
+        @words = words
+    end
 
-  def assign(words)
-    words.kind_of?(String) ?
-    @words = words.split(/\s+/) :
-      @words = words
-  end
+    def collect_words
+      @words.each{ |word| ' ' + word }.
+        collect{|wrd| wrd}.join(' ')
+    end
 
-  def collect_words
-    @words.each{ |word| ' ' + word }.
-      collect{|wrd| wrd}.join(' ')
-  end
+    def reverse
+      @words.reverse!
+    end
 
-  def reverse
-    @words.reverse!
-  end
+    def letters_numbers
+      letter_group.push( * number_group)
+    end
 
-  def letters_numbers
-    letter_group.push( * number_group)
-  end
+    def random_letters(options = {})
+      @words = Randomize.new(options, letter_group).generate
+    end
 
-  def random_letters(options = {})
-    @words = Randomize.new(options, letter_group).generate
-  end
+    def random_numbers(options = {})
+      @words = Randomize.new(options, number_group).generate
+    end
 
-  def random_numbers(options = {})
-    @words = Randomize.new(options, number_group).generate
-  end
+    def random_letters_numbers(options = {})
+      @words = Randomize.new(options, letters_numbers.shuffle).generate
+    end
 
-  def random_letters_numbers(options = {})
-    @words = Randomize.new(options, letters_numbers.shuffle).generate
-  end
+    def alphabet(options = {reverse: nil})
+      @words = [Alphabet.new(options).generate]
+    end
 
-  def alphabet(options = {reverse: nil})
-    @words = [Alphabet.new(options).generate]
-  end
+    def numbers(options = {reverse: nil})
+      @words = [Numbers.new(options).generate]
+    end
 
-  def numbers(options = {reverse: nil})
-    @words = [Numbers.new(options).generate]
-  end
+    def numbers_spoken()
 
-  def numbers_spoken()
+    end
 
   end
+
 end

data/run_script_tests.rb

@@ -0,0 +1,165 @@
+require 'sequel'
+
+DEBUG = false
+
+class RunScriptTests
+  NO_RUN = DEBUG ? false : false
+  TEST_ON_MEMORY_DATABASE = DEBUG ? true : false
+  NO_RSS_FEED = DEBUG ? true : false
+  PATH_TO_CW_SCRIPTS = '/Users/martyn/jekyll/documentation-theme-jekyll/cw_scripts'
+  ROOT = '/Users/martyn/cw/cw_clone'
+  PROGRESS_FILE = "data/text/progress.txt"
+  DB = Sequel.sqlite(File.join(ROOT, 'test.sqlite'))  unless(TEST_ON_MEMORY_DATABASE)
+  DB = Sequel.sqlite if(TEST_ON_MEMORY_DATABASE)
+
+  def initialize
+    create_tables if(TEST_ON_MEMORY_DATABASE)
+    populate_cw_scripts if(TEST_ON_MEMORY_DATABASE)
+  end
+
+  def create_tables
+    DB.create_table :scripts do
+      primary_key :id
+      String :script, :null => false
+      String :path, :null => false
+    end
+
+    DB.create_table :test_runs do
+      primary_key :id
+      DateTime :date_time
+      Fixnum :total_secs
+      String :result
+    end
+
+    DB.create_table :tests do
+      primary_key :id
+      Fixnum :test_run_id, :null => false
+      Fixnum :script_id, :null => false
+      Fixnum :wpm, :null => false
+      Fixnum :ewpm, :null => false
+      String :duration
+    end
+  end
+
+  def populate_cw_scripts
+    scripts = (Dir.glob(PATH_TO_CW_SCRIPTS + '/*.rb'))
+    scripts.each do |script|
+      script_name = File.basename(script,'.rb')
+      # populate the table
+      DB[:scripts].insert(:script => "#{script_name}",
+                          :path => PATH_TO_CW_SCRIPTS)
+    end
+    DB[:scripts].insert(:script => "example",
+                        :path => ROOT)
+  end
+
+  def reset_sentence_count
+    File.open(PROGRESS_FILE,'w') do |f|
+      f.puts "0"
+    end
+  end
+
+  def get_current_test_runs(test_run_id)
+    DB[:test_runs].where(:id => test_run_id)
+  end
+
+  def update_current_test_run(test_run_id,total_secs)
+    current = get_current_test_runs(test_run_id)
+    current.update(:total_secs=> total_secs, :result=>"pass")
+  end
+
+  def exec_command line
+    system(line)
+  end
+
+  def set_test_environment
+    "CW_ENV=test "
+  end
+
+  def run_test filename, environment = nil
+    environment == :test ?
+      env = set_test_environment : env = ''
+    exec_command(env + "bundle exec ruby #{filename}")
+  end
+
+  def execute_test_env filename
+    if NO_RUN
+      sleep 0.05
+    else
+      run_test(filename, :test)
+    end
+  end
+
+  class Timer
+    def initialize
+      @finish_time = @total_start_time = Time.now
+    end
+
+    def start
+      @start_time = Time.now
+    end
+    def finish
+      @finish_time = Time.now
+    end
+    def duration
+      @finish_time - @start_time
+    end
+    def total_secs
+      @finish_time - @total_start_time
+    end
+    def running_time
+      Time.now - @total_start_time
+    end
+  end
+
+  def test_runs_insert_dateTime
+    DB[:test_runs].insert(:date_time => Time.now,
+                           :total_secs => 0,
+                           :result    => "fail")
+  end
+
+  def reset_sentence_count_maybe script_name
+    if script_name.include?("book_reading")
+      reset_sentence_count
+    end
+  end
+
+  def print_last_five_results
+    DB[:test_runs].each do |test_run|
+      if(test_run[:id] > (@test_run_id - 5))
+        puts test_run[:date_time].to_s + ': ' +
+             "Total secs: " + test_run[:total_secs].to_s
+      end
+    end
+  end
+
+  def run
+    timer = Timer.new
+    @test_run_id = test_runs_insert_dateTime
+    DB[:scripts].each do |test|
+      filename = File.join test[:path], test[:script] + '.rb'
+      puts "[#{timer.running_time.to_i}] Running: #{test[:script]}"
+      reset_sentence_count_maybe test[:script]
+      timer.start
+#      next unless test[:script].include? ("example")
+      execute_test_env filename
+      timer.finish
+      reset_sentence_count_maybe test[:script]
+      DB[:tests].insert(:script_id    => test[:id],
+                         :test_run_id  => @test_run_id,
+                         :wpm          => 60,
+                         :ewpm         => 60,
+                         :duration     => "#{timer.duration}")
+      DB[:tests].all
+    end
+    update_current_test_run(@test_run_id,timer.total_secs)
+    run_test(PATH_TO_CW_SCRIPTS + '/rss_feed.rb') unless(NO_RSS_FEED)
+    print_last_five_results
+  end
+end
+
+test_scripts = RunScriptTests.new
+1.times do |loop_count|
+  test_scripts.run
+  break unless(DEBUG)
+end