my_segments 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in segments.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jason Soo
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,46 @@
+# Segments
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'segments'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install segments
+
+## Usage
+
+Example:
+
+```
+require 'segments'
+
+# Setup the lexicon
+db_path = '/tmp/foo.sqlite3'
+table_name = 'lexicon'
+lex = SegmentsLexicon.new(db_path, table_name)
+
+# Setup segments
+s = Segments.new(lex)
+
+# Search
+candidates = s.suggest('telepone')
+puts candidates.to_s
+```
+
+The sqlite3 table should have at least a "word" and "id" table, where word is a unique word in the lexicon, and id is a primary key.
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/my_segments/candidates.rb

@@ -0,0 +1,77 @@
+class Candidates
+	
+	attr_accessor :candidates		
+	
+	def initialize
+		@candidates = Array.new # An array of candidate objects
+		self
+	end
+	
+	def prune
+	 @candidates.delete_if { |x| x.votes < 1 }
+	end
+	
+	def add(candidate)
+		@candidates << candidate
+		self
+	end
+	
+	# Removes the candidate at the specified index
+	def remove(index)
+		@candidates.delete_at(index)
+	end
+	
+	# Returns whether or not the array contains a candidate with this
+	# solution id
+	def has_id?(id)
+		@candidates.collect(&:id).include?(id)
+	end
+
+	# Increments the votes of the given candidate by the value.
+	# Returns the affected candidate object
+	def vote_for(id, value)
+		candidate = @candidates[@candidates.collect(&:id).index(id)]
+		candidate.votes += value
+		candidate
+	end
+	
+	# Returns an array of candidates, sorted by their rank
+	def sort_by_rank
+		sorted = @candidates.sort{ |x,y| y.votes <=> x.votes }
+		@candidates
+	end
+
+	# Returns the total number of votes
+	def total_votes
+		@candidates.inject(0) { |sum, c| sum + c.votes }
+	end
+	
+	# Returns the number of candidates
+	def size
+		@candidates.size
+	end
+	
+	# Pretty prints the array of candidates
+	def to_s
+		s = ''
+		unless @candidates == nil
+			@candidates.each do |c|
+				s += "[#{c.id}, #{c.misspelled}, #{c.solution}, #{c.votes}]\n"
+			end
+		end
+    return s
+	end
+end
+
+class Candidate < Candidates
+
+	attr_accessor :id, :misspelled, :solution, :votes
+
+	def initialize(misspelled, solution, id, votes = 0.0)
+		@misspelled = misspelled
+		@solution   = solution
+		@id         = id
+		@votes		= votes
+		self
+	end
+end

data/lib/my_segments/segments.rb

@@ -0,0 +1 @@
+

data/lib/my_segments/substring_rules.rb

@@ -0,0 +1,125 @@
+
+class SubstringRules
+
+	def initialize(lexicon)
+		@candidates = Candidates.new
+    @lex = lexicon
+	end
+
+  # Generates substring rules (segments) for the query term
+  # and returns them.
+  def self.for(query_term)
+    segs = []
+		segs << self.method_1(query_term)
+		segs << self.method_3(query_term)
+		segs << self.method_4(query_term)
+		segs << self.method_5(query_term)
+		segs << self.method_6(query_term)
+		segs << self.method_7(query_term)
+    segs.flatten
+  end
+
+	def find(query)
+		@misspelled = query
+		
+		# First look for an exact match, and return if one is found
+		find_candidates([query], true)
+    if @candidates.size > 0
+  		return @candidates
+		end
+	end
+
+	# This function cuts off one letter at a time from the start and end of the search term...
+	# It then re-searches using the new term.  It continues to do so until the ET is reached,
+	# Or the term has become too small to cut off more letters.
+	# Example:
+	# %Slovakia%
+	# %lovaki%
+	# %ovak%
+	# etc
+	def self.method_1(query)
+		q = String.new(query)
+		@substring_rules = []
+		while q.size > 3 do
+			q = q[1..-2]
+			@substring_rules << "%" + q + "%"
+		end
+		@substring_rules
+	end
+
+	# This function replaces the middle of the search term with %'s
+	# MySQL views %'s "match anything".  The function then re-searches
+	# The database using the new query until either the ET is reached,
+	# Or until the query is too short to continue dividing.
+	# Example:
+	# %Slovakia%
+	# %Slov%kia%
+	# %Slo%ia%
+	# etc
+	def self.method_3(query)
+		q = String.new(query)
+		@substring_rules =  []
+		@length = q.length
+		while @length > 3 do
+			q.gsub!('%', '')
+			q[@length/2] = '%'
+			@length = q.length
+			@substring_rules << String.new(q)
+		end
+		@substring_rules
+	end
+
+
+	# This function divides the query in 1/2 and cuts off the front 1/2.
+	# It only adds %'s to the BEGINING of the word.
+	# Exmaple:
+	# %Slovakia%
+	# %akia
+	def self.method_4(query)
+	  if query.length == 1
+      return [query]
+    else
+  		query = ["%" + query[(query.length/2)..-1]]
+  		return query
+  	end
+	end
+
+
+	# Same as above function, but keeps the latter 1/2 of the query.
+	# However, a percent SHOULD be put at the end of the query and NOT
+	# at the begining of the query.
+	# Example:
+	# %Slovakia%
+	# Slov%
+	def self.method_5(query)
+	  if query.length == 1
+      return [query]
+    else
+  		return [query[0..(query.length/2)-1] + "%"]
+		end
+	end
+
+
+	# This function cuts everything out of the middle of the query...
+	# Only leaving the first and last letters.  It replaces the
+	# chars in the middle of the query wiht a %.
+	# Example:
+	# Slovakia
+	# S%a
+	def self.method_6(query)
+		query = [query[0].chr + "%" + query[-1].chr]
+	end
+
+	# Same as above, but it keeps the last two AND first two
+	# chars of the query.
+	# Example:
+	# Slovakia
+	# Sl%ia
+	def self.method_7(query)
+    if query.length == 1
+      return [query]
+    else
+  		return [query[0..1] + "%" + query[-2..-1]]
+		end
+	end
+end

data/lib/my_segments/tester.rb

@@ -0,0 +1,3 @@
+require_relative 'segments'
+segments = Segments.new
+puts segments.suggest('hummer')

data/lib/my_segments/version.rb

@@ -0,0 +1,3 @@
+class Segments
+  VERSION = "0.0.1"
+end

data/lib/my_segments.rb

@@ -0,0 +1,54 @@
+require 'segments_lexicon'
+require "my_segments/version"
+require "my_segments/candidates"
+require 'my_segments/substring_rules'
+
+class Segments
+  # Initializes with a segments lexicon
+  def initialize(segments_lexicon)
+    @lex = segments_lexicon
+  end
+
+  # Returns the query_term broken down into
+  # the substring rules (segments) we'll use
+  # for searching
+  def for_term(query_term)
+    SubstringRules.for(query_term)
+  end
+
+  # Takes a query_term, generates the segments
+  # for that term, and searches for those segment
+  # matches in the lexicon.
+  #
+  # Returns a ranked ordered list of candidates
+  def suggest(query_term)
+    @qt = query_term
+    @candidates = Candidates.new
+    srs = for_term(@qt)
+
+    srs.each do |seg|
+      @lex.search(seg).each do |result|
+        found(result)
+      end
+    end
+
+    # Run substring rules
+    # Check confidence
+    #   Run ngrams
+    # Return most confident candidate set
+    return @candidates
+  end
+
+  private #------
+
+  def found(result)
+    word = result["word"]
+    id   = result["id"]
+    if @candidates.has_id?(id)
+      @candidates.vote_for(id, 1.0)
+    else
+      c = Candidate.new(@qt, word, id)					
+      @candidates.add(c)
+    end
+  end
+end

data/my_segments.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'segments/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "my_segments"
+  gem.version       = Segments::VERSION
+  gem.authors       = ["Jason Soo"]
+  gem.email         = ["wwwjscom@gmail.com"]
+  gem.description   = %q{Segments gem}
+  gem.summary       = %q{Segments gem}
+  gem.homepage      = ""
+
+  gem.add_runtime_dependency "segments_lexicon"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/test/test_substring_rules.rb

@@ -0,0 +1,11 @@
+require_relative '../lib/segments/substring_rules'
+require 'test/unit'
+
+class TestSubstringRules < Test::Unit::TestCase
+
+  def test_substrings
+    segs = SubstringRules.for('telephone')
+    assert_instance_of(Array, segs)
+    assert_equal(14, segs.size)
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: my_segments
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jason Soo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: segments_lexicon
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Segments gem
+email:
+- wwwjscom@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/my_segments.rb
+- lib/my_segments/.candidates.rb.swp
+- lib/my_segments/candidates.rb
+- lib/my_segments/segments.rb
+- lib/my_segments/substring_rules.rb
+- lib/my_segments/tester.rb
+- lib/my_segments/version.rb
+- my_segments.gemspec
+- test/test_substring_rules.rb
+homepage: ''
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Segments gem
+test_files:
+- test/test_substring_rules.rb