autocompletion 0.0.1

data/README.markdown

@@ -0,0 +1,51 @@
+README
+======
+
+
+Summary
+-------
+This gem provides fast prefix-autocompletion in pure ruby.
+
+
+Installation
+------------
+`gem install autocompletion`
+
+
+Usage
+-----
+
+### Autocomplete words
+    auto = AutoCompletion.words(%w[foo bar baz])
+    auto.complete('f') # => ["foo"]
+    auto.complete('b') # => ["bar", "baz"]
+    auto.complete('z') # => []
+
+### Autocomplete objects by attributes
+    Person  = Struct.new(:first_name, :last_name)
+    people  = [
+      Person.new("Peter", "Parker"),
+      Person.new("Luke", "Skywalker"),
+      Person.new("Anakin", "Skywalker"),
+    ]
+    auto    = AutoCompletion.map(people) { |person|
+      [person.first_name, person.last_name]
+    }
+
+    auto.complete("P")
+    # => [#<struct Person first_name="Peter", last_name="Parker">]
+
+    auto.complete("S")
+    # => [#<struct Person first_name="Luke", last_name="Skywalker">,
+    #     #<struct Person first_name="Anakin", last_name="Skywalker">]
+
+    auto.complete("S", "L")
+    # => [#<struct Person first_name="Luke", last_name="Skywalker">]
+
+
+Links
+-----
+
+* __Github__          http://github.com/apeiros/autocompletion
+* __Documentation__   http://rdoc.info/github/apeiros/autocompletion/master/frames
+* __Rubygems__        http://rubygems.org/gems/autocompletion

data/Rakefile

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.expand_path('../rake/lib', __FILE__))
+Dir.glob(File.expand_path('../rake/tasks/**/*.{rake,task,rb}', __FILE__)) do |task_file|
+  begin
+    import task_file
+  rescue LoadError => e
+    warn "Failed to load task file #{task_file}"
+    warn "  #{e.class} #{e.message}"
+    warn "  #{e.backtrace.first}"
+  end
+end

data/autocompletion.gemspec

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+Gem::Specification.new do |s|
+  s.name                      = "autocompletion"
+  s.version                   = "0.0.1"
+  s.authors                   = "Stefan Rusterholz"
+  s.email                     = "stefan.rusterholz@gmail.com"
+  s.homepage                  = "http://github.com/apeiros/autocompletion"
+
+  s.description               = <<-DESCRIPTION.gsub(/^    /, '').chomp
+    This gem provides fast prefix-autocompletion in pure ruby.
+  DESCRIPTION
+
+  s.summary                   = <<-SUMMARY.gsub(/^    /, '').chomp
+    Fast prefix-autocompletion in pure ruby.
+  SUMMARY
+
+  s.files                     =
+    Dir['bin/**/*'] +
+    Dir['lib/**/*'] +
+    Dir['rake/**/*'] +
+    Dir['test/**/*'] +
+    %w[
+      autocompletion.gemspec
+      Rakefile
+      README.markdown
+    ]
+
+  if File.directory?('bin') then
+    executables = Dir.chdir('bin') { Dir.glob('**/*').select { |f| File.executable?(f) } }
+    s.executables = executables unless executables.empty?
+  end
+
+  s.required_rubygems_version = Gem::Requirement.new("> 1.3.1")
+  s.rubygems_version          = "1.3.1"
+  s.specification_version     = 3
+end

data/lib/autocompletion.rb

@@ -0,0 +1,204 @@
+# encoding: utf-8
+
+
+
+require 'autocompletion/version'
+
+
+
+# AutoCompletion
+# A binary search for prefix-matching is used to determine left- and right-
+# boundary. This means even with 1_000_000 items, a maximum of 40 comparisons
+# is required.
+#
+# @example Autocomplete words
+#     auto = AutoCompletion.words(%w[foo bar baz])
+#     auto.complete('f') # => ["foo"]
+#     auto.complete('b') # => ["bar", "baz"]
+#     auto.complete('z') # => []
+#
+# @example Autocomplete objects by attributes
+#     Person  = Struct.new(:first_name, :last_name)
+#     people  = [
+#       Person.new("Peter", "Parker"),
+#       Person.new("Luke", "Skywalker"),
+#       Person.new("Anakin", "Skywalker"),
+#     ]
+#     auto    = AutoCompletion.map(people) { |person|
+#       [person.first_name, person.last_name]
+#     }
+#
+#     auto.complete("P")
+#     # => [#<struct Person first_name="Peter", last_name="Parker">]
+#
+#     auto.complete("S")
+#     # => [#<struct Person first_name="Luke", last_name="Skywalker">,
+#     #     #<struct Person first_name="Anakin", last_name="Skywalker">]
+#
+#     auto.complete("S", "L")
+#     # => [#<struct Person first_name="Luke", last_name="Skywalker">]
+class AutoCompletion
+
+  # Raised by AutoCompletion::new
+  class InvalidOrder < ArgumentError
+    def initialize
+      super("The prefixes are not in sorted order")
+    end
+  end
+
+  # @return [AutoCompletion]
+  #   An autocompletion for a list of words.
+  def self.words(words)
+    unordered_tuples(words.map { |word| [word, word] })
+  end
+
+  # @return [AutoCompletion]
+  #   Map a list of entities to their keys. The block should return an array of valid
+  #   prefixes for the yielded entity.
+  def self.map(entities)
+    mapped = entities.flat_map { |entity|
+      keys = yield(entity)
+      keys.flat_map { |key| [key, entity] }
+    }
+
+    unordered_tuples(mapped.each_slice(2))
+  end
+
+  # @return [AutoCompletion]
+  #   Creates an AutoCompletion for an unordered array of the form [["prefix", value], …].
+  def self.unordered_tuples(entities)
+    new(entities.sort_by(&:first).flatten(1), true)
+  end
+
+  # All stored entities. A flat array of the form [prefix1, value1, prefix2, value2, …]
+  attr_reader :entities
+
+  # @param [Array<Array>] entities
+  #   A flat array of the form [prefix1, value1, prefix2, value2, …] containing all
+  #   prefixes and their corresponding value.
+  # @param [Boolean] force
+  #   If force is set to true, the order of entities is not verified. Use this only if
+  #   you know what you're doing.
+  #
+  # @see AutoCompletion::words, AutoCompletion::map
+  def initialize(entities, force=false)
+    @entities = entities
+    raise InvalidOrder.new unless force || valid?
+  end
+
+  # @return [Boolean]
+  #   Returns true if the prefixes are in a valid order.
+  def valid?
+    @entities.each_slice(2).each_cons(2) do |(a,_),(b,_)|
+      return false unless a <= b
+    end
+    true
+  end
+
+  # @return [Boolean]
+  #   Returns true if there are no prefixes stored in this AutoCompletion instance.
+  def empty?
+    @entities.empty?
+  end
+
+  # @return [Integer]
+  #   The number of prefixes stored. Note that the same prefix can occur multiple times.
+  def size
+    @entities.size>>1
+  end
+
+  # @return [Integer] The number of distinct entities
+  def count_distinct_entitites
+    result = {}
+    @entities.each_slice(2) do |key, value|
+      result[value] = true
+    end
+
+    result.size
+  end
+
+  # @return [Integer] The number of distinct prefixes
+  def count_distinct_prefixes
+    result = {}
+    @entities.each_slice(2) do |key, value|
+      result[key] = true
+    end
+
+    result.size
+  end
+
+  # @param [String] prefixes
+  #   A list of prefixes to match. All given prefixes must be matched.
+  #
+  # @return [Array]
+  #   Returns an array of distinct entities matching the given prefixes.
+  def complete(*prefixes)
+    # short-cut
+    return [] if empty? || prefixes.any? { |word|
+      word < @entities.first[0,word.size] || word > @entities[-2][0,word.size]
+    }
+
+    slices = prefixes.map { |word| range_search(word) }
+    return [] if slices.include?(nil) # short-cut
+
+    result = @entities[slices.pop].each_slice(2).map(&:last).uniq
+    slices.each do |slice|
+      result &= @entities[slice].each_slice(2).map(&:last)
+    end
+
+    result
+  end
+
+  # @return [nil, Range<Integer>]
+  #   Returns nil if AutoCompletion#empty?
+  #   Returns -1..-1 if the prefix is smaller than the smallest key
+  #   Returns AutoCompletion#size..AutoCompletion#size if the prefix is bigger than the biggest key
+  #   Returns the range for all matched keys and values otherwise
+  def range_search(prefix)
+    prefix_size   = prefix.size
+    length        = size()
+    found         = nil
+    left          = 0
+    right         = length-1
+    found         = false
+    max_exc_right = length
+
+    return nil if empty?
+    return -1..-1 if @entities[0][0,prefix_size] > prefix # prefix is smaller than smallest value
+    return length..length if @entities[-2][0,prefix_size] < prefix # prefix is bigger than biggest value
+
+    # binary search for smallest index
+    # mark biggest right that include prefix, and biggest mark that doesn't include prefix
+    while(left<right)
+      index     = (left+right)>>1
+      cmp_value = @entities.at(index<<1)[0,prefix_size]
+      case cmp_value <=> prefix
+        when -1 then
+          left          = index+1
+        when 1 then
+          right         = index
+          max_exc_right = right
+        else # 0
+          right         = index
+      end
+    end
+    return nil unless @entities.at(left<<1)[0,prefix_size] == prefix
+    final_left = left
+
+    # binary search for biggest index
+    right = max_exc_right-1
+    while(left<right)
+      index     = (left+right)>>1
+      cmp_value = @entities.at(index<<1)[0,prefix_size]
+      if cmp_value > prefix then
+        right = index
+      else
+        left = index+1
+      end
+    end
+    final_right = right
+    final_right -= 1 unless @entities.at(right<<1)[0,prefix_size] == prefix
+
+    return (final_left<<1)..((final_right<<1)+1)
+  end
+end

data/lib/autocompletion/version.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+begin
+  require 'rubygems/version' # newer rubygems use this
+rescue LoadError
+  require 'gem/version' # older rubygems use this
+end
+
+class AutoCompletion
+
+  # The version of the gem
+  Version = Gem::Version.new("0.0.1")
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: autocompletion
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Stefan Rusterholz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-19 00:00:00.000000000Z
+dependencies: []
+description: This gem provides fast prefix-autocompletion in pure ruby.
+email: stefan.rusterholz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/autocompletion/version.rb
+- lib/autocompletion.rb
+- autocompletion.gemspec
+- Rakefile
+- README.markdown
+homepage: http://github.com/apeiros/autocompletion
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Fast prefix-autocompletion in pure ruby.
+test_files: []