babelish_rnc 1.0.0.pre

data/lib/babelish_rnc/commandline.rb

@@ -0,0 +1,188 @@
+require 'thor'
+require 'yaml'
+class Commandline < Thor
+  include Thor::Actions
+  class_option :verbose, :type => :boolean
+  class_option :config, :type => :string, :aliases => "-c", :desc => "Read configuration from given file", :default => ".babelish"
+  map "-v" => :version
+
+  CSVCLASSES = [
+    {:name => "CSV2Strings", :ext => ".strings"},
+    {:name => "CSV2Android", :ext => ".xml"},
+    {:name => "CSV2JSON", :ext => ".json"},
+    {:name => "CSV2Php", :ext => ".php"},
+  ]
+
+  CSVCLASSES.each do |klass|
+    desc "#{klass[:name].downcase}", "Convert CSV file to #{klass[:ext]}"
+    method_option :filename, :type => :string, :aliases => "-i", :desc => "CSV file to convert from or name of file in Google Drive"
+    method_option :langs, :type => :hash, :aliases => "-L", :desc => "Languages to convert. i.e. English:en"
+
+    # optional options
+    method_option :excluded_states, :type => :array, :aliases => "-x", :desc => "Exclude rows with given state"
+    method_option :state_column, :type => :numeric, :aliases => "-s", :desc => "Position of column for state if any"
+    method_option :keys_column, :type => :numeric, :aliases => "-k", :desc => "Position of column for keys"
+    method_option :comments_column, :type => :numeric, :aliases => "-C", :desc => "Position of column for comments if any"
+    method_option :default_lang, :type => :string, :aliases => "-l", :desc => "Default language to use for empty values if any"
+    method_option :csv_separator, :type => :string, :aliases => "-S", :desc => "CSV column separator character, uses ',' by default"
+    method_option :output_dir, :type => :string, :aliases => "-d", :desc => "Path of output files"
+    method_option :output_basenames, :type => :array, :aliases => "-o", :desc => "Basename of output files"
+    method_option :stripping, :type => :boolean, :aliases => "-N", :default => false, :desc => "Strips values of spreadsheet"
+    method_option :ignore_lang_path, :type => :boolean, :aliases => "-I", :lazy_default => false, :desc => "Ignore the path component of langs"
+    method_option :fetch, :type => :boolean, :desc => "Download file from Google Drive"
+    method_option :sheet, :type => :numeric, :desc => "Index of worksheet to download. First index is 0"
+    if klass[:name] == "CSV2Strings"
+      method_option :macros_filename, :type => :boolean, :aliases => "-m", :lazy_default => false, :desc => "Filename containing defines of localized keys"
+    end
+    define_method("#{klass[:name].downcase}") do
+      csv2base(klass[:name])
+    end
+  end
+
+  BASECLASSES = [
+    {:name => "Strings2CSV", :ext => ".strings"},
+    {:name => "Android2CSV", :ext => ".xml"},
+    {:name => "JSON2CSV", :ext => ".json"},
+    {:name => "Php2CSV", :ext => ".php"},
+  ]
+
+  BASECLASSES.each do |klass|
+    desc "#{klass[:name].downcase}", "Convert #{klass[:ext]} files to CSV file"
+    method_option :filenames, :type => :array, :aliases => "-i", :desc => "location of strings files (FILENAMES)"
+
+    # optional options
+    method_option :csv_filename, :type => :string, :aliases => "-o", :desc => "location of output file"
+    method_option :headers, :type => :array, :aliases => "-h", :desc => "override headers of columns, default is name of input files and 'Variables' for reference"
+    method_option :dryrun, :type => :boolean, :aliases => "-n", :desc => "prints out content of hash without writing file"
+    define_method("#{klass[:name].downcase}") do
+      begin
+        base2csv(klass[:name])
+      rescue Errno::ENOENT => e
+        warn e.message
+      end
+    end
+  end
+
+  desc "csv_download", "Download Google Spreadsheet containing translations"
+  method_option :gd_filename, :type => :string, :desc => "File to download from Google Drive."
+  method_option :sheet, :type => :numeric, :desc => "Index of worksheet to download. First index is 0."
+  method_option :all, :type => :boolean, :lazy_default => true, :desc => "Download all worksheets to individual csv files."
+  method_option :output_filename, :type => :string, :desc => "Filepath of downloaded file."
+  def csv_download
+    all = options[:sheet] ? false : options[:all]
+    filename = options['gd_filename']
+    raise ArgumentError.new("csv_download command : missing file to download") unless filename
+    if all
+      download(filename)
+    else
+      download(filename, options['output_filename'], options['sheet'])
+    end
+  end
+
+  desc "open FILE", "Open local csv file in default editor or Google Spreadsheet containing translations in default browser"
+  def open(file = "translations.csv")
+    filename = file || options["filename"]
+    if File.exist?(filename)
+      say "Opening local file '#{filename}'"
+      system "open \"#{filename}\""
+    else
+      say "Opening Google Drive file '#{filename}'"
+      gd = BabelishRnc::GoogleDoc.new
+      gd.open filename.to_s
+    end
+  end
+
+  desc "init", "Create a configuration file from template"
+  def init
+    if File.exist?(".babelish")
+      say "Config file '.babelish' already exists."
+    else
+      say "Creating new config file '.babelish'."
+      config_file = File.expand_path("../../../.babelish.sample", __FILE__)
+      if File.exist?(config_file)
+        system "cp #{config_file} .babelish"
+      else
+        say "Template '#{config_file}' not found."
+      end
+    end
+  end
+
+
+  desc "version", "Display current version"
+  def version
+    require "babelish_rnc/version"
+    say "babelish_rnc #{BabelishRnc::VERSION}"
+  end
+
+  no_tasks do
+    def download(filename, output_filename = nil, worksheet_index = nil)
+      gd = BabelishRnc::GoogleDoc.new
+      if output_filename || worksheet_index
+        file_path = gd.download_spreadsheet filename.to_s, output_filename, worksheet_index
+        files = [file_path].compact
+      else
+        files = gd.download filename.to_s
+        file_path = files.join("\n") unless files.empty?
+      end
+
+      if file_path
+        say "File '#{filename}' downloaded to :\n#{file_path.to_s}"
+      else
+        say "Could not download the requested file: #{filename}"
+      end
+      files
+    end
+
+    def csv2base(classname)
+      args = options.dup
+      if options[:fetch]
+        say "Fetching csv file #{options[:filename]} from Google Drive"
+        files = download(options[:filename], nil, options[:sheet])
+        abort if files.empty? # no file downloaded
+        args.delete(:fetch)
+      else
+        files = [options[:filename]]
+      end
+      args.delete(:langs)
+      args.delete(:filename)
+
+      xcode_macros = BabelishRnc::XcodeMacros.new if options[:macros_filename]
+      files.each_with_index do |filename, index|
+        if options[:output_basenames]
+          args[:output_basename] = options[:output_basenames][index]
+        end
+
+        class_object = eval "BabelishRnc::#{classname}"
+        args = Thor::CoreExt::HashWithIndifferentAccess.new(args)
+        converter = class_object.new(filename, options[:langs], args)
+        say converter.convert
+        xcode_macros.process(converter.table, converter.keys, converter.comments) if options[:macros_filename]
+      end
+      if options[:macros_filename]
+        say "generating macros"
+        xcode_macros.write_content(options[:macros_filename])
+      end
+    end
+
+    def base2csv(classname)
+      class_object = eval "BabelishRnc::#{classname}"
+      converter = class_object.new(options)
+
+      debug_values = converter.convert(!options[:dryrun])
+      say debug_values.inspect if options[:dryrun]
+    end
+  end
+
+  def self.exit_on_failure?
+    true
+  end
+
+  private
+
+  def options
+    original_options = super
+    return original_options unless File.exist?(original_options["config"])
+    defaults = ::YAML.load_file(original_options["config"]) || {}
+    Thor::CoreExt::HashWithIndifferentAccess.new(defaults.merge(original_options))
+  end
+end

data/lib/babelish_rnc/csv2android.rb

@@ -0,0 +1,53 @@
+module BabelishRnc
+  class CSV2Android < Csv2Base
+    attr_accessor :file_path
+
+    def initialize(filename, langs, args = {})
+      super(filename, langs, args)
+
+      @file_path = args[:output_dir].to_s
+      @output_basename = args[:output_basename].to_s
+    end
+
+    def language_filepaths(language)
+      require 'pathname'
+      output_name = "strings.xml"
+      output_name = "#{@output_basename}.xml" unless @output_basename.empty?
+      filepath = Pathname.new(@file_path) + "values-#{language.code}" + output_name
+      return filepath ? [filepath] : []
+    end
+
+    def process_value(row_value, default_value)
+      value = super(row_value, default_value)
+      # if the value begins and ends with a quote we must leave them unescapted
+      if value.size > 4 && value[0, 2] == "\\\"" && value[value.size - 2, value.size] == "\\\""
+        value[0, 2] = "\""
+        value[value.size - 2, value.size] = "\""
+      end
+      value.to_utf8
+    end
+
+    def get_row_format(row_key, row_value, comment = nil, indentation = 0)
+      entry = comment.to_s.empty? ? "" : "\n\t<!-- #{comment} -->\n"
+      entry + "\t<string name=\"#{row_key}\">#{row_value}</string>\n"
+    end
+
+    def hash_to_output(content = {})
+      output = ''
+      if content && content.size > 0
+        output += "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+        output += "<resources>\n"
+        content.each do |key, value|
+          comment = @comments[key]
+          output += get_row_format(key, value, comment)
+        end
+        output += "</resources>\n"
+      end
+      return output
+    end
+
+    def extension
+      "xml"
+    end
+  end
+end

data/lib/babelish_rnc/csv2base.rb

@@ -0,0 +1,189 @@
+require 'pathname'
+module BabelishRnc
+  class Csv2Base
+    attr_accessor :output_dir, :output_basename
+    attr_accessor :ignore_lang_path
+    attr_accessor :langs
+    attr_accessor :csv_filename
+    attr_accessor :default_lang
+    attr_accessor :csv_separator
+    attr_accessor :excluded_states, :state_column, :keys_column, :comments_column
+    attr_accessor :languages
+
+    def initialize(filename, langs, args = {})
+      default_args = {
+        :excluded_states => [],
+        :state_column => nil,
+        :keys_column => 0,
+        :csv_separator => ","
+      }
+
+      args = default_args.merge!(args)
+      args = Thor::CoreExt::HashWithIndifferentAccess.new(args)
+      @langs = langs
+
+      # check input types
+      raise ArgumentError.new("wrong value of filename: #{filename.inspect}") unless filename.is_a?(String)
+      if !@langs.is_a?(Hash) || @langs.size == 0
+        raise ArgumentError.new("wrong format or/and langs parameter: #{@langs.inspect}")
+      end
+
+      @output_basename = args[:output_basename]
+      @output_dir = args[:output_dir].to_s
+      @csv_filename = filename
+      @excluded_states = args[:excluded_states]
+      @state_column = args[:state_column]
+      @keys_column = args[:keys_column]
+      @comments_column = args[:comments_column]
+      @default_lang = args[:default_lang]
+      @csv_separator = args[:csv_separator]
+      @ignore_lang_path = args[:ignore_lang_path]
+      @stripping = args[:stripping]
+      @languages = []
+      @comments = {}
+    end
+
+    def create_file_from_path(file_path)
+      path = File.dirname(file_path)
+      FileUtils.mkdir_p path
+      return File.new(file_path, "w")
+    end
+
+    def keys
+      @languages.each do |lang|
+        next unless lang
+        return lang.content.keys unless lang.content.keys.empty?
+      end
+      return []
+    end
+
+    def table
+      output_basename
+    end
+
+    def comments
+      @comments  
+    end
+
+    def language_filepaths(language)
+      #implement in subclass
+      []
+    end
+
+    def extension
+      #implement in subclass
+      ""
+    end
+
+    def default_filepath
+      Pathname.new(@output_dir) + "#{output_basename}.#{extension}"
+    end
+
+    def process_value(row_value, default_value)
+      value = row_value.nil? ? default_value : row_value
+      value = "" if value.nil?
+      value.gsub!(/\\*\"/, "\\\"") # escape double quotes
+      value.gsub!(/\n/, "\\n") # replace new lines with \n, dont strip
+      value.strip! if @stripping
+      return value.to_utf8
+    end
+
+    def get_row_format(row_key, row_value, comment = nil, indentation = 0)
+      # ignoring comment by default
+      "\"#{row_key}\"" + " " * indentation + " = \"#{row_value}\""
+    end
+
+    # Convert csv file to multiple Localizable.strings files for each column
+    def convert(name = @csv_filename)
+      rowIndex     = 0
+      excludedCols = []
+      defaultCol   = 0
+
+      CSV.foreach(name, :quote_char => '"', :col_sep => @csv_separator, :row_sep => :auto) do |row|
+
+        if rowIndex == 0
+          #check there's at least two columns
+          return unless row.count > 1
+        else
+          #skip empty lines (or sections)
+          next if row == nil or row[@keys_column].nil?
+        end
+
+        # go through columns
+        row.size.times do |i|
+          next if excludedCols.include? i
+
+          #header
+          if rowIndex == 0
+            # defaultCol can be the keyValue
+            defaultCol = i if self.default_lang == row[i]
+            # ignore all headers not listed in langs to create files
+            (excludedCols << i and next) unless @langs.has_key?(row[i])
+
+            language = Language.new(row[i])
+            if @langs[row[i]].is_a?(Array)
+              @langs[row[i]].each do |id|
+                language.add_language_id(id.to_s)
+              end
+            else
+              language.add_language_id(@langs[row[i]].to_s)
+            end
+            @languages[i] = language
+          elsif !@state_column || (row[@state_column].nil? || row[@state_column] == '' || !@excluded_states.include?(row[@state_column]))
+            key = row[@keys_column]
+            comment = @comments_column ? row[@comments_column] : nil
+            key.strip! if @stripping
+            default_value =  self.default_lang ? row[defaultCol] : nil
+            value = self.process_value(row[i], default_value)
+            @comments[key] = comment
+            @languages[i].add_content_pair(key, value)
+          end
+        end
+
+        rowIndex += 1
+      end
+
+      write_content
+    end
+
+    def write_content
+      info = "List of created files:\n"
+      count = 0
+      @languages.each do |language|
+        next if language.nil?
+
+        files = []
+        if @ignore_lang_path
+          files << create_file_from_path(default_filepath)
+        else
+          language_filepaths(language).each do |filename|
+            files << create_file_from_path(filename)
+          end
+        end
+        files.each do |file|
+          file.write hash_to_output(language.content)
+          info += "- #{File.absolute_path(file)}\n"
+          count += 1
+
+          file.close
+        end
+      end
+
+      info = "Created #{count} files.\n" + info
+      return info
+    end
+
+    def hash_to_output(content = {})
+      output = ''
+      indentation = content.map(&:first).max { |a, b| a.length <=> b.length }.length
+      if content && content.size > 0
+        content.each do |key, value|
+          comment = @comments[key]
+          defaultlang  = @languages[1].content[key]
+          output += get_row_format(key, value, comment, indentation - key.length, defaultlang)
+        end
+      end
+      return output
+    end
+  end
+end

data/lib/babelish_rnc/csv2json.rb

@@ -0,0 +1,21 @@
+module BabelishRnc
+  require 'json'
+  class CSV2JSON < Csv2Base
+
+    def language_filepaths(language)
+      require 'pathname'
+      filename = @output_basename || language.code
+      filepath = Pathname.new("#{@output_dir}#{filename}.json")
+
+      return filepath ? [filepath] : []
+    end
+
+    def hash_to_output(content = {})
+      return content.to_json
+    end
+
+    def extension
+      "js"
+    end
+  end
+end