stringray 1 → 2

data/.manifest

@@ -1,4 +1,3 @@
-lib/spec/rake/verify_ratio.rb
 lib/stringray.rb
 Rakefile
 README.mkdn

data/README.mkdn

@@ -31,9 +31,9 @@ merged.
 Requirements
 ------------
 
-To run git-blog, you need... nothing!
+To use StringRay, you need... nothing!
 
-To develop and contribute to git-blog, you also need:
+To develop and contribute to StringRay, however, you need:
 
 * `gem install rake`
 * `gem install rspec`

data/Rakefile

@@ -1,11 +1,11 @@
 ($:.unshift File.expand_path(File.join( File.dirname(__FILE__), 'lib' ))).uniq!
 require 'stringray'
-require 'merb-extlib/string' # String#/, because I'm a lazy fuck.
+require 'extlib/string' # String#/, because I'm a lazy fuck.
 require 'rake'
-require 'rake/rdoctask'
+require 'yard'
+require 'yard/rake/yardoc_task'
 require 'spec/rake/spectask'
 require 'spec/rake/verify_rcov'
-require 'spec/rake/verify_ratio'
 
 begin
   require 'echoe'
@@ -25,7 +25,7 @@ begin
     desc 'tests packaged files to ensure they are all present'
     task :verify => :package do
       # An error message will be displayed if files are missing
-      if system %(ruby -e "require 'rubygems'; require 'merb-core'; require 'pkg/merb_strokedb-#{Merb::Orms::StrokeDB::VERSION}/lib/merb_strokedb'")
+      if system %(ruby -e "require 'rubygems'; require 'pkg/stringray-#{StringRay::VERSION}/lib/stringray'")
         puts "\nThe library files are present"
       end
     end
@@ -71,12 +71,9 @@ ensure
     end
 
     RCov::VerifyTask.new(:verify) do |t|
-      t.threshold = 100
+      t.threshold = 95
       t.index_html = 'meta' / 'coverage' / 'index.html'
-    end
-
-    Spec::Rake::VerifySpecRatioTask.new(:ratio) do |t|
-      t.ratio = 1.00
+      t.require_exact_threshold = false
     end
 
     task :open do
@@ -84,15 +81,39 @@ ensure
     end
   end
   
+  namespace :yard do
+    YARD::Rake::YardocTask.new :generate do |t|
+      t.files   = ['lib/**/*.rb']
+      t.options = ['--output-dir', "meta/documentation"]
+    end
+    
+    YARD::Rake::YardocTask.new :dot_yardoc do |t|
+      t.files   = ['lib/**/*.rb']
+      t.options = ['--no-output']
+    end
+    
+    task :open do
+      system 'open ' + 'meta' / 'documentation' / 'index.html' if PLATFORM['darwin']
+    end
+  end
+  
   namespace :git do
     task :status do
       `git status`
     end
+    
+    task :commit => [:'echoe:manifest', :'yard:dot_yardoc'] do
+      `git commit`
+    end
+  end
+  
+  task :clobber => [:'echoe:clobber_package', :'echoe:clobber_docs', :'echoe:clobber_coverage'] do
+    rm_f 'meta'
   end
 
   desc 'Check everything over before commiting'
-  task :aok => [:'echoe:manifest', :'rcov:run', :'rcov:verify', :'rcov:ratio', :'rcov:open', :'git:status']
+  task :aok => [:'yard:generate', :'yard:open', :'echoe:manifest', :'rcov:run', :'rcov:verify', :'rcov:open', :'git:status']
 
   # desc 'Task run during continuous integration' # Invisible
-  task :cruise => [:'rcov:plain', :'rcov:verify', :'rcov:ratio']
+  task :cruise => [:'yard:generate', :'rcov:plain', :'rcov:verify', :'rcov:ratio']
 end

data/StringRay.gemspec

@@ -1,18 +1,18 @@
 
-# Gem::Specification for Stringray-1
+# Gem::Specification for Stringray-2
 # Originally generated by Echoe
 
 --- !ruby/object:Gem::Specification 
 name: stringray
 version: !ruby/object:Gem::Version 
-  version: "1"
+  version: "2"
 platform: ruby
 authors: 
 - elliottcable
 autorequire: 
 bindir: bin
 
-date: 2008-08-11 00:00:00 -08:00
+date: 2008-08-15 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -33,11 +33,9 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- lib/spec/rake/verify_ratio.rb
 - lib/stringray.rb
 - README.mkdn
 files: 
-- lib/spec/rake/verify_ratio.rb
 - lib/stringray.rb
 - Rakefile
 - README.mkdn

data/lib/stringray.rb

@@ -1,128 +1,227 @@
 module StringRay
-  VERSION = 1
+  VERSION = 2
   
-  # Splits a string into words. Not using the obvious names (+#split+, +#words+)
-  # because I want compatibility for inclusion into +String+.
-  def enumerate
+  @@whitespace = nil
+  @@delemiters = nil
+  
+  ##
+  # @see #enumerate
+  # Controls how +#enumerate+ deals with whitespace.
+  # 
+  # @param [Symbol] whitespace How to handle whitespace - :attach_before,
+  #   :standalone, or :attach_after
+  def self.whitespace= whitespace
+    @@whitespace = whitespace
+  end
+  
+  def self.whitespace
+    @@whitespace ||= :attach_before
+  end
+
+  ##
+  # @see #enumerate
+  # Controls how +#enumerate+ deals with delemiters.
+  # 
+  # @param [Symbol] delemiters How to handle delemiters - :attach_before,
+  #   :standalone, or :attach_after
+  def self.delemiters= delemiters
+    @@delemiters = delemiters
+  end
+  
+  def self.delemiters
+    @@delemiters ||= :attach_before
+  end
+  
+  ##
+  # Splits a string into an array of +StringRay+ container objects (+Word+,
+  # +Whitespace+, and +Delimiter+).
+  # 
+  # @yield [element] Allows each 'element' of the string to be operated on
+  #   after it is processed
+  # @yieldparam [Word, Whitespace, Delimiter] element The last processed
+  #   string 'element'
+  # @return [Array[Word, Whitespace, Delimiter]] An array of +StringRay+
+  #   container objects
+  # @since 2
+  def to_stray
     ray = []
+    new_element = lambda do |element|
+      yield ray.last if block_given? unless ray.empty?
+      ray << element
+    end
     
-    self.each_byte do |byte|
-      char = byte.chr
-      
+    self.scan(/./um) do |char|
       if Delimiter::Characters.include? char
-        ray << Delimiter.new(char)
+        new_element[Delimiter.new(char)]
         
       elsif Whitespace::Characters.include? char
         if ray.last.is_a? Whitespace
           ray.last << char
         else
-          ray << Whitespace.new(char)
+          new_element[Whitespace.new(char)]
         end
         
       else
         if ray.last.is_a? Word
           ray.last << char
         else
-          ray << Word.new(char)
+          new_element[Word.new(char)]
         end
         
       end
     end
     
-    ray
+    if block_given?
+      yield ray.last
+      self
+    else
+      ray
+    end
   end
   
-  # More sensible than +String#each+, this uses +#enumerate+ to enumerate on
-  # words. Accepts options as a hash, determining whether :whitespace and
-  # :delemiters will :attach_before, :standalone, or :attach_after. Default is
-  # for both to :attach_before.
-  def each_word opts = {}, &block
-    {:whitespace => :attach_before, :delemiters => :attach_before}.merge! opts
-    
-    # First, we create a two-dimensional array of words with any whitespace or
-    # delemiters that should attach to them.
-    words = self.enumerate
+  ##
+  # @see #to_stray
+  # @see #whitespace
+  # @see #delemiters
+  # Enumerates a string, similar to +#to_stray+, but returning an array of
+  # plain +String+s instead of container objects.
+  # 
+  # @param [Hash] options A hash of options
+  # @yield [word] Allows each word in the string to be operated on after it is
+  #   processed
+  # @yieldparam [String] word The last processed word
+  # @return [Array[String]] An array of words
+  # @since 1
+  def enumerate options = {}, &block
     mapped = []
     attach_before_next = []
     
-    words.each do |item|
-      case item
+    self.to_stray do |element|
+      case element
       when Delimiter
-        case opts[:delemiters]
+        case options[:delemiters] || StringRay::delemiters
         when :standalone
-          mapped << [item]
+          mapped << [element]
         when :attach_after
-          attach_before_next << item
+          attach_before_next << element
         else
           if attach_before_next.empty?
-            mapped.last << item
+            if mapped.last
+              mapped.last << element
+            else
+              attach_before_next << element
+            end
           else
-            attach_before_next << item
+            attach_before_next << element
           end
         end
         
       when Whitespace
-        case opts[:whitespace]
+        case options[:whitespace] || StringRay::whitespace
         when :standalone
-          mapped << [item]
+          mapped << [element]
         when :attach_after
-          attach_before_next << item
+          attach_before_next << element
         else
           if attach_before_next.empty?
-            mapped.last << item
+            if mapped.last
+              mapped.last << element
+            else
+              attach_before_next << element
+            end
           else
-            attach_before_next << item
+            attach_before_next << element
           end
         end
         
       when Word
         if not attach_before_next.empty?
-          mapped << [attach_before_next, item].flatten
+          mapped << [attach_before_next, element].flatten
           attach_before_next = []
         else
-          mapped << [item]
+          mapped << [element]
         end
         
       end
     end
-    (mapped.last << attach_before_next).flatten! if not attach_before_next.empty?
     
-    # Next, we yield each group of (word plus delimiters and whitespace) as a
-    # normal string to the block
-    mapped.each do |arr|
-      yield arr.map{|w|w.to_s}.join
+    if not attach_before_next.empty?
+      mapped << [Word.new] unless mapped.last
+      (mapped.last << attach_before_next).flatten!
+    end
+    
+    mapped.map do |arr|
+      string = arr.map{|w|w.to_s}.join
+      yield string if block_given?
+      string
     end
   end
   
+  # @deprecated
+  alias_method :each_word, :enumerate
+  
+  # @see StringRay::Word#new
+  def Word word; Word.new word; end
+  
+  ##
+  # A wrapper class for strings that are 'words' in and of themselves,
+  # composed of 'word characters'.
   class Word < String
     def inspect
       "(#{self})"
     end
   end
   
+  # @see StringRay::Whitespace#new
+  def Whitespace whitespace; Whitespace.new whitespace; end
+  
+  ##
+  # A wrapper class for strings that are 'whitespace' composed of 'whitespace
+  # characters'.
   class Whitespace < String
     Characters = [" ", "\t", "\n"]
+    
     def inspect
       "#{self}"
     end
   end
   
+  # @see StringRay::Delimiter#new
+  def Delimiter delimiter; Delimiter.new delimiter; end
+  
+  ##
+  # A wrapper class for strings that are 'delimiters' composed of 'delimiter
+  # characters'.
   class Delimiter < String
-    Characters = ['-', ',', '.', '?', '!']
+    Characters = ['-', ',', '.', '?', '!', ':', ';', '/', '\\', '|']
     
     def inspect
       "<#{self}>"
     end
   end
   
-  # This overrides +String#each+ with +StringRay#each_word+, thus allowing us
-  # to include +Enumerable+.
-  def self.included klass
-    klass.class_eval do
-      alias_method :each_at, :each
-      alias_method :each, :each_word
-      
-      include Enumerable
+  # This is mixed into any class including +StringRay+. It exposes
+  # +::make_enumerable!+ to said class.
+  module Extendables
+    
+    ##
+    # This overrides +String#each+ with +StringRay#enumerate+, thus allowing
+    # us to include +Enumerable+. Be careful, this breaks lots of existing
+    # code which depends on the old methodology of +String#each+! The
+    # overridden +String#each+ functionality will be exposed as
+    # +String#each_at+.
+    def make_enumerable!
+      self.class_eval do
+        alias_method :each_at, :each
+        alias_method :each, :enumerate
+        
+        include Enumerable
+      end
     end
+    
+  end
+  
+  def self.included klass
+    klass.send :extend, Extendables
   end
 end

data/spec/stringray_spec.rb

@@ -1,75 +1,173 @@
+($:.unshift File.expand_path(File.join( File.dirname(__FILE__), '..', 'lib' ))).uniq!
 require 'stringray'
 
+# Some shortcusts, because the author is a lazy typist...
+def Word word;              StringRay::Word.new word;             end
+def Whitespace whitespace;  StringRay::Whitespace.new whitespace; end
+def Delimiter delimiter;    StringRay::Delimiter.new delimiter;   end
+Space   = Whitespace ' '
+Period  = Delimiter '.'
+
 describe 'a String including StringRay' do
   before :all do
-    String.send :include, StringRay
+    class String
+      include StringRay
+    end
   end
   
-  describe '#enumerate' do
-    it 'should split a string into an array' do
-      string = 'The time has come to talk of many things - of sailing ' +
-        'ships and sealing wax, of cabbages and kings!'
-      array = []
-      string.each {|i| array << i }
-      array.should == ['The ','time ','has ','come ','to ','talk ','of ',
-        'many ','things - ','of ','sailing ','ships ','and ','sealing ',
-        'wax, ','of ','cabbages ','and ','kings!']
+  describe "#to_stray" do
+    it "should return a multi-dimensional array of container elements" do
+      string = 'This is a string.'
+      string.to_stray.should ==
+        [Word('This'), Space, Word('is'), Space, Word('a'), Space, Word('string'), Period]
+    end
+    
+    it "should yield each text element if passed a block" do
+      string = 'This is a string.'
+      
+      yielded = []
+      string.to_stray do |element|
+        yielded << element
+      end
+      
+      yielded.should ==
+        [Word('This'), Space, Word('is'), Space, Word('a'), Space, Word('string'), Period]
     end
   end
   
-  describe '#each_word' do
-    it 'should be able to attach delimeters to the beginning of the next word' do
-      string = 'The time has come to talk of many things - of sailing ' +
-        'ships and sealing wax, of cabbages and kings!'
-      array = []
-      string.each(:delemiters => :attach_after) {|i| array << i }
-      array.should == ['The ','time ','has ','come ','to ','talk ','of ',
-        'many ','things ','- of ','sailing ','ships ','and ','sealing ',
-        'wax',', of ','cabbages ','and ','kings!']
+  describe '#enumerate' do
+    it 'should split a string into an array' do
+      string = 'This is a string'
+      string.enumerate.should == 
+        ['This ','is ','a ','string']
     end
     
-    it 'should be able to let delimeters stand alone' do
-      string = 'The time has come to talk of many things - of sailing ' +
-        'ships and sealing wax, of cabbages and kings!'
-      array = []
-      string.each(:delemiters => :standalone) {|i| array << i }
-      array.should == ['The ','time ','has ','come ','to ','talk ','of ',
-        'many ','things ','- ', 'of ','sailing ','ships ','and ','sealing ',
-        'wax',', ','of ','cabbages ','and ','kings','!']
+    it 'should correctly treat commas and lists' do
+      string = 'Commas, commas, commas'
+      string.enumerate.should == 
+        ['Commas, ','commas, ','commas']
     end
     
-    it 'should be able to attach whitespace to the beginning of the next word' do
-      string = 'The time has come to talk of many things - of sailing ' +
-        'ships and sealing wax, of cabbages and kings!'
-      array = []
-      string.each(:whitespace => :attach_after) {|i| array << i }
-      array.should == ['The',' time',' has',' come',' to',' talk',' of',
-        ' many',' things',' - of',' sailing',' ships',' and',' sealing',
-        ' wax,',' of',' cabbages',' and',' kings!']
+    it 'should correctly treat periods and end-of-sentence demarcators' do
+      string = 'Punctuation. Cool right? Yah!'
+      string.enumerate.should == 
+        ['Punctuation. ','Cool ','right? ','Yah!']
     end
     
-    it 'should be able to let whitespace stand alone' do
-      string = 'The time has come to talk of many things - of sailing ' +
-        'ships and sealing wax, of cabbages and kings!'
-      array = []
-      string.each(:whitespace => :standalone) {|i| array << i }
-      array.should == ['The',' ','time',' ','has',' ','come',' ','to',' ','talk',' ','of',
-        ' ','many',' ','things',' -',' ','of',' ','sailing',' ','ships',' ','and',' ','sealing',
-        ' ','wax,',' ','of',' ','cabbages',' ','and',' ','kings!']
+    it 'should correctly treat dahses' do
+      string = 'I have - uh - dashes'
+      string.enumerate.should == 
+        ['I ','have - ','uh - ','dashes']
     end
     
-    it 'should be able to not split a delimated word' do
-      pending "Figure out a way to allow delemiters to _not_ split words " +
-        "- i.e. 'K-I-S-S-I-N-G' should be passed as a single word."
+    it 'should correctly treat ellipses' do
+      string = 'Where... are we... going'
+      string.enumerate.should == 
+        ['Where... ','are ','we... ','going']
+    end
+    
+    it 'should correctly treat a delimated word' do
+      string = 'Pneumono-ultra-microscopic-silico-volcano-koniosis'
+      string.enumerate.should == 
+        ['Pneumono-','ultra-','microscopic-','silico-','volcano-','koniosis']
+    end
+    
+    it 'should correctly treat inline line returns' do
+      string = "Line\nreturns\nyay"
+      string.enumerate.should == 
+        ["Line\n","returns\n","yay"]
+    end
+    
+    it 'should correctly treat prefacing line returns and whitespace' do
+      string = "\n\t # Code\n\n"
+      string.enumerate.should == 
+        ["\n\t # ","Code\n\n"]
+    end
+    
+    describe '(method options hash)' do
+      it 'should be able to attach delimeters to the beginning of the next word' do
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate(:delemiters => :attach_after).should == 
+          ['The ','time ','has ','come ','to ','talk ','of ',
+          'many ','things ','- of ','sailing ','ships ','and ','sealing ',
+          'wax',', of ','cabbages ','and ','kings!']
+      end
+    
+      it 'should be able to let delimeters stand alone' do
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate(:delemiters => :standalone).should ==
+          ['The ','time ','has ','come ','to ','talk ','of ',
+          'many ','things ','- ', 'of ','sailing ','ships ','and ','sealing ',
+          'wax',', ','of ','cabbages ','and ','kings','!']
+      end
+    
+      it 'should be able to attach whitespace to the beginning of the next word' do
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate(:whitespace => :attach_after).should ==
+          ['The',' time',' has',' come',' to',' talk',' of',
+          ' many',' things',' - of',' sailing',' ships',' and',' sealing',
+          ' wax,',' of',' cabbages',' and',' kings!']
+      end
+    
+      it 'should be able to let whitespace stand alone' do
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate(:whitespace => :standalone).should ==
+          ['The',' ','time',' ','has',' ','come',' ','to',' ','talk',' ','of',
+          ' ','many',' ','things',' -',' ','of',' ','sailing',' ','ships',' ','and',' ','sealing',
+          ' ','wax,',' ','of',' ','cabbages',' ','and',' ','kings!']
+      end
+    end
+    
+    describe '(class setter methods)' do
+      before :each do
+        StringRay::whitespace = nil
+        StringRay::delemiters = nil
+      end
+      
+      it 'should allow delemiter handling to be set through a class method' do
+        StringRay::whitespace = :attach_after
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate.should ==
+          ['The',' time',' has',' come',' to',' talk',' of',
+          ' many',' things',' - of',' sailing',' ships',' and',' sealing',
+          ' wax,',' of',' cabbages',' and',' kings!']
+        
+        StringRay::whitespace = :standalone
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate.should ==
+          ['The',' ','time',' ','has',' ','come',' ','to',' ','talk',' ','of',
+          ' ','many',' ','things',' -',' ','of',' ','sailing',' ','ships',' ','and',' ','sealing',
+          ' ','wax,',' ','of',' ','cabbages',' ','and',' ','kings!']
+      end
       
-      string = "String and Array, sitting in a tree - K-I-S-S-I-N-G!"
-      array = string.map
-      array.should == ['String ','and ','Array, ','sitting ','in ','a ','tree - ','K-','I-','S-','S-','I-','N-','G!']
+      it 'should allow whitespace handling to be set through a class method' do
+        StringRay::whitespace = :attach_after
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate.should ==
+          ['The',' time',' has',' come',' to',' talk',' of',
+          ' many',' things',' - of',' sailing',' ships',' and',' sealing',
+          ' wax,',' of',' cabbages',' and',' kings!']
+        
+        StringRay::whitespace = :standalone
+        string = 'The time has come to talk of many things - of sailing ' +
+          'ships and sealing wax, of cabbages and kings!'
+        string.enumerate.should ==
+          ['The',' ','time',' ','has',' ','come',' ','to',' ','talk',' ','of',
+          ' ','many',' ','things',' -',' ','of',' ','sailing',' ','ships',' ','and',' ','sealing',
+          ' ','wax,',' ','of',' ','cabbages',' ','and',' ','kings!']
+      end
     end
   end
   
   # TODO: Figure out a better way to say 'should be_include(Enumerable)'
-  it 'should also include enumerable' do
-    String.ancestors.should be_include(Enumerable)
-  end
+  # it 'should also include enumerable' do
+  #   EString.ancestors.should be_include(Enumerable)
+  # end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: stringray
 version: !ruby/object:Gem::Version 
-  version: "1"
+  version: "2"
 platform: ruby
 authors: 
 - elliottcable
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-11 00:00:00 -08:00
+date: 2008-08-15 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,11 +30,9 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- lib/spec/rake/verify_ratio.rb
 - lib/stringray.rb
 - README.mkdn
 files: 
-- lib/spec/rake/verify_ratio.rb
 - lib/stringray.rb
 - Rakefile
 - README.mkdn

data/lib/spec/rake/verify_ratio.rb

@@ -1,78 +0,0 @@
-module Spec
-  module Rake
-    
-    # A task that can verify that the ratio of (lines of spec)
-    # over (lines of code) doesn't drop below a certain threshold.
-    # It should be run after running Spec::Rake::SpecTask.
-    class VerifySpecRatioTask < ::Rake::TaskLib
-      # Name of the task. Defaults to :verify_spec_ratio
-      attr_accessor :name
-      
-      # Glob pattern to match code files. (default is '**/*.rb')
-      # Automatically excludes everything matching +spec_pattern+
-      attr_accessor :pattern
-      
-      # Glob pattern to match spec files. (default is 'spec/**/*_spec.rb')
-      attr_accessor :spec_pattern
-      
-      # Whether or not to output details. Defaults to true.
-      attr_accessor :verbose
-      
-      # The threshold value (in decimal value) for ratio. If the
-      # actual ratio is not above this value, the task will raise an
-      # exception. The ratio is devised as LoS/LoC, so values above 1
-      # mean expressive specs, while values below one mean weak specs.
-      attr_accessor :ratio
-      
-      def initialize(name=:verify_spec_ratio)
-        @name = name
-        @pattern = '**/*.rb'
-        @spec_pattern = 'spec/**/*_spec.rb'
-        @verbose = true
-        yield self if block_given?
-        raise "Ratio must be set" if @ratio.nil?
-        define_task
-      end
-      
-      def define_task
-        desc "Verify that spec-ratio is at least #{@ratio}%"
-        task @name do
-          loc = 0
-          los = 0
-          
-          code_files = Dir[@pattern]
-          spec_files = Dir[@spec_pattern]
-          
-          code_files.each do |code_file|
-            next if spec_files.include? code_file
-            code = File.open(code_file)
-            
-            code.each_line do |line|
-              line.gsub! /#(.*)/, '' # Get rid of all comments
-              line.gsub! /\s/, '' # Get rid of all whitespace
-              loc += 1 unless line.empty?
-            end
-          end
-          
-          spec_files.each do |spec_file|
-            spec = File.open(spec_file)
-            
-            spec.each_line do |line|
-              line.gsub! /#(.*)/, '' # Get rid of all comments
-              line.gsub! /\s/, '' # Get rid of all whitespace
-              los += 1 unless line.empty?
-            end
-          end
-          
-          ratio = (los.to_f / loc.to_f)
-          
-          puts "Spec-ratio: #{los}/#{loc} (#{ratio.to_s[0..3]}, expected >=: #{@ratio})" if @verbose
-          raise "Spec-ratio must be above #{@ratio} but was #{ratio.to_s[0..3]}" if ratio < @ratio
-          raise "Your spec-ratio file pattern matched no files" if loc == 0
-          raise "Your spec-ratio specfile pattern matched no files" if los == 0
-        end
-      end
-    end
-    
-  end
-end