translatomatic 0.1.3 → 0.2.0

data/lib/translatomatic/converter.rb

@@ -1,36 +1,48 @@
-# Converts files from one format to another
-class Translatomatic::Converter
+module Translatomatic
+  # Converts files from one format to another
+  class Converter
+    def initialize(options = {})
+      @options = options
+    end
 
-  def initialize(options = {})
-    @options = options
-  end
+    # Convert a resource file from one format to another.
+    # @param source [String] Path to source file. File must exist
+    # @param target [String] Path to target file. File will be created
+    #   or overwritten if it already exists.
+    # @return [Translatomatic::ResourceFile] The converted file.
+    def convert(source, target)
+      source_file = load_file(source)
+      target_file = load_file(target)
+      raise t('file.not_found', file: source) unless source_file.path.file?
 
-  # Convert a resource file from one format to another.
-  # @param source [String] Path to source file. File must exist
-  # @param target [String] Path to target file. File will be created
-  #   or overwritten if it already exists.
-  # @return [Translatomatic::ResourceFile] The converted file.
-  def convert(source, target)
-    source_path = Pathname.new(source.to_s)
-    target_path = Pathname.new(target.to_s)
-    raise t("file.not_found", file: source.to_s) unless source_path.file?
-    raise t("file.directory", file: target.to_s) if target_path.directory?
+      if source_file.type == target_file.type
+        # if same file type, modify source.
+        # this retains internal structure
+        target_file = source_file
+      else
+        # different file type, copy properties from source file to target
+        target_file.properties = source_file.properties
+      end
 
-    source_file = load_file(source_path)
-    target_file = load_file(target_path)
+      target_file.save(Pathname.new(target), @options)
+      target_file
+    end
 
-    # copy properties from source file to target
-    target_file.properties = source_file.properties
-    target_file.save(target_path, @options)
-    target_file
-  end
+    private
 
-  private
+    include Translatomatic::Util
 
-  def load_file(path)
-    file = Translatomatic::ResourceFile.load(path)
-    raise t("file.unsupported", file: path) unless file
-    file
-  end
+    def load_file(path)
+      path = Pathname.new(path.to_s)
+      raise t('file.directory', file: path) if path.directory?
 
+      file = if path.exist?
+               Translatomatic::ResourceFile.load(path)
+             else
+               Translatomatic::ResourceFile.create(path)
+             end
+      raise t('file.unsupported', file: path) unless file
+      file
+    end
+  end
 end

data/lib/translatomatic/database.rb

@@ -1,143 +1,160 @@
 require 'active_record'
 
-# Database functions
-class Translatomatic::Database
-
-  class << self
-    # @param options [Hash<Symbol,Object>] Database options
-    # @return [boolean] True if we can connect to the database
-    def enabled?(options = {})
-      new(options).connect
+module Translatomatic
+  # Database functions
+  class Database
+    class << self
+      # @param options [Hash<Symbol,Object>] Database options
+      # @return [boolean] True if we can connect to the database
+      def enabled?(options = {})
+        new(options).connect
+      end
     end
-  end
 
-  def initialize(options = {})
-    @env = options[:database_env] || DEFAULT_ENV
-    @db_config = database_config(@env, options)
-    @env_config = @db_config
-    raise t("database.no_environment",
-      env: @env, file: db_config_path) unless @env_config[@env]
-    @env_config = @env_config[@env] || {}
-
-    ActiveRecord::Base.configurations = @db_config
-    ActiveRecord::Tasks::DatabaseTasks.env = @env
-    ActiveRecord::Tasks::DatabaseTasks.db_dir = DB_PATH
-    ActiveRecord::Tasks::DatabaseTasks.root = DB_PATH
-    ActiveRecord::Tasks::DatabaseTasks.database_configuration = @db_config
-    create unless exists?
-    migrate
-  end
+    def initialize(options = {})
+      @env = options[:database_env] || DEFAULT_ENV
+      @db_config = database_config(@env, options)
+      env_config = @db_config
+      unless env_config[@env]
+        raise t('database.no_environment', env: @env, file: db_config_path)
+      end
+      @env_config = env_config[@env] || {}
+      init_active_record
+      create unless exists?
+    end
 
-  # Connect to the database
-  # @return [boolean] True if the connection was established
-  def connect
-    begin
+    # Connect to the database
+    # @return [boolean] True if the connection was established
+    def connect
       ActiveRecord::Base.establish_connection(@env_config)
+      migrate
       true
     rescue LoadError
       false
     end
-  end
 
-  # Disconnect from the database
-  # @return [void]
-  def disconnect
-    ActiveRecord::Base.remove_connection
-  end
+    # Disconnect from the database
+    # @return [void]
+    def disconnect
+      ActiveRecord::Base.remove_connection
+    end
 
-  # Test if the database exists
-  # @return [Boolean] true if the database exists
-  def exists?
-    begin
-      return true if sqlite_database_exists?
-      return false unless connect
-      ActiveRecord::Base.connection.tables
-    rescue
-      return false
+    # Test if the database exists
+    # @return [Boolean] true if the database exists
+    def exists?
+      begin
+        return true if sqlite_database_exists?
+        return false unless connect
+        ActiveRecord::Base.connection.tables
+      rescue StandardError
+        return false
+      end
+      true
     end
-    true
-  end
 
-  # Run outstanding migrations against the database
-  # @return [void]
-  def migrate
-    return false unless connect
-    ActiveRecord::Migrator.migrate(MIGRATIONS_PATH)
-    ActiveRecord::Base.clear_cache!
-    log.debug t("database.migrated")
-  end
+    # Run outstanding migrations against the database
+    # @return [void]
+    def migrate
+      return if @migrated
+      ActiveRecord::Migrator.migrate(MIGRATIONS_PATH)
+      ActiveRecord::Base.clear_cache!
+      log.debug t('database.migrated')
+      @migrated = true
+    end
 
-  # Create the database
-  # @return [boolean] True if the database was created
-  def create
-    begin
+    # Create the database
+    # @return [boolean] True if the database was created
+    def create
       ActiveRecord::Tasks::DatabaseTasks.create(@env_config)
-      log.debug t("database.created")
+      log.debug t('database.created')
       true
     rescue LoadError => e
-      log.debug t("database.could_not_create")
+      log.debug t('database.could_not_create')
       log.error e.message
       false
     end
-  end
 
-  # Drop the database
-  # @return [void]
-  def drop
-    disconnect
-    ActiveRecord::Tasks::DatabaseTasks.drop(@env_config)
-    log.debug t("database.deleted")
-  end
+    # Drop the database
+    # @return [void]
+    def drop
+      disconnect
+      ActiveRecord::Tasks::DatabaseTasks.drop(@env_config)
+      log.debug t('database.deleted')
+    end
 
-  private
+    # Shortcut to text model class
+    # @return [Class] Translatomatic::Model::Text
+    def text
+      Translatomatic::Model::Text
+    end
 
-  include Translatomatic::Util
-  include Translatomatic::DefineOptions
+    # Shortcut to locale model class
+    # @return [Class] Translatomatic::Model::Locale
+    def locale
+      Translatomatic::Model::Locale
+    end
 
-  def sqlite_database_exists?
-    @env_config['adapter'] == 'sqlite3' && File.exist?(@env_config['database'])
-  end
+    private
 
-  def self.join_path(*parts)
-    File.realpath(File.join(*parts))
-  end
+    include Translatomatic::Util
+    include Translatomatic::DefineOptions
+
+    class << self
+      private
 
-  DB_PATH = join_path(File.dirname(__FILE__), "..", "..", "db")
-  INTERNAL_CONFIG = File.join(DB_PATH, "database.yml")
-  CUSTOM_CONFIG = File.join(Dir.home, ".translatomatic", "database.yml")
-  DEFAULT_CONFIG = File.exist?(CUSTOM_CONFIG) ? CUSTOM_CONFIG : INTERNAL_CONFIG
-  MIGRATIONS_PATH = File.join(DB_PATH, "migrate")
-  GEM_ROOT = join_path(File.dirname(__FILE__), "..", "..")
-  DEFAULT_ENV = "production"
-
-  define_options(
-    { name: :database_config, desc: t("database.config_file"),
-      default: DEFAULT_CONFIG },
-    { name: :database_env, desc: t("database.env"),
-      default: DEFAULT_ENV })
-
-  # return path to database config
-  def database_config_path(options)
-    if options[:database_env] == "test"
-      INTERNAL_CONFIG  # rspec
-    elsif options[:database_config]
-      return options[:database_config]
-    else
-      DEFAULT_CONFIG
+      def join_path(*parts)
+        File.realpath(File.join(*parts))
+      end
     end
-  end
 
-  # return database config as a hash
-  def database_config(env, options)
-    if options[:database_config].kind_of?(Hash)
-      return { env => options[:database_config] }
+    def init_active_record
+      ActiveRecord::Base.configurations = @db_config
+      ActiveRecord::Tasks::DatabaseTasks.env = @env
+      ActiveRecord::Tasks::DatabaseTasks.db_dir = DB_PATH
+      ActiveRecord::Tasks::DatabaseTasks.root = DB_PATH
+      ActiveRecord::Tasks::DatabaseTasks.database_configuration = @db_config
     end
 
-    db_config_path = database_config_path(options)
-    dbconfig = File.read(db_config_path)
-    dbconfig.gsub!(/\$HOME/, Dir.home)
-    dbconfig.gsub!(/\$GEM_ROOT/, GEM_ROOT)
-    YAML::load(dbconfig) || {}
-  end
+    def sqlite_database_exists?
+      @env_config['adapter'] == 'sqlite3' &&
+        File.exist?(@env_config['database'])
+    end
+
+    DB_PATH = join_path(File.dirname(__FILE__), '..', '..', 'db')
+    INTERNAL_CONF = File.join(DB_PATH, 'database.yml')
+    CUSTOM_CONF = File.join(Dir.home, '.translatomatic', 'database.yml')
+    DEFAULT_CONF = File.exist?(CUSTOM_CONF) ? CUSTOM_CONF : INTERNAL_CONF
+    MIGRATIONS_PATH = File.join(DB_PATH, 'migrate')
+    GEM_ROOT = join_path(File.dirname(__FILE__), '..', '..')
+    DEFAULT_ENV = 'production'.freeze
+
+    define_option :database_config, desc: t('database.config_file'),
+                                    default: DEFAULT_CONF, type: :path
+    define_option :database_env, desc: t('database.env'),
+                                 default: DEFAULT_ENV
+
+    # return path to database config
+    def database_config_path(options)
+      if options[:database_env] == 'test'
+        INTERNAL_CONF # used for rspec
+      elsif options[:database_config]
+        options[:database_config]
+      else
+        DEFAULT_CONF
+      end
+    end
 
+    # return database config as a hash
+    def database_config(env, options)
+      if options[:database_config].is_a?(Hash)
+        return { env => options[:database_config] }
+      end
+
+      db_config_path = database_config_path(options)
+      dbconfig = File.read(db_config_path)
+      dbconfig.gsub!(/\$HOME/, Dir.home)
+      dbconfig.gsub!(/\$GEM_ROOT/, GEM_ROOT)
+      YAML.safe_load(dbconfig) || {}
+    end
+  end
 end

data/lib/translatomatic/define_options.rb

@@ -1,20 +1,19 @@
 module Translatomatic
   # @!visibility private
   module DefineOptions
-
     # @!visibility private
     module ClassMethods
       attr_reader :options
 
       private
 
-      def define_options(*options)
-        @options = options.collect { |i| Translatomatic::Option.new(i) }
+      def define_option(name, attributes = {})
+        @options ||= []
+        @options << Translatomatic::Option.new(attributes.merge(name: name))
       end
     end
 
-    private
-
+    # @!visibility private
     def self.included(klass)
       klass.extend(ClassMethods)
     end

data/lib/translatomatic/escaped_unicode.rb

@@ -1,90 +1,100 @@
-# Module to encode and decode unicode chars.
-# This code is highly influced by Florian Frank's JSON gem
-# @see https://github.com/jnbt/java-properties
-# @see https://github.com/flori/json/
+module Translatomatic
+  # Class to encode and decode unicode chars.
+  # This code is highly influenced by Florian Frank's JSON gem
+  # @see https://github.com/jnbt/java-properties
+  # @see https://github.com/flori/json/
+  class EscapedUnicode
+    class << self
+      # Decodes all unicode chars from escape sequences
+      # @param text [String]
+      # @return [String] The encoded text
+      def unescape(text)
+        string = text.gsub(/(?:\\[uU](?:[A-Fa-f\d]{4}))+/) do |c|
+          unescape_char(c)
+        end
+        string.force_encoding(::Encoding::UTF_8)
+        string
+      end
+
+      # Decodes all unicode chars into escape sequences
+      # @param text [String]
+      # @return [String] The decoded text
+      def escape(text)
+        string = text.dup
+        string.force_encoding(::Encoding::ASCII_8BIT)
+        string.gsub!(/["\\\x0-\x1f]/n) { |c| MAP[c] || c }
+        string.gsub!(ESCAPE_REGEX) { |c| escape_char(c) }
+        string.force_encoding(::Encoding::UTF_8)
+        string
+      end
 
-module Translatomatic::EscapedUnicode
+      private
 
-  # Decodes all unicode chars from escape sequences
-  # @param text [String]
-  # @return [String] The encoded text for chaining
-  def self.unescape(text)
-    string = text.dup
-    string = string.gsub(%r((?:\\[uU](?:[A-Fa-f\d]{4}))+)) do |c|
-      c.downcase!
-      bytes = EMPTY_8BIT_STRING.dup
-      i = 0
-      while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
-        bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
-        i += 1
+      def unescape_char(c)
+        c.downcase!
+        bytes = EMPTY_8BIT_STRING.dup
+        i = 0
+        while c[i] == '\\' && c[i + 1] == 'u'
+          (1..2).each do |j|
+            bytes << c[i + j * 2, 2].to_i(16)
+          end
+          i += 6
+        end
+        bytes.encode('utf-8', 'utf-16be')
       end
-      bytes.encode("utf-8", "utf-16be")
-    end
-    string.force_encoding(::Encoding::UTF_8)
 
-    text.replace string
-    text
-  end
+      def escape_char(c)
+        (c.size == 1) && raise(t('unicode.invalid_byte', byte: c))
+        s = c.encode('utf-16be', 'utf-8').unpack('H*')[0]
+        s.force_encoding(::Encoding::ASCII_8BIT)
+        s.gsub!(/.{4}/n, '\\\\u\&')
+        s.force_encoding(::Encoding::UTF_8)
+      end
+    end
 
-  # Decodes all unicode chars into escape sequences
-  # @param text [String]
-  # @return [String] The decoded text for chaining
-  def self.escape(text)
-    string = text.dup
-    string.force_encoding(::Encoding::ASCII_8BIT)
-    string.gsub!(/["\\\x0-\x1f]/n) { |c| MAP[c] || c }
-    string.gsub!(/(
+    # @private
+    ESCAPE_REGEX = /(
       (?:
         [\xc2-\xdf][\x80-\xbf]    |
         [\xe0-\xef][\x80-\xbf]{2} |
         [\xf0-\xf4][\x80-\xbf]{3}
         )+ |
         [\x80-\xc1\xf5-\xff]       # invalid
-        )/nx) { |c|
-          c.size == 1 and raise t("unicode.invalid_byte", byte: c)
-          s = c.encode("utf-16be", "utf-8").unpack('H*')[0]
-          s.force_encoding(::Encoding::ASCII_8BIT)
-          s.gsub!(/.{4}/n, '\\\\u\&')
-          s.force_encoding(::Encoding::UTF_8)
-        }
-    string.force_encoding(::Encoding::UTF_8)
-    text.replace string
-    text
-  end
-
-  private
+        )/nx
 
-  MAP = {
-    "\x0" => '\u0000',
-    "\x1" => '\u0001',
-    "\x2" => '\u0002',
-    "\x3" => '\u0003',
-    "\x4" => '\u0004',
-    "\x5" => '\u0005',
-    "\x6" => '\u0006',
-    "\x7" => '\u0007',
-    "\xb" => '\u000b',
-    "\xe" => '\u000e',
-    "\xf" => '\u000f',
-    "\x10" => '\u0010',
-    "\x11" => '\u0011',
-    "\x12" => '\u0012',
-    "\x13" => '\u0013',
-    "\x14" => '\u0014',
-    "\x15" => '\u0015',
-    "\x16" => '\u0016',
-    "\x17" => '\u0017',
-    "\x18" => '\u0018',
-    "\x19" => '\u0019',
-    "\x1a" => '\u001a',
-    "\x1b" => '\u001b',
-    "\x1c" => '\u001c',
-    "\x1d" => '\u001d',
-    "\x1e" => '\u001e',
-    "\x1f" => '\u001f',
-  }
-
-  EMPTY_8BIT_STRING = ''
-  EMPTY_8BIT_STRING.force_encoding(::Encoding::ASCII_8BIT)
+    # @private
+    MAP = {
+      "\x0" => '\u0000',
+      "\x1" => '\u0001',
+      "\x2" => '\u0002',
+      "\x3" => '\u0003',
+      "\x4" => '\u0004',
+      "\x5" => '\u0005',
+      "\x6" => '\u0006',
+      "\x7" => '\u0007',
+      "\xb" => '\u000b',
+      "\xe" => '\u000e',
+      "\xf" => '\u000f',
+      "\x10" => '\u0010',
+      "\x11" => '\u0011',
+      "\x12" => '\u0012',
+      "\x13" => '\u0013',
+      "\x14" => '\u0014',
+      "\x15" => '\u0015',
+      "\x16" => '\u0016',
+      "\x17" => '\u0017',
+      "\x18" => '\u0018',
+      "\x19" => '\u0019',
+      "\x1a" => '\u001a',
+      "\x1b" => '\u001b',
+      "\x1c" => '\u001c',
+      "\x1d" => '\u001d',
+      "\x1e" => '\u001e',
+      "\x1f" => '\u001f'
+    }.freeze
+    private_constant :MAP
 
+    # @private
+    EMPTY_8BIT_STRING = ''.force_encoding(::Encoding::ASCII_8BIT).freeze
+  end
 end