guessmethod 0.0.8 → 0.1.0

data/History.txt

@@ -1,3 +1,11 @@
+== 0.1.0 2007-09-23
+
+* Moved GuessConstant to inside GuessMethod
+* Cleaned up Formatter (a little, it should still be redone)
+* One more test for GuessConstant
+* Renamed Outputter, Formatter, and Options to have GuessMethod as a prefix to avoid name conflicts
+* Removed the dependency on HighLine
+
 == 0.0.8 2007-08-07
 
 * enhancements

data/README.txt

@@ -16,10 +16,10 @@ If you accidentally try to access <tt>File::RDWr</tt>, you'll get <tt>File::RDWR
 
 <tt>GuessMethod::Options</tt> is a hash with configuration values.
 
-* <code>GuessMethod::Options[:insert_weight]</code>, <code>GuessMethod::Options[:delete_weight]</code>, and <code>GuessMethod::Options[:substitution_weight]</code> change how the levenshtein distance is calculated between method and constant names.  The default values are all 1.
-* <code>GuessMethod::Options[:threshold]</code> determines what levenshtein distance a method or constant must be within to count as a possible match.  Values over 2 can give you unpredictable results, especially for short names.  The default value is 2.
-* <code>GuessMethod::Options[:max_inspect_length]</code> is, for now, the longest an object's inspect value can be before it's not displayed in messages, and is replaced with simply the standard #<Object:0x142100c>. The default value is 25.
-* <code>GuessMethod::Options[:active]</code> determines whether or not GuessMethod does its thing.  If set to false (or nil) it'll step aside.  Useful for when it gets in the way of something going off correctly (which happens sometimes).
+* <code>GuessMethodOptions[:insert_weight]</code>, <code>GuessMethodOptions[:delete_weight]</code>, and <code>GuessMethodOptions[:substitution_weight]</code> change how the levenshtein distance is calculated between method and constant names.  The default values are all 1.
+* <code>GuessMethodOptions[:threshold]</code> determines what levenshtein distance a method or constant must be within to count as a possible match.  Values over 2 can give you unpredictable results, especially for short names.  The default value is 2.
+* <code>GuessMethodOptions[:max_inspect_length]</code> is, for now, the longest an object's inspect value can be before it's not displayed in messages, and is replaced with simply the standard #<Object:0x142100c>. The default value is 25.
+* <code>GuessMethodOptions[:active]</code> determines whether or not GuessMethod does its thing.  If set to false (or nil) it'll step aside.  Useful for when it gets in the way of something going off correctly (which happens sometimes).
 
 = Warning
 

data/Rakefile

@@ -78,7 +78,7 @@ hoe = Hoe.new(GEM_NAME, VERS) do |p|
   
   # == Optional
   p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
-  p.extra_deps = [['highline', '>=1.2.7'], ['rake', '>=0.7']]     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  p.extra_deps = [['rake', '>=0.7']]     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
   #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
 end
 

data/lib/guessmethod.rb

@@ -1,5 +1,4 @@
 require 'string/levenshtein'
-require 'highline'
 
 # The GuessMethod module aliases out method_missing and
 # replaces it with its own, which attempts to find a
@@ -10,7 +9,7 @@ require 'highline'
 # gets called.
 module GuessMethod
   
-  Options = {
+  GuessMethodOptions = {
     :insert_weight => 1,
     :delete_weight => 1,
     :substitution_weight => 1,
@@ -32,18 +31,18 @@ module GuessMethod
   end
   
   def guess_method_missing(meth, *args, &block)
-    if Options[:active]
-      possible_methods = Guesser.find_closest(self.methods, meth)
+    if GuessMethodOptions[:active]
+      possible_methods = GuessMethodGuesser.find_closest(self.methods, meth)
       case possible_methods.size
       when 1
         call_method = possible_methods.first
-        $stderr.puts Outputter.replacing_method(meth, call_method, self)
+        $stderr.puts GuessMethodOutputter.replacing_method(meth, call_method, self)
         self.send(call_method, *args, &block)
       when 0
-        $stderr.puts Outputter.no_method_in_threshold(meth, self)
+        $stderr.puts GuessMethodOutputter.no_method_in_threshold(meth, self)
         old_method_missing(meth, *args, &block)
       else
-        $stderr.puts Outputter.ambiguous_method(meth, possible_methods, self)
+        $stderr.puts GuessMethodOutputter.ambiguous_method(meth, possible_methods, self)
         old_method_missing(meth, *args, &block)
       end
     else
@@ -51,143 +50,153 @@ module GuessMethod
     end
   end
   
-  # GuessMethod::Guesser uses map, min, and levensthtein to find the closest
+  # The GuessConstant module aliases out const_missing and
+  # replaces it with its own, which attempts to find a
+  # similarly named constant for the object at hand.
+  # If it finds one, it returns that instead, and prints
+  # a message to stderr explaining as much.  If it doesn't
+  # find a suitable constant, the orignial const_missing
+  # gets called. 
+  module GuessConstant
+    def self.extended(base)   #:nodoc:
+      base.class_eval do
+        unless respond_to? :const_missing
+          def self.const_missing(sym); super; end
+        end
+        class << self
+          alias_method :old_const_missing, :const_missing
+          alias_method :const_missing, :guess_const_missing
+        end
+      end
+    end
+
+    def guess_const_missing(sym)
+      if GuessMethodOptions[:active]
+        possible_consts = GuessMethodGuesser.find_closest(self.constants, sym)
+        case possible_consts.size
+        when 1
+          call_const = possible_consts.first
+          $stderr.puts GuessMethodOutputter.replacing_const(sym, call_const, self)
+          self.const_get(call_const)
+        when 0
+          $stderr.puts GuessMethodOutputter.no_const_in_threshold(sym, self)
+          old_const_missing(sym)
+        else
+          $stderr.puts GuessMethodOutputter.ambigious_const(sym, possible_consts, self)
+          old_const_missing(sym)
+        end
+      else
+        old_const_missing(sym)
+      end
+    end
+  end
+  
+  # GuessMethodGuesser uses map, min, and levensthtein to find the closest
   # match(es) in an array of strings
-  class Guesser
+  class GuessMethodGuesser
     def self.find_closest(haystack, needle)
       closest_distance = haystack.map {|x| x.to_s.downcase.levenshtein(needle.to_s.downcase,
-          Options[:insert_weight], Options[:delete_weight],
-          Options[:substitution_weight])}.min
-      if closest_distance <= Options[:threshold]
+          GuessMethodOptions[:insert_weight], GuessMethodOptions[:delete_weight],
+          GuessMethodOptions[:substitution_weight])}.min
+      if closest_distance <= GuessMethodOptions[:threshold]
         haystack.find_all {|x| x.to_s.downcase.levenshtein(needle.to_s.downcase,
-            Options[:insert_weight], Options[:delete_weight],
-            Options[:substitution_weight]) == closest_distance}
+            GuessMethodOptions[:insert_weight], GuessMethodOptions[:delete_weight],
+            GuessMethodOptions[:substitution_weight]) == closest_distance}
       else
         []
       end
     end
   end
   
-  # GuessMethod::Outputter uses HighLine to format
-  # alert messages generated by the GuessMethod method_missing
-  class Outputter
+  # GuessMethodOutputter uses a little Formatter class for colorization
+  class GuessMethodOutputter
     
-    Formatter = HighLine.new
+    class Formatter
+      ColorCodes = {
+        :bold  => '1',
+        :red   => '31',
+        :green => '32',
+        :cyan  => '36'
+      }
+      
+      # Returns an ANSI colorized string (for a limited set of options, see ColorCodes)
+      def self.color(text, *colors)
+        format = colors.map {|color| ColorCodes[color]}.join(';')
+        "\e[#{format}m#{text}\e[0m"
+      end
+    end
     
     def self.object(obj)  #:nodoc:
       inspected = obj.inspect
-      if obj.inspect.length > Options[:max_inspect_length]
+      if obj.inspect.length > GuessMethodOptions[:max_inspect_length]
         Formatter.color("#<#{obj.class}:0x#{(obj.object_id*2).to_s(16)}>", :green)
       else
-        message = Formatter.color(obj.inspect, :green, :bold)
-        message << ':'
-        message << Formatter.color(obj.class, :green)
+        Formatter.color(obj.inspect, :green, :bold) << ':' << Formatter.color(obj.class, :green)
       end
     end
     
     def self.ambiguous_method(meth, possibilities, obj) #:nodoc:
-      message = Formatter.color('ambigious method:', :red)
-      message << ' '
-      message << Formatter.color(meth, :green)
-      message << ' possible matches '
-      message << possibilities.map {|m| Formatter.color(m, :cyan)}.join(', ')
-      message << ' for '
-      message << Outputter.object(obj)
+      Formatter.color('ambigious method:', :red) <<
+      ' ' <<
+      Formatter.color(meth, :green) <<
+      ' possible matches ' <<
+      possibilities.map {|m| Formatter.color(m, :cyan)}.join(', ') <<
+      ' for ' <<
+      GuessMethodOutputter.object(obj)
     end
     
     def self.no_method_in_threshold(meth, obj)  #:nodoc:
-      message = Formatter.color('no method in threshold:', :red)
-      message << ' for '
-      message << Formatter.color(meth, :green)
-      message << ', sending to '
-      message << Outputter.object(obj)
-      message << "'s method_missing"
+      Formatter.color('no method in threshold:', :red) <<
+      ' for ' <<
+      Formatter.color(meth, :green) <<
+      ', sending to ' <<
+      GuessMethodOutputter.object(obj) <<
+      "'s method_missing"
     end
     
     def self.replacing_method(meth, call_method, obj) #:nodoc:
-      message = Formatter.color('attention:', :red)
-      message << ' sending '
-      message << Formatter.color(call_method, :cyan)
-      message << ' instead of '
-      message << Formatter.color(meth, :cyan)
-      message << ' to '
-      message << Outputter.object(obj)
+      Formatter.color('attention:', :red) <<
+      ' sending ' <<
+      Formatter.color(call_method, :cyan) <<
+      ' instead of ' <<
+      Formatter.color(meth, :cyan) <<
+      ' to ' <<
+      GuessMethodOutputter.object(obj)
     end
     
     def self.ambigious_const(sym, possibilities, obj) #:nodoc:
-      message = Formatter.color('ambigious constant:', :red)
-      message << ' '
-      message << Formatter.color(sym, :green)
-      message << ' possible matches '
-      message << possibilities.map {|m| Formatter.color(m, :cyan)}.join(', ')
-      message << ' for '
-      message << Outputter.object(obj)
+      Formatter.color('ambigious constant:', :red) <<
+      ' ' <<
+      Formatter.color(sym, :green) <<
+      ' possible matches ' <<
+      possibilities.map {|m| Formatter.color(m, :cyan)}.join(', ') <<
+      ' for ' <<
+      GuessMethodOutputter.object(obj)
     end
     
     def self.no_const_in_threshold(sym, obj) #:nodoc:
-      message = Formatter.color('no constant in threshold:', :red)
-      message << ' for '
-      message << Formatter.color(sym, :green)
-      message << ', sending to '
-      message << Formatter.color(obj, :green, :bold)
-      message << "'s const_missing"
+      Formatter.color('no constant in threshold:', :red) <<
+      ' for ' <<
+      Formatter.color(sym, :green) <<
+      ', sending to ' <<
+      Formatter.color(obj, :green, :bold) <<
+      "'s const_missing"
     end
     
     def self.replacing_const(sym, call_const, obj) #:nodoc:
-      message = Formatter.color('attention:', :red)
-      message << ' replacing non-existant constant '
-      message << Formatter.color(sym, :cyan)
-      message << ' with '
-      message << Formatter.color(call_const, :cyan)
-      message << ' for '
-      message << Formatter.color(obj, :green, :bold)
+      Formatter.color('attention:', :red) <<
+      ' replacing non-existant constant ' <<
+      Formatter.color(sym, :cyan) <<
+      ' with ' <<
+      Formatter.color(call_const, :cyan) <<
+      ' for ' <<
+      Formatter.color(obj, :green, :bold)
     end
     
   end
   
 end
 
-# The GuessConstant module aliases out const_missing and
-# replaces it with its own, which attempts to find a
-# similarly named constant for the object at hand.
-# If it finds one, it returns that instead, and prints
-# a message to stderr explaining as much.  If it doesn't
-# find a suitable constant, the orignial const_missing
-# gets called. 
-module GuessConstant
-  def self.extended(base)   #:nodoc:
-    base.class_eval do
-      unless respond_to? :const_missing
-        def self.const_missing(sym); super; end
-      end
-      class << self
-        alias_method :old_const_missing, :const_missing
-        alias_method :const_missing, :guess_const_missing
-      end
-    end
-  end
-  
-  def guess_const_missing(sym)
-    if Options[:active]
-      possible_consts = GuessMethod::Guesser.find_closest(self.constants, sym)
-      case possible_consts.size
-      when 1
-        call_const = possible_consts.first
-        $stderr.puts GuessMethod::Outputter.replacing_const(sym, call_const, self)
-        self.const_get(call_const)
-      when 0
-        $stderr.puts GuessMethod::Outputter.no_const_in_threshold(sym, self)
-        old_const_missing(sym)
-      else
-        $stderr.puts GuessMethod::Outputter.ambigious_const(sym, possible_consts, self)
-        old_const_missing(sym)
-      end
-    else
-      old_const_missing(sym)
-    end
-  end
-end
-
 require 'guessmethod/version'
 
 class Object; include GuessMethod; end

data/lib/guessmethod/version.rb

@@ -1,8 +1,8 @@
 module GuessMethod #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 0
-    TINY  = 8
+    MINOR = 1
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/spec/guessmethod_spec.rb

@@ -1,12 +1,16 @@
 require File.dirname(__FILE__) + '/spec_helper.rb'
 require 'lib/guessmethod.rb'
 
-describe "GuessMethod naturally" do
+describe 'GuessMethod naturally' do
   
   it "should define guess_method_missing on Object" do
     Object.should.respond_to? :guess_method_missing
   end
   
+  it 'should define guess_const_missing on Object' do
+    Object.should.respond_to? 'guess_const_missing'
+  end
+  
   it "should figure out toi means to_i" do
     '1'.toi.should == 1
   end
@@ -24,15 +28,15 @@ describe "GuessMethod naturally" do
   end
   
   it "should be off if it gets turned off" do
-    GuessMethod::Options[:active] = false
+    GuessMethodOptions[:active] = false
     lambda{Class.nw}.should raise_error(NoMethodError)
     lambda{Cass == Class}.should raise_error(NameError)
-    GuessMethod::Options[:active] = true
+    GuessMethodOptions[:active] = true
   end
   
   it "should be on if it gets turned on" do
-    GuessMethod::Options[:active] = false
-    GuessMethod::Options[:active] = true
+    GuessMethodOptions[:active] = false
+    GuessMethodOptions[:active] = true
     lambda{Class.nw}.should_not raise_error
     Cass.should == Class
   end
@@ -68,4 +72,4 @@ describe "On a method_missing-defining class, GuessMethod" do
     lambda{A.new.not_a_method}.should raise_error(NoMethodError)
   end
   
-end
+end

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>Guess Method</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/guessmethod"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/guessmethod" class="numbers">0.0.8</a>
+      <a href="http://rubyforge.org/projects/guessmethod" class="numbers">0.1.0</a>
     </div>
     <h1>&#x2192; &#8216;guessmethod&#8217;</h1>
 
@@ -87,10 +87,10 @@ attention: sending exit instead of eixt to main:Object
 
 
 	<ul>
-	<li><code>GuessMethod::Options[:insert_weight]</code>, <code>GuessMethod::Options[:delete_weight]</code>, <code>GuessMethod::Options[:substitution_weight]</code> change how the levenshtein distance is calculated between method and constant names.  The default values are all 1.</li>
-		<li><code>GuessMethod::Options[:threshold]</code> determines what levenshtein distance a method or constant must be within to count as a possible match.  Values over 2 can give you unpredictable results, especially for short names.  The default value is 2.</li>
-		<li><code>GuessMethod::Options[:max_inspect_length]</code> is, for now, the longest an object&#8217;s inspect value can be before it&#8217;s not displayed in messages, and is replaced with simply the standard #&lt;Object:0&#215;142100c&gt;. The default value is 25.</li>
-		<li><code>GuessMethod::Options[:active]</code> determines whether or not GuessMethod does its thing.  If set to false (or nil) it&#8217;ll step aside.  Useful for when it gets in the way of something going off correctly (which happens sometimes).</li>
+	<li><code>GuessMethodOptions[:insert_weight]</code>, <code>GuessMethodOptions[:delete_weight]</code>, <code>GuessMethodOptions[:substitution_weight]</code> change how the levenshtein distance is calculated between method and constant names.  The default values are all 1.</li>
+		<li><code>GuessMethodOptions[:threshold]</code> determines what levenshtein distance a method or constant must be within to count as a possible match.  Values over 2 can give you unpredictable results, especially for short names.  The default value is 2.</li>
+		<li><code>GuessMethodOptions[:max_inspect_length]</code> is, for now, the longest an object&#8217;s inspect value can be before it&#8217;s not displayed in messages, and is replaced with simply the standard #&lt;Object:0&#215;142100c&gt;. The default value is 25.</li>
+		<li><code>GuessMethodOptions[:active]</code> determines whether or not GuessMethod does its thing.  If set to false (or nil) it&#8217;ll step aside.  Useful for when it gets in the way of something going off correctly (which happens sometimes).</li>
 	</ul>
 
 
@@ -125,7 +125,7 @@ attention: sending exit instead of eixt to main:Object
 
 	<p>Comments are welcome. Send an email to chris @@ tie-rack .. org.</p>
     <p class="coda">
-      website generated via <a href="mailto:drnicwilliams@gmail.com">Dr Nic</a>'s <a href="http://newgem.rubyforge.org/">newgem</a>, on 6th August 2007<br>
+      website generated via <a href="mailto:drnicwilliams@gmail.com">Dr Nic</a>'s <a href="http://newgem.rubyforge.org/">newgem</a>, on 23rd September 2007<br>
       Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
     </p>
 </div>

data/website/index.txt

@@ -43,10 +43,10 @@ attention: sending exit instead of eixt to main:Object
 
 There are a number of options available which affect how GuessMethod works.
 
-* <code>GuessMethod::Options[:insert_weight]</code>, <code>GuessMethod::Options[:delete_weight]</code>, <code>GuessMethod::Options[:substitution_weight]</code> change how the levenshtein distance is calculated between method and constant names.  The default values are all 1.
-* <code>GuessMethod::Options[:threshold]</code> determines what levenshtein distance a method or constant must be within to count as a possible match.  Values over 2 can give you unpredictable results, especially for short names.  The default value is 2.
-* <code>GuessMethod::Options[:max_inspect_length]</code> is, for now, the longest an object's inspect value can be before it's not displayed in messages, and is replaced with simply the standard #&lt;Object:0x142100c&gt;. The default value is 25.
-* <code>GuessMethod::Options[:active]</code> determines whether or not GuessMethod does its thing.  If set to false (or nil) it'll step aside.  Useful for when it gets in the way of something going off correctly (which happens sometimes).
+* <code>GuessMethodOptions[:insert_weight]</code>, <code>GuessMethodOptions[:delete_weight]</code>, <code>GuessMethodOptions[:substitution_weight]</code> change how the levenshtein distance is calculated between method and constant names.  The default values are all 1.
+* <code>GuessMethodOptions[:threshold]</code> determines what levenshtein distance a method or constant must be within to count as a possible match.  Values over 2 can give you unpredictable results, especially for short names.  The default value is 2.
+* <code>GuessMethodOptions[:max_inspect_length]</code> is, for now, the longest an object's inspect value can be before it's not displayed in messages, and is replaced with simply the standard #&lt;Object:0x142100c&gt;. The default value is 25.
+* <code>GuessMethodOptions[:active]</code> determines whether or not GuessMethod does its thing.  If set to false (or nil) it'll step aside.  Useful for when it gets in the way of something going off correctly (which happens sometimes).
 
 h2. How to submit patches
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: guessmethod
 version: !ruby/object:Gem::Version 
-  version: 0.0.8
-date: 2007-09-22 00:00:00 -06:00
+  version: 0.1.0
+date: 2007-09-23 00:00:00 -06:00
 summary: an aggressive spell checker for irb
 require_paths: 
 - lib
@@ -64,15 +64,6 @@ extensions: []
 requirements: []
 
 dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: highline
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 1.2.7
-    version: 
 - !ruby/object:Gem::Dependency 
   name: rake
   version_requirement: