nil_conditional 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cf1d6643060be57fa65e068058c18be67b556f43
-  data.tar.gz: ea61686c2b12673eea19af37c53d893c2534fc4e
+  metadata.gz: 480a9c37b75244a79017defb5f87a09ec00bb4d2
+  data.tar.gz: c8ade086f96dccf7122da47898c418e923851579
 SHA512:
-  metadata.gz: 93a0f182e484b1ddc80ac388a64c2dbc62a01e01673655bacb7f09d1ee55d16bbc4daa864862d27c23794d34fd523a2d2c6a366b17db29a7fe3bfcf07b937e50
-  data.tar.gz: ebd9ee3c616386816517fccc54ab7c05d49461a40378a6ca1d33c2e6e94fd2f72de95a98d85d816078bb6a3eb5f595b4abea1252e7819ba82f813d107a97357e
+  metadata.gz: 4cecbcded18c99be80b8a9ba7e69cc11bc6d5eeee237b67f5013f4f8e3c43027ca5d8e18220aad045d22decba661a971d027a8dd65fcbab69a2bbb48cd5709d6
+  data.tar.gz: 40bb5fd2b473e6fdcd3635cdff15aba19d7c2007b373efbe64e770995276192a860329d8e7ebebc9de0f0bf283ee66cd7af12df2baaeddfecaa6718719ab894b

data/.gitignore

@@ -12,3 +12,4 @@
 *.o
 *.a
 mkmf.log
+.*.sw?

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.0

data/README.md

@@ -2,49 +2,76 @@
 
 Nil Conditional Operator in Ruby.
 
-## Summary
+This is my approach to create Nil Conditional Operator in Ruby. 
+
+This is very simple, and it is merely an experiment, so use it on your own risk.
+
+Nil Conditional Operator is inspired by Null Conditional Operator introduced in C# 6.0.
 
-This gem introduces Nil Conditional Operator (`_?`) in Ruby, similar to Null Conditional Operator in C# 6.0.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+`nil_conditional` is gemified and available on RubyGems.
 
-```ruby
-gem 'nil_conditional'
-```
 
-And then execute:
+## Usage
 
-    $ bundle
+Use preceding double underscore (`__`) for methods (for ex. `__method`)
+Use preceding double underscore and trailing block for local variables  (for ex. `__var{}`)
 
-Or install it yourself as:
+```ruby
 
-    $ gem install nil_conditional
+# logger is nil
+logger.foo.bar.car.cow
+NoMethodError: undefined method `foo` for #<NilClass>
 
-## Usage
+# logger is nil or doesn't exist
+__logger{}.foo.bar.car.cow
+=> #<NilConditional>
 
-```ruby
-empty_object = Object.new
-empty_object.non_existent_method_?
-=> nil
+# object exists and all methods are valid
+__object{}.foo.bar.car.cow
+=> "moooo"
 
-empty_object_?
-=> #<Object:0x00000002d89170> 
+# logger exists but doesn't have warn method
+logger.__warn('some warning')
+=> #<NilConditional>
 
-non_existent_object_?
-=> nil
+__non_existent_local_variable{}
+=> #<NilConditional>
 
-"test_string".sub_?("_string", '_case')
-=> "test_case"
+__non_existent_method
+=> #<NilConditional>
 
-:test_string.sub_?("string", "case")
-=> nil
+Object.new.non_existent_method
+NoMethodError: undefined method `non_existent_method` for #<Object>
 
-Object.foo_?.bar_?.car_?.cow_?
+Object.new.__non_existent_method
+=> #<NilConditional>
+
+Object.new.__non_existent_method.nil?
+=> true
+
+__new_object.foo.bar.car_?.cow_?
 => nil
 ```
 
+`NilConditional` instanced return always new NilConditional object if method is missing.
+These objects are also `eql` to `nil`.
+
+
+## Changelog
+
+* Changes from version with major 0
+
+  Previous version didn't support methods with special characters and there was no support for local variables
+  Previous version used trailing `_?` as NilConditional operator. Current version uses preceding double underscore character `__`.
+
+
+## Discussion
+
+Feel free to submit ideas via issues and discuss better solution to Nil Conditional Operator in Ruby
+
 ## License
 
 This is free software, licensed under MIT License. See LICENSE.txt file.

data/lib/nil_conditional.rb

@@ -1,17 +1,47 @@
-require "nil_conditional/version"
-
-module NilConditional
-
-  class ::Object
-    def method_missing(name, *params)
-      if name =~ /^.+_\?$/
-        original_method = name.to_s.sub(/_\?$/, '').to_sym
-        return send(original_method, *params) if respond_to?(original_method)
-        nil
-      else
-        super
+# NilConditional Operator in Ruby
+
+class Object
+  def method_missing(name, *params)
+    if name =~ /^__.+$/
+      original = name.to_s.sub(/^__/, '').to_sym
+
+      if block_given? && original =~ /^\w+$/
+        binding = Proc.new.binding
+        if binding.local_variable_defined?(original)
+          var = binding.local_variable_get(original)
+          return var unless var.nil?
+        end
+      end
+
+      if respond_to?(original)
+        return_value = block_given? ? send(original, *params, &Proc.new) : 
+          send(original, *params)
+        return return_value unless return_value.nil?
       end
+
+      NilConditional.new
+    else
+      super
     end
   end
+end
 
+class NilConditional
+  def method_missing(name, *params)
+    return self.class.new
+  end
+
+  def nil?
+    true
+  end
+
+  def ==(other)
+    return true if other == nil
+    super
+  end
+
+  def eql?(other)
+    return true if other.eql?(nil)
+    super
+  end
 end

data/nil_conditional.gemspec

@@ -1,11 +1,10 @@
 # coding: utf-8
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'nil_conditional/version'
 
 Gem::Specification.new do |spec|
   spec.name          = "nil_conditional"
-  spec.version       = NilConditional::VERSION
+  spec.version       = '1.0.0'
   spec.authors       = ["Grzegorz Bizon"]
   spec.email         = ["grzegorz.bizon@ntsn.pl"]
   spec.summary       = %q{Nil Conditional Operator in Ruby}
@@ -19,5 +18,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake",    "~> 10.0"
-  spec.add_development_dependency  "rspec",   "~> 3.2.0"
+  spec.add_development_dependency "rspec",   "~> 3.2.0"
 end

data/spec/local_variables_spec.rb

@@ -0,0 +1,20 @@
+describe 'local variables' do
+  context 'test variable' do
+    it 'should raise error when using non existent test variable' do
+      expect { test_variable }.to raise_error(NameError)
+    end
+
+    it 'should not raise error when using  __test_variable{}' do
+      expect { __test_variable{} }.to_not raise_error
+    end
+
+    it 'should return NilConditional instance when using non existent var with preceding __ and trailing block' do
+      expect(__test_variable{}).to be_a(NilConditional)
+    end
+
+    it 'should support chained methods with nil conditional' do
+      expect { __test_variable{}.foo_?.bar_?.car_?.cow_? }.to_not raise_error
+      expect(__test_variable{}.foo_?.bar_?.car_?.cow_?).to be_a(NilConditional)
+    end
+  end
+end

data/spec/nil_conditional_spec.rb

@@ -0,0 +1,15 @@
+describe NilConditional do
+  context 'nil value' do
+    it 'should be considered as nil' do
+      expect(NilConditional.new.nil?).to be(true)
+      expect(NilConditional.new).to eq(nil)
+      expect(NilConditional.new).to eql(nil)
+    end
+  end
+
+  context 'missing method behavior' do
+    it 'return new NilConditional object when method is missing' do
+      expect(NilConditional.new.non_existent_method).to be_a(NilConditional)
+    end
+  end
+end

data/spec/nil_spec.rb

@@ -0,0 +1,23 @@
+describe 'nil object' do
+  context 'local variable' do
+    it 'should return nil conditional if var is nil' do
+      var = nil
+      expect(__var{}).to be_a(NilConditional)
+    end
+  end
+
+  context 'test method' do
+    before do
+      allow(::Object).to receive(:nil_test) { nil }
+    end
+
+    it 'should return NilConditional instance when method return nil' do
+      expect(Object.nil_test).to be nil
+      expect(Object.new.__nil_test?).to be_a(NilConditional)
+    end
+
+    it 'should return NilConditional instance when method return nil and uses block' do
+      expect(Object.new.__nil_test?{}).to be_a(NilConditional)
+    end
+  end
+end

data/spec/object_spec.rb

@@ -1,25 +1,30 @@
 describe Object do
   context 'test method' do
-    it 'should not raise error when receiving test_method_?' do
+    it 'should raise error when receiving test_method' do
       expect { Object.new.test_method }.to raise_error(NoMethodError)
     end
 
-    it 'should not raise error when receiving test_method_?' do
-      expect { Object.new.test_method_? }.to_not raise_error
+    it 'should not raise error when receiving __test_method' do
+      expect { Object.new.__test_method }.to_not raise_error
     end
 
-    it 'should return nil when received non existent method with nil conditional' do
-      expect(Object.new.test_method_?).to be nil
+    it 'should return NilConditional instance when received non existent method with preceding __' do
+      expect(Object.new.__test_method).to be_a(NilConditional)
     end
 
     it 'should support chained methods with nil conditional' do
-      expect { Object.new.test_method_?.foo_?.bar_?.car_?.cow_? }.to_not raise_error
-      expect(Object.new.test_method_?.foo_?.bar_?.car_?.cow_?).to be nil
+      expect { Object.new.__test_method.foo_?.bar_?.car_?.cow_? }.to_not raise_error
+      expect(Object.new.__test_method.foo_?.bar_?.car_?.cow_?).to be_a(NilConditional)
     end
 
     it 'should support methods with arguments' do
-      expect { Object.test_method_with_args_?(1, 2, 3) }.to_not raise_error
-      expect(Object.test_method_with_args_?(1, 2, 3)).to be nil
+      expect { Object.__test_method_with_args(1, 2, 3) }.to_not raise_error
+      expect(Object.__test_method_with_args(1, 2, 3)).to be_a(NilConditional)
+    end
+
+    it 'should support methods with blocks' do
+      expect(Object.__test_method_with_block{ a = 'b' }).to be_a(NilConditional)
+      expect(['a', 'b'].__delete_if { |i| i == 'b' }).to eq([ 'a' ])
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nil_conditional
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Grzegorz Bizon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-15 00:00:00.000000000 Z
+date: 2015-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,13 +61,16 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/nil_conditional.rb
-- lib/nil_conditional/version.rb
 - nil_conditional.gemspec
+- spec/local_variables_spec.rb
+- spec/nil_conditional_spec.rb
+- spec/nil_spec.rb
 - spec/object_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/grzesiek/nil-conditional
@@ -90,11 +93,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Nil Conditional Operator in Ruby
 test_files:
+- spec/local_variables_spec.rb
+- spec/nil_conditional_spec.rb
+- spec/nil_spec.rb
 - spec/object_spec.rb
 - spec/spec_helper.rb
-has_rdoc: 

data/lib/nil_conditional/version.rb

@@ -1,3 +0,0 @@
-module NilConditional
-  VERSION = "0.0.1"
-end