smartdict-core 0.0.1

data/README.markdown

@@ -0,0 +1,77 @@
+# Smartdict
+
+Simple dictionary.
+
+## Installation
+
+```
+gem install smartdict
+```
+
+## Usage
+
+To get help just type:
+
+```
+smartdict --help
+```
+
+To get a help on specific command:
+
+```
+smartdict help <COMMAND>
+```
+
+### Translate words:
+
+To translate word `hallo` from German to Russian:
+
+  smartdict translate --from de --to ru hallo
+
+
+### List translated words:
+
+If you want to take a look at words you've translated use `list` command.
+You can specify date range and languages to filter words and
+you can specify format for output.
+
+To get more information see help:
+
+```
+smartdict translate --help
+```
+
+#### Example:
+
+To see words translated today:
+
+```
+smartdict list
+```
+
+To save words translated since 13th of January 2012 from English to Russian in
+[FictionBook](http://en.wikipedia.org/wiki/FictionBook) format to `words.fb2`
+file.
+
+
+```
+smartdict --since 2012-01-13 --from en --to ru --format fb2 > ./words.fb2
+```
+
+## How to configure?
+
+See file `$HOME/.smartdict/configuration.yml`.
+
+NOTE: currently not all options listed there have an effect.
+
+
+## Contributing to smartdict
+
+* Make sure all tests pass.
+* Send me a patch.
+
+## Copyright
+
+Copyright (c) 2012 Potapov Sergey. The software is distributed under
+[GNU GeneralPublic License version 2](http://www.gnu.org/licenses/gpl-2.0.txt).
+See GPL-LICENSE.txt file for more details.

data/bin/smartdict

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'rubygems'
+
+require 'smartdict'
+require 'smartdict/runner'
+
+# TODO: remove before release
+# require 'pry'
+
+Smartdict.env = :user
+
+args = ARGV.clone
+
+Smartdict.load_plugins
+
+# TODO :move Smartdict.run to Runner.run
+Smartdict.run
+Smartdict::Runner.run(args)

data/bin/smartdict-populator

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'rubygems'
+
+require 'smartdict'
+require 'smartdict/runner'
+
+Smartdict.env = :user
+
+args = ARGV.clone
+
+Smartdict.load_plugins
+
+# TODO :mode Smartdict.run to Runner.run
+Smartdict.run
+
+
+
+def translate(word)
+  Smartdict::Translator.translate(word)
+rescue Smartdict::TranslationNotFound
+end
+
+def translate_words(words, from_lang, to_lang)
+  words.each_with_index do |word, index|
+    translate word
+    if index % 10 == 0
+      print "#{index}/#{words.size} = %2.2f%" % [index.to_f/words.size * 100]
+      puts "  #{from_lang.name} -> #{to_lang.name}"
+    end
+  end
+end
+
+from_lang = Smartdict::Models::Language.first(:code => 'en')
+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
+
+  words = Smartdict::Models::Word.all(:language_id => from_lang.id).map(&:name)
+  translate_words(words, from_lang, to_lang)
+
+  from_lang, to_lang = to_lang, from_lang
+end
+
+
+

data/config/default_config.yml

@@ -0,0 +1,15 @@
+plugins:
+
+store:
+  adapter: sqlite
+
+default:
+  from_lang: en
+  to_lang: ru
+  format: text_color
+  langs:
+    - en
+    - ru
+    - de
+    - es
+    - fr

data/lib/smartdict/commands/abstract_command.rb

@@ -0,0 +1,225 @@
+# Basic class for all command classes.
+#
+# == Usage:
+#   class Smartdict::Commands::HelloCommand < Smartdict::Commands::AbstractCommand
+#     # arguments and their default values
+#     arguments :name
+#     default   :name => "world"
+#
+#     # options and their default values.
+#     options :greating => "Hello",
+#             :today => lambda { Time.now.strftime("%A") }
+#
+#     # Other helpful information about the command
+#     set_name        "hello"
+#     set_summary     "Summary for the hello command"
+#     set_description "Demonstrates how Command class works"
+#     set_syntax      "#{prog_name} NAME [--greating GREATING] [--today DAY]"
+#     set_usage <<-USAGE
+#       #{prog_name}
+#       #{prog_name} Sergey
+#       #{prog_name} --today Friday
+#     USAGE
+#
+#     # This method runs when command executes.
+#     def execute
+#       puts "#{@options[:greating]} #{@arguments[:name]}! Today is #{@options[:today]}."
+#     end
+#   end
+#
+#   # == Output:
+#   # smartdict hello
+#   # Hello world! Today is Monday.
+#   #
+#   # smartdict hello Sergey
+#   # Hello Sergey! Today is Monday.
+#   #
+#   # smartdict hello Sergey --today Friday
+#   # Hello Sergey! Today is Friday.
+class Smartdict::Commands::AbstractCommand
+  # Number of spaces for indent.
+  INDENT_SIZE = 2
+
+  # array with available arguments
+  class_attribute :known_arguments
+
+  # hash with default values for {known_arguments}.
+  class_attribute :default_argument_values
+
+  # hash with names of options and default values
+  class_attribute :known_options
+
+  # short summary message for a command
+  class_attribute :summary
+
+  # command description
+  class_attribute :description
+
+  # command name
+  class_attribute :name
+
+  # multi line text with syntax format
+  class_attribute :syntax
+
+  # multi line text with usage example
+  class_attribute :usage
+
+  # Runs command.
+  # @param [Array] args arguments passed from the command line
+  def self.run(args)
+    if ['--help', '-h'].include?(args.first)
+      puts help_message
+    else
+      self.new(args).execute
+    end
+  rescue Smartdict::Error => err
+    puts err.message
+  end
+
+  # Defines available arguments and their order.
+  def self.arguments(*argument_names)
+    self.known_arguments = argument_names
+  end
+
+  # Sets default values for arguments.
+  # @param [Hash] values
+  def self.default(values)
+    self.default_argument_values = values
+  end
+
+  # Defines available options with their default values.
+  # == Usage:
+  #   options :to => "en",
+  #           :from => lambda { Settings.current_language }
+  def self.options(options = {})
+    raise Smartdict::Error.new("options must be a hash") unless options.is_a? Hash
+    self.known_options = options
+  end
+
+  # Sets summary message for a command.
+  def self.set_summary(summary)
+    self.summary = summary
+  end
+
+  # Sets description message for a command.
+  def self.set_description(description)
+    self.description = description
+  end
+
+  # Defines name of a command.
+  def self.set_name(name)
+    self.name = name
+  end
+
+  # Sets syntax message.
+  # @param [String] syntax multi line text with number of syntax examples
+  def self.set_syntax(syntax)
+    self.syntax = syntax
+  end
+
+  # Sets usage examples
+  # @param [String] usage multi line text with number of usage examples.
+  def self.set_usage(usage)
+    self.usage = usage
+  end
+
+  # @return [String] program name. It's meant to be used in usage examples.
+  def self.prog_name
+    "smartdict #{name}"
+  end
+
+  # @return [String] help message for the command to be displayed.
+  def self.help_message
+    message = "#{description}\n\n"
+    message << "#{help_syntax_message}\n"
+    message << "#{help_usage_message}\n"
+  end
+
+  # @return [String] syntax part of the help message.
+  def self.help_syntax_message
+    result = " " * INDENT_SIZE + "Syntax:\n"
+    syntax.split("\n").map do |line|
+      result << " " * INDENT_SIZE * 2 + "#{line.strip}\n"
+    end
+    result
+  end
+
+  # @return [String] usage part of the help message.
+  def self.help_usage_message
+    result = " " * INDENT_SIZE + "Usage:\n"
+    usage.split("\n").map do |line|
+      result << " " * INDENT_SIZE * 2 + "#{line.strip}\n"
+    end
+    result
+  end
+
+  # Sets default values for class attributes.
+  def self.inherited(base)
+    base.known_arguments ||= []
+    base.default_argument_values ||= {}
+    base.known_options ||= {}
+  end
+
+
+
+  # @param [Array] args arguments passed from the command line
+  def initialize(args = [])
+    set_arguments_and_options!(args)
+  end
+
+  # Parses all passed arguments and initializes @arguments and @options variables.
+  # @param [Array] args arguments passed from the command line
+  def set_arguments_and_options!(args)
+    arguments, options = extract_arguments_and_options(args)
+    set_arguments!(arguments)
+    set_options!(options)
+  end
+
+  # Splits input args to arguments and options.
+  # Returns arguments as an array and options as a hash.
+  def extract_arguments_and_options(args)
+    arguments = []
+    options = {}
+    args = args.dup
+    while value = args.shift
+      if match = value.match(/^--(\w+)/)
+        options[match[1].to_sym] = args.shift
+      else
+        arguments << value
+      end
+    end
+    [arguments, options]
+  end
+
+  # Initializes @arguments variable.
+  # If no argument was passed then it uses default value.
+  def set_arguments!(arg_values)
+    @arguments = {}
+    known_arguments.each_with_index do |arg_name, index|
+      if value = arg_values[index]
+        @arguments[arg_name.to_sym] = value
+      elsif default_argument_values.has_key?(arg_name.to_sym)
+        @arguments[arg_name.to_sym] = default_argument_values[arg_name.to_sym]
+      else
+        raise Smartdict::Error.new("Argument `#{arg_name}` is not passed")
+      end
+    end
+  end
+
+  # Initializes @options variable.
+  # If no argument was passed then it uses default value.
+  def set_options!(options)
+    @options = {}
+    known_options.each do |opt_name, default_value|
+      value = options[opt_name]
+      unless value
+        value = case default_value
+          when Proc then default_value.call
+          else default_value
+        end
+      end
+      @options[opt_name] = value
+    end
+  end
+
+end

data/lib/smartdict/commands/has_format_list.rb

@@ -0,0 +1,28 @@
+# Extends {help_message} method to provide list of formats.
+module Smartdict::Commands::HasFormatList
+  def self.included(base)
+    base.extend ClassMethods
+    base.class_eval do
+      class << self
+        alias_method_chain :help_message, :formats
+      end
+    end
+  end
+
+  module ClassMethods
+    def help_message_with_formats
+      formats = Smartdict::Core::FormatManager.all
+      width = formats.values.map{|f| f.name.size}.max
+      indent = Smartdict::Commands::AbstractCommand::INDENT_SIZE
+
+      message  = " " * indent + "Formats:\n"
+      formats.each do |name, format|
+        message << " " * 2 * indent
+        message << name.ljust(width) + "    "
+        message << "#{format.description}\n"
+      end
+
+      help_message_without_formats << message
+    end
+  end
+end

data/lib/smartdict/commands/help_command.rb

@@ -0,0 +1,53 @@
+module Smartdict::Commands
+  class HelpCommand < AbstractCommand
+    include Smartdict::Core
+
+    arguments :command
+    default   :command => nil
+
+    set_name        "help"
+    set_summary     "Show help message"
+    set_description "Smartdict is a dictionary designed to improve you knowledge of foreign languages."
+    set_syntax <<-SYNTAX
+      smartdict COMMAND [arguments...] [options...]
+      #{prog_name} COMMAND
+      smartdict --help
+      smartdict --version
+    SYNTAX
+
+    set_usage <<-SYNTAX
+      #{prog_name} translate
+      #{prog_name} list
+    SYNTAX
+
+    def execute
+      if cmd_name = @arguments[:command]
+        if cmd_class = CommandManager.find(cmd_name)
+          puts cmd_class.help_message
+        else
+          abort "Uknown command: #{cmd_name}"
+        end
+      else
+        puts help_message
+      end
+    end
+
+    def help_message
+      message = "#{description}\n\n"
+      message << "#{self.class.help_syntax_message}\n"
+      message << help_commands_message
+    end
+
+
+    def help_commands_message
+      width = CommandManager.all.keys.map(&:size).max
+      result = " " * INDENT_SIZE + "Commands:\n"
+      CommandManager.all.each do |command_name, command_class|
+        result << " " * 2 * INDENT_SIZE + "#{command_name.ljust(width)}"
+        result << "    #{command_class.summary}\n"
+      end
+      result
+    end
+
+  end
+end

data/lib/smartdict/commands/list_command.rb

@@ -0,0 +1,45 @@
+module Smartdict::Commands
+  class ListCommand < AbstractCommand
+    include HasFormatList
+    include Smartdict::Models
+
+    set_name        "list"
+    set_summary     "Lists words you translated before"
+    set_description "Lists words you translated before in selected format(text_color by default)."
+    set_syntax <<-SYNTAX
+      #{prog_name} [--since DATE] [--till DATE] [--format FORMAT] [--from LANG] [--to LANG]
+    SYNTAX
+
+    set_usage <<-SYNTAX
+      #{prog_name}
+      #{prog_name} --since 2012-02-14 --till 2012-02-21
+      #{prog_name} --from de --to en --format text
+    SYNTAX
+
+    options :format => lambda { configatron.default.format },
+            :since  => lambda { Date.today },
+            :till   => lambda { Time.now },
+            :from   => nil,
+            :to     => nil,
+            :driver => nil
+
+    def execute
+      list_opts = {
+        :since     => @options[:since],
+        :till      => @options[:till],
+        :from_lang => @options[:from],
+        :to_lang   => @options[:to],
+        :driver    => @options[:driver]
+      }
+      translations = Smartdict::ListBuilder.build(list_opts)
+      puts format.format_list(translations)
+    end
+
+    def format
+      format = Smartdict::FormatManager.find(@options[:format])
+      raise Smartdict::Error.new("Wrong format: #{@options[:format]}") unless format
+      format
+    end
+
+  end
+end

data/lib/smartdict/commands/translate_command.rb

@@ -0,0 +1,35 @@
+module Smartdict::Commands
+  class TranslateCommand < AbstractCommand
+    include HasFormatList
+
+    set_name        "translate"
+    set_summary     "Translate a word"
+    set_description "Translate a word"
+    set_syntax       "#{prog_name} <WORD> [--from LANGUAGE] [--to LANGUAGE] [--format FORMAT]"
+    set_usage <<-USAGE
+      #{prog_name} hello
+      #{prog_name} again --from en --to ru
+      #{prog_name} again --format text
+    USAGE
+
+    arguments :word
+
+    options :from   => lambda { configatron.default.from_lang },
+            :to     => lambda { configatron.default.to_lang },
+            :format => lambda { configatron.default.format }
+
+    def execute
+      Smartdict::Translator.from_lang_code = @options[:from]
+      Smartdict::Translator.to_lang_code   = @options[:to]
+      translation = Smartdict::Translator.translate(@arguments[:word])
+      puts format.format_translation(translation)
+    end
+
+    def format
+      format = Smartdict::FormatManager.find(@options[:format])
+      raise Smartdict::Error.new("Wrong format: #{@options[:format]}") unless format
+      format
+    end
+
+  end
+end

data/lib/smartdict/commands.rb

@@ -0,0 +1,10 @@
+module Smartdict::Commands
+  extend ActiveSupport::Autoload
+
+  autoload :AbstractCommand
+  autoload :HelpCommand
+  autoload :TranslateCommand
+  autoload :ListCommand
+
+  autoload :HasFormatList
+end

data/lib/smartdict/core/command_manager.rb

@@ -0,0 +1,27 @@
+class Smartdict::Core::CommandManager
+  include Smartdict::Core::IsManager
+  include Smartdict::Commands
+
+  register 'help'     , HelpCommand
+  register 'translate', TranslateCommand
+  register 'list'     , ListCommand
+
+
+  def self.run(args)
+    first_arg = args.shift
+    case first_arg
+    when nil, '-h', '--help', 'help'
+      run_command :help, args
+    else
+      run_command(first_arg, args)
+    end
+  end
+
+  def self.run_command(name, args = [])
+    if command = find(name)
+      command.run(args)
+    else
+      abort "Unknown command: #{name}"
+    end
+  end
+end

data/lib/smartdict/core/driver_manager.rb

@@ -0,0 +1,9 @@
+# Managers {Smartdict::Driver translation drivers}.
+# Similar to {Smartdict::Core::CommandManager} it registers drivers
+# and provides interfaces to find them by name.
+class Smartdict::Core::DriverManager
+  include Smartdict::Core::IsManager
+  include Smartdict::Drivers
+
+  register 'google_translate', GoogleTranslateDriver
+end

data/lib/smartdict/core/format_manager.rb

@@ -0,0 +1,8 @@
+class Smartdict::Core::FormatManager
+  include Smartdict::Formats
+  include Smartdict::Core::IsManager
+
+  register "text"      , TextFormat
+  register "text_color", TextColorFormat
+  register "fb2"       , Fb2Format
+end

data/lib/smartdict/core/has_logger.rb

@@ -0,0 +1,12 @@
+module Smartdict::Core::HasLogger
+  def self.included(base)
+    base.extend         Methods
+    base.send :include, Methods
+  end
+
+  module Methods
+    def logger
+      Smartdict::Core::Logger.root_logger
+    end
+  end
+end

data/lib/smartdict/core/is_manager.rb

@@ -0,0 +1,21 @@
+module Smartdict::Core::IsManager
+  def self.included(receiver)
+    receiver.instance_variable_set("@entities", {})
+    receiver.extend ClassMethods
+  end
+
+  module ClassMethods
+    def register(name, klass)
+      raise Smartdict::Error.new("`#{name}` is already registered") if find(name)
+      @entities[name.to_s] = klass
+    end
+
+    def find(name)
+      @entities[name.to_s]
+    end
+
+    def all
+      @entities
+    end
+  end
+end

data/lib/smartdict/core/logger.rb

@@ -0,0 +1,5 @@
+class Smartdict::Core::Logger < ::Logger
+  def self.root_logger
+    @logger ||= self.new(Smartdict.log_path)
+  end
+end

data/lib/smartdict/core/plugin_manager.rb

@@ -0,0 +1,32 @@
+class Smartdict::Core::PluginManager
+  include Smartdict::Core::IsManager
+
+  def self.load_plugins
+    require_plugins
+    run_initializers
+  end
+
+
+  private
+
+  def self.require_plugins
+    Dir["#{Smartdict.plugins_dir}/*"].each do |plugin_dir|
+      plugin_name = File.basename plugin_dir
+      require_plugin(plugin_name)
+    end
+  end
+
+  def self.require_plugin(plugin_name)
+    $LOAD_PATH << "#{Smartdict.plugins_dir}/#{plugin_name}/lib"
+    require plugin_name
+  rescue LoadError
+    log.error "Can't load plugin `#{plugin_name}` from directory #{Smartdict.plugins_dir}"
+    $LOAD_PATH.pop
+  end
+
+  def self.run_initializers
+    all.each do |name, data|
+      Smartdict::Plugin::InitializerContext.new.instance_eval &data[:block]
+    end
+  end
+end