translatomatic 0.1.2 → 0.1.3

data/lib/translatomatic/string.rb

@@ -1,188 +1,188 @@
-module Translatomatic
-  # A string object with an associated locale.
-  class String
-
-    # @return [String] The string
-    attr_reader :value
-
-    # @return [Translatomatic::Locale] The string's locale
-    attr_reader :locale
-
-    # @return [Translatomatic::String] If this string is a substring of
-    #   another string, returns the original string. Otherwise, returns nil.
-    attr_reader :parent
-
-    # @return [Number] If this string is a substring of another string,
-    #   returns the starting offset of this string in the original.
-    attr_reader :offset
-
-    def initialize(value, locale, options = {})
-      @value = value.to_s || ''
-      @locale = Translatomatic::Locale.parse(locale)
-      @offset = options[:offset] || 0
-      @parent = options[:parent]
-    end
-
-    # @return [String] The value of the string
-    def to_s
-      @value
-    end
-
-    # @return [Number] The length of the string
-    def length
-      @value.length
-    end
-
-    # @return [boolean] True if the string is empty
-    def empty?
-      @value.empty?
-    end
-
-    # Invokes value.match
-    # @param pattern [Regexp,String] The regex pattern to match
-    # @return [MatchData] Object describing the match, or nil if no match
-    def match(pattern)
-      @value.match(pattern)
-    end
-
-    # @return [boolean] true if this string is a substring of another string
-    def substring?
-      @parent ? true : false
-    end
-
-    # @return [Symbol] The type of string, corresponding to TMX segtype.
-    # @see http://xml.coverpages.org/tmxSpec971212.html#SEGTYPE
-    def type
-      if sentences.length >= 2
-        :paragraph
-      else
-        script = script_data
-        @value.strip.match(/#{script.delimiter}\s*$/) ? :sentence : :phrase
-      end
-    end
-
-    # Find all sentences in the string
-    # @return [Array<Translatomatic::String] List of sentences
-    def sentences
-      substrings(sentence_regex)
-    end
-
-    # Find all substrings matching the given regex
-    # @return [Array<Translatomatic::String] List of substrings
-    def substrings(regex)
-      matches = matches(@value, regex)
-      strings = []
-      matches.each do |match|
-        substring = match.to_s
-        # find leading and trailing whitespace
-        next if substring.length == 0
-
-        parts = substring.match(/\A(\s*)(.*?)(\s*)\z/m).to_a
-        value = parts[2]
-        offset = match.offset(0)[0]
-        offset += parts[1].length  # leading whitespace
-        strings << self.class.new(value, locale, offset: offset, parent: self)
-      end
-
-      # return [self] if there's only one substring and it's equal to self
-      strings.length == 1 && strings[0].eql?(self) ? [self] : strings
-    end
-
-    # @return [boolean] true if other is a {Translatomatic::String} with
-    #   the same value and locale.
-    def eql?(other)
-      other.kind_of?(Translatomatic::String) && other.hash == hash
-    end
-
-    # (see #eql?)
-    def ==(other)
-      eql?(other)
-    end
-
-    # @!visibility private
-    def hash
-      [value, locale].hash
-    end
-
-    private
-
-    # @!visibility private
-    class Script
-      attr_reader :language
-      attr_reader :delimiter      # sentence delimiter
-      attr_reader :trailing_space # delimiter requires trailing space or eol
-      attr_reader :left_to_right  # script direction
-
-      def initialize(language:, delimiter:, trailing_space:, direction:)
-        @language = language
-        @delimiter = delimiter
-        @trailing_space = trailing_space
-        @left_to_right = direction == :ltr
-        raise "invalid direction" unless [:ltr, :rtl].include?(direction)
-      end
-    end
-
-    SCRIPT_DATA = [
-      # [language, delimiter, trailing space, direction]
-      # japanese, no space after
-      ["ja", "\u3002", false, :ltr],
-      # chinese, no space after
-      ["zh", "\u3002", false, :ltr],  # can be written any direction
-       # armenian, space after
-      ["hy", ":", true, :ltr],
-      # hindi, space after
-      ["hi", "।", true, :ltr],
-      # urdu, space after, right to left
-      ["ur", "\u06d4", true, :rtl],
-      # thai, spaces used to separate sentences
-      ["th", "\\s", false, :ltr],
-      # arabic, right to left
-      ["ar", "\\.", true, :rtl],
-      # hebrew, right to left
-      ["he", "\\.", true, :rtl],
-      # all other languages
-      ["default", "\\.", true, :ltr],
-    ]
-
-    class << self
-      attr_reader :script_data
-    end
-
-    begin
-      script_data = {}
-      SCRIPT_DATA.each do |lang, delimiter, trailing, ltr|
-        script = Script.new(language: lang, delimiter: delimiter,
-          trailing_space: trailing, direction: ltr)
-        script_data[lang] = script
-      end
-      @script_data = script_data
-    end
-
-    def matches(s, re)
-      start_at = 0
-      matches = []
-      while(m = s.match(re, start_at))
-        break if m.to_s.empty?
-        matches.push(m)
-        start_at = m.end(0)
-      end
-      matches
-    end
-
-    def sentence_regex
-      script = script_data
-      if script.trailing_space
-        regex = /.*?(?:#{script.delimiter}\s+|\z)/m
-      else
-        # no trailing space after delimiter
-        regex = /.*?(?:#{script.delimiter}|\z)/m
-      end
-    end
-
-    def script_data
-      data = self.class.script_data
-      data[locale.language] || data["default"]
-    end
-
-  end
-end
+module Translatomatic
+  # A string object with an associated locale.
+  class String
+
+    # @return [String] The string
+    attr_reader :value
+
+    # @return [Translatomatic::Locale] The string's locale
+    attr_reader :locale
+
+    # @return [Translatomatic::String] If this string is a substring of
+    #   another string, returns the original string. Otherwise, returns nil.
+    attr_reader :parent
+
+    # @return [Number] If this string is a substring of another string,
+    #   returns the starting offset of this string in the original.
+    attr_reader :offset
+
+    def initialize(value, locale, options = {})
+      @value = value.to_s || ''
+      @locale = Translatomatic::Locale.parse(locale)
+      @offset = options[:offset] || 0
+      @parent = options[:parent]
+    end
+
+    # @return [String] The value of the string
+    def to_s
+      @value
+    end
+
+    # @return [Number] The length of the string
+    def length
+      @value.length
+    end
+
+    # @return [boolean] True if the string is empty
+    def empty?
+      @value.empty?
+    end
+
+    # Invokes value.match
+    # @param pattern [Regexp,String] The regex pattern to match
+    # @return [MatchData] Object describing the match, or nil if no match
+    def match(pattern)
+      @value.match(pattern)
+    end
+
+    # @return [boolean] true if this string is a substring of another string
+    def substring?
+      @parent ? true : false
+    end
+
+    # @return [Symbol] The type of string, corresponding to TMX segtype.
+    # @see http://xml.coverpages.org/tmxSpec971212.html#SEGTYPE
+    def type
+      if sentences.length >= 2
+        :paragraph
+      else
+        script = script_data
+        @value.strip.match(/#{script.delimiter}\s*$/) ? :sentence : :phrase
+      end
+    end
+
+    # Find all sentences in the string
+    # @return [Array<Translatomatic::String] List of sentences
+    def sentences
+      substrings(sentence_regex)
+    end
+
+    # Find all substrings matching the given regex
+    # @return [Array<Translatomatic::String] List of substrings
+    def substrings(regex)
+      matches = matches(@value, regex)
+      strings = []
+      matches.each do |match|
+        substring = match.to_s
+        # find leading and trailing whitespace
+        next if substring.length == 0
+
+        parts = substring.match(/\A(\s*)(.*?)(\s*)\z/m).to_a
+        value = parts[2]
+        offset = match.offset(0)[0]
+        offset += parts[1].length  # leading whitespace
+        strings << self.class.new(value, locale, offset: offset, parent: self)
+      end
+
+      # return [self] if there's only one substring and it's equal to self
+      strings.length == 1 && strings[0].eql?(self) ? [self] : strings
+    end
+
+    # @return [boolean] true if other is a {Translatomatic::String} with
+    #   the same value and locale.
+    def eql?(other)
+      other.kind_of?(Translatomatic::String) && other.hash == hash
+    end
+
+    # (see #eql?)
+    def ==(other)
+      eql?(other)
+    end
+
+    # @!visibility private
+    def hash
+      [value, locale].hash
+    end
+
+    private
+
+    # @!visibility private
+    class Script
+      attr_reader :language
+      attr_reader :delimiter      # sentence delimiter
+      attr_reader :trailing_space # delimiter requires trailing space or eol
+      attr_reader :left_to_right  # script direction
+
+      def initialize(language:, delimiter:, trailing_space:, direction:)
+        @language = language
+        @delimiter = delimiter
+        @trailing_space = trailing_space
+        @left_to_right = direction == :ltr
+        raise "invalid direction" unless [:ltr, :rtl].include?(direction)
+      end
+    end
+
+    SCRIPT_DATA = [
+      # [language, delimiter, trailing space, direction]
+      # japanese, no space after
+      ["ja", "\u3002", false, :ltr],
+      # chinese, no space after
+      ["zh", "\u3002", false, :ltr],  # can be written any direction
+       # armenian, space after
+      ["hy", ":", true, :ltr],
+      # hindi, space after
+      ["hi", "।", true, :ltr],
+      # urdu, space after, right to left
+      ["ur", "\u06d4", true, :rtl],
+      # thai, spaces used to separate sentences
+      ["th", "\\s", false, :ltr],
+      # arabic, right to left
+      ["ar", "\\.", true, :rtl],
+      # hebrew, right to left
+      ["he", "\\.", true, :rtl],
+      # all other languages
+      ["default", "\\.", true, :ltr],
+    ]
+
+    class << self
+      attr_reader :script_data
+    end
+
+    begin
+      script_data = {}
+      SCRIPT_DATA.each do |lang, delimiter, trailing, ltr|
+        script = Script.new(language: lang, delimiter: delimiter,
+          trailing_space: trailing, direction: ltr)
+        script_data[lang] = script
+      end
+      @script_data = script_data
+    end
+
+    def matches(s, re)
+      start_at = 0
+      matches = []
+      while(m = s.match(re, start_at))
+        break if m.to_s.empty?
+        matches.push(m)
+        start_at = m.end(0)
+      end
+      matches
+    end
+
+    def sentence_regex
+      script = script_data
+      if script.trailing_space
+        regex = /.*?(?:#{script.delimiter}\s+|\z)/m
+      else
+        # no trailing space after delimiter
+        regex = /.*?(?:#{script.delimiter}|\z)/m
+      end
+    end
+
+    def script_data
+      data = self.class.script_data
+      data[locale.language] || data["default"]
+    end
+
+  end
+end

data/lib/translatomatic/tmx/document.rb

@@ -1,99 +1,99 @@
-module Translatomatic::TMX
-  # Translation Memory Exchange document
-  class Document
-
-    # Create a new instance
-    # @param units [Array<TranslationUnit>] A list of translation units
-    # @param source_locale [Locale] Source locale
-    # @return [Translatomatic::TMX::Document] a new TMX object
-    def initialize(units, source_locale)
-      units = [units] unless units.kind_of?(Array)
-      @units = units
-      @source_locale = source_locale
-    end
-
-    # @return [String] An XML string
-    def to_xml(options = {})
-      builder = Nokogiri::XML::Builder.new do |xml|
-        dtd = options[:dtd] || TMX_DTD
-        xml.doc.create_internal_subset('tmx', nil, dtd)
-        xml.tmx(version: "1.4") do
-          xml.header(creationtool: "Translatomatic",
-            creationtoolversion: Translatomatic::VERSION,
-            datatype: "PlainText",
-            segtype: "phrase",  # default segtype
-            adminlang: @source_locale.to_s,
-            srclang: @source_locale.to_s,
-            "o-tmf": DEFAULT_OTMF
-          )
-          xml.body { tmx_body(xml) }
-        end
-      end
-      builder.to_xml
-    end
-
-    # Create a TMX document from the given converter
-    # @param texts [Array<Translatomatic::Model::Text>] List of texts
-    # @return [Translatomatic::TMX::Document] TMX document
-    def self.from_texts(texts)
-      # group texts by from_text_id to create units
-      # source_locale: use from_text.locale
-      # origin: use text.translator
-      sources = texts.select { |i| i.from_text.nil? }
-      source_locales = sources.collect { |i| i.locale }.uniq
-      raise t("tmx.multiple_locales") if source_locales.length > 1
-      units = units_from_texts(texts)
-
-      return new(units, source_locales[0])
-    end
-
-    def self.valid?(xml)
-      options = Nokogiri::XML::ParseOptions::DTDVALID
-      doc = Nokogiri::XML::Document.parse(xml, nil, nil, options)
-      doc.internal_subset.validate(doc)
-    end
-
-    private
-
-    class << self
-      include Translatomatic::Util
-    end
-
-    TMX_DTD = "http://www.ttt.org/oscarstandards/tmx/tmx14.dtd"
-    DEFAULT_OTMF = "Translatomatic"
-
-    def tmx_body(xml)
-      @units.each do |unit|
-        xml.tu("segtype": unit.strings[0].type) do
-          unit.strings.each do |string|
-            xml.tuv("xml:lang": string.locale.to_s) do
-              xml.seg string.value
-            end
-          end
-        end
-      end
-    end
-
-    # @return [Array<Translatomatic::TMX::TranslationUnit] translation unit list
-    def self.units_from_texts(texts)
-      # group texts by from_text_id
-      texts_by_from_id = {}
-      texts.each do |text|
-        id = text.from_text_id || text.id
-        list = (texts_by_from_id[id] ||= [])
-        list << text
-      end
-
-      # create list of Translation Units
-      texts_by_from_id.values.collect do |list|
-        strings = list.uniq.collect { |i| string(i.value, i.locale) }
-        tmx_unit(strings)
-      end
-    end
-
-    def self.tmx_unit(strings)
-      Translatomatic::TMX::TranslationUnit.new(strings)
-    end
-
-  end # class
-end   # module
+module Translatomatic::TMX
+  # Translation Memory Exchange document
+  class Document
+
+    # Create a new instance
+    # @param units [Array<TranslationUnit>] A list of translation units
+    # @param source_locale [Locale] Source locale
+    # @return [Translatomatic::TMX::Document] a new TMX object
+    def initialize(units, source_locale)
+      units = [units] unless units.kind_of?(Array)
+      @units = units
+      @source_locale = source_locale
+    end
+
+    # @return [String] An XML string
+    def to_xml(options = {})
+      builder = Nokogiri::XML::Builder.new do |xml|
+        dtd = options[:dtd] || TMX_DTD
+        xml.doc.create_internal_subset('tmx', nil, dtd)
+        xml.tmx(version: "1.4") do
+          xml.header(creationtool: "Translatomatic",
+            creationtoolversion: Translatomatic::VERSION,
+            datatype: "PlainText",
+            segtype: "phrase",  # default segtype
+            adminlang: @source_locale.to_s,
+            srclang: @source_locale.to_s,
+            "o-tmf": DEFAULT_OTMF
+          )
+          xml.body { tmx_body(xml) }
+        end
+      end
+      builder.to_xml
+    end
+
+    # Create a TMX document from the given converter
+    # @param texts [Array<Translatomatic::Model::Text>] List of texts
+    # @return [Translatomatic::TMX::Document] TMX document
+    def self.from_texts(texts)
+      # group texts by from_text_id to create units
+      # source_locale: use from_text.locale
+      # origin: use text.translator
+      sources = texts.select { |i| i.from_text.nil? }
+      source_locales = sources.collect { |i| i.locale }.uniq
+      raise t("tmx.multiple_locales") if source_locales.length > 1
+      units = units_from_texts(texts)
+
+      return new(units, source_locales[0])
+    end
+
+    def self.valid?(xml)
+      options = Nokogiri::XML::ParseOptions::DTDVALID
+      doc = Nokogiri::XML::Document.parse(xml, nil, nil, options)
+      doc.internal_subset.validate(doc)
+    end
+
+    private
+
+    class << self
+      include Translatomatic::Util
+    end
+
+    TMX_DTD = "http://www.ttt.org/oscarstandards/tmx/tmx14.dtd"
+    DEFAULT_OTMF = "Translatomatic"
+
+    def tmx_body(xml)
+      @units.each do |unit|
+        xml.tu("segtype": unit.strings[0].type) do
+          unit.strings.each do |string|
+            xml.tuv("xml:lang": string.locale.to_s) do
+              xml.seg string.value
+            end
+          end
+        end
+      end
+    end
+
+    # @return [Array<Translatomatic::TMX::TranslationUnit] translation unit list
+    def self.units_from_texts(texts)
+      # group texts by from_text_id
+      texts_by_from_id = {}
+      texts.each do |text|
+        id = text.from_text_id || text.id
+        list = (texts_by_from_id[id] ||= [])
+        list << text
+      end
+
+      # create list of Translation Units
+      texts_by_from_id.values.collect do |list|
+        strings = list.uniq.collect { |i| string(i.value, i.locale) }
+        tmx_unit(strings)
+      end
+    end
+
+    def self.tmx_unit(strings)
+      Translatomatic::TMX::TranslationUnit.new(strings)
+    end
+
+  end # class
+end   # module