shunkuntype 1.0.1a

data/lib/shunkuntype/finished_check.rb

@@ -0,0 +1,44 @@
+class FinishCheck
+  STEPS=[[
+          ['frdejuki      1,2,3,4',1,2,3,4],
+          ['tgyh        5,6,7,8,9',5,6,7,8,9],
+          ['vbc    10,11,12,13,14', 10,11,12,13,14],
+          ['mn,    15,16,17,18,19', 15,16,17,18,19],
+          ['consol 20,21,22,23,24',20,21,22,23,24],
+          ['swx    25,26,27,28,29', 25,26,27,28,29],
+          ['lo.    30,31,32,33,34', 30,31,32,33,34],
+          ['aqz    35,36,37,38,39', 35,36,37,38,39],
+          [';p  40,41,42,43,44,45',40,41,42,43,44,45],
+          ['consol 46,47,48,49,50', 46,47,48,49,50]
+         ]]
+  def initialize
+    finish = [[],[]]
+    File.open(Shunkuntype::TRAIN_FILE,'r').each{|line|
+      name = line.chomp.split(',')[1]
+      step = name.scan(/\d+/)[0].to_i
+      finish[0] << step
+    }
+
+#    text=[['Basic','minute'],['GerardStrong','size']]
+    text=[['Basic','minute']]
+    1.times{|i|
+      print display(STEPS[i],finish[i],text[i][0],text[i][1])
+    }
+  end
+
+  def display(step,finished,title="***",command="***")
+    cont = "You've finished #{title} drills of...\n"
+    cont << sprintf("hour | %-21s | step\n",'contents')
+    step.each_with_index do |ele,indx|
+      cont << sprintf("%4s | %-21s | ",indx,ele[0])
+      ele[1..-1].each {|e2|
+        cont << e2.to_s+"," if finished.include?(e2)
+      }
+      cont<< "\n"
+    end
+    next_step=finished[-1].to_i+1
+    cont << "To continue one minute training: shunkuntype -d #{next_step}.\n\n"
+    return cont
+  end
+
+end

data/lib/shunkuntype/init.rb

@@ -0,0 +1,24 @@
+class InitDataFiles
+  def initialize
+    if File::exist?("./speed_data.txt") then
+      system "mv ./speed_data.txt #{Shunkuntype::SPEED_FILE}"
+      print "moving ./speed_data.txt #{Shunkuntype::SPEED_FILE}.\n"
+    end
+    if File::exist?("./training_data.txt") then
+      system "mv ./training_data.txt #{Shunkuntype::TRAIN_FILE}"
+      print "moving ./training_data.txt #{Shunkuntype::TRAIN_FILE}.\n"
+    end
+    if File::exist?(Shunkuntype::SPEED_FILE) then
+      print "#{Shunkuntype::SPEED_FILE} exits.\n"
+    else
+      File::open(Shunkuntype::SPEED_FILE,'a')
+      print "make #{Shunkuntype::SPEED_FILE}\n"
+    end
+    if File::exist?(Shunkuntype::TRAIN_FILE) then
+      print "#{Shunkuntype::TRAIN_FILE} exits.\n"
+    else
+      File::open(Shunkuntype::TRAIN_FILE,'a')
+      print "make #{Shunkuntype::TRAIN_FILE}\n"
+    end
+  end
+end

data/lib/shunkuntype/mk_summary.rb

@@ -0,0 +1,74 @@
+class MkSummary
+  def initialize
+    files = Dir::entries("./mem_data")
+    member = mk_member(files)
+    @scores = take_scores(files,member)
+  end
+
+  def mk_member(files)
+    member = []
+    files.each{|file|
+      if file.include?('training') then
+        name=file.split('_')[0]
+        member << name
+      end
+    }
+    return member
+  end
+
+  def take_scores(files,member)
+    scores = {}
+    member.each{|name|
+      p name
+      speed_file="#{name}_speed_data.txt"
+      if files.include?(speed_file)
+        file = File.readlines("mem_data/#{speed_file}")
+        init= (file[0]!=nil ? file[0].split(",")[2].to_f : 0.0 )
+        cur = (file[-1]!=nil ? file[-1].split(",")[2].to_f : 0.0 )
+        scores[name]=[init,cur]
+      end
+      training_file="#{name}_training_data.txt"
+      if files.include?(training_file)
+        file = File.readlines("mem_data/#{training_file}")
+        work_time = file.inject(0){|sum,line|
+          sec=line.split(',')[3].to_i
+          sec= (sec!=0)? sec : 60
+          sum + sec
+        }
+        step = (file[-1]!=nil ? file[-1].match(/STEP-(\d*)/)[1].to_i : 0 )
+        scores[name] << work_time/60 << step
+      end
+    }
+    return scores
+  end
+
+  def mk_html_table()
+    cont = ""
+    title = "Shunkun typer"
+    cont << "<table border=\"1\">\n<caption>#{title}<caption>\n"
+    cont << "<tr><th></th><th colspan=2>speed[sec]</th><th colspan=2>training</th></tr>\n"
+    cont << "<tr><th></th><th>init</th><th>current</th><th>total time[min]</th><th>step</th></tr>\n"
+    @scores.each_pair{|key,score|
+      cont << "<tr><th>#{key}</th>"
+      score.each{|val| cont << sprintf("<td>%5.2f</td>",val)}
+      cont << "</tr>\n"
+    }
+    cont << "</table>\n"
+    return cont
+  end
+
+  def mk_hiki_table()
+    t= Time.now
+    cont = "!!Shunkun typer #{t.localtime}\n"
+    cont << "|| ||>speed[sec]||>training\n"
+    cont << "||||init||current||total time[min]||step\n"
+    @scores.each_pair{|key,score|
+      cont << "||#{key}"
+      score.each{|val| cont << sprintf("||%5.2f",val)}
+      cont << "\n"
+    }
+    cont << "\n"
+    return cont
+  end
+end
+

data/lib/shunkuntype/options.rb

@@ -0,0 +1,24 @@
+#coding: utf-8
+
+require 'optparse'
+
+module Shunkuntype
+  class Command
+    module Options
+
+      def self.parse!(argv)
+        options = {}
+        command_parser = OptionParser.new do |opt|
+          opt.on_head('-v', '--version','Show program version') do |v|
+            puts options.ver
+            opt.version = Shunkuntype::VERSION
+            exit
+          end
+        end
+
+        command_parser.parse!(argv)
+      end
+
+    end
+  end
+end

data/lib/shunkuntype/plot.rb

@@ -0,0 +1,67 @@
+require 'time'
+
+class PlotPersonalData
+
+  def initialize
+    plot_data = read_data()
+    make_data_file(plot_data)
+
+    text=["Typing speed [words/min]","Work minutes [min]"]
+    2.times{|i|
+      opts = {:title=>"Elapsed time vs #{text[i]}",
+        :plot=>"plot \"./tmp.data\" using 1:#{i+2} w st\n",
+        :xlabel=>"Elapsed time[hrs]",:ylabel=>text[i],:xtics=>"0 2"}
+      listplot(opts)
+    }
+
+    opts = {:title=>"Elapsed time vs Finished steps",
+      :xlabel=>"Elapsed time[hrs]",:ylabel=>"Finished steps",:xtics=>"0 2",
+      :plot=>"plot \"./tmp.data\" u 1:4 w st ti \"basic drills\", \\
+\"./tmp.data\" u 1:5 w st ti \"Gerard Strong drills\""}
+    listplot(opts)
+  end
+
+  def read_data
+    today=Time.now.to_s
+    plot_data=[]
+    d_total_min=0
+    d_step=[[0],[0]]
+    File.open(Shunkuntype::TRAIN_FILE,'r'){|file|
+      while line=file.gets do
+        tmp=line.chomp.split(',')
+        d_day = ((Time.parse(tmp[0])-Time.parse(today))/3600/24) #hours
+        tmp << "60" if tmp.size ==3 # for backward consist. to "d,f,w"+",t"
+        d_speed = tmp[2].to_f/tmp[3].to_f*60
+        d_total_min += tmp[3].to_f/60.0  # total_second
+        name = tmp[1]
+        step = name.scan(/\d+/)[0].to_i # extract step from file name
+        name.include?('GerardStrong_data') ? d_step[1] << step : d_step[0] << step
+        plot_data << [d_day,d_speed,d_total_min,d_step[0][-1],d_step[1][-1]]
+      end
+    }
+    return plot_data
+  end
+
+  def make_data_file(outdata)
+    cont=""
+    outdata.each {|idata|
+      idata.each{|ele| cont << sprintf("%7.2f ",ele)}
+      cont << "\n"
+    }
+    File.open("./tmp.data",'w'){|io| io.print(cont)}
+  end
+
+  def listplot(opts)
+    cont = ""
+    cont << "set xrange \[#{opts[:x]}\]\n" if opts.has_key?(:x)
+    cont << "set yrange \[#{opts[:y]}\]\n" if opts.has_key?(:y)
+    cont << "set title \"#{opts[:title]}\"\n" if opts.has_key?(:title)
+    cont << "set xlabel \"#{opts[:xlabel]}\"\n" if opts.has_key?(:xlabel)
+    cont << "set ylabel \"#{opts[:ylabel]}\"\n" if opts.has_key?(:ylabel)
+    cont << "set xtics #{opts[:xtics]} \n" if opts.has_key?(:xtics)
+    cont << "#{opts[:plot]} \n"
+    File.open("./tmp.txt",'w'){|io| io.print(cont)}
+    system "gnuplot ./tmp.txt"
+  end
+
+end

data/lib/shunkuntype/plot_data.rb

@@ -0,0 +1,177 @@
+require 'time'
+require "gnuplot"
+
+class PlotData
+  attr_accessor :data, :title
+  #  def initialize()
+  def initialize(file_name="",x_col=nil,y_col=nil,title="")
+    @data=[]
+    read_general_data(file_name,x_col,y_col) if ""!=file_name
+    @title=title if ""!=title
+  end
+
+  def add_general_data(file, x_col, y_col)
+    read_general_data(file, x_col, y_col)
+  end
+
+  def read_general_data(file, x_col, y_col)
+    File.open(file,'r'){|file|
+      while line=file.gets do
+        tmp=line.chomp.split(',')
+        @data << [tmp[x_col],tmp[y_col]]
+      end
+    }
+  end
+
+  def to_gnuplot()
+    x,y=[],[]
+    @data.each{|ele|
+      x << ele[0]
+      y << ele[1]
+    }
+    return [x,y]
+  end
+
+  def mk_plot_data(x_func,y_func)
+    tmp_data=[]
+    @data.each{|ele|
+      x_data = x_func.call(ele[0])
+      y_data = y_func.call(ele[1])
+      tmp_data << [x_data,y_data]
+    }
+    @data = tmp_data
+  end
+
+  def sum_data
+    tmp_data=[]
+    y_data=0
+    @data.each{|ele| tmp_data << [ele[0], y_data+=ele[1]]}
+    @data = tmp_data
+  end
+
+  def sort
+    @data.sort!{|x,y| x[0] <=> y[0]}
+  end
+end
+
+class MkPlots
+
+  def initialize
+    @source_dir='mem_data'
+    @mem_names=[]
+    mk_mem_names()
+    work_all()
+    speed_all()
+  end
+
+  def work_all
+    all_data= @mem_names.inject([]){|all,name| all << work_view(name) }
+    text="Work minutes [min]"
+    plot(all_data,text)
+    plot(all_data,text,opts={:png=>true})
+    #      system 'cp res.png ~/Sites/nishitani0/Internal/data/cache/attach/ShunkunTyper2015/work.png'
+    system 'mv res.png work.png'
+  end
+
+  def speed_all
+    mk_mem_names
+    all_data= @mem_names.inject([]){|all,name| all << speed_view(name) }
+    text="Typing speed [sec/20 words]"
+    plot(all_data,text)
+    plot(all_data,text,opts={:png=>true})
+    system 'mv res.png speed.png'
+  end
+
+  def speed_view(name)
+    p name1 = "#{@source_dir}/#{name}_speed_data.txt"
+    data0 = PlotData.new(name1, 0, 2, name)
+    #  start=Time.parse(data0.data[0][0])
+    start=Time.parse(Time.now.to_s)
+    x_func = proc{|x| ((Time.parse(x)-start)/3600/24) }
+    y_func = proc{|x| x }
+    data0.mk_plot_data(x_func,y_func)
+    return data0
+  end
+
+  def mk_mem_names
+    names = Dir.entries(@source_dir)
+    names.each{|name|
+      title = name.split('_')[0]
+      @mem_names << title if (!@mem_names.include?(title) and title.match(/\w/))
+    }
+  end
+
+  def work_view(name)
+    p name0 = "#{@source_dir}/#{name}_training_data.txt"
+    p name1 = "#{@source_dir}/#{name}_speed_data.txt"
+    data0 = PlotData.new(name0,0,3,name)
+    data0.add_general_data(name1, 0, 2)
+    start=Time.parse(Time.now.to_s)
+    x_func = proc{|x| ((Time.parse(x)-start)/3600/24) }
+    y_func = proc{|x| x.to_f/60.0 }
+    data0.mk_plot_data(x_func,y_func)
+    data0.sort
+    data0.sum_data
+    return data0
+  end
+
+  def plot(data,text0,opts={})
+    Gnuplot.open do |gp|
+      Gnuplot::Plot.new( gp ) do |plot|
+        plot.title  "Elapsed time vs #{text0}"
+        plot.ylabel text0
+        plot.xlabel "Elapsed time[days]"
+        plot.xtics "0 7"
+        if true==opts.has_key?(:png) then
+          plot.term "pngcairo enhanced size 480,360"
+          plot.output "res.png"
+        end
+
+        plot.data = []
+        data.each{|ele|
+          plot.data << Gnuplot::DataSet.new( ele.to_gnuplot ) do |ds|
+            ds.with = "line"
+            if ""==ele.title then
+              ds.notitle
+            else
+              ds.title=ele.title
+            end
+          end
+        }
+      end
+    end
+  end
+end
+
+if __FILE__ == $0 then
+  data0 = PlotData.new()
+  data0.read_general_data(ARGV[0], 0, 3)
+  data0.add_general_data(ARGV[1], 0, 2)
+
+  start=Time.parse(data0.data[0][0])
+  x_func = proc{|x| ((Time.parse(x)-start)/3600/24) }
+  y_func = proc{|x| x.to_f/60.0 }
+  data0.mk_plot_data(x_func,y_func)
+  data0.sort
+  data0.sum_data
+
+  text="Work minutes [min]"
+  Gnuplot.open do |gp|
+    Gnuplot::Plot.new( gp ) do |plot|
+      plot.title  "Elapsed time vs #{text}"
+      plot.ylabel text
+      plot.xlabel "Elapsed time[days]"
+      plot.xtics "0 2"
+      x,y = data0.to_gnuplot
+
+      plot.data << Gnuplot::DataSet.new( [x, y] ) do |ds|
+        ds.with = "line"
+        ds.notitle
+      end
+    end
+  end
+
+end
+
+
+

data/lib/shunkuntype/speed.rb

@@ -0,0 +1,83 @@
+
+class SpeedCheck
+  attr_reader :number, :period
+
+  # print key positions
+  def print_keyboard
+    content = <<-EOF
+ q \\ w \\ e \\ r t \\ y u \\ i \\ o \\ p
+  a \\ s \\ d \\ f g \\ h j \\ k \\ l \\ ; enter
+sh z \\ x \\ c \\ v b \\ n m \\ , \\\ . \\  shift
+EOF
+    print content
+  end
+
+  def initialize
+    @number = 20 #default 20
+    @period = 60
+    check_data_files
+    data = mk_random_words
+    t0,t1,count = exec_speed_check(data)
+    keep_record(t0,t1,count)
+  end
+
+  def check_data_files
+    begin
+      file=open(Shunkuntype::SPEED_FILE,"r")
+      if file
+        puts "#{Shunkuntype::SPEED_FILE} opened succcessfully"
+      end
+    rescue
+      puts "#{Shunkuntype::SPEED_FILE} does not exist in this directory. --init or try in another dir."
+      exit
+    end
+  end
+  def mk_random_words
+    data=[]
+    data_dir=File.expand_path('../../../lib/data', __FILE__)
+    file=open("#{data_dir}/word.list",'r')
+    while word=file.gets do
+      data << word.chomp
+    end
+    data.shuffle!
+    data.each do |word|
+      print word+" "
+    end
+    return data
+  end
+
+  def exec_speed_check(data)
+    print "\n\n"+number.to_s+" words should be cleared."
+    print "\nType return-key to start."
+    line=$stdin.gets
+
+    t0=Time.now
+    count=0
+    @number.times do |i|
+      print_keyboard()
+      puts (i+1).to_s
+      word = data[i]
+      count+=word.length
+      while line!=word do
+        puts word
+        line=$stdin.gets.chomp
+      end
+    end
+    t1=Time.now
+    return t0,t1,count
+  end
+
+  def keep_record(t0,t1,count)
+    statement = t0.to_s+","
+    statement << @number.to_s+","
+    statement << (t1-t0).to_s+","
+    icount=@period/(t1-t0)*count
+    statement << icount.to_s+"\n"
+    data_file=open(Shunkuntype::SPEED_FILE,"a+")
+    data_file << statement
+    p statement
+
+    printf("%5.3f sec\n",Time.now-t0)
+    printf("%4d characters.\n",icount)
+  end
+end

data/lib/shunkuntype/training.rb

@@ -0,0 +1,89 @@
+class Training
+  def initialize(val_i)
+    val_i ||= 47
+    data_dir=File.expand_path('../../../lib/data', __FILE__)
+    base_name="STEP-#{val_i}.txt"
+    file_name=File.join(data_dir,base_name)
+
+    @period = 60
+    @counter = 0
+
+    @time_flag=true
+    print_keyboard
+    start_time,data=init_proc(file_name)
+    #size_training(file_name,data,start_time)
+    time_training(base_name,data,start_time)
+  end
+
+  # count correct spelling
+  def counter(word1,word2)
+    ws1=word1.split(/\s+/)
+    ws2=word2.split(/\s+/)
+    i,j=0,0
+    while (i < ws1.length) && (j < ws2.length) do
+      if ws1[i] == ws2[j] then
+        @counter+=1
+      end
+      i+=1
+      j+=1
+    end
+    puts @counter
+  end
+
+  # time loop
+  def loop_thread(sec)
+    Thread.start(sec) do |wait_time|
+      sleep wait_time
+      puts "\a Time up. Type return-key to finish.."
+      @time_flag=false
+    end
+  end
+
+  # print key positions
+  def print_keyboard
+    content = <<-EOF
+ q \\ w \\ e \\ r t \\ y u \\ i \\ o \\ p
+  a \\ s \\ d \\ f g \\ h j \\ k \\ l \\ ; enter
+sh z \\ x \\ c \\ v b \\ n m \\ , \\\ . \\  shift
+EOF
+    print content
+  end
+
+  def init_proc(file_name)
+    data=File.readlines(file_name)
+    data.each{|word| print word }
+    print "\nRepeat above sentences. Type return-key to start."
+    line=STDIN.gets
+    start_time = Time.now
+    return start_time,data
+  end
+
+  def keep_record(start_time,file_name,period)
+    data_file=open(Shunkuntype::TRAIN_FILE,"a")
+    data_file << "#{start_time},#{file_name},#{@counter},#{period}\n"
+    exit
+  end
+
+  def type_loop(data)
+    data.each do |sentence|
+      break if @time_flag == false
+      puts sentence
+      line=STDIN.gets.chomp
+      counter(sentence,line)
+    end
+  end
+
+  def size_training(file_name,data,start_time)
+    type_loop(data)
+    exit_proc(start_time,file_name,(Time.now-start_time).to_i)
+    return
+  end
+
+  def time_training(base_name,data,start_time)
+    loop_thread(@period)
+    data2=[]
+    20.times{ data2 << data }
+    type_loop(data2.flatten)
+    keep_record(start_time,base_name,@period)
+  end
+end

data/lib/shunkuntype/version.rb

@@ -0,0 +1,10 @@
+require 'fileutils'
+module Shunkuntype
+  VERSION = "1.0.1a"
+  data_path = File.join(ENV['HOME'], '.shunkuntype')
+#  SPEED_FILE="./shunkuntype_speed_data.txt"
+  SPEED_FILE=File.join(data_path,"speed_data.txt")
+#  TRAIN_FILE="./shunkuntype_training_data.txt"
+  TRAIN_FILE=File.join(data_path,"training_data.txt")
+  SERVER_FILE=File.join(data_path,"server_data.txt")
+end

data/lib/shunkuntype.rb

@@ -0,0 +1,83 @@
+require 'optparse'
+require "shunkuntype/version"
+require "shunkuntype/speed"
+require "shunkuntype/training"
+require "shunkuntype/init"
+require "shunkuntype/finished_check"
+require "shunkuntype/plot"
+require "shunkuntype/mk_summary"
+require "shunkuntype/plot_data"
+require "shunkuntype/db"
+require 'systemu'
+
+module Shunkuntype
+  class Command
+
+    def self.run(argv=[])
+      print "Shunkuntype says 'Hello world'.\n"
+      new(argv).execute
+    end
+
+    def initialize(argv=[])
+      @argv = argv
+    end
+
+    def execute
+      DB.prepare
+
+      @argv << '--help' if @argv.size==0
+      command_parser = OptionParser.new do |opt|
+        opt.on('-v', '--version','show program Version.') { |v|
+          opt.version = Shunkuntype::VERSION
+          puts opt.ver
+        }
+        opt.on('-i', '--init','Initialize data files') {|v| InitDataFiles.new }
+        opt.on('-c', '--check','Check speed') {|v| SpeedCheck.new }
+        opt.on('-d', '--drill [VAL]','one minute Drill [VAL]', Integer) {|v| Training.new(v) }
+        opt.on('-h', '--history','view training History') {|v| FinishCheck.new }
+        opt.on('-p', '--plot','Plot personal data') { |v| PlotPersonalData.new }
+        opt.on('-s', '--submit','Submit data to dmz0') { |v| report_submit()}
+        opt.on('--review [TAG]',[:html,:hiki],'Review training, TAGs=html or hiki'){|v| data_viewing(v)}
+      end
+      command_parser.parse!(@argv)
+      exit
+    end
+
+    def report_submit
+      server_info=File.readlines(Shunkuntype::SERVER_FILE)
+      p server_directory=server_info[0].chomp
+      p user_name=server_info[0].split('@')[0]
+      system "scp #{Shunkuntype::TRAIN_FILE} #{server_directory}/#{user_name}_training_data.txt"
+      system "scp #{Shunkuntype::SPEED_FILE} #{server_directory}/#{user_name}_speed_data.txt"
+    end
+
+    def data_viewing(form)
+      server_info=File.readlines(Shunkuntype::SERVER_FILE)
+      p server_directory=server_info[0].chomp
+      system "scp -r #{server_directory} ."
+      # write data to file
+      table = MkSummary.new
+      MkPlots.new
+      p form ||= :html
+      case form
+        when :html then
+        File.open('tmp.html','a'){|f|
+          f.write("<html>\n")
+          f.write(table.mk_html_table())
+          f.write("<p><img src=\"./work.png\" /></p>")
+          f.write("<p><img src=\"./speed.png\" /></p>")
+          f.write("</html>\n")
+        }
+        when :hiki then
+        File.open('tmp.hiki','a'){|f|
+          f.write(table.mk_hiki_table())
+          f.write('||{{attach_view(work.png)}}')
+          f.write('||{{attach_view(speed.png)}}')
+          f.write("\n")
+        }
+        else
+        exit
+      end
+    end
+  end
+end