smartdict-core 0.0.2 → 0.1.0

data/README.markdown

@@ -1,6 +1,9 @@
-# Smartdict
+# smartdict-core [![Build Status](https://secure.travis-ci.org/smartdict/smartdict-core.png)](http://travis-ci.org/smartdict/smartdict-core)
 
-Simple dictionary.
+By [Sergey Potapov](https://github.com/greyblake)
+
+
+Core of [Smartdict dictionary](https://github.com/smartdict/smartdict).
 
 ## Installation
 

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.1.0

data/bin/smartdict

@@ -4,17 +4,13 @@ $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'rubygems'
 
 require 'smartdict'
-require 'smartdict/runner'
 
-# TODO: remove before release
-# require 'pry'
-
-Smartdict.env = :user
+env = ENV["SMARTDICT_ENV"] ? ENV["SMARTDICT_ENV"].to_sym : :user
+Smartdict.env = env
 
 args = ARGV.clone
 
 Smartdict.load_plugins
 
-# TODO :move Smartdict.run to Runner.run
 Smartdict.run
-Smartdict::Runner.run(args)
+Smartdict::Core::CommandManager.run(args)

data/bin/smartdict-populator

@@ -15,11 +15,14 @@ Smartdict.load_plugins
 # TODO :mode Smartdict.run to Runner.run
 Smartdict.run
 
+$translator = Smartdict::Translator.new
 
 
 def translate(word)
-  Smartdict::Translator.translate(word)
+  $translator.translate(word, :log => true)
 rescue Smartdict::TranslationNotFound
+rescue NoMethodError => err
+  puts "Trouble word: #{word}"
 end
 
 def translate_words(words, from_lang, to_lang)
@@ -37,8 +40,8 @@ to_lang   = Smartdict::Models::Language.first(:code => 'ru')
 
 
 while(true)
-  Smartdict::Translator.from_lang_code = from_lang.code
-  Smartdict::Translator.to_lang_code = to_lang.code
+  $translator.default_opts[:from_lang] = from_lang.code
+  $translator.default_opts[:to_lang] = to_lang.code
 
   words = Smartdict::Models::Word.all(:language_id => from_lang.id).map(&:name)
   translate_words(words, from_lang, to_lang)

data/config/default_config.yml

@@ -13,3 +13,7 @@ default:
     - de
     - es
     - fr
+
+drivers:
+  default: google_translate
+  en-ru: lingvo_yandex

data/lib/smartdict/commands/list_command.rb

@@ -24,14 +24,14 @@ module Smartdict::Commands
             :driver => nil
 
     def execute
-      list_opts = {
+      fetch_opts = {
         :since     => @options[:since],
         :till      => @options[:till],
         :from_lang => @options[:from],
         :to_lang   => @options[:to],
         :driver    => @options[:driver]
       }
-      translations = Smartdict::ListBuilder.build(list_opts)
+      translations = Smartdict::Log.fetch(fetch_opts)
       puts format.format_list(translations)
     end
 

data/lib/smartdict/commands/translate_command.rb

@@ -16,12 +16,19 @@ module Smartdict::Commands
 
     options :from   => lambda { configatron.default.from_lang },
             :to     => lambda { configatron.default.to_lang },
-            :format => lambda { configatron.default.format }
+            :format => lambda { configatron.default.format },
+            :driver => nil
 
     def execute
-      Smartdict::Translator.from_lang_code = @options[:from]
-      Smartdict::Translator.to_lang_code   = @options[:to]
-      translation = Smartdict::Translator.translate(@arguments[:word])
+      translator_opts = {
+        :from_lang => @options[:from],
+        :to_lang   => @options[:to],
+        :log       => true
+      }
+      translator_opts[:driver] = @options[:driver] if @options[:driver]
+
+      translator = Smartdict::Translator.new(translator_opts)
+      translation = translator.translate(@arguments[:word])
       puts format.format_translation(translation)
     end
 

data/lib/smartdict/commands/version_command.rb

@@ -0,0 +1,29 @@
+module Smartdict::Commands
+  # Displays information about the program.
+  # It's executed when user runs one of:
+  # * smartdict -v
+  # * smartdict --version
+  # * smartdict version
+  class VersionCommand < AbstractCommand
+    include Smartdict::Core
+
+    set_name        "version"
+    set_summary     "Displays information about Smartdict"
+    set_description "Displays information about Smartdict"
+    set_syntax       prog_name
+
+    set_usage <<-SYNTAX
+      smartdict --version
+      smartdict -v
+      #{prog_name}
+    SYNTAX
+
+    # :nodoc:
+    def execute
+      info = Smartdict.info
+      puts "Smartdict core v#{info.version}\n" \
+           "Author: #{info.author} (#{info.email})\n" \
+           "URL: #{info.url}"
+    end
+  end
+end

data/lib/smartdict/commands.rb

@@ -3,6 +3,7 @@ module Smartdict::Commands
 
   autoload :AbstractCommand
   autoload :HelpCommand
+  autoload :VersionCommand
   autoload :TranslateCommand
   autoload :ListCommand
 

data/lib/smartdict/core/command_manager.rb

@@ -3,6 +3,7 @@ class Smartdict::Core::CommandManager
   include Smartdict::Commands
 
   register 'help'     , HelpCommand
+  register 'version'  , VersionCommand
   register 'translate', TranslateCommand
   register 'list'     , ListCommand
 
@@ -12,6 +13,8 @@ class Smartdict::Core::CommandManager
     case first_arg
     when nil, '-h', '--help', 'help'
       run_command :help, args
+    when nil, '-v', '--version', 'version'
+      run_command :version, args
     else
       run_command(first_arg, args)
     end

data/lib/smartdict/core/driver_manager.rb

@@ -6,4 +6,5 @@ class Smartdict::Core::DriverManager
   include Smartdict::Drivers
 
   register 'google_translate', GoogleTranslateDriver
+  register 'lingvo_yandex'   , LingvoYandexDriver
 end

data/lib/smartdict/drivers/abstract_driver.rb

@@ -27,7 +27,7 @@ class Smartdict::Drivers::AbstractDriver
   attr_accessor :translated, :transcription
 
   # Is used to identify a driver
-  cattr_accessor :name
+  class_attribute :name
 
   def self.translate(*args)
     self.new(*args).build_translation
@@ -40,9 +40,10 @@ class Smartdict::Drivers::AbstractDriver
 
   def initialize(word, from_lang, to_lang)
     @word      = word
-    @from_lang = from_lang
-    @to_lang   = to_lang
+    @from_lang = from_lang.to_s
+    @to_lang   = to_lang.to_s
     translate
+    raise Smartdict::TranslationNotFound if(translated.nil? || translated.empty?)
   end
 
   def build_translation

data/lib/smartdict/drivers/lingvo_yandex_driver.rb

@@ -0,0 +1,146 @@
+# encoding: utf-8
+
+require 'cgi'
+require 'nokogiri'
+
+module Smartdict::Drivers
+  # The translation driver for Google Translate service.
+  #
+  # DISCLAIMER:
+  # It's was written when I had one hand broken. Refactoring costs a lot of
+  # movements so that I've left it as it was. I'm gonna refactor it soon.
+  # -- Sergey Potapov
+  #
+  # TODO:
+  #   * Refactor
+  class LingvoYandexDriver < AbstractDriver
+
+    # Pretend being Firefox :)
+    USER_AGENT = "Mozilla/5.0 (X11; U; Linux x86_64; ru; rv:1.9.1.16) Gecko/20110429 Iceweasel/3.5.16 (like Firefox/3.5.1623123)"
+
+    # Host of Lingvo service.
+    HOST = "lingvo.yandex.ru"
+
+    # Mapping for word classes. Default is "other"
+    WORD_CLASSES = {
+      "имя существительное"     => "noun",
+      "имя прилагательное"      => "adjective",
+      "глагол"                  => "verb",
+      "наречие"                 => "adverb",
+      "предлог"                 => "preposition",
+      "имя числительное"        => "numeral",
+      "междометие (часть речи)" => "interjection",
+      "сокращение"              => "abbreviation",
+      "местоимение"             => "pronoun",
+      "союз (часть речи)"       => "conjunction"
+    }.tap{ |hash| hash.default = "other" }
+
+    set_name "lingvo_yandex"
+
+
+
+    # TODO: refactor
+    def translate
+      doc = Nokogiri::HTML(get_response)
+
+      if main_div = doc.css("div.b-translate > div.b-translate__value > ul > li#I").first
+        translate__value = main_div
+      else
+        main_div = doc.css("div.b-translate").first
+        translate__value = main_div.css("div.b-translate__value")
+      end
+
+      # Fetch transcription
+      self.transcription = main_div.xpath('(.//span[@class="b-translate__tr"])[1]').try(:text)
+
+      self.translated = {}
+
+      if translate__value.xpath("./i/acronym").any?
+        grep_meanings(translate__value)
+      else
+        translate__value.xpath("./ul/li").each do |li|
+          grep_meanings(li)
+        end
+      end
+    end
+
+    # TODO: refactor
+    def grep_meanings(html_element)
+      acronym = html_element.css("acronym").first
+      return unless acronym
+
+      ru_word_class = acronym["title"]
+      word_class = WORD_CLASSES[ru_word_class]
+      translations = []
+
+      html_element.css("ul > li").each do |tr|
+        # a text line with translations separated by commas
+        line = ""
+
+        # use strong tag as an anchor
+        strong = tr.css("strong").first
+        if strong && strong.text =~ /\d+|[а-я]+\)/
+          node = strong
+          while(node = node.next_sibling)
+            if node.text? || node.name == "a"
+              text = node.text
+              line << text unless text =~ /\(|\)/
+            elsif ["em", "acronym"].include? node.name
+              next
+            else
+              break
+            end
+          end
+        end
+        translations += words_from_line(line)
+      end
+
+
+      # sometimes there is only one meaning
+      if translations.empty?
+        if a_tag = html_element.css("span > a").first
+          line = a_tag.text
+        elsif span = html_element.css("span").first
+          line = span.text
+        elsif i_tag = html_element.xpath("i[2]")
+          line = i_tag.text
+        else
+          return nil
+        end
+        translations = words_from_line(line)
+      end
+
+      self.translated[word_class] = translations.uniq
+    end
+
+    def get_response
+      http = Net::HTTP.new(HOST, 80)
+      request = Net::HTTP::Get.new(http_path, { "User-Agent" => USER_AGENT })
+      http.request(request).read_body
+    end
+
+    # @return [String] http path for request to translate word.
+    def http_path
+      phrase = case [from_lang, to_lang]
+      when ["en", "ru"] then "с английского"
+      # ru -> en does not seem to be good and it's not trivial to parse
+      # when ["ru", "en"] then "по-английски"
+      else raise Smartdict::TranslationNotFound
+      end
+
+      "/#{escape(word)}/#{escape(phrase)}/"
+    end
+
+    def escape(str)
+      CGI.escape(str)
+    end
+
+
+    private
+
+    def words_from_line(line)
+      line.split(/,|;/).map(&:strip).reject(&:empty?)
+    end
+
+  end
+end

data/lib/smartdict/drivers.rb

@@ -3,4 +3,5 @@ module Smartdict::Drivers
 
   autoload :AbstractDriver
   autoload :GoogleTranslateDriver
+  autoload :LingvoYandexDriver
 end

data/lib/smartdict/errors.rb

@@ -1,6 +1,7 @@
 module Smartdict
 
-  class Error < ::Exception; end
+  class Error < ::StandardError; end
+
 
   class TranslationNotFound < Error
     def initialize(msg = "Translation is not found")
@@ -8,4 +9,15 @@ module Smartdict
     end
   end
 
+
+  class MissingOption < Error
+    def initialize(option)
+      @option = option
+    end
+
+    def message
+      "Translator option is missing: `#{@option}`"
+    end
+  end
+
 end

data/lib/smartdict/info.rb

@@ -0,0 +1,14 @@
+require 'singleton'
+
+module Smartdict
+  class Info < Struct.new(:version, :author, :email, :url)
+    include Singleton
+
+    def initialize
+      self.version = Smartdict::VERSION
+      self.author  = "Sergey Potapov"
+      self.email   = "open.smartdict@gmail.com"
+      self.url     = "http://smartdict.net"
+    end
+  end
+end

data/lib/smartdict/log.rb

@@ -0,0 +1,108 @@
+class Smartdict::Log
+  include Smartdict::Models
+
+  # Options:
+  # * +:since+
+  # * +:till+
+  # * +:from_lang+
+  # * +:to_lang+
+  # * +:driver+
+  # * +:limit+
+  # * +:order_desc+
+  # * +:unique+
+  #
+  # @return [Array] array of {Smartdict::Translation}.
+  def self.fetch(options = {})
+    new(options).send(:fetch)
+  end
+
+
+  private
+
+  def initialize(options)
+    @options = options
+  end
+
+  def fetch
+    fetch_translations.map(&:to_struct)
+  end
+
+
+
+  # Unfortunately it's not possible to build necessary query with DataMapper
+  # TODO: Refactor in QueryBuilder class.
+  def fetch_translations
+    adapter = Translation.repository.adapter
+
+    translations_table = Translation.storage_name
+    queries_table = TranslationQuery.storage_name
+
+    sql = "SELECT #{'DISTINCT' if @options[:unique]} #{translations_table}.id \n" \
+          "FROM #{translations_table} \n" \
+          "INNER JOIN #{queries_table} ON \n" \
+          "  #{queries_table}.translation_id == #{translations_table}.id"
+
+    if [:till, :since, :from_lang, :to_lang, :driver].any? {|opt| @options[opt] }
+      sql << " WHERE "
+
+      if @options[:till]
+        till = @options[:till].is_a?(String) ? Date.parse(@options[:till]) : @options[:till]
+        sql << " #{queries_table}.created_at < \"#{till.to_s(:db)}\" "
+        where = true
+      end
+
+      if @options[:since]
+        sql << " AND " if where
+        since = @options[:since].is_a?(String) ? Date.parse(@options[:since]) : @options[:since]
+        sql << " #{queries_table}.created_at >  \"#{since.to_s(:db)}\" "
+        where = true
+      end
+
+      if from_lang
+        sql << " AND " if where
+        sql << " #{translations_table}.from_lang_id = #{from_lang.id} "
+        where = true
+      end
+
+      if to_lang
+        sql << " AND " if where
+        sql << " #{translations_table}.to_lang_id = #{to_lang.id} "
+        where = true
+      end
+
+      if driver
+        sql << " AND " if where
+        sql << " #{translations_table}.driver_id = #{driver.id} "
+        where = true
+      end
+    end
+
+    if @options[:order_desc]
+      sql << " ORDER BY #{queries_table}.created_at DESC "
+    else
+      sql << " ORDER BY #{queries_table}.created_at "
+    end
+
+    if @options[:limit]
+      sql << " LIMIT #{@options[:limit]} "
+    end
+
+    ids = adapter.select(sql)
+    trs = Translation.all(:id => ids)
+    # Sort manually, since database doesn't guaranty required order
+    trs.sort! { |a, b| ids.index(a.id) <=> ids.index(b.id) }
+  end
+
+  def from_lang
+    Language[@options[:from_lang]]
+  end
+
+  def to_lang
+    Language[@options[:to_lang]]
+  end
+
+  def driver
+    Driver[@options[:driver]]
+  end
+
+end

data/lib/smartdict/models/translation.rb

@@ -2,11 +2,12 @@ class Smartdict::Models::Translation
   include DataMapper::Resource
   include Smartdict::Models
 
-  property :id          , Serial
-  property :word_id     , Integer, :unique_index => :index_translation
-  property :from_lang_id, Integer, :unique_index => :index_translation
-  property :to_lang_id  , Integer, :unique_index => :index_translation
-  property :driver_id   , Integer, :unique_index => :index_translation
+  property :id           , Serial
+  property :word_id      , Integer, :unique_index => :index_translation
+  property :from_lang_id , Integer, :unique_index => :index_translation
+  property :to_lang_id   , Integer, :unique_index => :index_translation
+  property :driver_id    , Integer, :unique_index => :index_translation
+  property :transcription, String
 
   belongs_to :word
   belongs_to :driver
@@ -28,14 +29,14 @@ class Smartdict::Models::Translation
     driver    = Driver[struct.driver]
 
     word = Word.first_or_create(:name => struct.word, :language_id => from_lang.id)
-    word.transcription = struct.transcription if word.transcription.blank?
     word.save!
 
     translation = self.create(
-      :word      => word,
-      :driver    => driver,
-      :from_lang_id => from_lang.id,
-      :to_lang_id   => to_lang.id
+      :word          => word,
+      :driver        => driver,
+      :from_lang_id  => from_lang.id,
+      :to_lang_id    => to_lang.id,
+      :transcription => struct.transcription
     )
 
     struct.translated.each do |word_class_name, meanings|
@@ -59,7 +60,7 @@ class Smartdict::Models::Translation
   end
 
 
-  # TODO: it's a hack. Remove.
+  # TODO: it's a hack which necessary because of weird DM bugs.
   def initialize(*args)
     self.class.finalize
     self.word_class_id = 1
@@ -69,7 +70,7 @@ class Smartdict::Models::Translation
   def to_struct
     struct = Smartdict::Translation.new(
       :word          => word.name,
-      :transcription => word.transcription,
+      :transcription => self.transcription,
       :from_lang     => from_lang.code,
       :to_lang       => to_lang.code,
       :driver        => driver.name

data/lib/smartdict/models/word.rb

@@ -4,7 +4,6 @@ class Smartdict::Models::Word
   property :id           , Serial
   property :name         , String, :unique_index => :index_word
   property :language_id  , Integer, :unique_index => :index_word
-  property :transcription, String
 
   belongs_to :language
   has n, :translations

data/lib/smartdict/storage/seeder.rb

@@ -19,8 +19,11 @@ module Smartdict::Storage::Seeder
 
   def seed_from(csv_file)
     model = csv_file_to_model(csv_file)
-    CSV.read(csv_file, :headers => true).each do |row|
-      model.create(row.to_hash)
+    csv = CSV.open(csv_file, 'r')
+    headers = csv.shift
+    while(row = csv.shift and not row.empty?)
+      attrs = Hash[headers.zip(row)]
+      model.create(attrs)
     end
   end
 
@@ -29,4 +32,4 @@ module Smartdict::Storage::Seeder
     model_name = plural_name.classify
     Smartdict::Models.const_get(model_name)
   end
-end
+end

data/lib/smartdict/storage/seeds/drivers.csv

@@ -1,2 +1,3 @@
 id,name
 1,google_translate
+2,lingvo_yandex

data/lib/smartdict/storage/seeds/word_classes.csv

@@ -7,4 +7,6 @@ id,name
 6,numeral
 7,interjection
 8,abbreviation
-9,other
+9,pronoun
+10,conjunction
+11,other

data/lib/smartdict/translator/base.rb

@@ -0,0 +1,35 @@
+# The very basic translator middleware.
+module Smartdict
+  class Translator::Base
+    # Just to make the interface compatible
+    def initialize(translator = nil)
+    end
+
+    def call(word, opts)
+      validate_opts!(opts)
+      driver = Smartdict::Core::DriverManager.find(opts[:driver])
+
+      translation_model = Models::Translation.find(word, opts[:from_lang], opts[:to_lang], opts[:driver])
+      unless translation_model
+        translation = driver.translate(word, opts[:from_lang], opts[:to_lang])
+        translation_model = Models::Translation.create_from_struct(translation)
+      end
+      log_query(translation_model) if opts[:log]
+      translation_model.to_struct
+    end
+
+
+    private
+
+    def validate_opts!(opts)
+      required_opts = [:from_lang, :to_lang, :driver, :log]
+      required_opts.each do |opt|
+        raise(MissingOption.new(opt)) if opts[opt].nil?
+      end
+    end
+
+    def log_query(translation)
+      Models::TranslationQuery.create(:translation => translation)
+    end
+  end
+end

data/lib/smartdict/translator/driver_configuration.rb

@@ -0,0 +1,19 @@
+# Middleware
+class Smartdict::Translator::DriverConfiguration
+  def initialize(translator)
+    @translator = translator
+  end
+
+  def call(word, opts)
+    unless opts[:driver]
+      opts[:driver] = define_driver(opts[:from_lang], opts[:to_lang])
+    end
+    @translator.call(word, opts)
+  end
+
+  def define_driver(from_lang, to_lang)
+    key = "#{from_lang}-#{to_lang}"
+    conf = configatron.drivers
+    conf.retrieve(key) || conf.retrieve(:default) || raise(Smartdict::Error.new("No default driver"))
+  end
+end

data/lib/smartdict/translator/language_detector.rb

@@ -0,0 +1,72 @@
+#encoding: utf-8
+
+# It's a translator middleware which tries to identify a language of the
+# passed word basing on :from_lang and :to_lang options. If it's possible to
+# explicitly identify a language and :from_lang and :to_lang options are
+# required to be exchanged it exchanges them.
+#
+# Example:
+#   detector = LanguageDetector.new(translator)
+#   detector.call("groß", :from_lang => :en, :to_lang => :de)
+#   # It delegates call to translator like this:
+#   #   translator.call("groß", :from_lang => :de, :to_lang => :en)
+#   # Because in English there is no character "ß" but it exists in German.
+#
+# NOTE: It doesn't support Ruby 1.8
+class Smartdict::Translator::LanguageDetector
+
+  CHARS = {
+    :ru => %w(А а Б б В в Г г Д д Е е Ё ё Ж ж З з И и Й й К к Л л М м Н н О о П п Р р С с Т т У у Ф ф Х х Ц ц Ч ч Ш ш Щ щ Ъ ъ Ы ы Ь ь Э э Ю ю Я я),
+    :en => %w(a A b B c C d D e E f F g G h H i I j J k K l L m M n N o O p P q Q r R s S t T u U v V w W x X y Y z Z),
+    :uk => %w(А а Б б В в Г г Ґ ґ Д д Е е Є є Ж ж З з И и І і Ї ї Й й К к Л л М м Н н О о П п Р р С с Т т У у Ф ф Х х Ц ц Ч ч Ш ш Щ щ Ь ь Ю ю Я я '),
+    :de => %w(a A b B c C d D e E f F g G h H i I j J k K l L m M n N o O p P q Q r R s S t T u U v V w W x X y Y z Z Ä ä Ö ö Ü ü ß),
+
+    # TODO: Add vowels with stresses
+    :es => %w(A a B b С с D d E e F f G g H h I i J j K k L l M m N n Ň ñ O o P p Q q R r S s T t U u V v W w X x Y y Z z)
+  }
+
+  def initialize(translator)
+    @translator = translator
+
+    @matchers = {}
+    CHARS.each do |lang, chars|
+      @matchers[lang] = Matcher.new(chars)
+    end
+  end
+
+  def call(word, opts)
+    if exchange?(word, opts[:from_lang], opts[:to_lang]) && !ruby18?
+      opts[:to_lang], opts[:from_lang] = opts[:from_lang], opts[:to_lang]
+    end
+    @translator.call(word, opts)
+  end
+
+
+  private
+
+  def exchange?(word, from_lang, to_lang)
+    from_matcher = @matchers[from_lang.to_sym]
+    to_matcher   = @matchers[to_lang.to_sym]
+    return false unless [from_matcher, to_matcher].all?
+    to_matcher.match?(word) && !from_matcher.match?(word)
+  end
+
+  def ruby18?
+    RUBY_VERSION =~ /^1\.8/
+  end
+
+
+
+  class Matcher
+    def initialize(chars)
+      @chars = chars + [" ", "-"]
+    end
+
+    def match?(word)
+      word.each_char do |char|
+        return false unless @chars.include? char
+      end
+      true
+    end
+  end
+end

data/lib/smartdict/translator.rb

@@ -1,38 +1,33 @@
 module Smartdict
   class Translator
+    extend ActiveSupport::Autoload
 
-    class_attribute :driver_name
-    self.driver_name = :google_translate
+    autoload :Base
+    autoload :DriverConfiguration
+    autoload :LanguageDetector
 
-    class_attribute :from_lang_code
-    self.from_lang_code = :en
+    attr_reader :default_opts
 
-    class_attribute :to_lang_code
-    self.to_lang_code = :ru
-
-    class_attribute :log_queries
-    self.log_queries = true
-
-
-    def self.translate(word)
-      unless translation_model = Models::Translation.find(word, from_lang_code, to_lang_code, driver_name)
-        translation = driver.translate(word, from_lang_code, to_lang_code)
-        translation_model = Models::Translation.create_from_struct(translation)
-      end
-      log_query(translation_model) if log_queries
-      translation_model.to_struct
+    def initialize(default_opts = {})
+      @default_opts = default_opts
+      @middleware_classes = [Base, DriverConfiguration, LanguageDetector]
+      @middleware = build_middleware
     end
 
-    def self.log_query(translation)
-      Models::TranslationQuery.create(:translation => translation)
+    def translate(word, opts = {})
+      opts.reverse_merge!(default_opts)
+      @middleware.last.call(word, opts)
     end
 
 
     private
 
-    def self.driver
-      Smartdict::Core::DriverManager.find(driver_name)
+    def build_middleware
+      hooks = []
+      @middleware_classes.each do |klass|
+        hooks << klass.new(hooks.last)
+      end
+      hooks
     end
-
   end
 end

data/lib/smartdict.rb

@@ -33,7 +33,8 @@ module Smartdict
   autoload :Translator
   autoload :Formats
   autoload :Translation
-  autoload :ListBuilder
+  autoload :Log
+  autoload :Info
 
   include Smartdict::Core
 
@@ -94,4 +95,8 @@ module Smartdict
   def plugins_dir
     ENV['SMARTDICT_PLUGINS_DIR'] or File.join(root_dir, 'plugins')
   end
+
+  def info
+    Info.instance
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: smartdict-core
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-09 00:00:00.000000000 Z
+date: 2012-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dm-core
@@ -139,6 +139,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -388,7 +404,6 @@ extensions: []
 extra_rdoc_files:
 - README.markdown
 files:
-- ./bin/smartdict
 - ./lib/smartdict-core.rb
 - ./lib/smartdict.rb
 - ./lib/smartdict/commands.rb
@@ -397,6 +412,7 @@ files:
 - ./lib/smartdict/commands/help_command.rb
 - ./lib/smartdict/commands/list_command.rb
 - ./lib/smartdict/commands/translate_command.rb
+- ./lib/smartdict/commands/version_command.rb
 - ./lib/smartdict/core.rb
 - ./lib/smartdict/core/command_manager.rb
 - ./lib/smartdict/core/driver_manager.rb
@@ -408,13 +424,15 @@ files:
 - ./lib/smartdict/drivers.rb
 - ./lib/smartdict/drivers/abstract_driver.rb
 - ./lib/smartdict/drivers/google_translate_driver.rb
+- ./lib/smartdict/drivers/lingvo_yandex_driver.rb
 - ./lib/smartdict/errors.rb
 - ./lib/smartdict/formats.rb
 - ./lib/smartdict/formats/abstract_format.rb
 - ./lib/smartdict/formats/fb2_format.rb
 - ./lib/smartdict/formats/text_color_format.rb
 - ./lib/smartdict/formats/text_format.rb
-- ./lib/smartdict/list_builder.rb
+- ./lib/smartdict/info.rb
+- ./lib/smartdict/log.rb
 - ./lib/smartdict/models.rb
 - ./lib/smartdict/models/driver.rb
 - ./lib/smartdict/models/language.rb
@@ -425,7 +443,6 @@ files:
 - ./lib/smartdict/models/word_class.rb
 - ./lib/smartdict/plugin.rb
 - ./lib/smartdict/plugin/initializer_context.rb
-- ./lib/smartdict/runner.rb
 - ./lib/smartdict/storage.rb
 - ./lib/smartdict/storage/seeder.rb
 - ./lib/smartdict/storage/seeds/drivers.csv
@@ -433,13 +450,15 @@ files:
 - ./lib/smartdict/storage/seeds/word_classes.csv
 - ./lib/smartdict/translation.rb
 - ./lib/smartdict/translator.rb
+- ./lib/smartdict/translator/base.rb
+- ./lib/smartdict/translator/driver_configuration.rb
+- ./lib/smartdict/translator/language_detector.rb
 - ./lib/smartdict/version.rb
 - GPL-LICENSE.txt
 - VERSION
+- bin/smartdict
 - config/default_config.yml
 - README.markdown
-- !binary |-
-  YmluL3NtYXJ0ZGljdA==
 - !binary |-
   YmluL3NtYXJ0ZGljdC1wb3B1bGF0b3I=
 homepage: http://github.com/smartdict/smartdict-core
@@ -463,7 +482,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: CLI dictionary

data/lib/smartdict/list_builder.rb

@@ -1,51 +0,0 @@
-# TODO: tests
-
-class Smartdict::ListBuilder
-  include Smartdict::Models
-
-  # Options:
-  # * +:since+
-  # * +:till+
-  # * +:from_lang+
-  # * +:to_lang+
-  # * +:driver+
-  #
-  # @return [Array] array of {Smartdict::Translation}.
-  def self.build(options = {})
-    new(options).send(:build)
-  end
-
-
-  private
-
-  def initialize(options)
-    @options = options
-    @options[:till] ||= Time.now
-  end
-
-  def build
-    fetch_translations.map(&:to_struct)
-  end
-
-  def fetch_translations
-    query = Translation.all(Translation.translation_queries.created_at.lte => @options[:till])
-    query = query.all(Translation.translation_queries.created_at.gte => @options[:since]) if @options[:since]
-    query = query.all(Translation.to_lang_id   => to_lang.id)   if to_lang
-    query = query.all(Translation.from_lang_id => from_lang.id) if from_lang
-    query = query.all(Translation.driver_id    => driver.id)    if driver
-    query
-  end
-
-  def from_lang
-    Language[@options[:from_lang]]
-  end
-
-  def to_lang
-    Language[@options[:to_lang]]
-  end
-
-  def driver
-    Driver[@options[:driver]]
-  end
-
-end

data/lib/smartdict/runner.rb

@@ -1,5 +0,0 @@
-class Smartdict::Runner
-  def self.run(args)
-    Smartdict::Core::CommandManager.run(args)
-  end
-end