reactive_support 0.1.2

data/lib/reactive_support/core_ext/object/exist.rb

@@ -0,0 +1,14 @@
+class Object
+
+  # The +#exists?+ method and its alias, +#exist?+, return +true+ if the object
+  # calling the method is not +nil+.
+  #
+  #     'foobar'.exists?      # => true 
+  #     nil.exists?           # => false
+
+  def exists?
+    !self.nil?
+  end
+
+  alias_method :exist?, :exists?
+end

data/lib/reactive_support/core_ext/object/inclusion.rb

@@ -0,0 +1,39 @@
+class Object
+
+  # The +#in?+ method returns +true+ if the calling object is included in the
+  # +object+ passed as a parameter. The +object+ parameter must be a String,
+  # Enumerable, or other object that responds to +#include?+. If it doesn't, 
+  # the #in? method will raise an ArgumentError.
+  #
+  # When passed an Array object, +#in?+ returns +true+ if the calling object
+  # is included as a member of the array:
+  # 
+  #     'foo'.in? ['foo', 'bar']    # => true
+  #     'foo'.in? ['bar', 'baz']    # => false
+  #
+  # When passed a Hash object, +#in?+ returns true if the calling object is
+  # included as a key in the hash. To look for an object in a hash's values,
+  # use the hash's +#values+ method.
+  #
+  #     'foo'.in? {'foo' => 'bar'}          # => true 
+  #     'foo'.in? {'bar' => 'foo'}          # => false
+  #     'foo'.in? {'bar' => 'foo'}.values   # => true 
+  # 
+  # When passed a String object, +#in?+ returns +true+ if the the calling object
+  # (which must also be a string) appears verbatim within the parameter object.
+  # If the passed-in object is a string but the calling object is something else,
+  # a TypeError will be returned.
+  #
+  #     'foo'.in? 'foobar'    # => true
+  #     'foo'.in? 'foto'      # => false
+  #     ['foo'].in? 'foobar'  # => TypeError
+  #
+  # When passed an object that does not respond to +#include?+, +#in?+ raises
+  # an ArgumentError.
+
+  def in?(object)
+    object.include?(self)
+  rescue NoMethodError
+    raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
+  end
+end

data/lib/reactive_support/core_ext/object/instance_variables.rb

@@ -0,0 +1,37 @@
+class Object 
+    # The +#instance_values+ method returns a hash mapping all the calling object's
+  # instance variable names to the variables' values. The hash keys are the 
+  # variables' names, as strings, without the '@' prepended to them. Each of the
+  # hash's values is the value corresponding to the given variable name.
+  #
+  #     class Widget
+  #       def initialize(x,y)
+  #         @x, @y = x, y
+  #       end
+  #     end
+  #     
+  #     widget = Widget.new('foo', 'bar')
+  #     widget.instance_values              # => {'x' => 'foo', 'y' => 'bar'}
+
+  def instance_values
+    Hash[instance_variables.map {|name| [name[1..-1], instance_variable_get(name) ] }]
+  end
+
+  # The +#instance_variable_names+ method returns an array of the names of 
+  # the instance variables defined on the calling object. The names themselves
+  # are returned as strings and, unlike in the +#instance_values+ method, 
+  # include the +'@'+ prefix.
+  #
+  #     class Widget
+  #       def initialize(x,y)
+  #         @x, @y = x, y
+  #       end
+  #     end
+  #
+  #     widget = Widget.new(1, 2)
+  #     widget.instance_variable_names    # => ['@x', '@y']
+
+  def instance_variable_names
+    instance_variables.map {|name| name.to_s }
+  end
+end

data/lib/reactive_support/core_ext/object/try.rb

@@ -0,0 +1,46 @@
+class Object
+  # The +#try+ method calls the given +method+ (with given +*args+ and +&block+)
+  # on the object calling it. The +#try+ method returns the output of the 
+  # method or, if an error is raised, +nil+. It accepts an arbitrary number 
+  # of arguments and an optional block, enabling it to be used with any method.
+  #
+  # The first argument is the name of the method to be called, given as a symbol.
+  # The rest are the arguments (if any) that should be passed into that
+  # method. Likewise, the +&block+ parameter will be passed on to the method
+  # being called.
+  #
+  # Examples of a method being called without args:
+  #     'foo'.try(:upcase)    # => 'FOO'
+  #     nil.try(:upcase)      # => nil
+  #
+  # Examples of a method being called with args:
+  #     %w(foo bar baz).try(:join, '.') # => 'foo.bar.baz'
+  #     nil.try(:join, '.')             # => nil
+  #
+  # Examples of a method being called with a block:
+  #     { foo: 10, bar: 18, baz: 32 }.try(:reject!) {|k,v| v < 25 } # => { baz: 32 }
+  #     nil.try(:reject) {|k,v| v == 'foo' }                        # => nil
+  #
+  # When called on +nil+, +#try+ returns +nil+ even if the method being sent
+  # is defined for NilClass:
+  #     nil.try(:inspect)     # => nil
+  #
+  # The +#try+ method can also be called with a block and no arguments. In this case,
+  # the block will be instance_eval'ed:
+  #     'foobar'.try { upcase.truncate(3) }     # => 'FOO'
+  #     nil.try { upcase.truncate(3) }          # => nil
+
+  def try(*args, &block)
+    return self if self.nil?
+
+    if args.empty? && block_given?
+      if block.arity.zero?
+        instance_eval(&block)
+      else
+        yield self
+      end
+    else
+      public_send(*args, &block) if args.respond_to?(:first)
+    end
+  end
+end

data/lib/reactive_support/extensions/reactive_extensions.rb

@@ -0,0 +1,41 @@
+require 'reactive_support'
+
+# The ReactiveExtensions module consists of methods I wish ActiveSupport provided.
+# These methods do not adhere to the ActiveSupport API. If you wish to include
+# them in your project, you will need to put this in your main project file:
+#     require 'reactive_support/extensions'
+#
+# ReactiveExtensions requires ReactiveSupport, so there is no need to require both
+# explicitly.
+
+module ReactiveExtensions
+
+  # The +#try_rescue+ method extends ReactiveSupport's +#try+ method so it
+  # rescues NoMethodErrors and TypeErrors as well as returning +nil+ when
+  # called on a +nil+ value.
+  #
+  # Like the +#try+ method, +#try_rescue+ takes 1 or more arguments. The first
+  # argument is the method to be called on the calling object, passed as a 
+  # symbol. The others are zero or more arguments that will be passed through to 
+  # that method, and +&block+ is an optional block that will be similarly passed through.
+  #
+  # Example of usage identical to +#try+:
+  #     nil.try(:map) {|a| a.to_s }           # => nil
+  #     nil.try_rescue(:map) {|a| a.to_s }    # => nil
+  #     
+  # Example of usage calling a method that is not defined on the calling object:
+  #     10.try(:to_h)           # => TypeError
+  #     10.try_rescue(:to_h)    # => nil
+  #
+  # Example of usage with invalid arguments:
+  #     %w(foo, bar, baz).try(:join, [:hello, :world])        # => TypeError
+  #     %w(foo, bar, baz).try_rescue(:join, [:hello, :world]) # => nil
+
+  def try_rescue(*args, &block)
+    self.try(*args, &block) rescue nil
+  end
+end
+
+class Object
+  include ReactiveExtensions
+end

data/lib/reactive_support.rb

@@ -0,0 +1,15 @@
+Dir['./lib/reactive_support/core_ext/object/**/*.rb'].each {|f| require f }
+
+# The ReactiveSupport module implements methods from ActiveSupport. It can be
+# included in Ruby's +Object+ class by adding +require 'reactive_support'+ to
+# your project file. Then, ReactiveSupport methods can be called on any Ruby
+# object just like the object's own methods.
+# 
+# In this example, ReactiveSupport's #try method is called on an array:
+#     require 'reactive_support'
+#     
+#     arr = %w(foo, bar, baz)
+#     arr.try(:join, '.') 
+
+module ReactiveSupport
+end

data/reactive_support.gemspec

@@ -0,0 +1,39 @@
+require File.expand_path('../version.rb', __FILE__)
+require File.expand_path('../files.rb', __FILE__)
+
+Gem::Specification.new do |s|
+  s.specification_version     = 1 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.required_ruby_version     = '>= 1.9.3'
+
+  s.name                      = 'reactive_support'
+  s.version                   = ReactiveSupport.gem_version
+  s.date                      = '2014-09-24'
+
+  s.description = "ActiveSupport methods re-implemented independently of the Rails ecosystem"
+  s.summary     = "ReactiveSupport provides useful ActiveSupport methods in a gem that is simple, stable, agnostic, and transparent."
+
+  s.authors                   = ["Dana Scheider"]
+  s.email                     = "dana.scheider@gmail.com"
+
+  # = MANIFEST =
+  s.files                     = ReactiveSupport.files
+  s.require_path              = 'lib'
+  # = MANIFEST =
+
+  s.test_files                = s.files.select {|path| path =~ /^spec\/.*.rb/ }
+  s.licenses                  = 'MIT'
+
+  s.extra_rdoc_files          = %w[CONTRIBUTING.md README.md LICENSE]
+
+  s.add_development_dependency 'rspec', '~> 3.1'
+  s.add_development_dependency 'bundler', '~> 1.6'
+  s.add_development_dependency 'coveralls', '~> 0.7'
+  s.add_development_dependency 'simplecov', '~> 0.9'
+
+  s.has_rdoc         = true
+  s.homepage         = "http://github.com/danascheider/reactive_support"
+  s.rdoc_options     = ["--line-numbers", "--inline-source", "--title", "ReactiveSupport"]
+  s.require_paths    = %w[lib]
+  s.rubygems_version = '1.1.1'
+end

data/spec/array_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper' 
+
+describe Array do 
+  describe '#from method' do 
+    context 'normal use' do 
+      context 'positive position' do 
+        it 'returns the end of the array' do 
+          expect([1, 2, 3, 4, 5].from(2)).to eql [3, 4, 5]
+        end
+      end
+
+      context 'negative position' do 
+        it 'returns the end of the array' do 
+          expect([1, 2, 3, 4, 5].from(-2)).to eql [4, 5]
+        end
+      end
+    end
+
+    context 'when array is empty' do 
+      it 'returns an empty array' do 
+        expect([].from(0)).to eql []
+      end
+    end
+
+    context 'position higher than max index' do 
+      it 'returns an empty array' do 
+        expect([1, 2, 3, 4, 5].from(100)).to eql []
+      end
+    end
+
+    context 'position lower than min index' do 
+      it 'returns an empty array' do 
+        expect([1, 2, 3].from(-4)).to eql []
+      end
+    end
+  end
+
+  describe '#to method' do 
+    context 'normal use' do 
+      context 'positive position' do 
+        it 'returns the beginning of the array' do 
+          expect([1, 2, 3, 4, 5].to(2)). to eql [1, 2, 3]
+        end
+      end
+
+      context 'negative position' do 
+        it 'returns the beginning of the array' do 
+          expect([1, 2, 3, 4, 5].to(-2)).to eql [1, 2, 3, 4]
+        end
+      end
+    end
+
+    context 'when array is empty' do 
+      it 'returns an empty array' do 
+        expect([].to(0)).to eql []
+      end
+    end
+
+    context 'position higher than max index' do 
+      it 'returns the whole array' do 
+        expect([1, 2, 3].to(10)).to eql [1, 2, 3]
+      end
+    end
+
+    context 'position lower than min index' do 
+      it 'returns an empty array' do 
+        expect([1, 2, 3].to(-5)).to eql []
+      end
+    end
+  end
+end

data/spec/reactive_extensions_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe ReactiveExtensions do 
+
+  describe '#try_rescue method' do 
+    context 'when self is nil' do 
+      it 'returns nil' do 
+        expect(nil.try_rescue(:collect) {|i| i + 2 }).to eql nil
+      end
+    end
+
+    context 'when the method can be executed successfully' do 
+      it 'calls the method' do 
+        expect('foo'.try_rescue(:upcase)).to eql 'FOO'
+      end
+    end
+
+    context 'when a NoMethodError is raised' do 
+      it 'returns nil' do 
+        expect(('foo').try_rescue(:bar)).to eql nil
+      end
+    end
+  end
+end

data/spec/reactive_support_spec.rb

@@ -0,0 +1,314 @@
+require 'spec_helper'
+
+describe ReactiveSupport do 
+  describe '#blank? method' do 
+    context 'when true' do 
+      hash = {
+        'empty string'      => '',
+        'whitespace string' => '   ',
+        'FalseClass'        => false,
+        'NilClass'          => nil,
+        'empty array'       => [],
+        'empty hash'        => {} 
+      }
+
+      hash.each do |k,v|
+        specify "#{k} returns true" do 
+          expect(v.blank?).to be true 
+        end
+      end
+    end
+
+    context 'when false' do 
+      hash = {
+        'non-blank object'              => 'foo',
+        'TrueClass'                     => true,
+        'enumerable with blank members' => [nil, false],
+        'numeric'                       => 10
+      }
+
+      hash.each do |k,v|
+        specify "#{k} returns false" do 
+          expect(v.blank?).to be false
+        end
+      end
+    end
+  end
+
+  describe '#deep_dup method' do 
+    context 'duplicable object' do 
+      before(:each) do 
+        @str = 'foo'
+      end
+
+      it 'returns a duplicate' do 
+        expect(@str.deep_dup).not_to be @str
+      end
+
+      it 'does not affect the original' do 
+        @str.deep_dup.instance_variable_set(:@a, 1)
+        expect(@string.instance_variable_get(:@a)).to eql nil
+      end
+    end
+
+    context 'non-duplicable object' do 
+      it 'returns itself' do 
+        num = 10
+        expect(num.deep_dup).to be num
+      end
+    end
+
+    context 'array' do 
+      it 'does not affect the original' do 
+        arr = [ [1, 2], 3 ]
+        arr.deep_dup[0][1] = 4
+        expect(arr[0][1]).to eql 2
+      end
+    end
+
+    context 'hash' do 
+      it 'does not affect the original' do 
+        h = { foo: { bar: 1 } }
+        h.deep_dup[:foo][:bar] = 10
+        expect(h[:foo][:bar]).to eql 1
+      end
+    end
+  end
+
+  describe '#duplicable? method' do 
+    context 'when true' do 
+      it 'returns true' do 
+        expect(['foo', 'bar', 'baz'].duplicable?).to be true
+      end
+    end
+
+    context 'when false' do 
+      hash = {
+        'NilClass'   => nil,
+        'FalseClass' => false,
+        'TrueClass'  => true,
+        'symbol'     => :symbol,
+        'numeric'    => 10,
+        'method'     => method(:puts)
+      }
+
+      hash.each do |k,v|
+        specify "#{k} returns false" do 
+          expect(v.duplicable?).to be false
+        end
+      end
+    end
+
+    context 'BigDecimal' do 
+      let(:dec) { BigDecimal.new('4.56') }
+
+      before(:each) do 
+        @condition = !!(RUBY_VERSION =~ /^1\.9/ || RUBY_VERSION =~ /jruby/)
+      end
+      context 'Ruby version >= 2.0.0' do 
+        it 'returns true' do 
+          expect(dec.duplicable?).to be true unless @condition 
+        end
+      end
+
+      context 'Ruby version 1.9.x' do 
+        it 'returns false' do 
+          expect(dec.duplicable?).to be false if @condition
+        end
+
+        it 'doesn\'t raise an error' do 
+          expect{ dec.duplicable? }.not_to raise_error if @condition
+        end
+      end
+    end
+  end
+
+  describe '#exist? method' do 
+    context 'existent object' do 
+      it 'returns true' do 
+        expect({foo: :bar}.exist?).to be true 
+      end
+    end
+
+    context 'nil' do 
+      it 'returns false' do 
+        expect(nil.exist?).to be false
+      end
+    end
+  end
+
+  describe '#exists? method' do 
+    context 'existent object' do 
+      it 'returns true' do 
+        expect({foo: :bar}.exists?).to be true
+      end
+    end
+
+    context 'nil' do 
+      it 'returns false' do 
+        expect(nil.exists?).to be false
+      end
+    end
+  end
+
+  describe '#in? method' do 
+    context 'when true' do 
+      hash = { 
+        'array contains calling object'        => ['foo', 'bar', 'baz'],
+        'hash contains the given key'          => { 'foo' => 'bar' },
+        'string contains the given characters' => 'foolish'
+      }
+
+      hash.each do |k,v|
+        specify k do 
+          expect('foo'.in? v).to be true 
+        end
+      end
+    end
+
+    context 'when false' do 
+      hash = {
+        'array doesn\'t contain calling object'    => ['bar', 'baz'],
+        'hash doesn\'t contain given key'          => { bar: :baz },
+        'string doesn\'t contain given characters' => 'something else'
+      }
+
+      hash.each do |k,v|
+        specify k do 
+          expect('foo'.in? v).to be false 
+        end
+      end
+    end
+
+    context 'error' do 
+      hash = {
+        'incompatible data types' => [{foo: 'bar'}, 'foobar', TypeError],
+        'invalid parameter'       => [10, 1000, ArgumentError]
+      }
+
+      hash.each do |k,v|
+        specify k do 
+          expect{ v[0].in? v[1] }.to raise_error(v[2])
+        end
+      end
+    end
+  end
+
+  describe '#instance_values method' do 
+    before(:each) do 
+      class C
+        def initialize(x,y)
+          @x, @y = x, y
+        end
+      end
+
+      @c = C.new('foo', 'bar')
+    end
+
+    it 'returns a hash' do 
+      expect(@c.instance_values).to be_a(Hash)
+    end
+
+    it 'uses instance variable names without @ as keys' do 
+      ['x', 'y'].each {|var| expect(@c.instance_values).to have_key(var) }
+    end
+
+    it 'returns variable values' do 
+      [['x', 'foo'], ['y','bar']].each {|(var, val)| expect(@c.instance_values[var]). to eql val }
+    end
+  end
+
+  describe '#instance_variable_names method' do 
+    before(:all) do 
+      class C
+        def initialize(x, y)
+          @x, @y = x, y
+        end
+      end
+
+      @c = C.new(1, 2)
+    end
+
+    it 'returns an array' do 
+      expect(@c.instance_variable_names).to be_an Array
+    end
+
+    it 'includes the name of the instance variables' do 
+      ['@x', '@y'].each {|var| expect(@c.instance_variable_names).to include(var) }
+    end
+  end
+
+  describe '#present? method' do 
+    context 'when true' do 
+      hash = {
+        'non-empty object'              => ['foo'],
+        'TrueClass'                     => true, 
+        'enumerable with blank members' => [nil, false],
+        'numeric'                       => 8.2
+      }
+
+      hash.each do |k,v|
+        specify k do 
+          expect(v.present?).to be true 
+        end
+      end
+    end
+
+    context 'when false' do 
+      hash = {
+        'empty string'      => '',
+        'whitespace string' => '   ',
+        'FalseClass'        => false,
+        'NilClass'          => nil,
+        'empty array'       => [],
+        'empty hash'        => {}
+      }
+
+      hash.each do |k,v|
+        specify k do 
+          expect(v.present?).to be false 
+        end
+      end
+    end
+  end
+
+  describe '#try method' do 
+    context 'NilClass' do 
+      it 'returns nil' do 
+        expect(nil.try(:inspect)).to be nil 
+      end
+    end
+
+    context 'when the calling object is not nil' do 
+      context 'no args, no block' do 
+        it 'evaluates the method' do 
+          expect('foo'.try(:to_i)).to eql 0
+        end
+      end
+
+      context 'no method, no args, block given' do 
+        it 'tries to evaluate the block' do 
+          expect(-17.25.try { abs.truncate }).to eql 17
+        end
+      end
+
+      context 'with args' do 
+        it 'evaluates the method' do 
+          expect(%w(foo bar baz).try(:join, '.')).to eql 'foo.bar.baz'
+        end
+      end
+
+      context 'with block' do 
+        it 'evaluates the method' do 
+          expect([1, 2, 3].try(:collect) {|i| i + 1 }).to eql [2, 3, 4]
+        end
+      end
+    end
+
+    context 'when the method is invalid' do 
+      it 'raises an error' do 
+        expect{ 'foo'.try(:collect) {|i| i * 3 } }.to raise_error(NoMethodError)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'simplecov'
+require 'coveralls'
+require 'rspec'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start if ENV["COVERAGE"]
+Coveralls.wear!
+
+require_relative '../lib/reactive_support'
+require_relative '../lib/reactive_support/core_ext/array/access'
+require_relative '../lib/reactive_support/extensions/reactive_extensions'
+
+RSpec.configure do |c|
+  c.order  = 'random'
+end

data/version.rb

@@ -0,0 +1,14 @@
+module ReactiveSupport
+  def self.gem_version
+    Gem::Version.new Version::STRING
+  end
+
+  module Version
+    MAJOR = '0'
+    MINOR = '1'
+    PATCH = '2'
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.').chomp('.')
+  end
+end