smartdict-core 0.0.1

data/lib/smartdict/core.rb

@@ -0,0 +1,12 @@
+module Smartdict::Core
+  extend ActiveSupport::Autoload
+
+  autoload :HasLogger
+  autoload :Logger
+  autoload :IsManager
+
+  autoload :PluginManager
+  autoload :CommandManager
+  autoload :DriverManager
+  autoload :FormatManager
+end

data/lib/smartdict/drivers/abstract_driver.rb

@@ -0,0 +1,61 @@
+# Translation driver provides an ability to translate words using external
+# data sources. It can be data from local disk, database or remote services
+# like Google Translate.
+# Every driver must inherit {Smartdict::Driver} and have implementation of
+# {#translate} method. This method should sets translated and transcription
+# properties. For examples you can see #{Smartdict::Driver::GoogleTranslateDriver}.
+#
+# In your implementation of {#translate} you need to use methods:
+# * word - returns a word what needs to be translated.
+# * from_lang - code of source language("en", "ru", etc)
+# * to_lang - code of target language("en, "ru, etc)
+#
+# Usage:
+#   class HelloWorldDriver < Smartdict::Driver
+#     # Set name of driver, so DriverManager can identify it.
+#     name "hello_world"
+#
+#     # This trivial example will always return the same translation.
+#     def translate
+#       self.translated = {"noun" => ["hello", "hi"], "verb" => ["greet"]}
+#       self.transcription = "he'leu"
+#     end
+#   end
+class Smartdict::Drivers::AbstractDriver
+
+  attr_reader :word, :from_lang, :to_lang
+  attr_accessor :translated, :transcription
+
+  # Is used to identify a driver
+  cattr_accessor :name
+
+  def self.translate(*args)
+    self.new(*args).build_translation
+  end
+
+  # Sets driver name
+  def self.set_name(name)
+    self.name = name.to_s
+  end
+
+  def initialize(word, from_lang, to_lang)
+    @word      = word
+    @from_lang = from_lang
+    @to_lang   = to_lang
+    translate
+  end
+
+  def build_translation
+    translation = Smartdict::Translation.new(
+      :word          => word,
+      :from_lang     => from_lang.to_s,
+      :to_lang       => to_lang.to_s,
+      :transcription => transcription,
+      :driver        => self.name
+    )
+    translated.each do |word_class, words|
+      translation.translated[word_class] = words
+    end
+    translation
+  end
+end

data/lib/smartdict/drivers/google_translate_driver.rb

@@ -0,0 +1,56 @@
+module Smartdict::Drivers
+  # The translation driver for Google Translate service.
+  class GoogleTranslateDriver < 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 Google Translate service.
+    HOST = "translate.google.com"
+
+    set_name "google_translate"
+
+    # Sets translation and transcription. GoogleTranslate doesn't provide
+    # transcription, so it's nil.
+    def translate
+      self.translated = response_to_hash(get_response)
+      self.transcription = nil
+    end
+
+
+    private
+
+    # Parses string return by GoogleTranslate
+    # Returns hash similar to this:
+    #   { "noun" => ["try", "attempt"],
+    #     "verb" => ["try", "offer"] }
+    # If no translation was found than returns nil.
+    # @return [Hash] every key is word class and every value is array of translated words.
+    def response_to_hash(response)
+      result = {}
+      array = YAML.load(response.gsub(/,+/, ', '))
+      array[1].each do |trans|
+        word_class = trans[0].empty? ? 'undefined' : trans[0]
+        result[word_class] = trans[1]
+      end
+      result
+    rescue NoMethodError
+      raise Smartdict::TranslationNotFound
+    end
+
+    # Sends remote request to GooogleTranslate service.
+    # @return [String] body of response.
+    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
+      w = word.gsub(' ', '+')
+      "/translate_a/t?client=t&text=#{w}&hl=en&sl=#{from_lang}&tl=#{to_lang}&multires=1&otf=1&rom=1&ssel=0&tsel=0&sc=1"
+    end
+
+  end
+end

data/lib/smartdict/drivers.rb

@@ -0,0 +1,6 @@
+module Smartdict::Drivers
+  extend ActiveSupport::Autoload
+
+  autoload :AbstractDriver
+  autoload :GoogleTranslateDriver
+end

data/lib/smartdict/errors.rb

@@ -0,0 +1,11 @@
+module Smartdict
+
+  class Error < ::Exception; end
+
+  class TranslationNotFound < Error
+    def initialize(msg = "Translation is not found")
+      super(msg)
+    end
+  end
+
+end

data/lib/smartdict/formats/abstract_format.rb

@@ -0,0 +1,21 @@
+class Smartdict::Formats::AbstractFormat
+  include Singleton
+
+  class_attribute :description
+
+  def self.set_description(description)
+    self.description = description
+  end
+
+  # @param [Models::Translation] translation
+  # @return [String]
+  def self.format_translation(translation)
+    instance.format_translation(translation)
+  end
+
+  # @param [Array] array of {Models::Translation}.
+  # @return [String]
+  def self.format_list(translations)
+    instance.format_list(translations)
+  end
+end

data/lib/smartdict/formats/fb2_format.rb

@@ -0,0 +1,40 @@
+require 'builder'
+
+class Smartdict::Formats::Fb2Format < Smartdict::Formats::AbstractFormat
+  set_description "Displays translation in fiction book format."
+
+
+  def format_list(translations)
+    xml = Builder::XmlMarkup.new(:indent => 2)
+    xml.instruct!
+    xml.FictionBook(:xmlns => "http://www.gribuser.ru/xml/fictionbook/2.0") do |book|
+      book.description do |desc|
+        desc.tag!("document-info") do |doc_info|
+          doc_info.tag!("program-used", "Smartdict version #{Smartdict::VERSION}")
+        end
+        desc.tag!('title-info') do |title_info|
+          title_info.tag!('book-title', "#{Time.now.strftime('%F')} - English words")
+          title_info.genre 'sci_linguistic'
+          title_info.annotation do |annotation|
+            annotation.p "English words to learn"
+            annotation.p "The content generate by program Smardict v#{Smartdict::VERSION}"
+          end
+        end
+      end
+      book.body do |body|
+        body.title "TITLE"
+        translations.each do |translation|
+          body.section do |word_section|
+            word_section.title {|title| title.p "#{translation.word}   [#{translation.transcription}]"}
+            translation.translated.each do |word_class, translations|
+              word_section.subtitle word_class
+              word_section.p translations.join("; ")
+              word_section.tag!("empty-line")
+            end
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/smartdict/formats/text_color_format.rb

@@ -0,0 +1,52 @@
+class Smartdict::Formats::TextColorFormat < Smartdict::Formats::AbstractFormat
+  set_description "Displays translation with ASCII highlight"
+
+  # :nodoc:
+  def format_translation(translation)
+    result = "#{bold_green(translation.word)}"
+    result << green(" [#{translation.transcription}]") if translation.transcription
+    result << "\n"
+
+    translation.translated.each do |word_class, words|
+      result << "  #{bold(word_class)}\n"
+      words.each do |word|
+        result << "    #{word}\n"
+      end
+    end
+
+    result
+  end
+
+  # :nodoc:
+  def format_list(translations)
+    result = ""
+    translations.each do |translation|
+      translated_words = translation.translated.values.map{|words| words.first(3)}.flatten
+
+      result << green(translation.word)
+      result << " - "
+      result << translated_words.join(", ")
+      result << "\n"
+    end
+    result
+  end
+
+
+  private
+
+  def bold_green(text)
+    colorize(text, "1;32")
+  end
+
+  def bold(text)
+    colorize(text, 1)
+  end
+
+  def green(text)
+    colorize(text, 32)
+  end
+
+  def colorize(text, color_code)
+    "\e[#{color_code}m#{text}\e[0m"
+  end
+end

data/lib/smartdict/formats/text_format.rb

@@ -0,0 +1,9 @@
+class Smartdict::Formats::TextFormat < Smartdict::Formats::TextColorFormat
+  set_description "Displays translation in pure text"
+
+  private
+
+  def colorize(text, color_code)
+    text
+  end
+end

data/lib/smartdict/formats.rb

@@ -0,0 +1,8 @@
+module Smartdict::Formats
+  extend ActiveSupport::Autoload
+
+  autoload :AbstractFormat
+  autoload :TextFormat
+  autoload :TextColorFormat
+  autoload :Fb2Format
+end

data/lib/smartdict/list_builder.rb

@@ -0,0 +1,51 @@
+# 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/models/driver.rb

@@ -0,0 +1,14 @@
+class Smartdict::Models::Driver
+  include DataMapper::Resource
+  include DataMapper::Validations
+  include DataMapper::Enum
+
+  acts_as_enumerated
+
+  property :id  , Serial
+  property :name, String, :unique_index => true
+
+  has n, :translations
+
+  validates_presence_of :name
+end

data/lib/smartdict/models/language.rb

@@ -0,0 +1,16 @@
+class Smartdict::Models::Language
+  include DataMapper::Resource
+  include DataMapper::Validations
+  include DataMapper::Enum
+
+  acts_as_enumerated :name_property => :code
+
+  property :id  , Serial
+  property :name, String
+  property :code, String, :unique_index => true, :length => 2
+
+  has n, :words
+
+  validates_presence_of   :name, :code
+  validates_uniqueness_of :name, :code
+end

data/lib/smartdict/models/translated_word.rb

@@ -0,0 +1,14 @@
+class Smartdict::Models::TranslatedWord
+  include DataMapper::Resource
+
+  property :id, Serial
+  property :translation_id, Integer, :unique_index => :index_translated_word
+  property :word_class_id , Integer, :unique_index => :index_translated_word
+  property :word_id       , Integer, :unique_index => :index_translated_word
+
+  belongs_to :translation
+  belongs_to :word_class
+  belongs_to :word
+
+  validates_presence_of :translation_id, :word_class_id, :word_id
+end

data/lib/smartdict/models/translation.rb

@@ -0,0 +1,83 @@
+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
+
+  belongs_to :word
+  belongs_to :driver
+  belongs_to :from_lang, 'Language'
+  belongs_to :to_lang  , 'Language'
+  has n, :translated_words
+  has n, :translation_queries
+
+  validates_presence_of :word
+  validates_presence_of :driver
+  validates_presence_of :from_lang_id
+  validates_presence_of :to_lang_id
+
+
+  # Create {Smartdict::Models::Translation} from {Smartdict::Translation}.
+  def self.create_from_struct(struct)
+    from_lang = Language[struct.from_lang]
+    to_lang   = Language[struct.to_lang]
+    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
+    )
+
+    struct.translated.each do |word_class_name, meanings|
+      meanings.each do |meaning|
+        w = Word.first_or_create(:name => meaning, :language_id => to_lang.id)
+        word_class = WordClass[word_class_name]
+        TranslatedWord.create(:word => w, :word_class => word_class, :translation => translation)
+      end
+    end
+
+    translation
+  end
+
+  def self.find(word, from_lang_code, to_lang_code, driver_name)
+    from_lang = Language[from_lang_code]
+    to_lang   = Language[to_lang_code]
+    driver    = Driver[driver_name]
+
+    word = Word.first(:name => word, :language_id => from_lang.id)
+    self.first(:from_lang => from_lang, :to_lang => to_lang, :word => word, :driver => driver)
+  end
+
+
+  # TODO: it's a hack. Remove.
+  def initialize(*args)
+    self.class.finalize
+    self.word_class_id = 1
+    super(*args)
+  end
+
+  def to_struct
+    struct = Smartdict::Translation.new(
+      :word          => word.name,
+      :transcription => word.transcription,
+      :from_lang     => from_lang.code,
+      :to_lang       => to_lang.code,
+      :driver        => driver.name
+    )
+    translated_words.each do |tw|
+      struct[tw.word_class.name] << tw.word.name
+    end
+    struct
+  end
+
+end

data/lib/smartdict/models/translation_query.rb

@@ -0,0 +1,13 @@
+class Smartdict::Models::TranslationQuery
+  include DataMapper::Resource
+
+  property :id            , Serial
+  property :created_at    , DateTime
+  property :translation_id, Integer
+
+  belongs_to :translation
+
+  before :save do
+    self.created_at = Time.now
+  end
+end

data/lib/smartdict/models/word.rb

@@ -0,0 +1,13 @@
+class Smartdict::Models::Word
+  include DataMapper::Resource
+
+  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
+
+  validates_presence_of :language_id, :name
+end

data/lib/smartdict/models/word_class.rb

@@ -0,0 +1,14 @@
+# Word class is the same what type of speech is (noun, verb, etc.)
+class Smartdict::Models::WordClass
+  include DataMapper::Resource
+  include DataMapper::Enum
+
+  acts_as_enumerated
+
+  property :id,   Serial
+  property :name, String
+
+  has n, :translations
+
+  validates_presence_of :name
+end

data/lib/smartdict/models.rb

@@ -0,0 +1,11 @@
+module Smartdict
+  module Models; end
+end
+
+require 'smartdict/models/language'
+require 'smartdict/models/translation'
+require 'smartdict/models/translation_query'
+require 'smartdict/models/word'
+require 'smartdict/models/word_class'
+require 'smartdict/models/translated_word'
+require 'smartdict/models/driver'

data/lib/smartdict/plugin/initializer_context.rb

@@ -0,0 +1,7 @@
+class Smartdict::Plugin::InitializerContext
+  include Smartdict::Core
+
+  def register_command(name, command_class)
+    CommandManager.register(name, command_class)
+  end
+end

data/lib/smartdict/plugin.rb

@@ -0,0 +1,9 @@
+class Smartdict::Plugin
+  extend ActiveSupport::Autoload
+
+  autoload :InitializerContext
+
+  def self.initializer(name, options = {}, &block)
+    Smartdict::Core::PluginManager.register(name, :options => options, :block => block)
+  end
+end

data/lib/smartdict/runner.rb

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

data/lib/smartdict/storage/seeder.rb

@@ -0,0 +1,32 @@
+require 'csv'
+
+module Smartdict::Storage::Seeder
+  extend self
+
+  def seed!
+    seed_files.each do |csv_file|
+      seed_from(csv_file)
+    end
+  end
+
+
+  private
+
+  def seed_files
+    seeds_dir = File.expand_path('../seeds', __FILE__)
+    Dir["#{seeds_dir}/*.csv"]
+  end
+
+  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)
+    end
+  end
+
+  def csv_file_to_model(csv_file)
+    plural_name = File.basename(csv_file).gsub(/\.csv$/, "")
+    model_name = plural_name.classify
+    Smartdict::Models.const_get(model_name)
+  end
+end

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

@@ -0,0 +1,2 @@
+id,name
+1,google_translate