translatomatic 0.1.3 → 0.2.0

data/lib/translatomatic/resource_file/csv.rb

@@ -1,37 +1,189 @@
 require 'csv'
 
-module Translatomatic::ResourceFile
-  # CSV resource file
-  class CSV < Base
+module Translatomatic
+  module ResourceFile
+    # CSV resource file
+    class CSV < Base
+      # (see Base.extensions)
+      def self.extensions
+        %w[csv]
+      end
 
-    # (see Translatomatic::ResourceFile::Base.extensions)
-    def self.extensions
-      %w{csv}
-    end
+      # (see Base#set)
+      def set(key, value)
+        super(key, value)
+        if @cellmap.include?(key)
+          @cellmap[key].value = value
+        else
+          add_row(key, value)
+        end
+      end
+
+      # (see Base#save)
+      def save(target = path, options = {})
+        use_headers = @options[:csv_headers]
+        csv_options = { write_headers: use_headers }
+        csv_options[:headers] = @headers if use_headers
 
-    # (see Translatomatic::ResourceFile::Base#save)
-    def save(target = path, options = {})
-      ::CSV.open(target, "wb") do |csv|
-        @properties.each do |key, value|
-          csv << [key, value]
+        ::CSV.open(target, 'wb', csv_options) do |csv|
+          @rows.each do |row|
+            csv << row.collect(&:value)
+          end
         end
       end
-    end
 
-    private
+      private
 
-    def init
-      @rows = []
-    end
+      DEFAULT_KEY_COLUMN = 'key'.freeze
+      DEFAULT_VALUE_COLUMN = 'value'.freeze
+      DEFAULT_COMMENT_COLUMN = 'comments'.freeze
+      CONTEXT_COLUMN = 'tm.context'.freeze
+
+      define_option :csv_headers, type: :boolean, default: false,
+                                  desc: t('file.csv.headers')
+      define_option :csv_translate_columns, type: :array,
+                                            desc: t('file.csv.translate_columns')
+      define_option :csv_key_column, default: DEFAULT_KEY_COLUMN,
+                                     desc: t('file.csv.key_column')
+      define_option :csv_value_column, default: DEFAULT_VALUE_COLUMN,
+                                       desc: t('file.csv.value_column')
+      define_option :csv_comment_column, default: DEFAULT_COMMENT_COLUMN,
+                                         desc: t('file.csv.comment_column')
+
+      # @private
+      Cell = Struct.new(:header, :key, :value, :translate)
 
-    def load
-      contents = read_contents(@path)
-      @rows = ::CSV.parse(contents)
-      @properties = {}
-      @rows.each do |key, value|
-        @properties[key] = value
+      def init
+        @rows = []
+        @cellmap = {} # map of String key -> Cell
+        @rownum = 0
+        @key_column = option(:csv_key_column, DEFAULT_KEY_COLUMN)
+        @value_column = option(:csv_value_column, DEFAULT_VALUE_COLUMN)
+        @comments_column = option(:csv_comment_column, DEFAULT_COMMENT_COLUMN)
+        @translate = option(:csv_translate_columns)
+      end
+
+      def option(key, default = nil)
+        @options[key] || default
+      end
+
+      def add_row(key, value)
+        @rows << load_row(@key_column => key, @value_column => value)
+      end
+
+      def load
+        contents = read_contents(@path)
+        csv_options = { headers: @options[:csv_headers] }
+
+        @rows = []
+        @rownum = 0
+
+        csv = ::CSV.parse(contents, csv_options)
+        csv.each do |row|
+          @rows << load_row(row)
+        end
+
+        init_properties
+      end
+
+      # initialise properties and cellmap from @rows
+      def init_properties
+        @properties = {}
+        @cellmap = {}
+        @rows.each do |row|
+          row.each do |cell|
+            @properties[cell.key] = cell.value if cell.translate
+            @cellmap[cell.key] = cell
+          end
+        end
       end
-    end
 
+      # @param row [Array<Cell>] row to convert to hash
+      def row_to_hash(row)
+        hash = {}
+        row.each do |cell|
+          hash[cell.header] = cell.value
+        end
+        hash
+      end
+
+      def load_row(row)
+        @rownum += 1
+        if row.is_a?(::CSV::Row)
+          @headers = row.headers
+          load_hash_row(row.to_h)
+        elsif row.is_a?(Hash)
+          load_hash_row(row)
+        elsif row.is_a?(Array)
+          load_array_row(row)
+        else
+          raise "invalid row data: #{row}"
+        end
+      end
+
+      # row is an array of values
+      # @return [Array<Cell>] cells
+      def load_array_row(row)
+        cells = []
+        row.each_with_index do |value, i|
+          translate = translate_column?((i + 1).to_s)
+          key = "key#{@rownum},#{i + 1}"
+          cells << Cell.new("column#{i + 1}", key, value, translate)
+        end
+        parse_metadata(cells)
+        cells
+      end
+
+      # row is a hash of column -> value
+      # @return [Array<Cell>] cells
+      def load_hash_row(row)
+        cells = []
+        # add a property for each column
+        colnum = 0
+        row.each do |column, value|
+          colnum += 1
+          translate = translate_column?(column)
+          key = "key#{@rownum},#{colnum}"
+          cells << Cell.new(column, key, value, translate)
+        end
+        parse_metadata(cells)
+        cells
+      end
+
+      def translate_column?(column)
+        if @translate.present?
+          # translation columns specified
+          @translate.include?(column)
+        elsif have_target_locale_column?
+          # if there is a column matching the target locale, translate that
+          # column only.
+          column == @target_locale.to_s
+        else
+          # translate if it's not the key column or comments column
+          column != @key_column && column != @comments_column
+        end
+      end
+
+      def have_target_locale_column?
+        @have_target_locale_column ||= begin
+          @target_locale && @headers &&
+            @headers.include?(@target_locale.to_s)
+        end
+      end
+
+      def parse_metadata(row)
+        comments_cell = find_cell(row, @comments_column)
+        return unless comments_cell
+        @metadata.parse_comment(comments_cell.value)
+        row.each do |cell|
+          @metadata.assign_key(cell.key, keep_context: true) if cell.translate
+        end
+        @metadata.clear_context
+      end
+
+      def find_cell(row, column_name)
+        row.find { |i| i.header == column_name }
+      end
+    end
   end
 end

data/lib/translatomatic/resource_file/html.rb

@@ -1,55 +1,34 @@
-module Translatomatic::ResourceFile
-  # HTML resource file
-  class HTML < XML
-
-    # (see Translatomatic::ResourceFile::Base.extensions)
-    def self.extensions
-      %w{html htm shtml}
-    end
-
-    # (see Translatomatic::ResourceFile::Base#locale_path)
-    def locale_path(locale)
-      extlist = extension_list
-      if extlist.length >= 2 && loc_idx = find_locale(extlist)
-        # part of the extension is the locale
-        # replace that part with the new locale
-        extlist[loc_idx] = locale.to_s
-        new_extension = extlist.join(".")
-        return strip_extensions.sub_ext("." + new_extension)
-      else
-        # add locale extension
-        ext = path.extname
-        # TODO: need configurable order for locale & ext here?
-        #path.sub_ext("#{ext}." + locale.to_s)
-        path.sub_ext("." + locale.to_s + ext)
+module Translatomatic
+  module ResourceFile
+    # HTML resource file
+    class HTML < XML
+      # (see Base.extensions)
+      def self.extensions
+        %w[html htm shtml]
       end
-    end
 
-    # (see Translatomatic::ResourceFile::Base#save)
-    def save(target = path, options = {})
-      if @doc
+      # (see Base#save)
+      def save(target = path, options = {})
+        return unless @doc
         add_created_by unless options[:no_created_by]
         target.write(@doc.to_html)
       end
-    end
 
-    private
+      private
 
-    def read_doc
-      doc = Nokogiri::HTML(@path.open) do |config|
-        config.noblanks
+      def read_doc
+        doc = Nokogiri::HTML(@path.open, &:noblanks)
+        parse_error(doc.errors[0]) if doc.errors.present?
+        doc
       end
-      parse_error(doc.errors[0]) if doc.errors.present?
-      doc
-    end
 
-    def empty_doc
-      Nokogiri::HTML("<html><body></body></html>")
-    end
+      def empty_doc
+        Nokogiri::HTML('<html><body></body></html>')
+      end
 
-    def text_nodes_xpath
-      '//*[not(self::code)]/text()'
+      def text_nodes_xpath
+        '//*[not(self::code)]/text()|//comment()'
+      end
     end
-
   end
 end

data/lib/translatomatic/resource_file/key_value_support.rb

@@ -0,0 +1,117 @@
+module Translatomatic
+  module ResourceFile
+    # @private
+    module KeyValueSupport
+      # (see Base.key_value?)
+      def self.key_value?
+        true
+      end
+
+      # (see Base#set)
+      def set(key, value)
+        super(key, value)
+        if @map.include?(key)
+          @map[key].value = value
+        else
+          element = Definition.new(key, value)
+          @elements << element
+          @map[key] = element
+          @properties[key] = value
+        end
+      end
+
+      # (see Base#save)
+      def save(target = path, options = {})
+        add_created_by unless options[:no_created_by] || created_by?
+        content = @elements.collect { |i| render_element(i) }.join
+        content = content.gsub(/[\r\n]+\Z/, '') + "\n"
+        target.write(content)
+      end
+
+      private
+
+      def init
+        @elements = []  # key/values or comment elements
+        @map = {}       # map key to elements
+      end
+
+      def load
+        @metadata.reset
+        @doc = read_doc
+        @elements = init_elements
+        @properties = {}
+        @elements.each do |element|
+          if element.is_a?(Comment)
+            @metadata.parse_comment(element.text)
+          elsif element.is_a?(Definition)
+            @metadata.assign_key(element.key)
+            @properties[element.key] = element.value
+            @map[element.key] = element
+          end
+        end
+      end
+
+      # parse document to a list of elements
+      def read_doc
+        content = read_contents(@path)
+        document = parse_doc(content)
+        raise t('file.invalid') unless document
+        document
+      end
+
+      def parse_doc(_content)
+        raise 'parse_doc must be implemented by subclass'
+      end
+
+      def render_element(_element)
+        raise 'render_element must be implemented by subclass'
+      end
+
+      def init_elements
+        # convert to a list of elements
+        @doc.content.collect do |item|
+          case item[0]
+          when :comment
+            content_to_comment(item)
+          when :definition
+            content_to_definition(item)
+          end
+        end
+      end
+
+      def content_to_definition(item)
+        key = unescape(item[1])
+        value = unescape(item[2])
+        # remove line continuations
+        value = value.gsub(/\\\n\s*/, '')
+        Definition.new(key, value)
+      end
+
+      def content_to_comment(item)
+        text = unescape(item[1])
+        Comment.new(text, item[2])
+      end
+
+      def add_created_by
+        @created_by ||= begin
+          created_by = Comment.new(created_by)
+          @elements.unshift(created_by)
+          created_by
+        end
+      end
+
+      def escape(value)
+        Translatomatic::StringEscaping.escape(value)
+      end
+
+      def unescape(value)
+        Translatomatic::StringEscaping.unescape_all(value)
+      end
+
+      # @private
+      Definition = Struct.new(:key, :value)
+      # @private
+      Comment = Struct.new(:text, :type)
+    end
+  end
+end

data/lib/translatomatic/resource_file/markdown.rb

@@ -1,50 +1,48 @@
 require 'kramdown'
 require 'reverse_markdown'
 
-module Translatomatic::ResourceFile
-  # Markdown resource file
-  class Markdown < HTML
-
-    # (see Translatomatic::ResourceFile::Base.extensions)
-    def self.extensions
-      %w{md}
-    end
+module Translatomatic
+  module ResourceFile
+    # Markdown resource file
+    class Markdown < HTML
+      # (see Base.extensions)
+      def self.extensions
+        %w[md]
+      end
 
-    # (see Translatomatic::ResourceFile::Base#save)
-    def save(target = path, options = {})
-      if @doc
-        add_created_by unless options[:no_created_by]
-        html = @doc.to_html
-        # convert html back to markdown
-        markdown = ReverseMarkdown.convert(html, unknown_tags: :bypass)
-        target.write(markdown.chomp)
+      # (see Base#save)
+      def save(target = path, options = {})
+        if @doc
+          add_created_by unless options[:no_created_by]
+          html = @doc.to_html
+          # convert html back to markdown
+          markdown = ReverseMarkdown.convert(html, unknown_tags: :bypass)
+          target.write(markdown.chomp)
+        end
       end
-    end
 
-    private
+      private
 
-    def add_created_by
-      @created_by ||= begin
-        body = @doc.at('body')
-        body.add_child("<p><i>#{created_by}</i></p>")
+      def add_created_by
+        @created_by ||= begin
+          body = @doc.at('body')
+          body.add_child("<p><i>#{created_by}</i></p>")
+        end
       end
-    end
 
-    def read_doc
-      # read markdown and convert to html
-      markdown = read_contents(@path)
-      if markdown.blank?
-        empty_doc
-      else
-        html = Kramdown::Document.new(markdown).to_html
-        # parse html with nokogiri
-        doc = Nokogiri::HTML(html) do |config|
-          config.noblanks
+      def read_doc
+        # read markdown and convert to html
+        markdown = read_contents(@path)
+        if markdown.blank?
+          empty_doc
+        else
+          html = Kramdown::Document.new(markdown).to_html
+          # parse html with nokogiri
+          doc = Nokogiri::HTML(html, &:noblanks)
+          parse_error(doc.errors[0]) if doc.errors.present?
+          doc
         end
-        parse_error(doc.errors[0]) if doc.errors.present?
-        doc
       end
     end
-
-  end  # class
-end    # module
+  end
+end