dictation 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea842ecf7f99848898ad32ac6accae61d57e59ba
+  data.tar.gz: 75f245d58bdfe3b456d8cda2d09327e9668a5c45
+SHA512:
+  metadata.gz: 664b01f3d7b97636e2c985428b3641dc184bfea53552b37a89730da128a4d170699482c05317010834e7e835114848835883b36581a680fa2691c995e7d7383a
+  data.tar.gz: 36072fec46ad89922e5c797fd8d95a86ccbb938709cbf32787c7ab029f0234741e35a9dd0b2993af98c44bd39970e09aa3f2b3106277959c7d103eb21e32e659

data/bin/dictation

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'dictation'
+
+Dictation::ControlCenter.launch

data/lib/dictation/commander.rb

@@ -0,0 +1,97 @@
+require 'optparse'
+
+module Dictation
+  class Commander
+    class << self
+      def order(args)
+        options = {}
+        commands = {
+            'new' => OptionParser.new do |opts|
+              opts.banner = set_banner('new')
+
+              opts.on('-d', '--dictate TTS', 'Specify two-letters language code for dictation') do |tts|
+                options[:dictate] = tts.downcase
+              end
+
+              opts.on('-v', '--verify TTS', 'Specify two-letters language code for verification') do |tts|
+                options[:verify] = tts.downcase
+              end
+            end,
+
+            'add' => OptionParser.new do |opts|
+              opts.banner = set_banner('add')
+
+              opts.on('-l', '--language LANGUAGE', 'Specify the target language file for adding more words') do |language|
+                options[:language] = language
+              end
+            end,
+
+            'dictate' => OptionParser.new do |opts|
+              opts.banner = set_banner('dictate')
+
+              opts.on('-l', '--language LANGUAGE', 'Specify the language for dictation') do |language|
+                options[:language] = language
+              end
+
+              opts.on('-b', '--begin WORD', 'Begin with given word') do |word|
+                options[:word_begin] = word
+              end
+
+              opts.on('-e', '--end WORD', 'End with given word') do |word|
+                options[:word_end] = word
+              end
+
+              opts.on('-s', '--start LINE', Integer, 'Start with given line') do |line|
+                options[:line_start] = line
+              end
+
+              opts.on('-f', '--finish LINE', Integer, 'Finish with given line') do |line|
+                options[:line_finish] = line
+              end
+            end,
+
+            'verify' => OptionParser.new do |opts|
+              opts.banner = set_banner('verify')
+
+              opts.on('-l', '--language LANGUAGE', 'Specify the language for dictation') do |language|
+                options[:language] = language
+              end
+
+              opts.on('-b', '--begin WORD', 'Begin with given word') do |word|
+                options[:word_begin] = word
+              end
+
+              opts.on('-e', '--end WORD', 'End with given word') do |word|
+                options[:word_end] = word
+              end
+
+              opts.on('-s', '--start LINE', Integer, 'Start with given line') do |line|
+                options[:line_start] = line
+              end
+
+              opts.on('-f', '--finish LINE', Integer, 'Finish with given line') do |line|
+                options[:line_finish] = line
+              end
+            end
+        }
+        valid_cmds = ['new', 'add', 'dictate', 'verify']
+        if valid_cmds.include?(args[0])
+          commands[args.shift].order!
+          options
+        else
+          puts "Unknown commands [#{args[0]}], only support #{valid_cmds.inspect}."
+        end
+      end
+
+      def get_caller_file_name
+        caller[-1].match(/\S+\.rb/)
+      end
+
+      def set_banner(cmd)
+        "Usage: #{get_caller_file_name} #{cmd} [options]"
+      end
+    end
+
+    private_class_method :new, :get_caller_file_name, :set_banner
+  end
+end

data/lib/dictation/control_center.rb

@@ -0,0 +1,121 @@
+module Dictation
+  class ControlCenter
+    class << self
+      def launch
+        if OperatingSystem.supported?
+          command = ARGV[0]
+          options = Commander.order(ARGV)
+          case command
+          when 'new'
+            execute_new(options)
+          when 'add'
+            execute_add(options)
+          when 'dictate'
+            execute_dictate(options)
+          when 'verify'
+            execute_verify(options)
+          end
+        else
+          puts 'Sorry, your Operating System is not supported.  Only Mac OSX has built-in TTS (Text-to-Speech).'
+        end
+      end
+
+      def execute_new(options)
+        if options[:dictate] && options[:verify]
+          File.open("dict_#{options[:dictate]}_#{options[:verify]}.txt", "w") {}
+        else
+          puts 'Please give both dictate (-d) and verify (-v) languages.'
+        end
+      end
+
+      def execute_add(options)
+        if options[:language]
+          dictionary = get_dictionary(options[:language])
+          if dictionary
+            words = Typewriter.new.collect
+            Serializer.serialize(words, dictionary)
+          else
+            puts 'Can not find any dictionary file.'
+          end
+        else
+          puts 'Please specify the target language (-l).'
+        end
+      end
+
+      def execute_dictate(options)
+        execute_speak(options, :dictates)
+      end
+
+      def execute_verify(options)
+        execute_speak(options, :verifies)
+      end
+
+      def get_dictionary(language)
+        dictionary = nil
+        regex = /dict_#{language}_[a-z]{2}\.txt/
+        Dir.glob("*").each do |file|
+          (dictionary = file) && break if file.match(regex)
+        end
+        dictionary
+      end
+
+      def get_languages(dictionary)
+        regex = /dict_([a-z]{2})_([a-z]{2})\.txt/
+        md = dictionary.match(regex)
+        [md[1], md[2]]
+      end
+
+      def get_words(options)
+        words = []
+        dictionary = nil
+        language = options[:language]
+        word_begin = options[:word_begin]
+        word_end = options[:word_end]
+        line_start = options[:line_start]
+        line_finish = options[:line_finish]
+
+        if language
+          dictionary = get_dictionary(language)
+        end
+
+        if dictionary && (word_begin || line_start)
+          if word_end
+            words = Serializer.deserialize_a_portion_by_given_word(dictionary, word_begin, word_end)
+          elsif line_finish
+            words = Serializer.deserialize_a_portion_by_given_line(dictionary, line_start, line_finish)
+          else
+            words = (word_begin ? Serializer.deserialize_a_portion_by_given_word(dictionary, word_begin) : Serializer.deserialize_a_portion_by_given_line(dictionary, line_start))
+          end
+        else
+          words = Serializer.deserialize(dictionary)
+        end
+
+        words
+      end
+
+      def set_teacher(dictionary)
+        languages = get_languages(dictionary)
+        tts_dictate = TTS.new(languages[0].intern)
+        tts_verify = TTS.new(languages[1].intern)
+        Teacher.new(tts_dictate, tts_verify)
+      end
+
+      def execute_speak(options, action)
+        if options.has_key?(:language)
+          words = get_words(options)
+          dictionary = get_dictionary(options[:language])
+          if dictionary
+            teacher = set_teacher(dictionary)
+            teacher.send(action, words)
+          else
+            puts 'Please check if the given language is correct (two-letters country code) or whether the dictionary file exists.'
+          end
+        else
+          puts 'Please specify target learning language by two-letters country code (-l)'
+        end
+      end
+    end
+
+    private_class_method :new, :get_dictionary, :get_languages, :get_words, :set_teacher, :execute_speak, :execute_new, :execute_add, :execute_dictate, :execute_verify
+  end
+end

data/lib/dictation/operating_system.rb

@@ -0,0 +1,43 @@
+module Dictation
+  class OperatingSystem
+    TYPE = {
+      lin:     'linux',
+      mac:     'osx',
+      win:     'windows',
+      unknown: 'UNKNOWN'
+    }
+    
+    SUPPORTED_TYPE = [TYPE[:mac]]
+    
+    class << self
+      def match_os(regex)
+        !!RUBY_PLATFORM.match(regex)
+      end
+      
+      def is_linux?
+        match_os(/linux/)
+      end
+
+      def is_mac?
+        match_os(/darwin/)
+      end
+
+      def is_windows?
+        match_os(/mswin|mingw|cygwin|bccwin|wince|emx/)
+      end
+      
+      def what
+        return TYPE[:lin] if is_linux?
+        return TYPE[:mac] if is_mac?
+        return TYPE[:win] if is_windows?
+        return TYPE[:unknown]
+      end
+      
+      def supported?
+        SUPPORTED_TYPE.include?(what)
+      end
+    end
+    
+    private_class_method :new, :match_os, :is_linux?, :is_mac?, :is_windows?, :what
+  end
+end

data/lib/dictation/serializer.rb

@@ -0,0 +1,45 @@
+module Dictation
+  class Serializer
+    class << self
+      def serialize(data, file)
+        if Array === data
+          data = data.inject('') do |chunk, word|
+            chunk += word.to_json + "\n"
+          end
+        end
+        File.open(file, 'a') { |f| f.write(data) }
+      end
+    
+      def deserialize(file)
+        words = []
+        File.open(file).each do |line|
+          words.push(JSON.parse(line))
+        end
+        words
+      end
+
+      def deserialize_a_portion_by_given_word(file, start, stop = nil)
+        all_words = deserialize(file)
+        idx_start = all_words.index { |x| x.value == start }
+        idx_stop = ( stop.nil? ? nil : all_words.index { |x| x.value == stop } )
+        idx_stop = all_words.size if idx_stop.nil?
+        if !idx_start.nil? && idx_start <= idx_stop
+          return all_words[idx_start..idx_stop]
+        end
+      end
+
+      def deserialize_a_portion_by_given_line(file, start, stop = nil)
+        all_words = deserialize(file)
+        unless stop.nil?
+          if stop >= start && stop <= all_words.size
+            return all_words[start-1..stop-1]
+          end
+        else
+          if start <= all_words.size
+            return all_words[start-1..-1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dictation/teacher.rb

@@ -0,0 +1,35 @@
+module Dictation
+  class Teacher
+    SLEEP_INTERVAL_WRITE_LETTER = 0.8
+    SLEEP_INTERVAL_READ_LETTER = 0.1
+    SLEEP_INTERVAL_GENERAL = 0.5
+
+    def initialize(tts_dictate, tts_verify)
+      @tts_dictate = tts_dictate
+      @tts_verify = tts_verify
+    end
+    
+    def dictates(words)
+      words.each do |word|
+        vocabulary = word.value
+        @tts_dictate.speak(vocabulary)
+        sleep(vocabulary.length * SLEEP_INTERVAL_WRITE_LETTER)
+      end
+    end
+    
+    def verifies(words)
+      words.each do |word|
+        @tts_dictate.speak(word.value)
+        sleep(SLEEP_INTERVAL_GENERAL)
+        word.orthography.each do |letter|
+          @tts_dictate.speak(letter)
+          sleep(SLEEP_INTERVAL_READ_LETTER)
+        end
+        sleep(SLEEP_INTERVAL_GENERAL)
+        @tts_verify.speak(word.translation)
+        puts word.value + '     ' + word.translation
+        sleep(SLEEP_INTERVAL_GENERAL)
+      end
+    end
+  end
+end

data/lib/dictation/tts.rb

@@ -0,0 +1,46 @@
+module Dictation
+  class TTS
+    def initialize(language, voice = nil)
+      set_language_and_voice(language, voice)
+    end
+    
+    def get_available_language_and_voice_pairs
+      list_of_available_voices = `say -v '?'`.split("\n")
+      languages_and_voices = list_of_available_voices.inject({}) do |collection, record|
+        matched_results = record.match(/^(.*[^\s])\s+([a-z]{2})_[A-Z]{2}\s+/)
+        available_language = matched_results[2].downcase.intern
+        available_voice = matched_results[1]
+        if collection.has_key?(available_language)
+          collection[available_language] << available_voice
+        else
+          collection[available_language] = [available_voice]
+        end
+        collection
+      end
+    end
+    
+    def set_language_and_voice(language, voice)
+      system_languages_and_voices = get_available_language_and_voice_pairs
+      @language = language
+      if system_languages_and_voices.keys.include?(@language)
+        if voice
+          if system_languages_and_voices[@language].include?(voice)
+            @voice = voice
+          else
+            raise("No available voice found, please check if you have downloaded voice [#{voice}] in System Preferences -> Speech")
+          end
+        else
+          @voice = system_languages_and_voices[@language].first
+        end
+      else
+        raise("No available language found, please check if you have any voice for [#{language}] in System Preferences -> Speech")
+      end
+    end
+    
+    def speak(text)
+      system("say -v #{@voice} #{text} > /dev/null 2>&1")
+    end
+    
+    private :get_available_language_and_voice_pairs, :set_language_and_voice
+  end
+end

data/lib/dictation/typewriter.rb

@@ -0,0 +1,62 @@
+module Dictation
+  class Typewriter
+    attr_accessor :words
+
+    def initialize
+      @words = []
+    end
+
+    def get_input_if_not_nil
+      input = gets
+      input.nil? ? nil : input.chomp!
+    end
+
+    def record
+      paint_print('Word:         ', :blue)
+      value = get_input_if_not_nil
+      paint_print('Translation:  ', :yellow)
+      translation = get_input_if_not_nil
+      @words.push(Word.new(value, translation)) if value && translation
+    end
+
+    def collect
+      paint_puts('Please type word and translation one by one, press Enter key to save.  When you finish, press Ctrl+C.', :pink)
+      Signal.trap('SIGINT') do
+        puts ''
+        break
+      end
+      loop do
+        record
+      end
+      paint_puts("=" * 80, :green)
+      paint_puts("Input is done.", :green)
+      @words
+    end
+
+    def paint(text, color)
+      case color
+        when :green
+          color_code = 32
+        when :yellow
+          color_code = 33
+        when :blue
+          color_code = 34
+        when :pink
+          color_code = 35
+        else
+          color_code = 0
+      end
+      "\e[#{color_code}m#{text}\e[0m"
+    end
+
+    def paint_print(text, color)
+      print(paint(text, color))
+    end
+
+    def paint_puts(text, color)
+      puts(paint(text, color))
+    end
+
+    private :get_input_if_not_nil, :record, :paint, :paint_print, :paint_puts
+  end
+end

data/lib/dictation/word.rb

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+
+require 'json'
+
+module Dictation
+  class Word
+    attr_accessor :value, :translation
+    
+    def initialize(value, translation = nil)
+      @value = value
+      @translation = translation
+    end
+    
+    def orthography
+      decompose(@value)
+    end
+    
+    def decompose(word)
+      word.split(//).map! do |x|
+        normalize(x)
+      end
+    end
+    
+    def normalize(letter)
+      letter = letter.downcase.chomp
+      case letter
+      when 'ß'
+        'ss'
+      else
+        letter
+      end
+    end
+    
+    def to_json(*args)
+      {
+        'json_class' => self.class.name,
+        'data'       => [ @value, @translation ]
+      }.to_json(*args)
+    end
+    
+    class << self
+      def json_create(object)
+        new(*object['data'])
+      end
+    end
+    
+    private :decompose, :normalize
+  end
+end

data/lib/dictation.rb

@@ -0,0 +1 @@
+Dir[(File.expand_path(File.dirname(__FILE__)) + "/dictation/*.rb")].each { |file| require file }

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: dictation
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jing Li
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-27 00:00:00.000000000 Z
+dependencies: []
+description: Practice foreign language by listening and writing (only for Mac OS X).
+email:
+- thyrlian@gmail.com
+executables:
+- dictation
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dictation.rb
+- lib/dictation/operating_system.rb
+- lib/dictation/word.rb
+- lib/dictation/serializer.rb
+- lib/dictation/tts.rb
+- lib/dictation/teacher.rb
+- lib/dictation/typewriter.rb
+- lib/dictation/commander.rb
+- lib/dictation/control_center.rb
+- bin/dictation
+homepage: http://github.com/thyrlian/dictation
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.4
+signing_key: 
+specification_version: 4
+summary: Practice foreign language by listening and writing.
+test_files: []