significance 0.1.1 → 0.2.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+-
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG.rdoc

@@ -0,0 +1,15 @@
+== 0.1.0
+
+* Serious effort at making a legit gem.
+
+== 0.0.1
+
+* Testing setup
+
+== 0.1.3
+
+* Lowering dependency requirements
+
+== 0.1.4
+
+* Support for Set

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.11.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", "~> 1.8.4"
+  # gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,31 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    jeweler (1.8.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    json (1.7.5)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.11.0)
+      rspec-core (~> 2.11.0)
+      rspec-expectations (~> 2.11.0)
+      rspec-mocks (~> 2.11.0)
+    rspec-core (2.11.1)
+    rspec-expectations (2.11.3)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.11.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  jeweler (~> 1.8.4)
+  rdoc (~> 3.12)
+  rspec (~> 2.11.0)

data/{MIT-LICENSE → LICENSE.txt}

@@ -1,4 +1,4 @@
-Copyright 2011 caleon.
+Copyright (c) 2012 caleon
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -4,27 +4,32 @@ Similar in behavior to Object#presence defined in ActiveSupport, Significance is
 
 The utility of this gem can best be demonstrated when considering the merging of two hashes. Under normal circumstances the mere existence of an equivalent key in the second hash results in its overriding the corresponding value in the original hash. Using Hash#significant_merge, however, the second hash will retain only key-value pairs whose values are "significant," even applying the significance filter recursively into child hashes or arrays.
 
+== Usage:
 
-== Examples:
-
-	ruby-1.9.2-head :025 > [h1, h2, h3, h4, h5].each_with_index{|hsh, i| puts("# #{hsh}.significant") || puts("# => #{hsh.significant}");  nil}
-	  {:a=>1, :b=>2, :c=>3, :d=>4}.significant
-	  => {:a=>1, :b=>2, :c=>3, :d=>4}
-
-	  {:a=>1, :b=>nil, :c=>[], :d=>{}, :e=>" ", :f=>"798", :g=>""}.significant
-	  => {:a=>1, :f=>"798"}
+    gem 'significance', :git => "git://github.com/caleon/significance.git"
 
-	  {:a=>1, :b=>nil, :c=>[nil], :d=>{:thing=>nil}, :e=>" [] ", :f=>"        789"}.significant
-	  => {:a=>1, :e=>"[]", :f=>"789"}
 
-	  {:a=>1, :b=>nil, :c=>[nil, nil], :d=>{:thing=>nil, :thing2=>[]}, :e=>{:thing3=>{:thing4=>{}}}, :f=>[{}], :g=>[{}, {}]}.significant
-	  => {:a=>1}
+== Examples:
 
-	  {:a=>1, :b=>nil, :c=>[nil, {nil=>1, 27=>""}, " "], :d=>{:thing=>{:z=>{:y=>{:x=>{:w=>{:v=>{:u=>[:t, ":s", {:r=>:q}]}}}}}}}, :f=>[{}, [""]]}.significant
-	  => {:a=>1, :c=>[{nil=>1}], :d=>{:thing=>{:z=>{:y=>{:x=>{:w=>{:v=>{:u=>[:t, ":s", {:r=>:q}]}}}}}}}}
+    ruby-1.9.2-head :025 > [h1, h2, h3, h4, h5].each_with_index{|hsh, i| puts("# #{hsh}.significant") || puts("# => #{hsh.significant}");  nil}
+    {:a=>1, :b=>2, :c=>3, :d=>4}.significant
+    => {:a=>1, :b=>2, :c=>3, :d=>4}
+    
+    {:a=>1, :b=>nil, :c=>[], :d=>{}, :e=>" ", :f=>"798", :g=>""}.significant
+    => {:a=>1, :f=>"798"}
+    
+    {:a=>1, :b=>nil, :c=>[nil], :d=>{:thing=>nil}, :e=>" [] ", :f=>"        789"}.significant
+    => {:a=>1, :e=>"[]", :f=>"789"}
+    
+    {:a=>1, :b=>nil, :c=>[nil, nil], :d=>{:thing=>nil, :thing2=>[]}, :e=>{:thing3=>{:thing4=>{}}}, :f=>[{}], :g=>[{}, {}]}.significant
+    => {:a=>1}
+    
+    {:a=>1, :b=>nil, :c=>[nil, {nil=>1, 27=>""}, " "], :d=>{:thing=>{:z=>{:y=>{:x=>{:w=>{:v=>{:u=>[:t, ":s", {:r=>:q}]}}}}}}}, :f=>[{}, [""]]}.significant
+    => {:a=>1, :c=>[{nil=>1}], :d=>{:thing=>{:z=>{:y=>{:x=>{:w=>{:v=>{:u=>[:t, ":s", {:r=>:q}]}}}}}}}}
         
-	  [nil, 1, 3, '', [], [nil, [{}, 2]], ['']].significant
-	  => [1, 3, [[2]]]
+    [nil, 1, 3, '', [], [nil, [{}, 2]], ['']].significant
+    => [1, 3, [[2]]]
+
 
 === TODO: utilize the following:
 

data/Rakefile

@@ -1,37 +1,60 @@
-#!/usr/bin/env rake
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
 begin
-  require 'bundler/setup'
-rescue LoadError
-  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+  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
-begin
-  require 'rdoc/task'
-rescue LoadError
-  require 'rdoc/rdoc'
-  require 'rake/rdoctask'
-  RDoc::Task = Rake::RDocTask
+require 'rake'
+
+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 = "significance"
+  gem.homepage = "http://github.com/caleon/significance"
+  gem.license = "MIT"
+  gem.summary = %Q{Similar in behavior to Object#presence defined in ActiveSupport, Significance is a state which determines not just the blank-ness of an object but whether or not the non-blank object has any real-world value.}
+  gem.description = <<-DESC
+    Similar in behavior to Object#presence defined in ActiveSupport,
+    Significance is a state which determines not just the blank-ness of an
+    object but whether or not the non-blank object has any real-world value.
+    The utility of this gem can best be demonstrated when considering the
+    merging of two hashes. Under normal circumstances the mere existence of an
+    equivalent key in the second hash results in its overriding the
+    corresponding value in the original hash. Using Hash#significant_merge,
+    however, the second hash will retain only key-value pairs whose values are
+    "significant," even applying the significance filter recursively into child
+    hashes or arrays.
+  DESC
+  gem.email = "caleon@gmail.com"
+  gem.authors = ["caleon"]
+  # dependencies defined in Gemfile
 end
+Jeweler::RubygemsDotOrgTasks.new
 
-RDoc::Task.new(:rdoc) do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'Significance'
-  rdoc.options << '--line-numbers'
-  rdoc.rdoc_files.include('README.rdoc')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
 
+task :default => :spec
 
-Bundler::GemHelper.install_tasks
-
-require 'rake/testtask'
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = false
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Significance #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
 end
-
-
-task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.2.0

data/lib/significance/core_ext.rb

@@ -1,5 +1,7 @@
+require 'active_support/core_ext/object/blank'
 require 'significance/core_ext/object'
 require 'significance/core_ext/false_class'
 require 'significance/core_ext/string'
 require 'significance/core_ext/array'
+require 'significance/core_ext/set'
 require 'significance/core_ext/hash'

data/lib/significance/core_ext/hash.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/hash/reverse_merge'
+
 class Hash # also deep now.
   def significant
     Hash.new.tap { |hsh| each(&significance_each_block(hsh)) }
@@ -5,12 +7,12 @@ class Hash # also deep now.
 
   # also allows nil so we don't need Something.new(params.merge(params[:etc] || {}))
   def significant_merge(other_hash={})
-    return self unless (other_hash ||= {}).significant?
+    return self unless (other_hash ||= {}).significant.present?
     merge(other_hash.significant)
   end
   # destructive
   def significant_merge!(other_hash={})
-    return self unless (other_hash ||= {}).significant?
+    return self unless (other_hash ||= {}).significant.present?
     merge!(other_hash.significant)
   end
   # need to call significant on self now.

data/lib/significance/core_ext/object.rb

@@ -1,8 +1,8 @@
 class Object # `significant == self` is the way to end the recursion.
-  def blank?
-    respond_to?(:empty?) ? empty? : !self
-  end
-  
+  # def blank?
+  #   respond_to?(:empty?) ? empty? : !self
+  # end
+
   def significant?
     !blank? and significant == self
   end
@@ -10,7 +10,7 @@ class Object # `significant == self` is the way to end the recursion.
   def significant
     self
   end
-  
+
   def keep_significant
     respond_to?(:replace) ? replace(significant) : significant
   end

data/lib/significance/core_ext/set.rb

@@ -0,0 +1,5 @@
+class Set # now it's deep.
+  def significant
+    select(&:significant_significance?).map(&:significant)
+  end
+end

data/lib/significance/core_ext/string.rb

@@ -5,8 +5,8 @@ class String
   def significant
     strip
   end
-  
-  def strictly_significant_string
+
+  def strictly_significant
     gsub(/\s+/, '')
   end
 end

data/spec/significance_spec.rb

@@ -0,0 +1,220 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Significance' do
+
+  describe Object do
+
+    describe 'Basic check for methods being available' do
+
+      it { should respond_to :significant? }
+      it { should respond_to :significant }
+      it { should respond_to :keep_significant }
+      it { should respond_to :significant! }
+      it { should respond_to :significance }
+      it { should respond_to :significant_significance }
+      it { should respond_to :significant_significance? }
+    end
+
+    describe '#significant?' do
+      it { should be_significant }
+    end
+
+    describe '#significant' do
+      it 'returns self' do
+        subject.significant.should be subject
+      end
+    end
+
+    describe '#keep_significant' do
+      it 'returns self' do
+        subject.should_not respond_to :replace
+        subject.keep_significant.should be subject
+      end
+    end
+
+    describe '#significant!' do
+      it 'is an alias for #keep_significant' do
+        subject.should_receive(:keep_significant)
+        subject.significant!
+      end
+    end
+
+    describe '#significant_significance' do
+      before(:each) do
+        significant = mock('significant')
+        subject.should_receive(:significant).and_return(significant)
+        significant.should_receive(:significance)
+      end
+
+      it 'chain-calls #significant and #significance' do
+        subject.significant_significance
+      end
+
+      it 'is aliased to #sigsig' do
+        subject.sigsig
+      end
+    end
+
+    describe '#significant_significance?' do
+      before(:each) do
+        sigsig = mock('sigsig')
+        subject.should_receive(:significant_significance).and_return(sigsig)
+        sigsig.should_receive(:significant?)
+      end
+
+      it 'chain-calls #significant_significance and #significant?' do
+        subject.significant_significance?
+      end
+
+      it 'is aliased as #sigsig?' do
+        subject.sigsig?
+      end
+    end
+  end
+
+  describe false do
+    it { should be_significant }
+  end
+
+  describe String do
+
+    describe '#significant' do
+      it 'strips whitespaces on either end' do
+        subject.should_receive(:strip)
+        subject.significant
+      end
+    end
+
+    describe '#strictly_significant' do
+      it 'removes all whitespaces within' do
+        subject.should_receive(:gsub).with(/\s+/, '')
+        subject.strictly_significant
+      end
+    end
+  end
+
+  describe Array do
+    let(:element) { mock('el', :significant_significance? => true) }
+    subject { [element, element] }
+    describe '#significant' do
+
+      it 'calls #significant_significance? on each element' do
+        element.should_receive(:significant_significance?).twice
+        subject.significant
+      end
+
+      it 'calls #significant on the filtered elements' do
+        element.should_receive(:significant).twice.and_return(element)
+        subject.significant.should =~ [element, element]
+      end
+    end
+  end
+
+  describe Set do
+
+  end
+
+  describe Hash do
+
+    describe '#significant' do
+
+      it 'returns a new Hash' do
+        subject.significant.should_not be subject
+      end
+
+      it 'calls #significance_each_block on each' do
+        # hsh.stub(:significance_each_block).and_return(Proc.new { |x| x.to_s })
+        subject.should_receive(:each)#.with(kind_of(Proc))
+        subject.significant
+      end
+    end
+
+    let(:other_hash) { mock('other_hash') }
+
+    describe '#significant_merge' do
+
+      context 'when other hash is empty' do
+        before { other_hash.stub(:significant => {}) }
+
+        it 'returns self' do
+          subject.significant_merge(other_hash).should be subject
+        end
+      end
+
+      context 'when other hash is significant' do
+        before { other_hash.stub(:significant => other_hash,
+                                 :present? => true) }
+
+        it 'calls merge with #significant on other hash' do
+          other_hash.should_receive(:significant).twice
+          subject.should_receive(:merge).with(other_hash)
+          subject.significant_merge(other_hash)
+        end
+      end
+    end
+
+    describe '#significant_merge!' do
+
+      context 'when other hash is empty' do
+        before { other_hash.stub(:significant => {}) }
+
+        it 'returns self' do
+          subject.significant_merge!(other_hash).should be subject
+        end
+      end
+
+      context 'when other hash is significant' do
+        before { other_hash.stub(:significant => other_hash,
+                                 :present? => true) }
+
+        it 'calls merge! with #significant on other hash' do
+          other_hash.should_receive(:significant).twice
+          subject.should_receive(:merge!).with(other_hash)
+          subject.significant_merge!(other_hash)
+        end
+      end
+    end
+
+    describe '#reverse_significant_merge' do
+
+      context 'when other hash is empty' do
+        it 'returns self' do
+          other_hash.stub(:merge => :merged_hash)
+          subject.reverse_significant_merge(other_hash).should be :merged_hash
+        end
+      end
+
+      context 'when other hash is significant' do
+        before { other_hash.stub(:significant => other_hash,
+                                 :present? => true) }
+
+        it 'calls merge with #significant on other hash' do
+          subject.should_receive(:significant).and_return(subject)
+          subject.should_receive(:reverse_merge).with(other_hash)
+          subject.reverse_significant_merge(other_hash)
+        end
+      end
+    end
+
+    describe '#reverse_significant_merge!' do
+
+      context 'when other hash is empty' do
+        it 'returns self' do
+          subject.stub(:merge! => :merged_hash)
+          subject.reverse_significant_merge!(other_hash).should be :merged_hash
+        end
+      end
+
+      context 'when other hash is significant' do
+        before { other_hash.stub(:significant => other_hash,
+                                 :present? => true) }
+
+        it 'calls merge with #significant on other hash' do
+          subject.should_receive(:significant).and_return(subject)
+          subject.should_receive(:reverse_merge!).with(other_hash)
+          subject.reverse_significant_merge!(other_hash)
+        end
+      end
+    end
+  end
+end