tli 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4b9966de4cb9e2ccf16508faf6c4c3a97716de52
-  data.tar.gz: 4ed76add32b44156e3e8349d522821c727493528
+  metadata.gz: 730a60e8950b873bbc345d1895d469f73f7f3558
+  data.tar.gz: abb4e3490296da6ee68cea8f16280b6b19b8a54c
 SHA512:
-  metadata.gz: df5cd7d25888649b8b4ec74e91131cd5de463a4b6c4644a1ce90bacc24ca33ddc749d01434efee91319a1f0e024a738fb30dc375eab79bd2e9c35c2f5833ae48
-  data.tar.gz: b93823f30b565d0f452bf2ee910e7ac4118e673a1141cddd7403e869544aa7411905b4ed9a29cdcbd909138f0cb81bfb5775dc390c8a67d9d9259a8f80d5c243
+  metadata.gz: d32ee6f5b694a17a618a3b7206c4024bb8a2cc60c2b026028cb6d5bf96a8cb467182780c36ee919e3995b5be0d8db40ef3df26ed6662aa3dfb6f28b655671096
+  data.tar.gz: b4cc9323ad4b1c4bfa0b6d181694b93a852ab9d323a0c1f7f6a037e52fa951f2ebdb9a654cc9ed96b1c6b9eccdd767b731460ea747a8c5a0ab1e385b377b8e50

data/bin/tli

@@ -1,35 +1,9 @@
 #!/usr/bin/env ruby
 require_relative '../lib/tli'
-
-OPTIONS = {
-  '--source'    => 'option_value',
-  '-s'          => 'option_value',
-  '--target'    => 'option_value',
-  '-t'          => 'option_value',
-  '--backend'   => 'option_value',
-  '-b'          => 'option_value',
-  '--play'      => 'option',
-  '-p'          => 'option'
-}
-
-
-length = ARGV.length
-params = Hash.new('')
-index = 0
-while index < length
-  arg = ARGV[index]
-  if OPTIONS.include?(arg)
-    if OPTIONS[arg] == 'option_value'
-      raise "#{arg} requires a value." if index + 1 >= length
-      params[arg] = ARGV[index+1]
-      index += 1
-    else
-      params[arg] = true
-    end
-  else
-    params[:text] << ' ' + arg
-  end
-  index += 1
+begin
+  Tli.new.invoke(ARGV)
+  exit(0)
+rescue => e
+  STDERR.puts e.message
+  exit(1)
 end
-
-puts Tli.translate(params[:text], params['--source'], params['--target'])

data/lib/application.rb

@@ -0,0 +1,19 @@
+require_relative 'config'
+# Provides configuration values for the application.
+class Application
+  def self.app_dir
+    @app_dir ||= CONFIG[CONFIG[:env]][:app_dir]
+  end
+
+  def self.db_file
+    @db_file ||= CONFIG[CONFIG[:env]][:db_file]
+  end
+
+  def self.strings_dir
+    @strings_dir ||= CONFIG[CONFIG[:env]][:strings_dir]
+  end
+
+  def self.player
+    @player ||= CONFIG[CONFIG[:env]][:player]
+  end
+end

data/lib/config.rb

@@ -0,0 +1,25 @@
+working_directory = File.expand_path(File.dirname(__FILE__))
+CONFIG = {
+  env: :production,
+  development: {
+    app_dir: working_directory + '/../app_dir',
+    strings_dir: working_directory + '/../assets/strings',
+    db_file: working_directory + '/../app_dir/db/translations.db',
+    cache_results: false,
+    player: 'touch'
+  },
+  test: {
+    app_dir: working_directory + '/../app_dir',
+    strings_dir: working_directory + '/../assets/strings',
+    db_file: working_directory + '/../app_dir/db/translations.db',
+    cache_results: false,
+    player: 'touch'
+  },
+  production: {
+    app_dir: Dir.home + '/.tli',
+    strings_dir: working_directory + '/../assets/strings',
+    db_file: Dir.home + '/.tli/db/translations.db',
+    cache_results: true,
+    player: 'mplayer'
+  }
+}

data/lib/dictionaries/dictionary.rb

@@ -0,0 +1,11 @@
+# Base class for dictionaries
+class Dictionary
+
+  def define(word, source, target, play = false); end
+
+  def langs; end
+
+  def provide_tts?; end
+
+  def self.name; end
+end

data/lib/dictionaries/google_dictionary.rb

@@ -0,0 +1,88 @@
+require_relative 'dictionary'
+require_relative '../google'
+
+# Class for the Google Dictionary (actually Translate)
+class GoogleDictionary < Dictionary
+  include Google
+  API_URL = 'http://translate.google.com/translate_a/t'
+
+  def self.name
+    'Google Translate'
+  end
+
+  def provide_tts?
+    true
+  end
+
+  def langs
+    { 'af'  => 'Afrikaans',   'sq'  => 'Albanian',        'ar'  => 'Arabic',
+      'hy'  => 'Armenian',    'az'  => 'Azerbaijani',     'eu'  => 'Basque',
+      'be'  => 'Belarusian',  'bg'  => 'Bulgarian',       'ca'  => 'Catalan',
+      'hr'  => 'Croatian',    'cs'  => 'Czech',           'et'  => 'Estonian',
+      'da'  => 'Danish',      'nl'  => 'Dutch',           'en'  => 'English',
+      'tl'  => 'Filipino',    'fi'  => 'Finnish',         'fr'  => 'French',
+      'gl'  => 'Galician',    'ht'  => 'Haitian, Creole', 'is'  => 'Icelandic',
+      'ka'  => 'Georgian',    'de'  => 'German',          'el'  => 'Greek',
+      'iw'  => 'Hebrew',      'hi'  => 'Hindi',           'hu'  => 'Hungarian',
+      'id'  => 'Indonesian',  'ga'  => 'Irish',           'it'  => 'Italian',
+      'ko'  => 'Korean',      'la'  => 'Latin',           'lv'  => 'Latvian',
+      'mk'  => 'Macedonian',  'ms'  => 'Malay',           'mt'  => 'Maltese',
+      'fa'  => 'Persian',     'pl'  => 'Polish',          'pt'  => 'Portuguese',
+      'ro'  => 'Romanian',    'sl'  => 'Slovenian',       'th'  => 'Thai',
+      'ja'  => 'Japanese',    'lt'  => 'Lithuanian',      'no'  => 'Norwegian',
+      'vi'  => 'Vietnamese',  'cy'  => 'Welsh',           'yi'  => 'Yiddish',
+      'ru'  => 'Russian',     'sr'  => 'Serbian',         'sk'  => 'Slovak',
+      'es'  => 'Spanish',     'sw'  => 'Swahili',         'sv'  => 'Swedish',
+      'tr'  => 'Turkish',     'uk'  => 'Ukrainian',       'ur'  => 'Urdu',
+      'zh-TW' => 'Chinese, (Traditional)', 'zh-CN' => 'Chinese, (Simplified)' }
+  end
+
+  def define(word, source, target, options = {})
+    fail "Unknown language code '#{source}'" unless langs.include?(source)
+    fail "Unknown language code '#{target}'" unless langs.include?(target)
+
+    if options[:tts]
+      audio_file = StringUtil.tts_file_name(word, source, 'google')
+      get_pronunciation(word, source, audio_file) unless File.exist?(audio_file)
+    end
+
+    json = JSON.parse(get_data(word, source, target, options))
+    render extract_definitions(json)
+  end
+
+  private
+
+  def extract_definitions(json)
+    result = []
+    if json.include?('dict')
+      json['dict'].each do |item|
+        definition = { class: item['pos'], entries: [] }
+        item['entry'].each do |e|
+          data = { word: e['word'], score: (e['score'] || 1e9) }
+          definition[:entries] << data
+        end
+        result << definition
+      end
+    elsif json.include?('sentences')
+      json['sentences'].each do |item|
+        if item.include?('trans')
+          definition = { class: 'translation', entries: [] }
+          definition[:entries] << { word: item['trans'], score: 0 }
+          result << definition
+          break
+        end
+      end
+    end
+    result
+  end
+
+  def render(result)
+    output = ''
+    result.each do |entry|
+      output << "#{entry[:class]}\n#{'-' * entry[:class].length}\n"
+      entry[:entries].sort! { |x, y| x[:score] <=> y[:score] }
+      output << entry[:entries].map { |e| e[:word] }.join(', ') + "\n\n"
+    end
+    output
+  end
+end

data/lib/google.rb

@@ -0,0 +1,31 @@
+# Provides common functionality for both GoogleTranslator and GoogleDictionary
+module Google
+  TEXT_API_URL    = 'http://translate.google.com/translate_a/t'
+  SPEECH_API_URL  = 'http://translate.google.com/translate_tts'
+
+  def get_pronunciation(text, source, audio_file)
+    File.open(audio_file, 'w') do |f|
+      f.write(RestClient.get(SPEECH_API_URL, params: { tl: source, q: text }))
+    end
+  end
+
+  def get_translation(text, source, target)
+    headers = {
+      params: { client: 'p', text: text, sl: source, tl: target },
+      user_agent: 'Mozilla/5.0'
+    }
+    RestClient.get(TEXT_API_URL, headers).to_s.force_encoding(Encoding::UTF_8)
+  end
+
+  def get_data(text, source, target, options = {})
+    return get_translation(text, source, target) unless options[:cache_results]
+
+    data = { text: text, source: source, target: target, service: 'google' }
+    entry = Translation.find_by(data)
+    if entry.nil?
+      data[:response] = get_translation(text, source, target)
+      entry = Translation.create(data)
+    end
+    entry.response
+  end
+end

data/lib/help.rb

@@ -0,0 +1,6 @@
+# Provides help-related methods
+module Help
+  def help
+    File.open(Application.strings_dir + '/help.txt').read
+  end
+end

data/lib/player.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+# Plays an audio file using an external program.
+class Player
+  def self.play(audio_file, player)
+     `#{player} #{audio_file} 2>&1 > /dev/null &`
+  end
+end

data/lib/string_util.rb

@@ -0,0 +1,14 @@
+require 'digest/sha1'
+require_relative 'application'
+
+# String-related helper functions
+class StringUtil
+  def self.tts_file_name(text, target, service)
+    hash = StringUtil.tts_hash(text, target, service)
+    "#{Application.app_dir}/pronunciations/#{hash}.mp3"
+  end
+
+  def self.tts_hash(text, target, service)
+    Digest::SHA1.hexdigest("#{text}_#{target}_#{service}")
+  end
+end

data/lib/tli.rb

@@ -1,7 +1,166 @@
-require_relative 'translators/google_translator.rb'
+# encoding: utf-8
+require 'readline'
+require_relative 'translators/google_translator'
+require_relative 'dictionaries/google_dictionary'
+require_relative 'help'
+require_relative 'translation'
+
+# Command Line Interface for the translator
 class Tli
-  def Tli.translate(text, source, target)
-    translator = GoogleTranslator.new
-    return translator.translate(text, source, target)
+  include Help
+  DEFAULTS = {
+    service: 'google',
+    source: 'en',
+    target: 'es',
+    player: Application.player
+  }
+
+  OPTIONS = {
+    source:         :key_value,
+    target:         :key_value,
+    service:        :key_value,
+    info:           :key_value,
+    player:         :key_value,
+    cache_results:  :flag,
+    play:           :flag,
+    help:           :flag,
+    lts:            :flag
+  }
+
+  SERVICES = {
+    'google' => GoogleTranslator
+  }
+
+  TRANSLATORS = {
+    'google'  => GoogleTranslator.new
+  }
+
+  DICTIONARIES = {
+    'google'  => GoogleDictionary.new
+  }
+
+  attr_reader :stdin, :stdout, :stderr
+
+  def initialize(readline = Readline, stdin = $stdin,
+                 stdout = $stdout, stderr = $stderr)
+    @readline = readline
+    @stdin = stdin
+    @stdout = stdout
+    @stderr = stderr
+  end
+
+  def invoke(args)
+    params = parse_options(args)
+    params = read_config_file(params)
+
+    return stdout.puts help                 if params[:help] == true
+    return stdout.puts list_services        if params[:lts] == true
+    return stdout.puts info(params[:info])  unless params[:info].empty?
+
+    params[:source]  = DEFAULTS[:source]    if params[:source].empty?
+    params[:target]  = DEFAULTS[:target]    if params[:target].empty?
+    params[:service] = DEFAULTS[:service]   if params[:service].empty?
+    params[:player]  = DEFAULTS[:player]    if params[:player].empty?
+
+    if !params[:words].empty?
+      process_input(params)
+    else
+      while buf = @readline.readline('> ', true)
+        params[:words] = buf.split(/\s+/)
+        process_input(params)
+      end
+    end
+  end
+
+  def process_input(params)
+    options = {
+      tts: params[:play] == true,
+      cache_results: params[:cache_results] == true,
+      player: params[:player]
+    }
+    if params[:words].length == 1
+      define(params[:words].join(' '), params[:source],
+             params[:target], params[:service], options)
+    elsif params[:words].length > 1
+      translate(params[:words].join(' '), params[:source],
+                params[:target], params[:service], options)
+    end
+  end
+
+  def translate(text, source, target, service, options = {})
+    result = TRANSLATORS[service].translate(text, source, target, options)
+    if options[:tts] && TRANSLATORS[service].provide_tts?
+      stdout.puts '♬'
+      stdout.puts result
+      audio_file = StringUtil.tts_file_name(text, source, service)
+      Player.play(audio_file, options[:player])
+    else
+      stdout.puts result
+    end
+  end
+
+  def define(word, source, target, service, options = {})
+    result = DICTIONARIES[service].define(word, source, target, options)
+    if options[:tts] && DICTIONARIES[service].provide_tts?
+      stdout.puts '♬'
+      stdout.puts result
+      audio_file = StringUtil.tts_file_name(word, source, service)
+      Player.play(audio_file, options[:player])
+    else
+      stdout.puts result
+    end
+  end
+
+  def parse_options(args)
+    length = args.length
+    params = Hash.new('')
+    params[:words] = []
+    index = 0
+    while index < length
+      arg = args[index]
+      unless arg.start_with?('--')
+        params[:words] << arg
+        index += 1
+        next
+      end
+
+      sym = arg[2..-1].to_sym
+      fail "#{arg}: not a valid option" unless OPTIONS.include?(sym)
+      if OPTIONS[sym] == :key_value
+        fail "#{arg} requires a value" if index + 1 >= length
+        params[sym] = args[index + 1]
+        index += 1
+      else
+        params[sym] = true
+      end
+      index += 1
+    end
+    params
+  end
+
+  def read_config_file(params)
+    if File.exist?(Application.app_dir + '/tli.conf')
+      config = JSON.parse(File.read(Application.app_dir + '/tli.conf'))
+      OPTIONS.each do |key, _|
+        if config['settings'][key.to_s] && params[key].empty?
+          params[key] = config['settings'][key.to_s]
+        end
+      end
+    end
+    params
+  end
+
+  def info(service)
+    SERVICES[service].info
+  end
+
+  def list_services
+    list = "Available translation services\n\n"
+    list += "id\t\tName\n"
+    list += "--\t\t----\n"
+    SERVICES.each do |key, value|
+      list += "#{key}\t\t#{value.name}"
+    end
+    list
   end
 end

data/lib/translation.rb

@@ -0,0 +1,8 @@
+require 'active_record'
+require_relative 'application'
+ActiveRecord::Base .establish_connection(adapter: 'sqlite3',
+                                         database: Application.db_file)
+
+ActiveRecord::Migrator.migrate('db/migrate')
+class Translation < ActiveRecord::Base
+end

data/lib/translators/google_translator.rb

@@ -1,46 +1,74 @@
 require 'rest_client'
 require_relative 'translator'
-require_relative '../text_decoder'
+require_relative '../player'
+require_relative '../string_util'
+require_relative '../google'
 
+# Class for the Google Translate service.
 class GoogleTranslator < Translator
-  API_URL = 'http://translate.google.com/translate_a/t'
-  def get_langs
-    { 'af'    => 'Afrikaans',   'sq'  => 'Albanian',        'ar'  => 'Arabic',
-      'hy'    => 'Armenian',    'az'  => 'Azerbaijani',     'eu'  => 'Basque',
-      'be'    => 'Belarusian',  'bg'  => 'Bulgarian',       'ca'  => 'Catalan',
-      'hr'    => 'Croatian',    'cs'  => 'Czech',           'et'  => 'Estonian',
-      'da'    => 'Danish',      'nl'  => 'Dutch',           'en'  => 'English',
-      'tl'    => 'Filipino',    'fi'  => 'Finnish',         'fr'  => 'French',
-      'gl'    => 'Galician',    'ht'  => 'Haitian, Creole', 'is'  => 'Icelandic',
-      'ka'    => 'Georgian',    'de'  => 'German',          'el'  => 'Greek',
-      'iw'    => 'Hebrew',      'hi'  => 'Hindi',           'hu'  => 'Hungarian',
-      'id'    => 'Indonesian',  'ga'  => 'Irish',           'it'  => 'Italian',
-      'ko'    => 'Korean',      'la'  => 'Latin',           'lv'  => 'Latvian',
-      'mk'    => 'Macedonian',  'ms'  => 'Malay',           'mt'  => 'Maltese',
-      'fa'    => 'Persian',     'pl'  => 'Polish',          'pt'  => 'Portuguese',
-      'ro'    => 'Romanian',    'sl'  => 'Slovenian',       'th'  => 'Thai',
-      'ja'    => 'Japanese',    'lt'  => 'Lithuanian',      'no'  => 'Norwegian',
-      'vi'    => 'Vietnamese',  'cy'  => 'Welsh',           'yi'  => 'Yiddish',
-      'ru'    => 'Russian',     'sr'  => 'Serbian',         'sk'  => 'Slovak',
-      'es'    => 'Spanish',     'sw'  => 'Swahili',         'sv'  => 'Swedish',
-      'tr'    => 'Turkish',     'uk'  => 'Ukrainian',       'ur'  => 'Urdu',
-      'zh-TW' => 'Chinese, (Traditional)','zh-CN'=> 'Chinese, (Simplified)' }
+  include Google
+
+  def self.name
+    'Google Translate'
+  end
+
+  def provide_tts?
+    true
+  end
+
+  def langs
+    { 'af'  => 'Afrikaans',   'sq'  => 'Albanian',        'ar'  => 'Arabic',
+      'hy'  => 'Armenian',    'az'  => 'Azerbaijani',     'eu'  => 'Basque',
+      'be'  => 'Belarusian',  'bg'  => 'Bulgarian',       'ca'  => 'Catalan',
+      'hr'  => 'Croatian',    'cs'  => 'Czech',           'et'  => 'Estonian',
+      'da'  => 'Danish',      'nl'  => 'Dutch',           'en'  => 'English',
+      'tl'  => 'Filipino',    'fi'  => 'Finnish',         'fr'  => 'French',
+      'gl'  => 'Galician',    'ht'  => 'Haitian, Creole', 'is'  => 'Icelandic',
+      'ka'  => 'Georgian',    'de'  => 'German',          'el'  => 'Greek',
+      'iw'  => 'Hebrew',      'hi'  => 'Hindi',           'hu'  => 'Hungarian',
+      'id'  => 'Indonesian',  'ga'  => 'Irish',           'it'  => 'Italian',
+      'ko'  => 'Korean',      'la'  => 'Latin',           'lv'  => 'Latvian',
+      'mk'  => 'Macedonian',  'ms'  => 'Malay',           'mt'  => 'Maltese',
+      'fa'  => 'Persian',     'pl'  => 'Polish',          'pt'  => 'Portuguese',
+      'ro'  => 'Romanian',    'sl'  => 'Slovenian',       'th'  => 'Thai',
+      'ja'  => 'Japanese',    'lt'  => 'Lithuanian',      'no'  => 'Norwegian',
+      'vi'  => 'Vietnamese',  'cy'  => 'Welsh',           'yi'  => 'Yiddish',
+      'ru'  => 'Russian',     'sr'  => 'Serbian',         'sk'  => 'Slovak',
+      'es'  => 'Spanish',     'sw'  => 'Swahili',         'sv'  => 'Swedish',
+      'tr'  => 'Turkish',     'uk'  => 'Ukrainian',       'ur'  => 'Urdu',
+      'zh-TW' => 'Chinese, (Traditional)', 'zh-CN' => 'Chinese, (Simplified)' }
   end
 
-  def translate(text, source, target)
-    raise "Unknown language code '#{source}'" if !get_langs.include?(source)
-    raise "Unknown language code '#{target}'" if !get_langs.include?(target)
-    response = RestClient.get(API_URL, params: {client: 'p', text: text, sl: source, tl: target})
-    json = JSON.parse(TextDecoder.decode(response.to_s, target))
+  def translate(text, source, target, options = {})
+    fail "Unknown language code '#{source}'" unless langs.include?(source)
+    fail "Unknown language code '#{target}'" unless langs.include?(target)
+
+    if options[:tts]
+      audio_file = StringUtil.tts_file_name(text, source, 'google')
+      unless File.exist?(audio_file)
+        get_pronunciation(text, source, audio_file)
+      end
+    end
+    json = JSON.parse(get_data(text, source, target, options))
+    extract_translation(json)
+  end
+
+  def self.info
+    File.open(Application.strings_dir + '/google_info.txt').read
+  end
+
+  private
+
+  def extract_translation(json)
     translation = ''
-    json['sentences'].each do |entry|
-      if entry.include?('trans')
-        translation = entry['trans']
-        break
+    if json.include?('sentences')
+      json['sentences'].each do |entry|
+        if entry.include?('trans')
+          translation = entry['trans']
+          break
+        end
       end
     end
     translation
   end
 end
-
-

data/lib/translators/translator.rb

@@ -1,4 +1,12 @@
+# Base class for translators
 class Translator
-  def translate(text, source, target); end
-  def get_langs; end
+  def translate(text, source, target, options = {}); end
+
+  def langs; end
+
+  def provide_tts?; end
+
+  def info; end
+
+  def self.name; end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tli
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Rafael Rendón Pablo
@@ -10,8 +10,10 @@ bindir: bin
 cert_chain: []
 date: 2015-02-19 00:00:00.000000000 Z
 dependencies: []
-description: With tli you can translate text and find definitions using services like
-  Google Translate, Yandex Translate, Oxford dictionaries, etc. All in one.
+description: |-
+  With tli you can translate text and find definitions using\
+                       services like Google Translate, Yandex, Cambridge \
+                       dictionaries, etc. All in one.
 email: rafaelrendonpablo@gmail.com
 executables:
 - tli
@@ -19,8 +21,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/tli
-- lib/text_decoder.rb
+- lib/application.rb
+- lib/config.rb
+- lib/dictionaries/dictionary.rb
+- lib/dictionaries/google_dictionary.rb
+- lib/google.rb
+- lib/help.rb
+- lib/player.rb
+- lib/string_util.rb
 - lib/tli.rb
+- lib/translation.rb
 - lib/translators/google_translator.rb
 - lib/translators/translator.rb
 homepage: https://github.com/rendon/tli
@@ -46,6 +56,6 @@ rubyforge_project:
 rubygems_version: 2.4.3
 signing_key: 
 specification_version: 4
-summary: TransLate It! A command line tool to translate text from (and to) almost
+summary: TransLate It! A command line tool to translate text from \ (and to) almost
   any language.
 test_files: []

data/lib/text_decoder.rb

@@ -1,12 +0,0 @@
-class TextDecoder
-  def self.decode(text, lang_code)
-    result = ''
-    case lang_code
-    when 'en', 'es', 'fr'
-      result = text.force_encoding('ISO-8859-1').encode('UTF-8')
-    when 'ru'
-      result = text.force_encoding('Windows-1251').encode('UTF-8')
-    end
-    result
-  end
-end