boolean 1.0.0

data/.rspec

@@ -0,0 +1 @@
+-cfs

data/Gemfile

@@ -0,0 +1,13 @@
+source :rubygems
+
+group :development do
+  # FRAMEWORK
+  gem 'jeweler'
+
+  # SPECS
+  gem 'rspec'
+
+  # DOCS
+  gem 'yard'
+  gem 'RedCloth', require: nil
+end

data/Gemfile.lock

@@ -0,0 +1,29 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    RedCloth (4.2.7)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+    yard (0.6.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  RedCloth
+  jeweler
+  rspec
+  yard

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Tim Morgan
+
+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.textile

@@ -0,0 +1,60 @@
+h1. Boolean -- Additional Boolean-related core extensions
+
+| *Author* | Tim Morgan |
+| *Version* | 1.0 (Feb 15, 2011) |
+| *License* | Released under the MIT license. |
+
+h2. About
+
+*Boolean* adds some helpful methods for working with Ruby's Boolean types,
+@TrueClass@ and @FalseClass@ (the singleton classes whose only instances are
+@true@ and @false@, respectively).
+
+With *Boolean*, you get a @Boolean@ mixin so you can refer to @true@ and @false@
+under a common class name:
+
+<pre><code>
+  if variable.kind_of?(Boolean) then
+    [ ... ]
+  end
+</code></pre>
+
+You can also type-cast Ruby objects into their Boolean values:
+
+<pre><code>
+  "string".to_bool #=> true
+  nil.to_bool #=> false
+</code></pre>
+
+And you can parse various Ruby objects to Booleans:
+
+<pre><code>
+  "yes".parse_bool #=> true
+  "no".parse_bool #=> false
+  1.parse_bool => true
+  0.parse_bool => false
+</code></pre>
+
+(@parse_bool@ is also aliased as @to_b@ to be consistent with the
+@to_i@/@to_int@ naming paradigm.)
+
+Lastly, inline with the @Integer()@ method, you have a @Boolean()@ method:
+
+<pre><code>
+  Boolean("yes") #=> true
+  Boolean("no") #=> false
+  Boolean("maybe") #=> ArgumentError
+</code></pre>
+
+h2. Installation and Usage
+
+Just add the gem to your project's @Gemfile@:
+
+<pre><code>
+gem 'boolean'
+</code></pre>
+
+All the features shown in the previous section are now available in your project
+code.
+
+More information can be found in the class and method documentation.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+
+#################################### BUNDLER ###################################
+
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+#################################### JEWELER ###################################
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name        = "boolean"
+  gem.homepage    = "http://rubygems.org/gems/boolean"
+  gem.license     = "MIT"
+  gem.summary     = %Q{Useful methods for working with Booleans}
+  gem.description = %Q{This gem extends core classes, adding helpful methods for working with Booleans (such as #to_bool and #parse_bool, and a Boolean type).}
+  gem.email       = "git@timothymorgan.info"
+  gem.authors     = [ "Tim Morgan" ]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+##################################### RSPEC ####################################
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+
+##################################### YARD #####################################
+
+require 'yard'
+YARD::Rake::YardocTask.new do |doc|
+  doc.options << "-m" << "textile"
+  doc.options << "--protected"
+  doc.options << "--no-private"
+  doc.options << "-r" << "README.textile"
+  doc.options << "-o" << "doc"
+  doc.options << "--title" << "Boolean Documentation".inspect
+
+  doc.files = [ 'lib/**/*', 'README.textile' ]
+end
+
+desc "Generate API documentation"
+task :doc => :yard

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/boolean.gemspec

@@ -0,0 +1,63 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{boolean}
+  s.version = "1.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tim Morgan"]
+  s.date = %q{2011-02-15}
+  s.description = %q{This gem extends core classes, adding helpful methods for working with Booleans (such as #to_bool and #parse_bool, and a Boolean type).}
+  s.email = %q{git@timothymorgan.info}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.textile"
+  ]
+  s.files = [
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.textile",
+    "Rakefile",
+    "VERSION",
+    "boolean.gemspec",
+    "lib/boolean.rb",
+    "spec/boolean_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://rubygems.org/gems/boolean}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.2}
+  s.summary = %q{Useful methods for working with Booleans}
+  s.test_files = [
+    "spec/boolean_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<yard>, [">= 0"])
+      s.add_development_dependency(%q<RedCloth>, [">= 0"])
+    else
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<yard>, [">= 0"])
+      s.add_dependency(%q<RedCloth>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<yard>, [">= 0"])
+    s.add_dependency(%q<RedCloth>, [">= 0"])
+  end
+end
+

data/lib/boolean.rb

@@ -0,0 +1,124 @@
+# Mixin module that adds no features, but simply includes a @Boolean@ type in
+# the parent class's heirarchy. This allows you to do things like:
+#
+# <pre><code>
+#   if variable.kind_of?(Boolean) then
+#     [ ... ]
+#   end
+# </code></pre>
+
+module Boolean; end
+
+class TrueClass
+  include Boolean
+
+  # Returns the _typecasted_ value of this object.
+  #
+  # @return [true] @true@.
+  def to_bool() true end
+
+  # Returns the _parsed_ value of this object.
+  #
+  # @return [true] @true@.
+  def parse_bool() true end
+  
+  # @see #parse_bool
+  def to_b() true end
+end
+
+class FalseClass
+  include Boolean
+
+  # Returns the _typecasted_ value of this object.
+  #
+  # @return [false] @false@.
+  def to_bool() false end
+
+  # Returns the _parsed_ value of this object.
+  #
+  # @return [false] @false@.
+  def parse_bool() false end
+  
+  # @see #parse_bool
+  def to_b() false end
+end
+
+class NilClass
+  # Returns the _typecasted_ value of this object.
+  #
+  # @return [false] @false@.
+  def to_bool() false end
+
+  # Returns the _parsed_ value of this object.
+  #
+  # @return [false] @false@.
+  def parse_bool() false end
+
+  # @see #parse_bool
+  def to_b() false end
+end
+
+class Object
+  # Returns the _typecasted_ value of this object. This would be @true@ for all
+  # objects except @false@ and @nil@, which type-cast to @false@.
+  #
+  # @return [true, false] The typecast value of this object.
+  def to_bool() true end
+end
+
+class String
+  # Returns the _parsed_ value of this object. Strings beginning with any of
+  # "y", "t", or "1" are considered @true@, whereas all else are considered
+  # @false@.
+  #
+  # @return [true, false] The parsed Boolean value of this string.
+  # @see #parse_bool!
+  def parse_bool() %w( y Y 1 t T ).include? self[0] end
+
+  # @see #parse_bool
+  def to_b() parse_bool end
+
+  # Similar to {#parse_bool}, but raises an error unless the string can be
+  # explicitly parsed to @true@ or @false@. Strings beginning with "n", "f", or
+  # "0" are considered false.
+  #
+  # @return [true, false] The parsed Boolean value of this string.
+  # @raise [ArgumentError] If the string does not seem to represent @true@ or
+  #   @false@.
+  # @example
+  #   "true".parse_bool! #=> true
+  #   "no".parse_bool! #=> false
+  #   "maybe".parse_bool! #=> ArgumentError
+  def parse_bool!
+    if %w( y Y 1 t T ).include? self[0] then
+      true
+    elsif %w( n N 0 f F ).include? self[0] then
+      false
+    else
+      raise ArgumentError, "Invalid value for parse_bool!: #{inspect}"
+    end
+  end
+
+  # @see #parse_bool!
+  def to_b!() parse_bool! end
+end
+
+module Kernel
+  # @see String#parse_bool!
+  def Boolean(string)
+      string.parse_bool!
+  rescue ArgumentError => err
+    raise ArgumentError, err.message.gsub('parse_bool!', 'Boolean()')
+  end
+end
+
+class Numeric
+  # Returns the _parsed_ value of this object. Numbers equal to zero are
+  # considered @false@; all others are considered @true@.
+  #
+  # @return [true, false] The parsed Boolean value of this number.
+  def parse_bool() not zero? end
+
+  # @see #parse_bool
+  def to_b() not zero? end
+end

data/spec/boolean_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+describe TrueClass do
+  [ :to_bool, :parse_bool, :to_b ].each do |method|
+    describe "##{method}" do
+      it("should return true") { true.send(method).should eql(true) }
+    end
+  end
+
+  it("should be a kind of Boolean") { true.should be_kind_of(Boolean) }
+end
+
+describe FalseClass do
+  [ :to_bool, :parse_bool, :to_b ].each do |method|
+    describe "##{method}" do
+      it("should return false") { false.send(method).should eql(false) }
+    end
+  end
+
+  it("should be a kind of Boolean") { false.should be_kind_of(Boolean) }
+end
+
+describe NilClass do
+  [ :to_bool, :parse_bool, :to_b ].each do |method|
+    describe "##{method}" do
+      it("should return false") { nil.send(method).should eql(false) }
+    end
+  end
+end
+
+describe Object do
+  describe "#to_bool" do
+    it("should return true") { Object.new.to_bool.should eql(true) }
+  end
+
+  it("should not be a kind of Boolean") { Object.new.should_not be_kind_of(Boolean) }
+end
+
+describe Numeric do
+  [ :parse_bool, :to_b ].each do |method|
+    describe "##{method}" do
+      it "should return true if the number is not zero" do
+        1.send(method).should eql(true)
+        1.0.send(method).should eql(true)
+        -1.send(method).should eql(true)
+        -1.0.send(method).should eql(true)
+      end
+
+      it "should return false if the number is zero" do
+        0.send(method).should eql(false)
+        0.0.send(method).should eql(false)
+      end
+    end
+  end
+end
+
+describe String do
+  [ :parse_bool, :to_b ].each do |method|
+    describe "##{method}" do
+      it "should return true if the string starts with 1, y, Y, t, or T" do
+        "y".send(method).should eql(true)
+        "Y".send(method).should eql(true)
+        "yes".send(method).should eql(true)
+        "YES".send(method).should eql(true)
+        "Yes".send(method).should eql(true)
+        "t".send(method).should eql(true)
+        "T".send(method).should eql(true)
+        "true".send(method).should eql(true)
+        "TRUE".send(method).should eql(true)
+        "True".send(method).should eql(true)
+        "1".send(method).should eql(true)
+      end
+
+      it "should return false otherwise" do
+        "n".send(method).should eql(false)
+        "N".send(method).should eql(false)
+        "no".send(method).should eql(false)
+        "NO".send(method).should eql(false)
+        "No".send(method).should eql(false)
+        "f".send(method).should eql(false)
+        "F".send(method).should eql(false)
+        "false".send(method).should eql(false)
+        "FALSE".send(method).should eql(false)
+        "False".send(method).should eql(false)
+        "0".send(method).should eql(false)
+
+        "m".send(method).should eql(false)
+        "maybe".send(method).should eql(false)
+        "MAYBE".send(method).should eql(false)
+        "Maybe".send(method).should eql(false)
+        "i".send(method).should eql(false)
+        "I".send(method).should eql(false)
+        "i don't know".send(method).should eql(false)
+        "I DON'T KNOW".send(method).should eql(false)
+        "I don't know".send(method).should eql(false)
+      end
+    end
+  end
+
+  [ :parse_bool!, :to_b! ].each do |method|
+    describe "##{method}" do
+      it "should return true if the string starts with 1, y, Y, t, or T" do
+        "y".send(method).should eql(true)
+        "Y".send(method).should eql(true)
+        "yes".send(method).should eql(true)
+        "YES".send(method).should eql(true)
+        "Yes".send(method).should eql(true)
+        "t".send(method).should eql(true)
+        "T".send(method).should eql(true)
+        "true".send(method).should eql(true)
+        "TRUE".send(method).should eql(true)
+        "True".send(method).should eql(true)
+        "1".send(method).should eql(true)
+      end
+
+      it "should return false if the string starts with 0, n, N, f, or F" do
+        "n".send(method).should eql(false)
+        "N".send(method).should eql(false)
+        "no".send(method).should eql(false)
+        "NO".send(method).should eql(false)
+        "No".send(method).should eql(false)
+        "f".send(method).should eql(false)
+        "F".send(method).should eql(false)
+        "false".send(method).should eql(false)
+        "FALSE".send(method).should eql(false)
+        "False".send(method).should eql(false)
+        "0".send(method).should eql(false)
+      end
+
+      it "should raise ArgumentError otherwise" do
+        -> { "m".send(method) }.should raise_error(ArgumentError)
+        -> { "maybe".send(method) }.should raise_error(ArgumentError)
+        -> { "MAYBE".send(method) }.should raise_error(ArgumentError)
+        -> { "Maybe".send(method) }.should raise_error(ArgumentError)
+        -> { "i".send(method) }.should raise_error(ArgumentError)
+        -> { "I".send(method) }.should raise_error(ArgumentError)
+        -> { "i don't know".send(method) }.should raise_error(ArgumentError)
+        -> { "I DON'T KNOW".send(method) }.should raise_error(ArgumentError)
+        -> { "I don't know".send(method) }.should raise_error(ArgumentError)
+      end
+    end
+  end
+end
+
+describe Kernel do
+  describe "#Boolean" do
+    it "should call String#parse_bool! and return the result" do
+      string = mock('String')
+      result = mock('result')
+
+      string.should_receive(:parse_bool!).once.and_return(result)
+
+      Boolean(string).should eql(result)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'boolean'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  # configuration here
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: boolean
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Tim Morgan
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-15 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: RedCloth
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+description: "This gem extends core classes, adding helpful methods for working with Booleans (such as #to_bool and #parse_bool, and a Boolean type)."
+email: git@timothymorgan.info
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.textile
+files: 
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.textile
+- Rakefile
+- VERSION
+- boolean.gemspec
+- lib/boolean.rb
+- spec/boolean_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/boolean
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 4093550238213875755
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Useful methods for working with Booleans
+test_files: 
+- spec/boolean_spec.rb
+- spec/spec_helper.rb