booleanize 0.3

data/CHANGELOG

@@ -0,0 +1,11 @@
+0.3.0 (06 May 2009)
+* Ruby 1.9 Support
+* Booleanize::Config class as Singleton
+* Fixes on the tests to run on Ruby 1.9
+
+0.2.0 (02 Dec 2008)
+* Now booleanize will receive symbols, arrays or hashes as parameters.
+
+0.1.0 (30 Nov 2008)
+* Initial release
+

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 [name of plugin creator]
+
+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.rdoc

@@ -0,0 +1,135 @@
+= Booleanize
+
+Booleanize is a Ruby on Rails plugin that adds new methods to help you work with your models' boolean attributes. Basically, it creates two new instance methods and two named scopes for each specified boolean attribute.
+
+== Instance Methods
+
+Suppose you have a boolean attribute called <tt>active</tt> inside a User model. If you pass the name of this attribute to the booleanize method, two new methods will be created: 
+
+* <tt>active?</tt> - Returns if the attribute's value is <tt>true</tt> or <tt>false</tt>
+* <tt>active_humanize</tt> - Returns a string representing each of the <tt>true</tt> or <tt>false</tt> values.
+
+=== Examples
+
+  class User < ActiveRecord::Base
+    booleanize :active
+  end
+  
+  u = User.new(:active => true)
+  u.active? #=> true
+  u.active_humanize #=> "True"
+  u.active = false  
+  u.active? #=> false
+  u.active_humanize #=> "False"
+  
+You can also specify which strings Booleanize should use for each of the <tt>true</tt> and <tt>false</tt> values, by passing an array with the format [:attr_name, "string for true", "string for false"].
+
+  class User < ActiveRecord::Base
+    booleanize [:active, "Yes", "No"]
+  end
+  
+  u = User.new(:active => true)
+  u.active_humanize #=> "Yes"
+  
+== Named scopes
+
+Booleanize will create two new named_scopes for each received attribute. Using the example given above, we'll have:
+
+* <tt>active</tt>  - Will return all the objects for which the <tt>active</tt> boolean attribute is true. It's equivalent to
+  
+  <tt>named_scope :active, :conditions => {:active => true}</tt>
+  
+* <tt>not_active</tt> - Will return all the objects for which the <tt>active</tt> boolean attribute is false. It's equivalent to 
+
+  <tt>named_scope :not-active, :conditions => {:active => false}</tt>
+  
+== Booleanizing your booleans  
+  
+The <tt>booleanize</tt> method can receive several parameters. Each parameter can be:
+* A Symbol
+* A Hash like {:attr_name => ['str_for_true', 'str_for_false']}
+* An Array with three elements, like [:attr_name, 'str_for_true', 'str_for_false']
+
+    class User < ActiveRecord::Base
+      booleanize :active, [:smart, "Yes!", "No, very dumb"], :deleted => ["Yes, I'm gone", "No, I'm still here!"]
+    end
+    
+You must pay attention to the fact that the Hash parameter must be the last one (or the only one), otherwise you must enclose it with {...}
+
+  class User < ActiveRecord::Base
+    booleanize {:deleted => ["Yes, I'm gone", "No, I'm still here!"]}, :active, [:smart, "Yes!", "No, very dumb"]
+  end
+  
+But obviously you can pass several key/value pairs in a single Hash
+
+  class User < ActiveRecord::Base
+    booleanize :active => ["Yes, use me!", "No, I'm disabled"], :deleted => ["Yes, I'm gone", "No, I'm still here!"]
+  end  
+  
+== Resume
+
+It's simple: Instead of writing this:
+
+  class User < ActiveRecord::Base
+    named_scope :active, :conditions => {:active => true}
+    named_scope :not_active, :conditions => {:active => false}
+    
+    def active_humanize
+      active ? "Yes" : "No"
+    end
+    
+    def active?
+      active ? true : false  #=> because we'll always want it to return true or false, and never nil.
+    end
+  end  
+  
+You can simply write
+
+  class User < ActiveRecord::Base
+    booleanize :active => ["Yes", "No"]
+  end
+  
+== Installation
+
+Just clone the plugin inside <tt>RAILS_ROOT/vendor/plugins</tt>
+
+  git clone git://github.com/cassiomarques/booleanize.git 
+  
+== Running the tests
+
+Booleanize is a fully tested plugin. If you'd like to run the tests, you'll need:
+
+* RSpec installed as a gem
+* SQlite3
+* SQlite3 Ruby adapter
+
+Just enter the plugin's folder and run
+
+  rake spec
+  
+And happilly watch all the tests pass (if everything needed for the tests is installed in your computer).
+
+== LICENSE
+
+Copyright (c) 2008 Cassio Marques
+
+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/Rakefile

@@ -0,0 +1,20 @@
+require 'rake'
+require 'spec/rake/spectask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ["--color", "--format", "specdoc"]
+end  
+
+desc 'Generate documentation for the booleanize plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Booleanize'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/lib/booleanize"

data/lib/booleanize.rb

@@ -0,0 +1,136 @@
+# = Booleanize plugin
+#
+# This plugin adds some helper methods to boolean attributes in Active Record models.
+# Author: Cassio Marques (cassiommc@gmail.com)
+#
+# = Description
+#
+# Creates two instance methods and two named scopes for each of the received boolean attributes.
+#  
+# == Instance methods
+#   
+#   Creates a attr_name_humanize for each boolean attribute, which returns a specific string for each boolean true or false.
+#   Creates a attr_name? method for each boolean attribute.
+#
+# == Named scopes
+#
+#   Creates two named scopes for esch boolean attribute:
+#     named_scope :attr_name, :conditions => {:attr_name => true}
+#     named_scope :not_attr_name, :conditions => {:attr_name => false}
+#
+# == How to use it
+#
+#   The <tt>booleanize</tt> method can receive several parameters. Each parameter can be:
+#   * A Symbol
+#   * A Hash like {:attr_name => ['str_for_true', 'str_for_false']}
+#   * A Array with three elements, like [:attr_name, 'str_for_true', 'str_for_false']
+#
+#   class User < ActiveRecord::Base
+#     booleanize :active, [:smart, "Yes!", "No, very dumb"], :deleted => ["Yes, I'm gone", "No, I'm still here!"]
+#   end
+#
+# You must pay attention to the fact that the Hash parameter must be the last one, otherwise you must enclose it with {...}
+#
+# You'll have a humanized instance method for each received boolean attribute:
+#
+#   u = User.new(:acive => true. :smart => false)
+#   u.smart_humanize #=> "No, very dumb"
+#
+#   If you pass a symbol instead of an array, booleanize will use the 'True' default text for boolean true
+#   and the 'False' default text for boolean false.
+#
+#   booleanize :active, [:smart, "Yes", "No"]
+#
+#   u.active_humanize #=> "True"
+#   u.active? #=> true
+#
+# You'll also get two new named_scope methods for your model
+#
+#   active_users = User.active #=> same as named_scope :active, :conditions => {:active => true}
+#   disabled_users = User.not_active #=> same as named_scope :not_active, :conditions => {:active => false}
+#
+require 'singleton'
+
+module Booleanize
+
+  class Config
+    include Singleton
+    
+    attr_accessor :default_for_true, :default_for_false
+    
+    def self.default_strings(options = {})
+      error = "Wrong configuration parameters for booleanize: You should pass something like {:true => \"Yes\", :false => \"No\" }"
+      raise error unless options.is_a?(Hash) and [:true, :false].all? { |k| options.has_key? k }
+      instance.default_for_true = options[:true]
+      instance.default_for_false = options[:false]
+    end
+
+    protected
+    def self.default_for_true; instance.default_for_true rescue nil; end
+    def self.default_for_false; instance.default_for_false rescue nil; end
+  end
+
+  def booleanize(*params)
+    params.each do |param|
+      case param
+        when Symbol; create_methods_for_symbol(param)
+        when Array; create_methods_for_array(param)
+        when Hash; create_methods_for_hash(param)
+        else raise_error
+      end
+    end
+  end
+
+  private
+
+    def create_true_named_scope(attr_name)
+      named_scope attr_name, :conditions => { attr_name => true }
+    end
+
+    def create_false_named_scope(attr_name)
+      named_scope :"not_#{attr_name}", :conditions => { attr_name => false }
+    end
+
+    def create_humanize_method(attr_name, true_str, false_str)
+      true_str = (true_str.nil? ? (Config.default_for_true.nil? ? "True" : Config.default_for_true) : true_str.to_s)
+      false_str = (false_str.nil? ? (Config.default_for_false.nil? ? "False" : Config.default_for_false) : false_str.to_s)
+      class_eval("def #{attr_name}_humanize; #{attr_name} ? #{true_str.inspect} : #{false_str.inspect}; end")
+      
+    end
+
+    def create_methods(attr_name, true_str = nil, false_str = nil)
+      create_true_named_scope(attr_name)
+      create_false_named_scope(attr_name)
+      create_humanize_method(attr_name, true_str, false_str)
+    end
+
+    def create_methods_for_array(array)
+      first_is_symbol = array[0].is_a? Symbol
+      second_is_string = array[1].is_a? String
+      third_is_string = array[2].is_a? String
+
+      if array.length == 3 && first_is_symbol && second_is_string && third_is_string
+        create_methods(array[0], array[1], array[2])
+      else
+        raise_error(array)
+      end
+    end
+
+    def create_methods_for_symbol(symbol)
+      create_methods(symbol)
+    end
+
+    def create_methods_for_hash(hash)
+      hash.each_pair do |k, v|
+        raise_error unless v.is_a? Array and v.length == 2
+        create_methods(k, v[0], v[1])
+      end
+    end
+
+    def raise_error(param)
+      raise "You can only pass a three element Array ([:attr_name, 'str_for_true', 'str_for_false']), a Symbol or a Hash (:attr_name => ['str_for_true', 'str_for_false']). You passed #{param.inspect}"
+    end
+
+end
+
+ActiveRecord::Base.send(:extend, Booleanize)

data/spec/booleanize_spec.rb

@@ -0,0 +1,236 @@
+require 'rubygems'
+require 'spec'
+require 'active_record'
+require File.dirname(__FILE__) + "/../lib/booleanize"
+
+ActiveRecord::Base.establish_connection(:adapter=>"sqlite3", :database => ":memory:")
+require File.dirname(__FILE__) + "/db/create_testing_structure"
+
+CreateTestingStructure.migrate(:up)
+
+class User < ActiveRecord::Base
+  booleanize [:dumb, "Dumb as hell!", "No, this is a smart one!"], :active, [:smart, "Yes!", "No, very dumb"], :deleted => ["Yes, I'm gone", "No, I'm still here!"]
+end
+
+class Post < ActiveRecord::Base
+  booleanize :deleted => ["Yes", "No"], :rated => ["Yes", "No"]
+end
+
+describe "booleanize" do  
+  def smart_user
+    User.new(:name => "Smart Dude", :active => true, :dumb => false, :smart => true, :deleted => false)
+  end
+  
+  def dumb_user
+    User.new(:name => "Dumb Dude", :active => true, :dumb => true, :smart => false, :deleted => false)
+  end  
+  
+  it "should raise an exception if any of the attributes is not a Symbol or a three elements array" do
+    lambda do
+      class Bla < ActiveRecord::Base
+        booleanize "bla"
+      end
+    end.should raise_error
+  end
+  
+  it "should raise an exception if it receives an array but it's not in the format [:attr_name, 'string for true', 'string for false']" do
+    lambda do
+      class Bla < ActiveRecord::Base
+        booleanize [:bla]
+      end.should raise_error
+    end
+    lambda do
+      class Bla < ActiveRecord::Base
+        booleanize [:bla, 'Yes!']
+      end
+    end.should raise_error
+    lambda do
+      class Bla < ActiveRecord::Base
+        booleanize [:bla, 'Yes!', :no]
+      end
+    end.should raise_error    
+  end
+  
+  it "should raise an exception if it receives a hash but it's not in the format :attr_name => ['str_for_true', 'str_for_false']" do
+    lambda do
+      class Bla < ActiveRecord::Base
+        booleanize :attr_nam => []
+      end.should raise_error
+    end
+    lambda do
+      class Bla < ActiveRecord::Base
+        booleanize :attr_name => ['str_for_true']
+      end
+    end.should raise_error
+    lambda do
+      class Bla < ActiveRecord::Base
+        booleanize :attr_name => ['bla', 'ble', 'bli']
+      end.should raise_error
+    end
+  end
+    
+  describe "creating boolean_attr_name? method" do
+    it "should respond to a boolean_attr_name? for each received attribute" do
+      u = smart_user
+      [:active?, :dumb?, :smart?].each {|m| u.should respond_to(m)}
+    end
+    
+    it "should return true if the attribute's value is true'" do
+      smart_user.should be_smart
+      smart_user.should_not be_dumb
+    end
+    
+    it "should return false if the attribute's value is false" do
+      dumb_user.should be_dumb
+      dumb_user.should_not be_smart
+    end
+    
+    it "should return the new boolean value when a new value is assigned to the attribute" do
+      u = smart_user
+      u.active = false
+      u.should_not be_active
+    end
+    
+    it "should return false is the attribute is nil" do
+      u = smart_user
+      u.active = nil
+      u.active?.should == false
+    end
+  end
+  
+  describe "creating boolean_attr_name_humanize method" do
+    describe "when a symbol is passed" do
+      it "should respond to a boolean_attr_name_humanize method for each received attribute" do
+        u = dumb_user 
+        [:active_humanize, :dumb_humanize, :smart_humanize].each {|m| u.should respond_to(m)}
+      end
+    end
+    
+    describe "when an array is passed" do
+      it "should return the specified string for true" do
+        smart_user.smart_humanize.should eql("Yes!")
+      end
+      
+      it "should return the specified string for false" do
+        dumb_user.smart_humanize.should eql("No, very dumb")
+      end
+      
+      it "should return the string for false when the attribute is nil" do
+        u = dumb_user
+        u.smart = nil
+        u.smart_humanize.should == "No, very dumb"
+      end
+    end
+    
+    describe "when a hash is passed" do
+      it "should return the specified string for true" do
+        u = smart_user
+        u.deleted = true
+        u.deleted_humanize.should eql("Yes, I'm gone")
+      end
+      
+      it "should return the specified string for false" do
+        smart_user.deleted_humanize.should eql("No, I'm still here!") 
+      end
+      
+      it "should return the string for false when the attribute is nil" do
+        u = smart_user
+        u.deleted = nil
+        u.deleted_humanize.should eql("No, I'm still here!")
+      end
+      
+      it "should respond to attr_name?" do
+        smart_user.should respond_to(:deleted)
+      end
+      
+      describe "with more than on key/value pair" do
+        it "should create a 'humanize' method for each key" do
+          p = Post.new(:rated => true, :deleted => false)
+          p.rated_humanize.should eql("Yes")
+          p.deleted_humanize.should eql("No")
+        end
+      end
+    end
+    
+    describe "when a symbol is passed" do
+      it "should return the default string for true" do
+        smart_user.active_humanize.should eql("True")
+      end
+      
+      it "should return the default string for false" do
+        u = smart_user
+        u.active = false
+        u.active_humanize.should eql("False")
+      end
+      
+      it "should return the string for false when the attribute is nil" do
+        u = smart_user
+        u.active = false
+        u.active_humanize.should eql("False")
+      end
+    end
+  end 
+  
+  describe "creating named_scopes" do
+    before do
+      3.times {|i| smart_user.save!; dumb_user.save! }            
+    end
+    
+    after do
+      User.delete_all
+    end
+    
+    it "should have a named scope that returns all the objects for which the boolean attribute is true" do
+      User.smart.should have(3).items
+      User.active.should have(6).items
+    end
+    
+    it "should have a named scope that returns all the objects for which the boolean attribute is false" do
+      User.not_smart.should have(3).items
+      User.not_active.should be_empty
+    end
+    
+    it "should have a named scope that returns all the objects for which a boolean attribute passed as a hash is true" do
+      User.deleted.should be_empty
+    end
+    
+    it "should have a named scope that returns all the objects for which a boolean attribute passed as a hash is false" do
+      User.not_deleted.should have(6).items
+    end
+  end 
+
+  describe "with global configuration" do
+    before do
+      Booleanize::Config.default_strings :true => "Oh yes!", :false => "Nooo"
+      
+      User.class_eval do
+        booleanize :active
+        booleanize :smart => ["Too smart", "Duh!"]
+      end
+    end
+    
+    it "should use the globally defined string for true" do
+      User.create(:active => true).active_humanize.should == "Oh yes!"
+    end
+
+    it "should use the globally defined string for false" do
+      User.create(:active => false).active_humanize.should == "Nooo"
+    end
+
+    it "should use the string for yes specified in the class definition" do
+      User.create(:smart => true).smart_humanize.should == "Too smart"
+    end
+
+    it "should use the string for no specified in the class definition" do
+      User.create(:smart => false).smart_humanize.should == "Duh!"
+    end
+
+    it "should raise an exception if the config parameters are not inside a two pairs hash" do
+      ["hello", {:bla => :foo}, ["bla", "ble"]].each do |params|
+        lambda { Booleanize::Config.default_strings params }.should raise_error
+      end
+    end
+  end
+end
+
+

data/spec/db/create_testing_structure.rb

@@ -0,0 +1,20 @@
+class CreateTestingStructure < ActiveRecord::Migration
+  def self.up
+    create_table :users do |t|
+      t.string :name
+      t.boolean :smart
+      t.boolean :active
+      t.boolean :dumb
+      t.boolean :deleted
+    end
+    create_table :posts do |t|
+      t.boolean :deleted
+      t.boolean :rated
+    end
+  end
+    
+  def self.down
+    drop_table :users
+    drop_table :posts
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: booleanize
+version: !ruby/object:Gem::Version 
+  version: "0.3"
+platform: ruby
+authors: 
+- "C\xC3\xA1ssio Marques"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-04 00:00:00 -03:00
+default_executable: 
+dependencies: []
+
+description: A Rails plugin that adds some new methods for boolean attributes in Active Record models.
+email: cassiommc@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- CHANGELOG
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- init.rb
+- lib/booleanize.rb
+has_rdoc: true
+homepage: http://github.com/cassiomarques/booleanize
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.3
+signing_key: 
+specification_version: 3
+summary: A Rails plugin that adds some new methods for boolean attributes in Active Record models.
+test_files: 
+- spec/booleanize_spec.rb
+- spec/db/create_testing_structure.rb