babelyoda 1.6.0 → 2.0.0

data/.gitignore

@@ -0,0 +1,5 @@
+.rvmrc
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/CHANGELOG

@@ -1,3 +1,4 @@
 v1.1.0. Initial release.
 v1.4.0. Better command line options handling + Bugfixes.
 v1.5.0. Fixed a major bug in localization of XIB files.
+v2.0.0. Full re-write. Yay!

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in babelyoda.gemspec
+gemspec
+
+

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2009 Andrey Subbotin
+Copyright (c) 2010-2012 Andrey Subbotin
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,6 +1,6 @@
 = babelyoda
 
-A simple utility to push/pull l10n resources of an iPhone project to/from the translators.
+A simple utility to push/pull l10n resources of an Xcode project to/from the translators.
 
 == Note on Patches/Pull Requests
  
@@ -14,4 +14,4 @@ A simple utility to push/pull l10n resources of an iPhone project to/from the tr
 
 == Copyright
 
-Copyright (c) 2010 Andrey Subbotin. See LICENSE for details.
+Copyright (c) 2010-2012 Andrey Subbotin. See LICENSE for details.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/babelyoda.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "babelyoda/version"
+
+Gem::Specification.new do |s|
+  s.name        = "babelyoda"
+  s.version     = Babelyoda::VERSION
+  s.authors     = ["Andrey Subbotin"]
+  s.email       = ["andrey@subbotin.me"]
+  s.homepage    = "http://github.com/eploko/babelyoda"
+  s.summary     = "Xcode project localization made easy"
+  s.description = "A simple utility to push/pull l10n resources of an Xcode project to/from the translators"
+
+  s.rubyforge_project = "babelyoda"
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "rspec",       '~> 2.8', '>= 2.8.0'
+  s.add_runtime_dependency "awesome_print",   '~> 1.0', '>= 1.0.2'
+  s.add_runtime_dependency "rake",            '~> 0.9', '>= 0.9.2.2'
+  s.add_runtime_dependency "active_support",  '~> 3.0', '>= 3.0.0'
+  s.add_runtime_dependency "rchardet19",      '~> 1.3', '>= 1.3.5'
+  s.add_runtime_dependency "builder",         '~> 3.0', '>= 3.0.0'
+  s.add_runtime_dependency "nokogiri",        '~> 1.5', '>= 1.5.0'
+  s.add_runtime_dependency "term-ansicolor",  '~> 1.0', '>= 1.0.7'
+end

data/lib/babelyoda/file.rb

@@ -0,0 +1,20 @@
+class File
+  def self.lproj_part(filename)
+    filename.split('/').each do |part|
+      return part if part =~ /^.*\.lproj$/
+    end
+    nil
+  end
+  
+  def self.omit_lproj(filename)
+    File.join(filename.split('/').delete_if { |p| p.match(/^.*\.lproj$/) })
+  end
+  
+  def self.localized(filename, language)
+    if lproj_part(filename)
+      File.join(filename.split('/').map { |p| p.match(/^.*\.lproj$/) ? "#{language}.lproj" : p })
+    else
+      File.join(File.dirname(filename), "#{language}.lproj", File.basename(filename))
+    end
+  end
+end

data/lib/babelyoda/genstrings.rb

@@ -0,0 +1,27 @@
+require 'fileutils'
+require 'tmpdir'
+
+require_relative 'keyset'
+require_relative 'strings'
+
+module Babelyoda
+  class Genstrings
+    def self.run(files = [], language, &block)
+      keysets = {}
+      files.each do |fn|
+        Dir.mktmpdir do |dir|
+          raise "ERROR: genstrings failed." unless Kernel.system("genstrings -littleEndian -o '#{dir}' '#{fn}'")
+          Dir.glob(File.join(dir, '*.strings')).each do |strings_file|
+            strings = Babelyoda::Strings.new(strings_file, language).read!
+            strings.name = File.join('Resources', File.basename(strings.name))
+            keysets[strings.name] ||= Keyset.new(strings.name)
+            keysets[strings.name].merge!(strings)
+          end
+        end
+      end
+      keysets.each_value do |item|
+        yield(item)
+      end
+    end
+  end
+end

data/lib/babelyoda/git.rb

@@ -0,0 +1,99 @@
+require_relative 'git_versions'
+require_relative 'logger'
+require_relative 'specification_loader'
+
+module Babelyoda
+	class Git
+		include Babelyoda::SpecificationLoader
+
+    def version_exist?(filename)
+      versions.exist?(filename)
+	  end
+	  
+	  def store_version!(filename)
+	    @versions[filename] = git_ls_sha1(filename)
+      should_add = !File.exist?(versions.filename)
+	    versions.save!
+    end
+    
+    def fetch_versions!(*filenames, &block)
+      Dir.mktmpdir do |dir|
+        results = []
+        filenames.each do |fn|
+          full_fn = File.join(dir, fn)
+          dirname = File.dirname(full_fn)
+          FileUtils.mkdir_p dirname
+          git_show(@versions[fn], full_fn)
+          results << full_fn
+        end
+        block.call(results)
+      end
+    end
+    
+    def transaction(msg)
+      check_requirements!
+      yield if block_given?
+      if git_status.size > 0
+        git_add!('.')
+        git_add!('-u')
+        git_commit!(msg)
+      end
+    end
+		
+  private
+
+    def versions
+	    @versions ||= GitVersions.new
+    end
+    
+		def check_requirements!
+		  $logger.error "GIT: The working copy is not clean. Please commit your work before running Babelyoda tasks." unless clean?
+		end
+
+    def git_modified?(filename)
+      git_status.has_key?(filename)
+    end
+    
+    def git_status
+      result = {}
+      `git status --porcelain`.scan(/^(\sM|\?\?)\s+(.*)$/).each do |m|
+        result[m[1]] = m[0]
+      end
+      result
+    end
+    
+    def git_add!(filename)
+	    ncmd = ['git', 'add', filename]
+	    rc = Kernel.system(*ncmd)
+	    $logger.error "GIT ERROR: #{ncmd}" unless rc
+    end
+
+    def git_commit!(msg)
+	    ncmd = ['git', 'commit', '-m', msg]
+	    rc = Kernel.system(*ncmd)
+	    $logger.error "GIT ERROR: #{ncmd}" unless rc
+    end
+    
+    def git_show(sha1, filename = nil)
+	    ncmd = ['git', 'show', sha1]
+      IO.popen(ncmd) { |io|
+        blob = io.read
+        if filename
+          File.open(filename, 'w') {|f| f.write(blob) }
+        end
+        blob
+      }
+	    $logger.error "GIT ERROR: #{ncmd}" unless $? == 0
+    end
+    
+    def git_ls_sha1(filename)
+      matches = `git ls-files -s '#{filename}'`.match(/^\d{6}\s+([^\s]+)\s+.*$/)
+      $logger.error "GIT ERROR: Couldn't get SHA1 for: #{filename}" unless matches
+      matches[1]
+    end
+  
+    def clean?
+      `git status 2>&1`.match(/^nothing to commit \(working directory clean\)$/)
+	  end
+	end
+end

data/lib/babelyoda/git_versions.rb

@@ -0,0 +1,39 @@
+require 'fileutils'
+require 'yaml'
+
+module Babelyoda
+  class GitVersions
+
+    def initialize
+      @versions = load || {}
+    end
+    
+    def exist?(filename)
+      @versions.has_key?(filename)
+    end
+    
+    def filename
+      '.babelyoda/git_versions.yml'
+    end
+    
+    def save!
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.open(filename, 'w') {|f| f.write(@versions.to_yaml) }
+    end
+    
+    def [](filename)
+      @versions[filename]
+    end
+    
+    def []=(filename, value)
+      @versions[filename] = value
+    end
+    
+  private
+    
+    def load
+      @versions = YAML::load_file(filename) if File.exist?(filename)
+    end
+        
+  end
+end

data/lib/babelyoda/ibtool.rb

@@ -0,0 +1,51 @@
+require_relative 'logger'
+require_relative 'strings'
+
+module Babelyoda
+  class Ibtool
+    def self.extract_strings(xib_filename, language)
+      Dir.mktmpdir do |dir|
+        basename = File.basename(xib_filename, '.xib')
+        strings_filename = File.join(dir, "#{basename}.strings")
+        cmd = "ibtool --generate-strings-file '#{strings_filename}' '#{xib_filename}'"
+        $logger.error "IBTOOL ERROR: #{cmd}" unless Kernel.system(cmd)
+        return Babelyoda::Strings.new(strings_filename, language).read!
+      end
+    end
+    
+    def self.localize(source_xib_fn, target_xib_fn, strings_fn)
+      # ibtool
+      #   --strings-file path_to_strings/fr/MainWindow.strings                      # The latest localized strings for the French XIB
+      #   --write path_to_project/fr.lproj/MainWindow.xib                           # The new French XIB that will be created
+      #   path_to_project/English.lproj/MainWindow.new.xib                          # The new English XIB
+
+      ncmd = ['ibtool', '--strings-file', strings_fn, '--write', target_xib_fn, source_xib_fn]
+      rc = Kernel.system(*ncmd)
+      $logger.error "IBTOOL ERROR: #{ncmd}" unless rc
+    end
+    
+    def self.localize_incrementally(source_xib_fn, target_xib_fn, strings_fn, old_source_xib_fn, old_target_xib_fn)
+      # ibtool
+      #   --previous-file path_to_project/English.lproj/MainWindow.old.xib          # The old English XIB
+      #   --incremental-file path_to_project/fr.lproj/MainWindow.old.xib            # The old French XIB
+      #   --strings-file path_to_strings/fr/MainWindow.strings                      # The latest localized strings for the French XIB
+      #   --localize-incremental
+      #   --write path_to_project/fr.lproj/MainWindow.xib                           # The new French XIB that will be created
+      #   path_to_project/English.lproj/MainWindow.new.xib                          # The new English XIB
+
+      ncmd = ['ibtool', '--previous-file', old_source_xib_fn, '--incremental-file', old_target_xib_fn, 
+        '--strings-file', strings_fn, '--localize-incremental', '--write', target_xib_fn, source_xib_fn]
+      rc = Kernel.system(*ncmd)
+      $logger.error "IBTOOL ERROR: #{ncmd}" unless rc
+    end
+    
+    def self.import_strings(filename, strings_filename)
+      ncmd = ['ibtool', '--import-strings-file', strings_filename, filename]
+      rc = Kernel.system(*ncmd)
+      $logger.error "IBTOOL ERROR: #{ncmd}" unless rc
+    end
+    
+  private
+  
+  end
+end

data/lib/babelyoda/keyset.rb

@@ -0,0 +1,58 @@
+module Babelyoda
+  class Keyset
+    attr_accessor :name
+    attr_accessor :keys
+    
+    def self.keyset_name(filename)
+      raise ArgumentError.new("Invlaid filename for a .strings file: #{filename}") unless filename.match(/\.strings$/)
+      parts = File.join(File.dirname(filename), File.basename(filename, '.strings')).split('/')
+      parts.delete_if { |part| part.match(/\.lproj$/) }
+      File.join(parts)
+    end
+    
+    def initialize(name)
+      @name = name
+      @keys = {}
+    end
+    
+    def to_s ; "<#{self.class}: name = #{name}, keys.size = #{keys.size}>" ; end
+    
+    def empty? ; keys.size == 0 ; end
+    
+    def merge!(keyset, options = {})
+      result = { :new => 0, :updated => 0 }
+      keyset.keys.each_pair do |id, key|
+        if @keys.has_key?(id)
+          result[:updated] += 1 if @keys[id].merge!(key, options)
+        else
+          @keys[id] = key.dup
+          result[:new] += 1
+        end
+      end
+      return result
+    end
+    
+    def merge_key!(localization_key)
+      if @keys.has_key?(localization_key.id)
+        @keys[localization_key.id].merge!(localization_key)
+      else
+        @keys[localization_key.id] = localization_key
+      end
+    end
+    
+    def ensure_languages!(languages = [])
+      @keys.each_value do |key|
+        languages.each do |language| 
+          key.values[language] ||= Babelyoda::LocalizationValue.new(language, '')
+        end
+      end
+    end
+    
+    def drop_empty!
+      @keys.delete_if do |id, key|
+        key.drop_empty!
+        key.empty?
+      end
+    end
+  end
+end

data/lib/babelyoda/localization_key.rb

@@ -0,0 +1,56 @@
+module Babelyoda
+  class LocalizationKey
+    attr_reader :id
+    attr_reader :context
+    attr_reader :values
+    
+    def initialize(id, context)
+      @id = id
+      @context = context
+      @values = {}
+    end
+    
+    def <<(localization_value)
+      @values[localization_value.language.to_sym] = localization_value.dup
+      self
+    end
+    
+    def merge!(localization_key, options = {})
+      updated = false
+      
+      context_changed = false
+      if @context != localization_key.context
+        @context = localization_key.context
+        updated = context_changed = true
+      end
+      
+      localization_key.values.each_value do |value|
+        if @values.has_key?(value.language.to_sym)
+          updated = true if @values[value.language.to_sym].merge!(value, options)
+        else
+          @values[value.language.to_sym] = value.dup
+          updated = true
+        end
+      end
+      
+      # Mark all values as requiring translation if the context has changed.
+      if context_changed
+        @values.each_value do |value|
+          value.status = :requires_translation
+        end
+      end
+      
+      return updated
+    end
+    
+    def drop_empty!
+      @values.delete_if do |id, value|
+        value.text.empty?
+      end
+    end
+    
+    def empty?
+      @values.empty?
+    end
+  end
+end

data/lib/babelyoda/localization_value.rb

@@ -0,0 +1,26 @@
+module Babelyoda
+  class LocalizationValue
+    attr_accessor :language
+    attr_accessor :status
+    attr_accessor :text
+    
+    def initialize(language, text, status = :requires_translation)
+      @language, @text, @status = language.to_sym, text, status.to_sym
+    end
+    
+    def merge!(other_value, options = {})
+      updated = false
+      options = { preserve: false }.merge!(options)
+      unless @language.to_sym == other_value.language.to_sym
+        raise RuntimeError.new("Can't merge values in different languages: #{@language.to_sym} and #{other_value.language.to_sym}") 
+      end
+      if (!options[:preserve] || @status.to_sym == :requires_translation)
+        unless @text == other_value.text
+          @text = other_value.text 
+          updated = true
+        end
+      end
+      return updated
+    end
+  end
+end

data/lib/babelyoda/logger.rb

@@ -0,0 +1,16 @@
+require 'term/ansicolor'
+
+module Babelyoda
+  class Logger
+    include Term::ANSIColor
+    
+    def exe(cmd) ; putcmd cmd ; system cmd ; end
+    def putcmd(cmd) ; print magenta, "CMD: #{cmd}", reset, "\n" ; end
+    def status(msg) ; print blue, "--- #{msg} ---", reset, "\n" ; end
+    def success(msg) ; print green, bold, 'SUCCESS: ', msg, reset, "\n" ; end
+    def error(msg) ; print red, bold, 'ERROR: ', msg, reset, "\n" ; exit 1 ; end
+    def escape_cmd_args(args) ; args.collect{ |arg| "'#{arg}'"}.join(' ') ; end
+  end
+end
+
+$logger ||= Babelyoda::Logger.new

data/lib/babelyoda/rake.rb

@@ -0,0 +1,10 @@
+require_relative 'specification'
+
+module Babelyoda
+  module Rake
+    def self.spec(&block)
+      spec = Babelyoda::Specification.load
+      block.call(spec) if spec
+    end
+  end
+end

data/lib/babelyoda/specification.rb

@@ -0,0 +1,40 @@
+require 'erb'
+
+require_relative 'specification_loader'
+
+module Babelyoda
+	class Specification
+		include Babelyoda::SpecificationLoader
+
+    attr_accessor :name
+    attr_accessor :development_language
+    attr_accessor :localization_languages
+    attr_accessor :engine
+    attr_accessor :source_files    
+    attr_accessor :resources_folder
+    attr_accessor :xib_files    
+    attr_accessor :strings_files
+    attr_accessor :scm
+    
+    FILENAME = 'Babelfile'
+    
+    def self.generate_default_babelfile
+      template_file_name = File.join(BABELYODA_PATH, 'templates', 'Babelfile.erb')
+      template = File.read(template_file_name)
+      File.open(FILENAME, "w+") do |f|
+        f.write(ERB.new(template).result())
+      end
+    end
+    
+    def self.load
+      trace_spec = @spec.nil? && ::Rake.application.options.trace
+	    @spec ||= load_from_file(filename = FILENAME)
+	    @spec.dump if trace_spec && @spec
+	    return @spec
+    end
+    
+    def all_languages
+      [ development_language, localization_languages].flatten!
+    end
+  end
+end

data/lib/babelyoda/specification_loader.rb

@@ -0,0 +1,35 @@
+require 'awesome_print'
+
+module Babelyoda
+	module SpecificationLoader
+		def self.included(klass)
+	    klass.extend ClassMethods
+	  end
+
+    def initialize(*args)
+    	super
+    	yield(self) if block_given?
+    end
+
+	  def method_missing(method_name, *args, &block)
+	    msg = "You tried to call the method #{method_name}. There is no such method."
+	    raise msg
+  	end
+
+    def dump
+    	ap self, :indent => -2
+    end
+    
+    module ClassMethods
+
+		  def load_from_file(filename)
+		    return nil unless File.exist?(filename)
+		    spec = eval(File.read(filename))
+		    raise "Wrong specification class: #{spec.class.to_s}" unless spec.instance_of?(self)
+		    return spec
+		  end
+		  
+    end
+
+	end
+end

data/lib/babelyoda/strings.rb

@@ -1,11 +1,67 @@
-module BabelYoda
-  class StringsHelper
-    def self.safe_init_strings_file(path)
-      unless File.exists? path
-        empty_strings_file = File.join File.dirname(__FILE__), '..', '..', 'data', 'empty.strings'
-        FileUtils.mkdir_p File.split(path)[0], :verbose => true
-        FileUtils.cp empty_strings_file, path, :verbose => true
+require 'rchardet19'
+
+require_relative 'keyset'
+require_relative 'strings_lexer'
+require_relative 'strings_parser'
+
+module Babelyoda
+	class Strings < Keyset
+	  attr_reader :filename
+	  attr_reader :language
+	  
+	  def initialize(filename, language)
+	    super(Babelyoda::Keyset.keyset_name(filename))
+	    @filename, @language = filename, language
+	  end
+
+	  def read!
+      raise ArgumentError.new("File not found: #{filename}") unless File.exist?(@filename)
+      read
+    end
+    
+    def read
+      if File.exist?(@filename)
+        File.open(@filename, read_mode) do |f|
+          lexer = StringsLexer.new
+          parser = StringsParser.new(lexer, @language)
+          parser.parse(f.read) do |localization_key|
+            merge_key!(localization_key)
+          end        
+        end
+      end
+      self
+    end      
+
+    def save!
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.open(filename, "wb") do |f|
+        keys.each_pair do |id, key|
+          next unless key.values[language]
+          f << "/* #{key.context} */\n" if key.context
+          f << "\"#{id}\" = \"#{key.values[language].text}\";\n"
+          f << "\n"
+        end
+      end
+    end
+    
+    def self.save_keyset(keyset, filename, language)
+      strings = self.new(filename, language)
+      strings.merge!(keyset)
+      strings.save!
+    end
+    
+  private
+            
+    def read_mode
+      cd = CharDet.detect(File.read(@filename))
+      encoding_str = Encoding.aliases[cd.encoding] || cd.encoding
+      encoding_str = 'UTF-8' if encoding_str == 'utf-8'
+      if (encoding_str != "UTF-8")
+        "rb:#{encoding_str}:UTF-8"
+      else
+        "r"
       end
     end
-  end
+          
+	end
 end

data/lib/babelyoda/strings_lexer.rb

@@ -0,0 +1,12 @@
+module Babelyoda
+  class StringsLexer
+    TOKENS = [ :multiline_comment, :singleline_comment, :string, :reserved0, :equal_sign, :semicolon ].freeze
+
+    def lex(str)
+      str.scan(/(\/\*.*\*\/)|(\s*\/\/.*\n)|((["])(?:\\?+.)*?\4)|(\s*=\s*)|(;)/).each do |m|
+        idx = m.index { |x| x }
+        yield TOKENS[idx], m[idx].strip
+      end
+    end
+  end
+end