much-boolean 0.0.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 19242c1105e248ee22d620f3753f9df082af7a07
-  data.tar.gz: c2da6ded6b3ff22e1c7999e81ad7bebe1c4c9be5
+SHA256:
+  metadata.gz: d1fc3165719932c28dd78776ec526e4f0f0b72b61f987271396003e2e17a4354
+  data.tar.gz: 190c8c50385772aa25101e0a2a2e04948d56ae9df8056a3c57f1e74dc4b99fb2
 SHA512:
-  metadata.gz: c5df601f8ee5f18616f19fd2e3257daae376ec8e8d41bfc45066b96cbdedad74ee61a4483c964b4af47f8da933868e5312b301ff1a4108174172d328300b906a
-  data.tar.gz: 3f087f6b1a4bbc1b27a9894d6771a409c0ba0868c33e4e91a5b25f21830d079f2135f67ca5814646a2767df4f0964a8db7a321ca532b61e3594ad757605d4c40
+  metadata.gz: e5596cac8da12906767898be162b6dae6f03f64f63e72c882907b03a4819f04241596d299ae6485c01595d87362852621d93f2bedd985e6e41b54a4cfa863aca
+  data.tar.gz: ace459e19aeebf53ad35c5a69f13c6d07cf1d6b56c2dc47c9ff011909239d0f337d61cbbe9a36670e0f3f7259ad0bc783c93a27c703fc2da2f17eab7dc38dfa0

data/Gemfile

@@ -1,6 +1,7 @@
 source "https://rubygems.org"
 
+ruby "~> 2.5"
+
 gemspec
 
-gem 'rake', "~> 10.4.0"
-gem 'pry', "~> 0.9.0"
+gem "pry"

data/{LICENSE.txt → LICENSE}

@@ -1,4 +1,4 @@
-Copyright (c) 2015-Present Kelly Redding and Collin Redding
+Copyright (c) 2016-Present Kelly Redding and Collin Redding
 
 MIT License
 

data/README.md

@@ -1,16 +1,165 @@
 # MuchBoolean
 
-TODO: Write a gem description
+An API for friendly boolean conversion, interpretation and handling
 
 ## Usage
 
-TODO: Write code samples and usage instructions here
+```ruby
+require "much-boolean"
+MuchBoolean::FALSE_VALUES # => [ 0, "0",
+                          #      false, "false", "False", "FALSE", "f", "F",
+                          #      "no", "No", "NO", "n", "N"
+                          #    ]
+
+
+# convert human-friendly representative values to actual booleans
+
+# nil and empty-string values
+MuchBoolean.convert(nil) # => false
+MuchBoolean.convert("")  # => false
+MuchBoolean.convert(:"") # => false
+
+# zero/one type values
+MuchBoolean.convert(0)    # => false
+MuchBoolean.convert("0")  # => false
+MuchBoolean.convert(:"0") # => false
+MuchBoolean.convert(1)    # => true
+MuchBoolean.convert("1")  # => true
+MuchBoolean.convert(:"1") # => true
+
+# true/false type values
+MuchBoolean.convert(false)   # => false
+MuchBoolean.convert("f")     # => false
+MuchBoolean.convert(:f)      # => false
+MuchBoolean.convert("F")     # => false
+MuchBoolean.convert(:F)      # => false
+MuchBoolean.convert("false") # => false
+MuchBoolean.convert(:false)  # => false
+MuchBoolean.convert("False") # => false
+MuchBoolean.convert(:False)  # => false
+MuchBoolean.convert("FALSE") # => false
+MuchBoolean.convert(:FALSE)  # => false
+MuchBoolean.convert(true)    # => true
+MuchBoolean.convert("t")     # => true
+MuchBoolean.convert(:t)      # => true
+MuchBoolean.convert("T")     # => true
+MuchBoolean.convert(:T)      # => true
+MuchBoolean.convert("true")  # => true
+MuchBoolean.convert(:true)   # => true
+MuchBoolean.convert("True")  # => true
+MuchBoolean.convert(:True)   # => true
+MuchBoolean.convert("TRUE")  # => true
+MuchBoolean.convert(:TRUE)   # => true
+
+# on/off type values
+MuchBoolean.convert("off") # => false
+MuchBoolean.convert(:off)  # => false
+MuchBoolean.convert("Off") # => false
+MuchBoolean.convert(:Off)  # => false
+MuchBoolean.convert("OFF") # => false
+MuchBoolean.convert(:OFF)  # => false
+MuchBoolean.convert("on")  # => true
+MuchBoolean.convert(:on)   # => true
+MuchBoolean.convert("On")  # => true
+MuchBoolean.convert(:On)   # => true
+MuchBoolean.convert("ON")  # => true
+MuchBoolean.convert(:ON)   # => true
+
+# yes/no type values
+MuchBoolean.convert("n")   # => false
+MuchBoolean.convert(:n)    # => false
+MuchBoolean.convert("N")   # => false
+MuchBoolean.convert(:N)    # => false
+MuchBoolean.convert("no")  # => false
+MuchBoolean.convert(:no)   # => false
+MuchBoolean.convert("No")  # => false
+MuchBoolean.convert(:No)   # => false
+MuchBoolean.convert("NO")  # => false
+MuchBoolean.convert(:NO)   # => false
+MuchBoolean.convert("y")   # => true
+MuchBoolean.convert(:y)    # => true
+MuchBoolean.convert("Y")   # => true
+MuchBoolean.convert(:Y)    # => true
+MuchBoolean.convert("yes") # => true
+MuchBoolean.convert(:yes)  # => true
+MuchBoolean.convert("Yes") # => true
+MuchBoolean.convert(:Yes)  # => true
+MuchBoolean.convert("YES") # => true
+MuchBoolean.convert(:YES)  # => true
+
+# all other values always interpreted as `true`
+MuchBoolean.convert("some-string") # => true
+MuchBoolean.convert(1938)          # => true
+MuchBoolean.convert(1938.5)        # => true
+MuchBoolean.convert(Date.today)    # => true
+MuchBoolean.convert(Time.now)      # => true
+
+
+# convert actual booleans back to human-friendly representative values
+
+MuchBoolean.one_zero(true)       # => 1
+MuchBoolean.one_zero(false)      # => 0
+MuchBoolean.one_zero(true).to_s  # => "1"
+MuchBoolean.one_zero(false).to_s # => "0"
+
+MuchBoolean.t_f(true)         # => "t"
+MuchBoolean.t_f(false)        # => "f"
+MuchBoolean.T_F(true)         # => "T"
+MuchBoolean.T_F(false)        # => "F"
+MuchBoolean.true_false(true)  # => "true"
+MuchBoolean.true_false(false) # => "false"
+MuchBoolean.True_False(true)  # => "True"
+MuchBoolean.True_False(false) # => "False"
+MuchBoolean.TRUE_FALSE(true)  # => "TRUE"
+MuchBoolean.TRUE_FALSE(false) # => "FALSE"
+
+MuchBoolean.on_off(true)  # => "on"
+MuchBoolean.on_off(false) # => "off"
+MuchBoolean.On_Off(true)  # => "On"
+MuchBoolean.On_Off(false) # => "Off"
+MuchBoolean.ON_OFF(true)  # => "ON"
+MuchBoolean.ON_OFF(false) # => "OFF"
+
+MuchBoolean.y_n(true)     # => "y"
+MuchBoolean.y_n(false)    # => "n"
+MuchBoolean.Y_N(true)     # => "Y"
+MuchBoolean.Y_N(false)    # => "N"
+MuchBoolean.yes_no(true)  # => "yes"
+MuchBoolean.yes_no(false) # => "no"
+MuchBoolean.Yes_No(true)  # => "Yes"
+MuchBoolean.Yes_No(false) # => "No"
+MuchBoolean.YES_NO(true)  # => "YES"
+MuchBoolean.YES_NO(false) # => "NO"
+
+
+# create instances to track given human-friendly values and the boolean values they map to
+
+bool = MuchBoolean.new
+bool.given  # => nil
+bool.actual # => nil
+
+MuchBoolean::FALSE_VALUES.each do |val|
+  bool = MuchBoolean.new(val)
+  bool.given    # => {val}
+  bool.actual   # => false
+  bool == false # => true
+  bool == true  # => false
+end
+
+["some-string", 1938, 1938.5, Date.today, Time.now].each do |val|
+  bool = MuchBoolean.new(val)
+  bool.given    # => {val}
+  bool.actual   # => true
+  bool == true  # => true
+  bool == false # => false
+end
+```
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'much-boolean'
+    gem "much-boolean"
 
 And then execute:
 

data/lib/much-boolean.rb

@@ -1,5 +1,124 @@
+# frozen_string_literal: true
+
 require "much-boolean/version"
 
-module MuchBoolean
-  # TODO: your code goes here...
+class MuchBoolean
+  FALSE_VALUES =
+    [
+      nil,
+      "",
+      :"",
+      0,
+      "0",
+      :"0",
+      false,
+      "f",
+      :f,
+      "F",
+      :F,
+      "false",
+      :false,
+      "False",
+      :False,
+      "FALSE",
+      :FALSE,
+      "off",
+      :off,
+      "Off",
+      :Off,
+      "OFF",
+      :OFF,
+      "n",
+      :n,
+      "N",
+      :N,
+      "no",
+      :no,
+      "No",
+      :No,
+      "NO",
+      :NO,
+    ].freeze
+
+  def self.convert(value)
+    !FALSE_VALUES.include?(value)
+  end
+
+  def self.one_zero(boolean)
+    Mapping.new(boolean, 1, 0)
+  end
+
+  def self.t_f(boolean)
+    Mapping.new(boolean, "t", "f")
+  end
+
+  def self.T_F(boolean)
+    Mapping.new(boolean, "T", "F")
+  end
+
+  def self.true_false(boolean)
+    Mapping.new(boolean, "true", "false")
+  end
+
+  def self.True_False(boolean)
+    Mapping.new(boolean, "True", "False")
+  end
+
+  def self.TRUE_FALSE(boolean)
+    Mapping.new(boolean, "TRUE", "FALSE")
+  end
+
+  def self.on_off(boolean)
+    Mapping.new(boolean, "on", "off")
+  end
+
+  def self.On_Off(boolean)
+    Mapping.new(boolean, "On", "Off")
+  end
+
+  def self.ON_OFF(boolean)
+    Mapping.new(boolean, "ON", "OFF")
+  end
+
+  def self.y_n(boolean)
+    Mapping.new(boolean, "y", "n")
+  end
+
+  def self.Y_N(boolean)
+    Mapping.new(boolean, "Y", "N")
+  end
+
+  def self.yes_no(boolean)
+    Mapping.new(boolean, "yes", "no")
+  end
+
+  def self.Yes_No(boolean)
+    Mapping.new(boolean, "Yes", "No")
+  end
+
+  def self.YES_NO(boolean)
+    Mapping.new(boolean, "YES", "NO")
+  end
+
+  attr_reader :given, :actual
+
+  def initialize(given = nil)
+    @given  = given
+    @actual = self.class.convert(@given)
+  end
+
+  def ==(other_boolean)
+    if other_boolean.kind_of?(MuchBoolean)
+      self.actual == other_boolean.actual
+    else
+      self.actual == other_boolean
+    end
+  end
+
+  module Mapping
+    def self.new(boolean_value, true_value, false_value)
+      return false_value if MuchBoolean.convert(boolean_value) == false
+      true_value
+    end
+  end
 end

data/lib/much-boolean/version.rb

@@ -1,3 +1,5 @@
-module MuchBoolean
-  VERSION = "0.0.1"
+# frozen_string_literal: true
+
+class MuchBoolean
+  VERSION = "0.2.0"
 end

data/much-boolean.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "much-boolean/version"
 
@@ -7,17 +7,16 @@ Gem::Specification.new do |gem|
   gem.name        = "much-boolean"
   gem.version     = MuchBoolean::VERSION
   gem.authors     = ["Kelly Redding", "Collin Redding"]
-  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
-  gem.description = %q{Much boolean}
-  gem.summary     = %q{Much boolean}
-  gem.homepage    = "http://github.com/redding/much-boolean"
-  gem.license     = 'MIT'
+  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com "]
+  gem.summary     = "An API for friendly boolean conversion, interpretation, and handling."
+  gem.description = "An API for friendly boolean conversion, interpretation, and handling."
+  gem.homepage    = "https://github.com/redding/much-boolean"
+  gem.license     = "MIT"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_development_dependency("assert", ["~> 2.14"])
-
+  gem.add_development_dependency("assert", ["~> 2.19.0"])
 end

data/test/helper.rb

@@ -5,8 +5,6 @@
 $LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
 
 # require pry for debugging (`binding.pry`)
-require 'pry'
+require "pry"
 
-require 'test/support/factory'
-
-# TODO: put test helpers here...
+require "test/support/factory"

data/test/support/factory.rb

@@ -1,6 +1,5 @@
-require 'assert/factory'
+require "assert/factory"
 
 module Factory
   extend Assert::Factory
-
 end

data/test/unit/much-boolean_tests.rb

@@ -0,0 +1,292 @@
+require "assert"
+require "much-boolean"
+
+class MuchBoolean
+
+  class UnitTests < Assert::Context
+    desc "MuchBoolean"
+    subject{ MuchBoolean }
+
+    should have_imeths :convert
+    should have_imeths :one_zero
+    should have_imeths :t_f, :T_F, :true_false, :True_False, :TRUE_FALSE
+    should have_imeths :on_off, :On_Off, :ON_OFF
+    should have_imeths :y_n, :Y_N, :yes_no, :Yes_No, :YES_NO
+
+    should "know its false values" do
+      exp =
+        [
+          nil,
+          "",
+          :"",
+          0,
+          "0",
+          :"0",
+          false,
+          "f",
+          :f,
+          "F",
+          :F,
+          "false",
+          :false,
+          "False",
+          :False,
+          "FALSE",
+          :FALSE,
+          "off",
+          :off,
+          "Off",
+          :Off,
+          "OFF",
+          :OFF,
+          "n",
+          :n,
+          "N",
+          :N,
+          "no",
+          :no,
+          "No",
+          :No,
+          "NO",
+          :NO,
+        ]
+      assert_equal exp, subject::FALSE_VALUES
+    end
+
+    should "convert nil and empty-string values as `false`" do
+      [nil, "", :""].each do |val|
+        assert_that(MuchBoolean.convert(val)).is_false
+      end
+    end
+
+    should "convert zero-ish values as `false`" do
+      [0, "0", :"0"].each do |val|
+        assert_that(MuchBoolean.convert(val)).is_false
+      end
+    end
+
+    should "convert false-ish values as `false`" do
+      [
+        false,
+        "f",
+        :f,
+        "F",
+        :F,
+        "false",
+        :false,
+        "False",
+        :False,
+        "FALSE",
+        :FALSE,
+      ].each do |val|
+        assert_that(MuchBoolean.convert(val)).is_false
+      end
+    end
+
+    should "convert off-ish values as `false`" do
+      ["off", :off, "Off", :Off, "OFF", :OFF].each do |val|
+        assert_that(MuchBoolean.convert(val)).is_false
+      end
+    end
+
+    should "convert no-ish values as `false`" do
+      ["n", :n, "N", :N, "no", :no, "No", :No, "NO", :NO].each do |val|
+        assert_that(MuchBoolean.convert(val)).is_false
+      end
+    end
+
+    should "convert one-ish values as `true`" do
+      [1, "1", :"1"].each do |val|
+        assert_that(MuchBoolean.convert(val)).is_true
+      end
+    end
+
+    should "convert true-ish values as `true`" do
+      [
+        true,
+        "t",
+        :t,
+        "T",
+        :T,
+        "true",
+        :true,
+        "True",
+        :True,
+        "TRUE",
+        :TRUE,
+      ].each do |val|
+        assert_that(MuchBoolean.convert(val)).is_true
+      end
+    end
+
+    should "convert on-ish values as `false`" do
+      ["on", :on, "On", :On, "ON", :ON].each do |val|
+        assert_that(MuchBoolean.convert(val)).is_true
+      end
+    end
+
+    should "convert yes-ish values as `true`" do
+      ["y", :y, "Y", :Y, "yes", :yes, "Yes", :Yes, "YES", :YES].each do |val|
+        assert_that(MuchBoolean.convert(val)).is_true
+      end
+    end
+
+    should "convert all other values as `true`" do
+      [Factory.string, Factory.integer, Factory.date, Factory.time].each do |val|
+        assert_that(MuchBoolean.convert(val)).is_true
+      end
+    end
+
+    should "encode booleans as ones and zeros" do
+      assert_that(MuchBoolean.one_zero(true)).equals(1)
+      assert_that(MuchBoolean.one_zero(false)).equals(0)
+      assert_that(MuchBoolean.one_zero(nil)).equals(0)
+      assert_that(MuchBoolean.one_zero("")).equals(0)
+      assert_that(MuchBoolean.one_zero(Factory.string)).equals(1)
+
+      assert_that(MuchBoolean.convert(MuchBoolean.one_zero(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.one_zero(false))).is_false
+    end
+
+    should "encode booleans as true/false strings" do
+      assert_that(MuchBoolean.t_f(true)).equals("t")
+      assert_that(MuchBoolean.t_f(false)).equals("f")
+      assert_that(MuchBoolean.t_f(nil)).equals("f")
+      assert_that(MuchBoolean.t_f("")).equals("f")
+      assert_that(MuchBoolean.t_f(Factory.string)).equals("t")
+      assert_that(MuchBoolean.T_F(true)).equals("T")
+      assert_that(MuchBoolean.T_F(false)).equals("F")
+      assert_that(MuchBoolean.T_F(nil)).equals("F")
+      assert_that(MuchBoolean.T_F("")).equals("F")
+      assert_that(MuchBoolean.T_F(Factory.string)).equals("T")
+      assert_that(MuchBoolean.true_false(true)).equals("true")
+      assert_that(MuchBoolean.true_false(false)).equals("false")
+      assert_that(MuchBoolean.true_false(nil)).equals("false")
+      assert_that(MuchBoolean.true_false("")).equals("false")
+      assert_that(MuchBoolean.true_false(Factory.string)).equals("true")
+      assert_that(MuchBoolean.True_False(true)).equals("True")
+      assert_that(MuchBoolean.True_False(false)).equals("False")
+      assert_that(MuchBoolean.True_False(nil)).equals("False")
+      assert_that(MuchBoolean.True_False("")).equals("False")
+      assert_that(MuchBoolean.True_False(Factory.string)).equals("True")
+      assert_that(MuchBoolean.TRUE_FALSE(true)).equals("TRUE")
+      assert_that(MuchBoolean.TRUE_FALSE(false)).equals("FALSE")
+      assert_that(MuchBoolean.TRUE_FALSE(nil)).equals("FALSE")
+      assert_that(MuchBoolean.TRUE_FALSE("")).equals("FALSE")
+      assert_that(MuchBoolean.TRUE_FALSE(Factory.string)).equals("TRUE")
+
+      assert_that(MuchBoolean.convert(MuchBoolean.t_f(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.t_f(false))).is_false
+      assert_that(MuchBoolean.convert(MuchBoolean.T_F(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.T_F(false))).is_false
+      assert_that(MuchBoolean.convert(MuchBoolean.true_false(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.true_false(false))).is_false
+      assert_that(MuchBoolean.convert(MuchBoolean.True_False(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.True_False(false))).is_false
+      assert_that(MuchBoolean.convert(MuchBoolean.TRUE_FALSE(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.TRUE_FALSE(false))).is_false
+    end
+
+    should "encode booleans as on/off strings" do
+      assert_that(MuchBoolean.on_off(true)).equals("on")
+      assert_that(MuchBoolean.on_off(false)).equals("off")
+      assert_that(MuchBoolean.on_off(nil)).equals("off")
+      assert_that(MuchBoolean.on_off("")).equals("off")
+      assert_that(MuchBoolean.on_off(Factory.string)).equals("on")
+      assert_that(MuchBoolean.On_Off(true)).equals("On")
+      assert_that(MuchBoolean.On_Off(false)).equals("Off")
+      assert_that(MuchBoolean.On_Off(nil)).equals("Off")
+      assert_that(MuchBoolean.On_Off("")).equals("Off")
+      assert_that(MuchBoolean.On_Off(Factory.string)).equals("On")
+      assert_that(MuchBoolean.ON_OFF(true)).equals("ON")
+      assert_that(MuchBoolean.ON_OFF(false)).equals("OFF")
+      assert_that(MuchBoolean.ON_OFF(nil)).equals("OFF")
+      assert_that(MuchBoolean.ON_OFF("")).equals("OFF")
+      assert_that(MuchBoolean.ON_OFF(Factory.string)).equals("ON")
+
+      assert_that(MuchBoolean.convert(MuchBoolean.on_off(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.on_off(false))).is_false
+      assert_that(MuchBoolean.convert(MuchBoolean.On_Off(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.On_Off(false))).is_false
+      assert_that(MuchBoolean.convert(MuchBoolean.ON_OFF(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.ON_OFF(false))).is_false
+    end
+
+    should "encode booleans as yes/no strings" do
+      assert_that(MuchBoolean.y_n(true)).equals("y")
+      assert_that(MuchBoolean.y_n(false)).equals("n")
+      assert_that(MuchBoolean.y_n(nil)).equals("n")
+      assert_that(MuchBoolean.y_n("")).equals("n")
+      assert_that(MuchBoolean.y_n(Factory.string)).equals("y")
+      assert_that(MuchBoolean.Y_N(true)).equals("Y")
+      assert_that(MuchBoolean.Y_N(false)).equals("N")
+      assert_that(MuchBoolean.Y_N(nil)).equals("N")
+      assert_that(MuchBoolean.Y_N("")).equals("N")
+      assert_that(MuchBoolean.Y_N(Factory.string)).equals("Y")
+      assert_that(MuchBoolean.yes_no(true)).equals("yes")
+      assert_that(MuchBoolean.yes_no(false)).equals("no")
+      assert_that(MuchBoolean.yes_no(nil)).equals("no")
+      assert_that(MuchBoolean.yes_no("")).equals("no")
+      assert_that(MuchBoolean.yes_no(Factory.string)).equals("yes")
+      assert_that(MuchBoolean.Yes_No(true)).equals("Yes")
+      assert_that(MuchBoolean.Yes_No(false)).equals("No")
+      assert_that(MuchBoolean.Yes_No(nil)).equals("No")
+      assert_that(MuchBoolean.Yes_No("")).equals("No")
+      assert_that(MuchBoolean.Yes_No(Factory.string)).equals("Yes")
+      assert_that(MuchBoolean.YES_NO(true)).equals("YES")
+      assert_that(MuchBoolean.YES_NO(false)).equals("NO")
+      assert_that(MuchBoolean.YES_NO(nil)).equals("NO")
+      assert_that(MuchBoolean.YES_NO("")).equals("NO")
+      assert_that(MuchBoolean.YES_NO(Factory.string)).equals("YES")
+
+      assert_that(MuchBoolean.convert(MuchBoolean.y_n(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.y_n(false))).is_false
+      assert_that(MuchBoolean.convert(MuchBoolean.Y_N(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.Y_N(false))).is_false
+      assert_that(MuchBoolean.convert(MuchBoolean.yes_no(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.yes_no(false))).is_false
+      assert_that(MuchBoolean.convert(MuchBoolean.Yes_No(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.Yes_No(false))).is_false
+      assert_that(MuchBoolean.convert(MuchBoolean.YES_NO(true))).is_true
+      assert_that(MuchBoolean.convert(MuchBoolean.YES_NO(false))).is_false
+    end
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ @bool }
+
+    setup do
+      @actual = Factory.boolean
+      @bool = MuchBoolean.new(@actual)
+    end
+
+    should have_reader :given, :actual
+
+    should "know its given and actual boolean values" do
+      assert_that(subject.given).equals(@actual)
+      assert_that(subject.actual).equals(@actual)
+
+      str  = Factory.string
+      bool = MuchBoolean.new(str)
+      assert_that(bool.given).equals(str)
+      assert_that(bool.actual).is_true
+    end
+
+    should "default its actual value to nil when given nil" do
+      bool = MuchBoolean.new
+      assert_that(bool.given).is_nil
+      assert_that(bool.actual).is_false
+    end
+
+    should "know if it is equal to another much boolean or not" do
+      equal_bool = MuchBoolean.new(@actual)
+      not_bool   = MuchBoolean.new(!@actual)
+
+      assert_that(subject).equals(equal_bool)
+      assert_that(subject).does_not_equal(not_bool)
+      assert_that(subject).equals(@actual)
+      assert_that(subject).does_not_equal(!@actual)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: much-boolean
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Kelly Redding
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-17 00:00:00.000000000 Z
+date: 2020-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: assert
@@ -17,35 +17,36 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: 2.19.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.14'
-description: Much boolean
+        version: 2.19.0
+description: An API for friendly boolean conversion, interpretation, and handling.
 email:
 - kelly@kellyredding.com
-- collin.redding@me.com
+- 'collin.redding@me.com '
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
 - Gemfile
-- LICENSE.txt
+- LICENSE
 - README.md
-- Rakefile
 - lib/much-boolean.rb
 - lib/much-boolean/version.rb
-- log/.gitkeep
+- log/.keep
 - much-boolean.gemspec
 - test/helper.rb
 - test/support/factory.rb
+- test/system/.keep
+- test/unit/much-boolean_tests.rb
 - tmp/.gitkeep
-homepage: http://github.com/redding/much-boolean
+homepage: https://github.com/redding/much-boolean
 licenses:
 - MIT
 metadata: {}
@@ -64,11 +65,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
-summary: Much boolean
+summary: An API for friendly boolean conversion, interpretation, and handling.
 test_files:
 - test/helper.rb
 - test/support/factory.rb
+- test/system/.keep
+- test/unit/much-boolean_tests.rb

data/Rakefile

@@ -1 +0,0 @@
-require "bundler/gem_tasks"