konjak 0.0.19 → 0.0.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 768f8768ce6cf9b74a7efdbc099fe192d8315263
-  data.tar.gz: 6ea6d582ac4df35043317bc274bf9391716fe5f3
+  metadata.gz: ffdb00c55006924feabdbc94d04742f2469f047b
+  data.tar.gz: d8df2981f8610a26295b044893f1409b3f3c0284
 SHA512:
-  metadata.gz: 90a225fc3be21ca3a273ff7304c5c803d72ed372449a53143090909b48e4272ba8cf9f47bc0522dc502e50582ebcd0c76c3dffce4ef605c7322e3448c9a0ab48
-  data.tar.gz: cdf1f709324975a459b808e7c855efcfa981cee5f96839905ab3744cd52fa80a7247f199957617059b1f509211582aa32558c1a8e666b827ae303a503f29f6b2
+  metadata.gz: 0a6205a76ce7c53e181b14d75109e12bfb6d3d55781b30f29d1895824a47261ac85277fdf9aa100c91b5e628d8eeb15445defaf3e4ebe74a796ea6e3af854c62
+  data.tar.gz: 1bdec79054206addf2b551ddc53ebc22d4e70a8492a526655b8d81d5504d64d8f61e67e49e62789b5353ba52436302be04d99895f2a8d947de43aec42d0dfc03

data/lib/konjak/tmx_segmentor/strategy.rb

@@ -7,117 +7,121 @@ require 'konjak/tmx_segmentor/segment_string'
 module Konjak
   class TmxSegmentor < Segmentor
     class Strategy
+      Edge = Struct.new(:prev,  :current)
+      Node = Struct.new(:range, :segment)
+      Node::None = -1
+
       include Mem
 
-      def initialize(tmx, lang, options = {})
-        @tmx = tmx
-        @lang = lang
+      def initialize(tmx, lang, text, options = {})
+        @tmx     = tmx
+        @lang    = lang
+        @text    = text
         @options = default_options.merge(options)
       end
 
-      def segmentize(text)
-        range_segment_pairs = []
-
-        translation_units.each {|tu|
-          segment = tu.variant(@lang).segment
-          text.scan(compile_pattern(segment)) {
-            range_segment_pairs << [($~.begin(0)...$~.end(0)), segment]
-          }
-        }
-
+      def segments
         # Can't split text
-        return [text] if range_segment_pairs.empty?
-
-        range_segment_pairs.uniq! {|rsp| [rsp[0], rsp[1].text] }
-        range_segment_pairs.sort_by! {|(m, s)|
-          [m.begin, -s.text.size]
-        }
-
-        max_weight_range_segments = max_weight_range_segments(range_segment_pairs)
+        return [@text] if nodes.empty?
 
         segments = []
         prev_text_index = 0
-        max_weight_range_segments.each do |(range, segment)|
-          prev_text = text[prev_text_index...range.begin]
+        max_cost_path.each do |node|
+          range     = node.range
+          segment   = node.segment
+          prev_text = @text[prev_text_index...range.begin]
 
           segments << prev_text unless prev_text.empty?
 
-          segments << SegmentString.new(text[range.begin, range.size], segment)
+          segments << SegmentString.new(@text[range.begin, range.size], segment)
 
           prev_text_index = range.end
         end
-        after_text = text[prev_text_index..-1]
+        after_text = @text[prev_text_index..-1]
         segments << after_text unless after_text.empty?
         segments
       end
 
 
-      def max_weight_range_segments(range_segment_pairs)
-        edges      = []
-        prev_nodes = Array.new(range_segment_pairs.size, -1)
-        weights    = range_segment_pairs.map {|rsp| rsp[0].size }
+      def max_cost_path
+        prev_nodes = nodes.map {|node| [node, Node::None] }.to_h
+        costs      = nodes.map {|node| [node, node.range.size] }.to_h
 
-        range_segment_pairs.each_with_index do |rsp, rsp_i|
-          ((rsp_i + 1)...range_segment_pairs.size).each do |rsp2_i|
-            rsp2 = range_segment_pairs[rsp2_i]
+        edges.each do |edge|
+          node, node2  = edge.prev, edge.current
+          new_node2_cost = costs[node] + calc_edge_cost(edge)
 
-            next if rsp2[0].begin < rsp[0].end
-
-            edges << [rsp_i, rsp2_i]
+          if costs[node2] < new_node2_cost
+            costs[node2] = new_node2_cost
+            prev_nodes[node2] = node
           end
         end
 
-        edges.each do |(rsp_i, rsp2_i)|
-          new_rsp2_weight = weights[rsp_i] + range_segment_pairs[rsp2_i][0].size
+        node, _ = costs.max_by {|_, cost| cost }
 
-          if weights[rsp2_i] < new_rsp2_weight
-            weights[rsp2_i] = new_rsp2_weight
-            prev_nodes[rsp2_i] = rsp_i
+        max_cost_node_indexes = Enumerator.new {|y|
+          loop do
+            break if node == Node::None
+            y << node
+            node = prev_nodes[node]
           end
-        end
+        }.to_a.reverse
+      end
 
-        node_index = weights.index(weights.max)
+      private
 
-        max_weight_range_segment_indexes = Enumerator.new {|y|
-          loop do
-            break if node_index == -1
-            y << node_index
-            node_index = prev_nodes[node_index]
+      def edges
+        return @edges if @edges
+
+        @edges     = []
+        nodes.each_with_index do |node, node_i|
+          ((node_i + 1)...nodes.size).each do |node2_i|
+            node2 = nodes[node2_i]
+
+            next if node2.range.begin < node.range.end
+
+            @edges << Edge.new(node, node2)
           end
-        }.to_a.reverse
+        end
 
-        max_weight_range_segment_indexes.map {|i|
-          range_segment_pairs[i]
-        }
+        @edges
       end
 
-      private
+      def nodes
+        return @nodes if @nodes
+
+        @nodes = []
+
+        translation_units.each {|tu|
+          segment = tu.variant(@lang).segment
+          @text.scan(compile_pattern(segment)) {
+            @nodes << Node.new(($~.begin(0)...$~.end(0)), segment)
+          }
+        }
+
+        @nodes.uniq! {|node| [node.range, node.segment.text] }
+        @nodes.sort_by! {|node| [node.range.begin, -node.segment.text.size] }
+
+        @nodes
+      end
 
       def default_options
         {
-          min_segment_length: 10,
-          max_segment_length: nil
+          translation_unit_filter: -> (tu) { true },
+          calc_edge_cost:  -> (edge) { edge.current.size }
         }
       end
 
-      def min_segment_length
-        @options[:min_segment_length]
+      def calc_edge_cost(edge)
+        @options[:calc_edge_cost].call(edge)
       end
 
-      def max_segment_length
-        @options[:max_segment_length]
+      def translation_unit_filter
+        @options[:translation_unit_filter]
       end
 
       def translation_units
-        @translation_units ||= @tmx.body.translation_units.select {|tu|
-          segment = tu.variant(@lang).segment
-          segment_length = segment.text.length
-
-          next false if segment_length < min_segment_length
-          next false if max_segment_length && max_segment_length < segment_length
-
-          true
-        }
+        @translation_units ||= @tmx.body.translation_units.select(&translation_unit_filter)
       end
     end
   end

data/lib/konjak/tmx_segmentor.rb

@@ -11,7 +11,7 @@ module Konjak
     }
 
     def segments
-      strategy.segmentize(content)
+      strategy.segments
     end
 
     private
@@ -33,7 +33,7 @@ module Konjak
     end
 
     def strategy
-      STRATEGIES[format].new(tmx, lang, @options)
+      STRATEGIES[format].new(tmx, lang, content, @options)
     end
 
   end

data/lib/konjak/version.rb

@@ -1,3 +1,3 @@
 module Konjak
-  VERSION = "0.0.19"
+  VERSION = "0.0.20"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: konjak
 version: !ruby/object:Gem::Version
-  version: 0.0.19
+  version: 0.0.20
 platform: ruby
 authors:
 - Seiei Higa
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-29 00:00:00.000000000 Z
+date: 2015-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport