translatomatic 0.1.3 → 0.2.0

data/lib/translatomatic/resource_file/properties.rb

@@ -1,91 +1,62 @@
-require 'date'
-
-module Translatomatic::ResourceFile
-  # Properties resource file
-  # @see https://docs.oracle.com/javase/tutorial/essential/environment/properties.html
-  class Properties < Base
-
-    # (see Translatomatic::ResourceFile::Base.extensions)
-    def self.extensions
-      %w{properties}
-    end
-
-    # (see Translatomatic::ResourceFile::Base.is_key_value?)
-    def self.is_key_value?
-      true
-    end
-
-    # (see Translatomatic::ResourceFile::Base.supports_variable_interpolation?)
-    def self.supports_variable_interpolation?
-      true
-    end
-
-    # (see Translatomatic::ResourceFile::Base#save)
-    def save(target = path, options = {})
-      out = ""
-      out += add_created_by unless options[:no_created_by]
-      properties.each do |key, value|
-        # TODO: maintain original line ending format?
-        value = value.gsub("\n", "\\n") if value  # convert newlines to \n
-        out += "#{key} = #{value}\n"
+require 'treetop'
+
+module Translatomatic
+  module ResourceFile
+    # Properties resource file
+    # @see https://docs.oracle.com/javase/tutorial/essential/environment/properties.html
+    class Properties < Base
+      include KeyValueSupport
+
+      # (see Base.extensions)
+      def self.extensions
+        %w[properties]
       end
-      # escape unicode characters
-      out = Translatomatic::EscapedUnicode.escape(out)
-      target.write(out)
-    end
-
-    # (see Translatomatic::ResourceFile::Base#create_variable)
-    def create_variable(name)
-      return "{#{name}}"
-    end
 
-    # (see Translatomatic::ResourceFile::Base#variable_regex)
-    def variable_regex
-      /\{.*?\}/
-    end
+      # (see Base.supports_variable_interpolation?)
+      def self.supports_variable_interpolation?
+        true
+      end
 
-    private
+      # (see Base.preferred_locale_separator)
+      def self.preferred_locale_separator
+        '_'
+      end
 
-    def load
-      @properties = read_properties
-    end
+      # (see Base#create_variable)
+      def create_variable(name)
+        "{#{name}}"
+      end
 
-    def add_created_by
-      comment(created_by)
-    end
+      # (see Base#variable_regex)
+      def variable_regex
+        /\{.*?\}/
+      end
 
-    def comment(text)
-      "# #{text}\n"
-    end
+      private
 
-    def read_properties
-      contents = read_contents(@path)
-      # convert escaped unicode characters into unicode
-      contents = Translatomatic::EscapedUnicode.unescape(contents)
-      result = {}
-      contents.gsub!(/\\\s*\n\s*/m, '')  # put multi line strings on one line
-      lines = contents.split("\n")
+      Treetop.load(File.join(__dir__, 'properties.treetop'))
+      # @private
+      class Parser < PropertiesParser; end
 
-      lines.each do |line|
-        line.strip!
-        next if line.length == 0
-        equal_idx = line.index("=")
-        colon_idx = line.index(":")
+      def parse_doc(content)
+        Parser.new.parse(content)
+      end
 
-        if line[0] == ?! || line[0] == ?#
-          # comment
-          # TODO: translate comments or keep originals?
-          next
-        elsif equal_idx.nil? && colon_idx.nil?
-          # TODO: throw exception here?
-          return {}
+      def render_element(element)
+        if element.is_a? Comment
+          return '' if element.text.nil?
+          comments = element.text.split(/[\r\n]+/)
+          comments.collect do |comment|
+            format("%<type>c %<comment>s\n",
+                   type: element.type, comment: comment.strip)
+          end.join
+        elsif element.is_a? Definition
+          key = element.key
+          value = element.value
+          format(%(%<key>s = %<value>s\n),
+                 key: escape(key), value: escape(value))
         end
-        name, value = line.split(/\s*[=:]\s*/, 2)
-        value = value.gsub("\\n", "\n")      # convert \n to newlines
-        result[name] = value
       end
-      result
     end
-
   end
 end

data/lib/translatomatic/resource_file/properties.treetop

@@ -0,0 +1,87 @@
+# https://en.wikipedia.org/wiki/.properties
+grammar Properties
+  rule document
+    (whitespace / comment / definition)* {
+      def content
+        elements.collect { |i| i.content }.select { |i| i[0] != :whitespace }
+      end
+    }
+  end
+
+  rule comment
+    start_comment comment_content end_comment {
+      def content
+        [:comment, elements[1].text_value, elements[0].text_value]
+      end
+    }
+  end
+
+  rule start_comment
+    '#' / '!'
+  end
+
+  rule eof
+    !character
+  end
+
+  rule end_comment
+    newline / eof
+  end
+
+  rule comment_content
+    (!end_comment character)+
+  end
+
+  rule definition
+    key assignment value? end_definition {
+      def content
+        [:definition, elements[0].text_value, elements[2] ? elements[2].text_value : nil]
+      end
+    }
+  end
+
+  rule end_definition
+    newline / eof
+  end
+
+  rule newline
+    "\n"
+  end
+
+  rule line_continuation
+    "\\" newline whitespace*
+  end
+
+  rule assignment
+    whitespace* ('=' / ':') whitespace*
+  end
+
+  rule character
+    .
+  end
+
+  rule key
+    ('\\ ' / !assignment character)+
+    #(!assignment word)+
+  end
+
+  rule value_character
+    line_continuation / character
+  end
+
+  rule word
+    ('\\ ' / !assignment character)+
+  end
+
+  rule value
+    (!newline value_character)+
+  end
+
+  rule whitespace
+    [ \t\r\n] {
+      def content
+        [:whitespace, text_value]
+      end
+    }
+  end
+end

data/lib/translatomatic/resource_file/resw.rb

@@ -1,51 +1,66 @@
-module Translatomatic::ResourceFile
-  # Windows resources file (XML)
-  class RESW < XML
+module Translatomatic
+  module ResourceFile
+    # Windows resources file (XML)
+    class RESW < XML
+      # (see Base.extensions)
+      def self.extensions
+        %w[resw resx]
+      end
 
-    # (see Translatomatic::ResourceFile::Base.extensions)
-    def self.extensions
-      %w{resw resx}
-    end
+      # (see Base.key_value?)
+      def self.key_value?
+        true
+      end
 
-    # (see Translatomatic::ResourceFile::Base.is_key_value?)
-    def self.is_key_value?
-      true
-    end
+      private
 
-    # (see Translatomatic::ResourceFile::Base#locale_path)
-    def locale_path(locale)
-      # e.g. strings/en-US/resources.resw
-      dir = path.dirname
-      dir.parent + locale.to_s + path.basename
-    end
+      def init_nodemap
+        @nodemap = {}
+        nodes = @doc.search('//data/@name|//text()|//comment()')
+        nodes.each do |node|
+          process_node(node)
+        end
+      end
 
-    private
+      def process_node(node)
+        if node.comment?
+          @metadata.parse_comment(node.content)
+        elsif node.type == Nokogiri::XML::Node::ATTRIBUTE_NODE # data name=""
+          @key = node.content
+        elsif node.text?
+          process_text_node(node)
+        end
+      end
 
-    def init_nodemap
-      result = {}
-      key_values = @doc.search('//data/@name|//text()')
-      key_values.each_slice(2) do |key, value|
-        key = key.value
-        value = value
-        result[key] = value
+      def process_text_node(node)
+        parent = node.parent
+        if parent.name == 'value' # <value>content</value>
+          found_value(node)
+        elsif parent.name == 'comment'
+          @metadata.parse_comment(node.content)
+        end
+      end
+
+      def found_value(value)
+        @nodemap[@key] = value if @key
+        @metadata.assign_key(@key)
+        @key = nil
       end
-      @nodemap = result
-    end
 
-    def create_node(key, value)
-      # add xml: <data name="key"><value>value</value></data>
-      data_node = Nokogiri::XML::Node.new("data", @doc)
-      data_node["name"] = key
-      value_node = Nokogiri::XML::Node.new("value", @doc)
-      text_node = Nokogiri::XML::Text.new(value, @doc)
-      value_node.add_child(text_node)
-      data_node.add_child(value_node)
+      def create_node(key, value)
+        # add xml: <data name="key"><value>value</value></data>
+        data_node = Nokogiri::XML::Node.new('data', @doc)
+        data_node['name'] = key
+        value_node = Nokogiri::XML::Node.new('value', @doc)
+        text_node = Nokogiri::XML::Text.new(value.to_s, @doc)
+        value_node.add_child(text_node)
+        data_node.add_child(value_node)
 
-      @doc.root.add_child(data_node)
+        @doc.root.add_child(data_node)
 
-      @nodemap[key] = text_node
-      @properties[key] = value
+        @nodemap[key] = text_node
+        @properties[key] = value
+      end
     end
-
-  end # class
-end   # module
+  end
+end

data/lib/translatomatic/resource_file/subtitle.rb

@@ -1,75 +1,107 @@
-module Translatomatic::ResourceFile
-  # Subtitle resource file.
-  # requires 'titlekit' gem
-  class Subtitle < Base
+module Translatomatic
+  module ResourceFile
+    # Subtitle resource file.
+    # requires 'titlekit' gem
+    class Subtitle < Base
+      # (see Base.extensions)
+      def self.extensions
+        %w[srt ass ssa]
+      end
 
-    # (see Translatomatic::ResourceFile::Base.extensions)
-    def self.extensions
-      %w{srt ass ssa}
-    end
+      # (see Base.enabled?)
+      def self.enabled?
+        @enabled ||= begin
+          require 'titlekit'
+          true
+        rescue LoadError
+          false
+        end
+      end
 
-    # (see Translatomatic::ResourceFile::Base.enabled?)
-    def self.enabled?
-      @enabled ||= begin
-        require 'titlekit'
-        true
-      rescue LoadError
-        false
+      # (see Base#set)
+      def set(key, value)
+        super(key, value)
+
+        if @subtitle_map.include?(key)
+          @subtitle_map[key][:lines] = value.to_s
+        else
+          add_subtitle(lines: value) unless value.blank?
+        end
       end
-    end
 
-    # (see Translatomatic::ResourceFile::Base#set)
-    def set(key, value)
-      super(key, value)
-      if @subtitle_map.include?(key)
-        @subtitle_map[key][:lines] = value
+      # (see Base#save)
+      def save(target = path, options = {})
+        add_created_by unless options[:no_created_by] || created_by?
+        export(target)
       end
-    end
 
-    # (see Translatomatic::ResourceFile::Base#save)
-    def save(target = path, options = {})
-      export(target)
-    end
+      private
 
-    private
+      def init
+        @subtitle_map = {}
+        @subtitles = []
+        @keynum = 1
+      end
 
-    def init
-      @subtitle_map = {}
-      @subtitles = []
-    end
+      def load
+        @metadata.reset
+        subtitles = import(@path)
+        subtitles.each { |i| add_subtitle(i) }
+        init_properties
+      end
 
-    def load
-      @subtitles = import(@path)
-      init_subtitle_map
-      init_properties
-    end
+      def process_metadata(key, subtitle)
+        lines = subtitle[:lines] || ''
+        context = @metadata.parse_comment(lines)
+        @metadata.assign_key(key) unless context.present?
+      end
 
-    def init_subtitle_map
-      # map of key1 => subtitle, key2 => subtitle, ...
-      @keynum = 1
-      @subtitles.each_with_index do |subtitle, i|
+      def add_created_by
+        # TODO
+      end
+
+      def add_subtitle(subtitle = {})
         key = "key#{@keynum}"
+        subtitle[:id] ||= @keynum
+        subtitle[:start] ||= @keynum * 10
+        subtitle[:end] ||= @keynum * 10 + 5
+        process_metadata(key, subtitle)
         @keynum += 1
         @subtitle_map[key] = subtitle
+        @subtitles << subtitle
       end
-    end
 
-    def init_properties
-      @properties = @subtitle_map.transform_values { |i| i[:lines] }
-    end
+      # Find the first gap in subtitles with a minimum length in seconds.
+      # @return [Array] [start, end] Start and end times of the gap
+      def find_gap(min_length)
+        last = 0
+        @subtitles.each do |subtitle|
+          return [last, subtitle.start] if subtitle.start - last >= min_length
+          last = subtitle.end
+        end
+        [last, -1]
+      end
 
-    def import(path)
-      import_export_class(path).import(read_contents(path))
-    end
+      def init_properties
+        @properties = @subtitle_map.transform_values { |i| i[:lines] }
+      end
 
-    def export(target, options = {})
-      content = import_export_class(target).export(@subtitles) || ''
-      target.write(content.chomp)
-    end
+      def import(path)
+        contents = read_contents(path)
+        return [] if contents.blank?
+        import_export_class(path).import(contents)
+      end
 
-    def import_export_class(path)
-      class_name = path.extname.sub(/^\./, '').upcase
-      Titlekit.const_get(class_name)
+      def export(target, _options = {})
+        content = import_export_class(target).export(@subtitles) || ''
+        content = content.gsub(/[\r\n]+\Z/, '') + "\n"
+        target.write(content)
+      end
+
+      def import_export_class(path)
+        class_name = path.extname.sub(/^\./, '').upcase
+        Titlekit.const_get(class_name)
+      end
     end
   end
 end