string_score 1.0.0 → 1.1.0

data/LICENSE

@@ -25,4 +25,4 @@ 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.
-jlindley@Amp:~/Projects/string_score[master*]$ st
+

data/README.mdown

@@ -15,20 +15,20 @@ Tested under Ruby 1.9.2 and Ruby 1.8.7.
 Usage
 ---
 
-    gem install string_score
-    
+    $ gem install string_score
+
     scorer = StringScore.new("string to test against")
     scorer.score("string to test")
+    scorer.sort_by_score(['strings', 'to', 'sort'])
 
 Or, include it into String for a convenience method:
 
-
-    String.send(:include, StringScore)
-    
-    # and then
+    require 'string_score/ext/string'
     
     "Hello World".score("hello")
     "Hello World".score("Whirl", 0.5) # or for fuzzy
+    
+    "Hello World".sort_by_score(["xyz", "hello"]) #=> ["hello", "xyx"]
 
 Copyright
 ---

data/lib/string_score.rb

@@ -3,15 +3,12 @@ module StringScore
   class InternalError < RuntimeError; end
   class ArgumentError < RuntimeError; end
 
-  NON_STRING_MSG = "Supply a string or an object with can be coerced to a string."
-  NON_STRING_ERROR_MESSAGE = /undefined method `to_s'/
-
   def score(target_string, fuzziness = 0.0)
-    if @string_scorer && @string_scorer.base_string != self
-      @string_scorer = nil
-    end
-    @string_scorer ||= StringScore.new(self, fuzziness)
-    @string_scorer.score(target_string)
+    StringScore.new(self, fuzziness).score(target_string)
+  end
+
+  def sort_by_score(target, fuzziness = 0.0, &block)
+    StringScore.new(self, fuzziness).sort_by_score(target)
   end
 
   # proxy to Scorer to simplify calling API
@@ -19,133 +16,6 @@ module StringScore
     StringScore::Scorer.new(base_string.to_s, fuzziness)
   end
 
-  class Scorer
-
-    attr_accessor :base_string, :default_fuziness
-
-    def initialize(string, fuzziness=0.0)
-      with_error_handling do
-        @default_fuziness = fuzziness
-        @base_string = string.to_s
-      end
-    end
-
-    def score(target_string, fuzziness=nil)
-      with_error_handling do
-        return 1 if (base_string == target_string.to_s)
-        partial_score(target_string, (fuzziness || default_fuziness))
-      end
-    end
-
-    def partial_score(target, fuzziness)
-
-      string = base_string.dup # clean copy for chomping
-      over_all_index = 0
-
-      cumulative_score = 0.0
-
-      target_length = target.length.to_f
-      string_length = string.length.to_f
-
-      start_of_string_bonus = false
-
-      abbreviation_score = 0
-      fuzzies = 1.0
-      final_score = 0.0
-
-      target_index = 0
-
-      target.each_char do |c|
-        over_all_index = (base_string.length - string.length)
-
-        character_score = 0.0
-
-        index_c_lowercase = string.index(c.downcase)
-        index_c_uppercase = string.index(c.upcase)
-
-        current_index = [index_c_lowercase, index_c_uppercase].compact.min
-        over_all_index += current_index.to_i
-
-        if ! current_index
-
-          if fuzziness > 0.0
-            fuzzies += (1 - fuzziness)
-            target_index += 1
-            next
-          else
-            return 0 # abort on any mismatch
-          end
-
-        end
-
-        if string.slice(current_index, 1) == c
-          character_score = 0.2 # exact case match
-        else
-          character_score = 0.1 # character but not case match
-        end
-
-        # consecutive bonus
-        if current_index == 0
-          character_score += 0.6
-          if target_index == 0
-            start_of_string_bonus = true
-          end
-        end
-
-        # acronym bonus
-        previous_index = over_all_index - 1
-        if base_string.slice(previous_index, 1) == ' '
-          character_score += 0.8
-        end
-
-        cumulative_score += character_score
-        target_index += 1
-        string = string[(current_index + 1), (string.length - 1)]
-      end
-
-      matched_score = cumulative_score.to_f / string_length.to_f
-
-      with_long_string_bonus = (((matched_score * (target_length.to_f / string_length.to_f)) + matched_score) / 2)
-
-      final_score = with_long_string_bonus / fuzzies
-
-      if start_of_string_bonus
-        if final_score + 0.15 < 1.0
-          final_score += 0.15
-        elsif final_score + 0.15 >= 1.0
-          final_score = 1.0
-        end
-      end
-
-      if final_score > 1.0 || final_score < 0.0
-        raise StringScore::InternalError, "Out of range score: '#{final_score}'"
-      end
-
-      final_score
-    end
-
-    def with_error_handling
-
-      yield
-
-    rescue StringScore::InternalError, StringScore::ArgumentError
-
-      raise # allow nesting of #with_error_handling
-
-    rescue NoMethodError => e
-
-      if e.message =~ NON_STRING_MSG
-        raise StringScore::ArgumentError, NON_STRING_MSG
-      else
-        raise StringScore::InternalError, "#{e.class}: #{e.message}"
-      end
-
-    rescue => e
-
-      raise StringScore::InternalError, "#{e.class}: #{e.message}"
-
-    end
-
-  end
-
 end
+
+require 'string_score/scorer'

data/lib/string_score/ext/string.rb

@@ -0,0 +1,5 @@
+require 'string_score'
+
+class String
+  include StringScore
+end

data/lib/string_score/scorer.rb

@@ -0,0 +1,151 @@
+class StringScore::Scorer
+
+  attr_accessor :base_string, :default_fuziness
+
+  NON_STRING_MSG = "Supply a string or an object with can be coerced to a string."
+  NON_STRING_ERROR_MESSAGE = /undefined method `to_s'/
+
+  def initialize(string, fuzziness=0.0)
+    with_error_handling do
+      @default_fuziness = fuzziness
+      @base_string = string.to_s
+    end
+  end
+
+  def score(target, fuzziness=nil, &block)
+    if target.kind_of?(String)
+      with_error_handling do
+        return 1 if (base_string == target.to_s)
+        partial_score(target, (fuzziness || default_fuziness))
+      end
+    else
+      raise StringScore::ArgumentError, "Must supply a string."
+    end
+  end
+
+  def sort_by_score(target_iterator, fuzziness=nil, &block)
+    if target_iterator.respond_to?(:each)
+      scored = target_iterator.map do |target|
+        to_match = if block_given?
+          block.call(target)
+        else
+          target
+        end
+        [score(to_match, fuzziness), target]
+      end
+      scored.sort_by{ |t| t[0] }.reverse.map{ |t| t[1] }
+    else
+      raise StringScore::ArgumentError, "Must supply an iterable object with strings."
+    end
+  end
+
+  def partial_score(target, fuzziness)
+
+    string = base_string.dup # clean copy for chomping
+    over_all_index = 0
+
+    cumulative_score = 0.0
+
+    target_length = target.length.to_f
+    string_length = string.length.to_f
+
+    start_of_string_bonus = false
+
+    abbreviation_score = 0
+    fuzzies = 1.0
+    final_score = 0.0
+
+    target_index = 0
+
+    target.each_char do |c|
+      over_all_index = (base_string.length - string.length)
+
+      character_score = 0.0
+
+      index_c_lowercase = string.index(c.downcase)
+      index_c_uppercase = string.index(c.upcase)
+
+      current_index = [index_c_lowercase, index_c_uppercase].compact.min
+      over_all_index += current_index.to_i
+
+      if ! current_index
+
+        if fuzziness > 0.0
+          fuzzies += (1 - fuzziness)
+          target_index += 1
+          next
+        else
+          return 0 # abort on any mismatch
+        end
+
+      end
+
+      if string.slice(current_index, 1) == c
+        character_score = 0.2 # exact case match
+      else
+        character_score = 0.1 # character but not case match
+      end
+
+      # consecutive bonus
+      if current_index == 0
+        character_score += 0.6
+        if target_index == 0
+          start_of_string_bonus = true
+        end
+      end
+
+      # acronym bonus
+      previous_index = over_all_index - 1
+      if base_string.slice(previous_index, 1) == ' '
+        character_score += 0.8
+      end
+
+      cumulative_score += character_score
+      target_index += 1
+      string = string[(current_index + 1), (string.length - 1)]
+    end
+
+    matched_score = cumulative_score.to_f / string_length.to_f
+
+    with_long_string_bonus = (((matched_score * (target_length.to_f / string_length.to_f)) + matched_score) / 2)
+
+    final_score = with_long_string_bonus / fuzzies
+
+    if start_of_string_bonus
+      if final_score + 0.15 < 1.0
+        final_score += 0.15
+      elsif final_score + 0.15 >= 1.0
+        final_score = 1.0
+      end
+    end
+
+    if final_score > 1.0 || final_score < 0.0
+      raise StringScore::InternalError, "Out of range score: '#{final_score}'"
+    end
+
+    final_score
+  end
+
+  def with_error_handling
+
+    yield
+
+  rescue StringScore::InternalError, StringScore::ArgumentError
+
+    raise # allow nesting of #with_error_handling
+
+  rescue NoMethodError => e
+
+    if e.message =~ NON_STRING_ERROR_MESSAGE
+      raise StringScore::ArgumentError, NON_STRING_MSG
+    else
+      raise StringScore::InternalError, "#{e.class}: #{e.message}"
+    end
+
+  rescue => e
+
+    raise StringScore::InternalError, "#{e.class}: #{e.message}"
+
+  end
+
+end

data/lib/string_score/version.rb

@@ -1,3 +1,3 @@
 module StringScore
-  VERSION = "1.0.0"
+  VERSION = "1.1.0"
 end

data/spec/string_score_spec.rb

@@ -1,6 +1,5 @@
 require 'string_score'
-
-String.send(:include, StringScore)
+require 'string_score/ext/string'
 
 RSpec::Matchers.define :be_greater_than do |expected|
   match do |actual|
@@ -18,7 +17,7 @@ describe StringScore do
 
   subject { StringScore.new('Hello World') }
 
-  it "provides a method directly on a string instance" do
+  it "provides a method directly on a string instance for scoring" do
     "foobar".score('foo').should == StringScore.new("foobar").score('foo')
   end
 
@@ -110,4 +109,51 @@ describe StringScore do
     subject.score('Hz', 0.9).should be_greater_than(subject.score('Hz', 0.5))
   end
 
+  it "accepts an array of values to score" do
+    subject.sort_by_score(["Hello"]).should be_kind_of(Array)
+  end
+
+  it "provides a method directly on a string instance for scoring" do
+    target_list = ['foo', 'foobar', 'xyz']
+    "foobar".sort_by_score(target_list).should == StringScore.new("foobar").sort_by_score(target_list)
+  end
+
+  it "sorts a passed array by score, highest to lowest" do
+    subject.sort_by_score(["xyz", "Hello", "hello"]).should == ["Hello", "hello", "xyz"]
+  end
+
+  it "sorts equal matches alphabetically" do
+    subject.score("ell").should == subject.score("llo")
+    subject.sort_by_score(["llo", "ell"]).should == ["ell", "llo"]
+  end
+
+  it "passes fuzziness checks through with arrays" do
+    subject.sort_by_score(["hey", "abc"]).should == ['abc', 'hey']
+    subject.sort_by_score(["hey", "abc"], 0.5).should == ['hey', 'abc']
+  end
+
+  it "accepts a block to provide a scoring target for non-string lists" do
+    nested_list = [
+      [nil, "there"],
+      [nil, "hello"],
+      [nil, "World"]
+    ]
+
+    expected_sort = [
+      [nil, "hello"],
+      [nil, "World"],
+      [nil, "there"]
+    ]
+
+    subject.sort_by_score(nested_list){|t| t[1] }.should == expected_sort
+  end
+
+  it "raises an argument error if passed an invalid score target" do
+    expect { subject.score(nil) }.to raise_error(StringScore::ArgumentError)
+  end
+
+  it "raises an argument error if passed an invalid sort target" do
+    expect { subject.sort_by_score(nil) }.to raise_error(StringScore::ArgumentError)
+  end
+
 end

metadata

@@ -1,13 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: string_score
 version: !ruby/object:Gem::Version 
-  hash: 23
   prerelease: 
-  segments: 
-  - 1
-  - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Jim Lindley
@@ -15,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-15 00:00:00 -07:00
+date: 2011-03-16 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,11 +21,6 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 2
-        - 5
-        - 0
         version: 2.5.0
   type: :development
   version_requirements: *id001
@@ -50,6 +40,8 @@ files:
 - README.mdown
 - Rakefile
 - lib/string_score.rb
+- lib/string_score/ext/string.rb
+- lib/string_score/scorer.rb
 - lib/string_score/version.rb
 - spec/string_score_spec.rb
 - string_score.gemspec
@@ -67,18 +59,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
       version: "0"
 requirements: []