coalesce 0.0.1

data/README.md

@@ -0,0 +1,55 @@
+# Coalesce
+
+## Ruby, as a community, unfairly discriminates against `false`, and it needs to stop.
+
+ Do you write code like this? `val = maybe_nil || fallback`
+
+If so, **you are part of the problem!**
+
+`false` is a perfectly non-nil object, and you're excluding it out of convenience!
+
+## C#'s ?? operator
+
+The null coalescing operator `??` is a C# idiom that provides a concise fallback mechanism for expressions that return `null`.
+
+    Object maybeObject = null;
+    Object fallbackObject = new Object();
+    Object obj = maybeObject ?? fallbackObject;
+
+In Ruby, we generally write this:
+
+    maybe_object = nil
+    fallback_object = Object.new
+    obj = maybe_object || fallback_object
+
+However, this idiom is only an approximation, and introduces subtle bugs when we try to allow false values:
+
+    maybe_val = false # assumed to be a valid value
+    fallback_val = 5
+    val = maybe_val || fallback_val # => 5, whoops!
+
+## Meet the _? method
+
+With `coalesce`, you can write this instead:
+
+    maybe_val = false # assumed to be a valid value
+    fallback_val = 5
+    val = maybe_val._? fallback_val # => false, like we expected!
+
+And if you still need the short-circuiting behavior of the `||` operator, you can pass a block instead:
+
+    val = maybe_val._? { generate_fallback(data) }
+
+## Benefits
+
+I've noticed a positive side-effect of using `_?` is that I explicitly call out when I'm counting on the short-circuiting behavior, and that awareness of the short-circuiting behavior is causing me to use it in ways I would never use `||`.
+
+For example, using it to assert an object's existence before returning it.
+
+    def give_me_the_data
+      @data_finder.try_to_find_data._? { raise "Oh no, we suck at finding data!" }
+    end
+
+I probably wouldn't think to use a `||` there, and it might look weird, especially with a more complex expression.
+
+And, of course, I'm grateful to be reunited with my long lost friend, `false`.

data/Rakefile

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

data/coalesce.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |gem|
+  gem.name          = 'coalesce'
+  gem.description   = "Adds a nil-coalescing method to Ruby, similar to C#'s ?? null-coalescing operator"
+  gem.homepage      = "https://github.com/kibiz0r/#{gem.name}"
+  gem.version       = '0.0.1'
+
+  gem.authors       = ['Michael Harrington']
+  gem.email         = ['kibiz0r@gmail.com']
+
+  gem.files         = `git ls-files`.split($\)
+  gem.require_paths = ['lib']
+
+  gem.summary       = <<-END.gsub(/^ +/, '')
+    foo || bar is a nice idiom for returning bar if foo is nil. Unfortunately, it also returns bar if foo is false.
+    foo._? bar is a clean alternative that respects false values.
+    foo._? { bar } allows you to keep the short-circuiting behavior of the || operator.
+  END
+end

data/lib/bubble-wrap/coalesce.rb

@@ -0,0 +1,3 @@
+require 'bubble-wrap/loader'
+
+BubbleWrap.require 'lib/coalesce.rb'

data/lib/coalesce.rb

@@ -0,0 +1,16 @@
+class Object
+  def _?(x = nil)
+    self
+  end
+end
+
+class NilClass
+  def _?(x = nil)
+    if block_given?
+      yield
+    else
+      x
+    end
+  end
+end
+

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification 
+name: coalesce
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Michael Harrington
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-09-11 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Adds a nil-coalescing method to Ruby, similar to C#'s ?? null-coalescing operator
+email: 
+- kibiz0r@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- Rakefile
+- coalesce.gemspec
+- lib/bubble-wrap/coalesce.rb
+- lib/coalesce.rb
+has_rdoc: true
+homepage: https://github.com/kibiz0r/coalesce
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: foo || bar is a nice idiom for returning bar if foo is nil. Unfortunately, it also returns bar if foo is false. foo._? bar is a clean alternative that respects false values. foo._? { bar } allows you to keep the short-circuiting behavior of the || operator.
+test_files: []
+