scrutiny 0.0.1 → 0.0.2

data/README.textile

@@ -9,33 +9,63 @@ Then require the gem:
 
 bq. @require 'scrutiny'@
 
-This will make several methods available on the String class:
+Then call the @scrutinize@ method on a String object:
+
+bq. @my_new_string = "Hello Scrutiny!".scrutinize@
+
+This attaches several methods to the object:
+* @letters@
 * @words@
 * @sentences@
 * @has_at_least@
 * @has_at_most@
-* @has_something@
+* @has_exactly@
+* @has_something_like@
+* @each_letter@
 * @each_word@
 * @each_sentence@
 
-Perhaps the simplest example is something like:
+You can now parse the string into its component words...
+
+bq. @my_new_string.words => ["Hello", "Scrutiny"]@
+
+and check the constraints of the string...
+
+bq. @my_new_string.has_at_least 2.words # => true@
+
+as well as check constraints on a smaller scope.
 
-bq. @"How many words are here?".words => ["How", "many", "words", "are", "here"]@
+bq. @my_new_string.each_word :has_at_least, 10.letters # => false@
 
-Similarly, you can parse the sentences as well:
 
-bq. @"Hello. How are you?".sentences => ["Hello.", "How are you?"]@
+The same semantics apply to sentences as well.
 
+@"Hello. How are you?".scrutinize.sentences => ["Hello.", "How are you?"]@
 
 You can also use the @has_at_least@ and @has_at_most@ methods to check if a string fits within some constraints.
 
-bq. @"This sentence is too short.".has_at_least(8.words) => false@
+bq. @my_masterpiece = "Hi. My name is Joe. I work in a button factory.".scrutinize@
+
+bq. @my_masterpiece.has_at_least 3.sentences # => true@
+
+bq. @my_masterpiece.has_at_most 2.sentences # => false@
+
+bq. @my_masterpiece.words.inject(:+) # => "HelloMynameisJoeIworkinabuttonfactory"@
+
+h2. Release Notes
+
+h3. 0.0.2
+* Added support for per-letter constraints.
+* Added the @each_letter()@ method; Returns @true@ if the constraint holds for each letter, @false@ otherwise.
+* Added the @has_exactly()@ method; Returns @true@ if the constraint matches exactly, @false@ otherwise.
+* Moved business methods into a module. String are now prepared with the @scrutinize()@ method.
 
-bq. @"This sentence is much too long.".has_at_most(1.word) => false@
+h3. 0.0.1
+* First release of anything meaningful.
 
-bq. @"Perhaps I need to write more here.".has_at_least(5.sentences) => false@
+h2. Thanks
 
-bq. @"This sentence is just right.".has_at_least(1.sentence) => true@
+Thank you for spending the cycles to read this.
 
 
 h2. LICENSE:

data/Rakefile

@@ -3,8 +3,8 @@ require 'rubygems/package_task'
 require 'rspec/core/rake_task'
  
 GEM = "scrutiny"
-GEM_VERSION = "0.0.1"
-SUMMARY = "Adds methods to String and Integer to check constraints on written text."
+GEM_VERSION = "0.0.2"
+SUMMARY = "Helper methods for analyzing written words in strings."
 AUTHOR = "Jared Stilwell"
 EMAIL = "jared.k.stilwell@gmail.com"
 HOMEPAGE = "http://uprightnetizen.com/scrutiny-gem"

data/lib/scrutiny.rb

@@ -1,46 +1,83 @@
-class String
+module Scrutiny
+  def letters
+    self.scan(/[A-Za-z]/)
+  end
+  
   def words
     self.scan(/[\w\'\"\-\_\$\#\@\^\&\*\(\)\~\[\]\{\}\<\>\/]+/)
   end
-  
+
   def sentences
     self.scan(/[\w\'\"\-\_\$\#\@\^\&\*\(\)\~\[\]\{\}\<\>\/][^\.\?\!]*[\.\?\!]/)
   end
-  
+
   def has_at_least(matcher)
     constraint = matcher.call(self)
     constraint[:matches].count >= constraint[:limit]
   end
-  
+
   def has_at_most(matcher)
     constraint = matcher.call(self)
     constraint[:matches].count <= constraint[:limit]
   end
   
+  def has_exactly(matcher)
+    constraint = matcher.call(self)
+    constraint[:matches].count == constraint[:limit]
+  end
+
   def has_something_like(regexp)
     self.scan(regexp).count > 0
   end
   
-  def each_word(action, regexp)
+  def each_letter(action, matcher)
+    result = true
+    self.letters.each do |letter|
+      letter.scrutinize
+      result = letter.method(action).call(matcher) && result
+    end
+    result
+  end
+
+  def each_word(action, matcher)
     result = true
     self.words.each do |word|
-     result = word.method(action).call(regexp) && result 
+      word.scrutinize
+      result = word.method(action).call(matcher) && result 
     end
-    
     result
   end
-  
+
   def each_sentence(action, matcher)
     result = true
     self.sentences.each do |sentence|
+      sentence.scrutinize
       result = sentence.method(action).call(matcher) && result
     end
-    
     result
   end
+end 
+
+class String
+  def scrutinize
+    class << self
+      include Scrutiny
+    end
+    self
+  end
 end
 
 class Integer
+  def letter
+    self.letters
+  end
+  
+  def letters
+    Proc.new do |string|
+      {:limit => self, :matches => string.letters}
+    end
+  end
+  
   def word
     self.words
   end

metadata

@@ -2,7 +2,7 @@
 name: scrutiny
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Jared Stilwell
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-14 00:00:00 Z
+date: 2011-09-15 00:00:00 Z
 dependencies: []
 
 description: 
@@ -51,6 +51,6 @@ rubyforge_project:
 rubygems_version: 1.8.5
 signing_key: 
 specification_version: 3
-summary: Adds methods to String and Integer to check constraints on written text.
+summary: Helper methods for analyzing written words in strings.
 test_files: []