rambling-trie 0.9.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bb17c6b1df5c473eb696bc484ff0e3b46517867
-  data.tar.gz: 0b6daafa67a20409389b80aaf9ac5d1bc6694cd2
+  metadata.gz: 9b23cfe0d2b236a7970f4666f0df6a7cc4226d22
+  data.tar.gz: 5147da530a25b386fdafd9cc59ccb1c35b2a2efc
 SHA512:
-  metadata.gz: ecaecb91b920793208c878134881f08a7718d9f9771857a49cb15f8059e35273e29f81ce21a497de37566cfae8273a13ff611b43f0d049694b0207c65efa35bd
-  data.tar.gz: 810db517696450d411d75ad59df68e410e0c1109ad1133bc7aa95363609520f8db51031a72e1b3392475524f8d10b28ca1e827bd5dbb9c3fba0aaa2417eeef41
+  metadata.gz: 71405a6dd24e710629d9e8cb8d307b2faa5664f029bcdedd749063d106e6706bce5fb07fb6ecbf776098668d0b5ab3826e3f3d6d9f75e96e516c2cbce07de2ab
+  data.tar.gz: 6d5a292f676c979dbf2e3b7cc25d8a932cf087c14325df539b2ccafd872083d9ca1140224eb4edbc93c4fb0e920bd7f75374ba0bbd260d911fdf057fdb5cdd0d

data/lib/rambling/trie/compressed_node.rb

@@ -22,18 +22,15 @@ module Rambling
       # @return [Boolean] `true` if the characters are found and form a word,
       # `false` otherwise.
       def word? chars
-        if chars.empty?
-          terminal?
-        else
-          has_word? chars
-        end
+        chars.empty? ? terminal? : has_word?(chars)
       end
 
       # Returns all words that start with the specified characters.
       # @param [Array] chars the characters to look for in the trie.
       # @return [Array] all the words contained in the trie that start with the specified characters.
       def scan chars
-        closest_node(chars).to_a
+        node = chars.empty? ? self : closest_node(chars)
+        node.to_a
       end
 
       # Always return `true` for a raw (compressed) node.
@@ -42,70 +39,58 @@ module Rambling
         true
       end
 
-      protected
+      private
 
-      def closest_node chars
-        if chars.empty?
-          self
-        else
-          current_length = 0
-          current_key, current_key_string = current_key chars.slice!(0)
+      def has_partial_word? chars
+        recursive_get(:partial_word?, chars) || false
+      end
 
-          begin
-            current_length += 1
+      def has_word? chars
+        current_key = nil
 
-            if current_key_string.length == current_length || chars.empty?
-              return children_tree[current_key].closest_node chars
-            end
-          end while current_key_string[current_length] == chars.slice!(0)
+        while !chars.empty?
+          if current_key
+            current_key << chars.slice!(0)
+          else
+            current_key = chars.slice!(0)
+          end
 
-          Rambling::Trie::MissingNode.new
+          child = children_tree[current_key.to_sym]
+          return child.word? chars if child
         end
+
+        false
       end
 
-      private
+      def closest_node chars
+        recursive_get(:scan, chars) || Rambling::Trie::MissingNode.new
+      end
 
-      def has_partial_word? chars
+      def recursive_get method, chars
         current_length = 0
-        current_key, current_key_string = current_key chars.slice!(0)
+        current_key = current_key chars.slice!(0)
 
         begin
           current_length += 1
 
-          if current_key_string.length == current_length || chars.empty?
-            return children_tree[current_key].partial_word? chars
+          if (current_key && current_key.length == current_length) || chars.empty?
+            return children_tree[current_key.to_sym].send method, chars
           end
-        end while current_key_string[current_length] == chars.slice!(0)
-
-        false
-      end
-
-      def has_word? chars
-        current_key_string = ''
-
-        while !chars.empty?
-          current_key_string << chars.slice!(0)
-          current_key = current_key_string.to_sym
-          child = children_tree[current_key]
-          return child.word? chars if child
-        end
-
-        false
+        end while current_key && current_key[current_length] == chars.slice!(0)
       end
 
       def current_key letter
-        current_key_string = current_key = ''
+        current_key = nil
 
         children_tree.keys.each do |key|
           key_string = key.to_s
           if key_string.start_with? letter
-            current_key = key
-            current_key_string = key_string
+            current_key = key_string
             break
           end
         end
 
-        [current_key, current_key_string]
+        current_key
       end
     end
   end

data/lib/rambling/trie/compressor.rb

@@ -5,39 +5,37 @@ module Rambling
       # Compresses a node from a Trie data structure.
       # @param [RawNode] node the node to compress
       # @return [CompressedNode] node the compressed version of the node
-      def compress node, parent = nil
+      def compress node
         if node.compressable?
-          merge_node_with_compressed_child node, parent
+          merge_with_child_and_compress node
         else
-          copy_node_and_compress_children node, parent
+          copy_node_and_compress_children node
         end
       end
 
       private
 
-      def merge_node_with_compressed_child node, parent
-        compressed_child = compress node.children.first
+      def merge_with_child_and_compress node
+        child = node.children.first
 
-        new_node = Rambling::Trie::CompressedNode.new parent
-        new_node.letter = node.letter.to_s << compressed_child.letter.to_s
-        new_node.terminal! if compressed_child.terminal?
-        new_node.children_tree = compressed_child.children_tree
+        new_node = Rambling::Trie::CompressedNode.new node.parent
+        new_node.letter = node.letter.to_s << child.letter.to_s
+        new_node.terminal! if child.terminal?
+        new_node.children_tree = child.children_tree
 
-        new_node.children.each do |child|
-          child.parent = new_node
-        end
-
-        new_node
+        compress new_node
       end
 
-      def copy_node_and_compress_children node, parent
-        new_node = Rambling::Trie::CompressedNode.new parent
-
+      def copy_node_and_compress_children node
+        new_node = Rambling::Trie::CompressedNode.new node.parent
         new_node.letter = node.letter
         new_node.terminal! if node.terminal?
 
-        node.children.map do |child|
-          compress child, new_node
+        node.children.each do |child|
+          compressed_child = compress child
+
+          compressed_child.parent = new_node
+          new_node[compressed_child.letter] = compressed_child
         end
 
         new_node

data/lib/rambling/trie/container.rb

@@ -49,14 +49,14 @@ module Rambling
       # @param [String] word the word or partial word to look for in the trie.
       # @return [Boolean] `true` if the word or partial word is found, `false` otherwise.
       def partial_word? word = ''
-        root.partial_word? word.chars.to_a
+        root.partial_word? word.chars
       end
 
       # Checks if a whole word exists in the trie.
       # @param [String] word the word to look for in the trie.
       # @return [Boolean] `true` only if the word is found and the last character corresponds to a terminal node.
       def word? word = ''
-        root.word? word.chars.to_a
+        root.word? word.chars
       end
 
       # Returns all words that start with the specified characters.

data/lib/rambling/trie/node.rb

@@ -73,9 +73,9 @@ module Rambling
         parent.to_s << letter.to_s
       end
 
-      def letter= new_letter
-        if new_letter
-          @letter = new_letter.to_sym
+      def letter= letter
+        if letter
+          @letter = letter.to_sym
           parent[letter] = self if parent
         end
       end

data/lib/rambling/trie/tasks/helpers/path.rb

@@ -4,6 +4,10 @@ module Helpers
       Pathname.new(full_path *filename).cleanpath
     end
 
+    def dictionary
+      path 'assets', 'dictionaries', 'words_with_friends.txt'
+    end
+
     private
 
     def full_path *filename

data/lib/rambling/trie/tasks/performance/all.rb

@@ -1,4 +1,17 @@
 namespace :performance do
-  desc 'Generate profiling and performance reports'
-  task all: ['profile:call_tree', :report]
+  desc 'Generate all profiling and performance reports'
+  task all: [
+    'benchmark:all',
+    'profile:call_tree:all',
+    'profile:memory:all',
+  ]
+
+  namespace :all do
+    desc 'Generate and store all profiling and performance reports'
+    task save: [
+      'benchmark:all:save',
+      'profile:call_tree:all',
+      'profile:memory:all',
+    ]
+  end
 end

data/lib/rambling/trie/tasks/performance/benchmark.rb

@@ -3,17 +3,38 @@ require_relative '../helpers/path'
 namespace :performance do
   include Helpers::Path
 
+  class BenchmarkReport
+    attr_reader :output
+
+    def initialize output
+      @output = output
+    end
+
+    def finish
+      output.close
+    end
+  end
+
   class BenchmarkMeasurement
     def initialize output
       @output = output
     end
 
+    def param_to_s param
+      case param
+      when Rambling::Trie::Container
+        ''
+      else
+        param.to_s
+      end
+    end
+
     def perform times, params = nil
       params = Array params
       params << nil unless params.any?
 
       params.each do |param|
-        output.print "#{param}".ljust 20
+        output.print param_to_s(param).ljust 20
 
         measure times, param do |param|
           yield param
@@ -43,64 +64,88 @@ namespace :performance do
     end
   end
 
-  def with_file filename = nil
-    output = filename.nil? ? IO.new(1) : File.open(filename, 'a+')
+  def benchmark_report= benchmark_report
+    @benchmark_report = benchmark_report
+  end
 
-    yield output
+  def benchmark_report
+    Rake::Task['performance:benchmark:output:stdout'].invoke unless @benchmark_report
 
-    output.close
+    @benchmark_report
   end
 
-  def generate_lookups_benchmark filename = nil
-    with_file filename do |output|
-      measure = BenchmarkMeasurement.new output
-      measure.banner
-
-      trie = Rambling::Trie.create path('assets', 'dictionaries', 'words_with_friends.txt')
-      [ trie, trie.clone.compress! ].each do |trie|
-        output.puts "==> #{trie.compressed? ? 'Compressed' : 'Uncompressed'}"
-        words = %w(hi help beautiful impressionism anthropological)
+  def output
+    benchmark_report.output
+  end
 
-        output.puts '`word?`'
-        measure.perform 200_000, words do |word|
-          trie.word? word
-        end
+  def generate_lookups_benchmark filename = nil
+    measure = BenchmarkMeasurement.new output
+    measure.banner
+
+    trie = Rambling::Trie.create dictionary
+    compressed_trie = Rambling::Trie.create(dictionary).compress!
+    [ trie, compressed_trie ].each do |trie|
+      output.puts "==> #{trie.compressed? ? 'Compressed' : 'Uncompressed'}"
+      words = %w(hi help beautiful impressionism anthropological)
+
+      output.puts '`word?`'
+      measure.perform 200_000, words do |word|
+        trie.word? word
+      end
 
-        output.puts '`partial_word?`'
-        measure.perform 200_000, words do |word|
-          trie.partial_word? word
-        end
+      output.puts '`partial_word?`'
+      measure.perform 200_000, words do |word|
+        trie.partial_word? word
       end
     end
   end
 
   def generate_scans_benchmark filename = nil
-    with_file filename do |output|
-      measure = BenchmarkMeasurement.new output
-      measure.banner
-
-      words = {
-        hi: 1_000,
-        help: 100_000,
-        beautiful: 100_000,
-        impressionism: 200_000,
-        anthropological: 200_000,
-      }
-      trie = Rambling::Trie.create path('assets', 'dictionaries', 'words_with_friends.txt')
-
-      [ trie, trie.clone.compress! ].each do |trie|
-        output.puts "==> #{trie.compressed? ? 'Compressed' : 'Uncompressed'}"
-        output.puts "`scan`"
-        words.each do |word, times|
-          measure.perform times, word.to_s do |word|
-            trie.scan(word).size
-          end
+    measure = BenchmarkMeasurement.new output
+    measure.banner
+
+    words = {
+      hi: 1_000,
+      help: 100_000,
+      beautiful: 100_000,
+      impressionism: 200_000,
+      anthropological: 200_000,
+    }
+
+    trie = Rambling::Trie.create dictionary
+    compressed_trie = Rambling::Trie.create(dictionary).compress!
+
+    [ trie, compressed_trie ].each do |trie|
+      output.puts "==> #{trie.compressed? ? 'Compressed' : 'Uncompressed'}"
+      output.puts "`scan`"
+      words.each do |word, times|
+        measure.perform times, word.to_s do |word|
+          trie.scan(word).size
         end
       end
     end
   end
 
   namespace :benchmark do
+    namespace :output do
+      desc 'Set task reporting output to stdout'
+      task :stdout do
+        self.benchmark_report = BenchmarkReport.new IO.new(1)
+      end
+
+      desc 'Set task reporting output to file'
+      task file: ['performance:directory'] do
+        path = path 'reports', Rambling::Trie::VERSION, 'benchmark'
+        file = File.open path, 'a+'
+        self.benchmark_report = BenchmarkReport.new file
+      end
+
+      desc 'Close output stream'
+      task :close do
+        benchmark_report.finish unless benchmark_report.nil?
+      end
+    end
+
     desc 'Generate lookups performance benchmark report'
     task :lookups do
       generate_lookups_benchmark
@@ -111,50 +156,53 @@ namespace :performance do
       generate_scans_benchmark
     end
 
-    namespace :lookups do
-      desc 'Generate performance benchmark report store results in reports/'
-      task save: ['performance:directory'] do
-        puts 'Generating performance benchmark report for lookups...'
-        generate_lookups_benchmark path('reports', Rambling::Trie::VERSION, 'benchmark')
-        puts "Benchmarks have been saved to reports/#{Rambling::Trie::VERSION}/benchmark"
-      end
-    end
-
+    desc 'Generate creation performance benchmark report'
     task :creation do
-      with_file do |output|
-        measure = BenchmarkMeasurement.new output
-        measure.banner
-
-        output.puts '==> Creation'
-        output.puts '`Rambling::Trie.create`'
-        measure.perform 5 do
-          trie = Rambling::Trie.create path('assets', 'dictionaries', 'words_with_friends.txt')
-        end
+      measure = BenchmarkMeasurement.new output
+      measure.banner
+
+      output.puts '==> Creation'
+      output.puts '`Rambling::Trie.create`'
+      measure.perform 5 do
+        trie = Rambling::Trie.create dictionary
+        nil
       end
     end
 
+    desc 'Generate compression performance benchmark report'
     task :compression do
-      with_file do |output|
-        measure = BenchmarkMeasurement.new output
-        measure.banner
+      measure = BenchmarkMeasurement.new output
+      measure.banner
 
-        output.puts '==> Compression'
-        output.puts '`compress!`'
+      output.puts '==> Compression'
+      output.puts '`compress!`'
 
-        trie = Rambling::Trie.create path('assets', 'dictionaries', 'words_with_friends.txt')
-        measure.perform 5 do
-          trie.clone.compress!
-        end
+      tries = []
+      5.times { tries << Rambling::Trie.create(dictionary) }
+
+      measure.perform 5, tries do |trie|
+        trie.compress!
+        nil
       end
     end
 
+    desc 'Generate all performance benchmark reports'
     task all: [
-      'performance:benchmark:creation',
-      'performance:benchmark:compression',
-      'performance:benchmark:lookups',
-      'performance:benchmark:scans',
+      'creation',
+      'compression',
+      'lookups',
+      'scans',
     ]
 
+    namespace :all do
+      desc "Generate and store performance benchmark report in reports/#{Rambling::Trie::VERSION}"
+      task save: [
+        'output:file',
+        'all'
+      ]
+    end
+
+    desc 'Compare ips for different implementations (changes over time)'
     task :compare do
       Benchmark.ips do |b|
         hash = { 'thing' => 'gniht' }
@@ -170,3 +218,7 @@ namespace :performance do
     end
   end
 end
+
+current_tasks =  Rake.application.top_level_tasks
+current_tasks << 'performance:benchmark:output:close'
+Rake.application.instance_variable_set :@top_level_tasks, current_tasks