do_riak 0.10.1.pre

data/gems/gems/bacon-1.1.0/test/spec_bacon.rb

@@ -0,0 +1,374 @@
+$-w,w = nil, $-w
+require File.join(File.dirname(__FILE__), '../lib/bacon')
+$-w = w
+
+# Hooray for meta-testing.
+module MetaTests
+  def succeed
+    lambda { |block|
+      block.should.not.raise Bacon::Error
+      true
+    }
+  end
+
+  def fail
+    lambda { |block|
+      block.should.raise Bacon::Error
+      true
+    }
+  end
+
+  def equal_string(x)
+    lambda { |s|
+      x == s.to_s
+    }
+  end
+end
+
+describe "Bacon" do
+  extend MetaTests
+  
+  it "should have should.satisfy" do
+    lambda { should.satisfy { 1 == 1 } }.should succeed
+    lambda { should.satisfy { 1 } }.should succeed
+
+    lambda { should.satisfy { 1 != 1 } }.should fail
+    lambda { should.satisfy { false } }.should fail
+    lambda { should.satisfy { false } }.should fail
+
+    lambda { 1.should.satisfy { |n| n % 2 == 0 } }.should fail
+    lambda { 2.should.satisfy { |n| n % 2 == 0 } }.should succeed
+  end
+
+  it "should have should.equal" do
+    lambda { "string1".should == "string1" }.should succeed
+    lambda { "string1".should == "string2" }.should fail
+    lambda { "1".should == 1 }.should fail
+
+    lambda { "string1".should.equal "string1" }.should succeed
+    lambda { "string1".should.equal "string2" }.should fail
+    lambda { "1".should.equal 1 }.should fail
+  end
+
+  it "should have should.raise" do
+    lambda { lambda { raise "Error" }.should.raise }.should succeed
+    lambda { lambda { raise "Error" }.should.raise RuntimeError }.should succeed
+    lambda { lambda { raise "Error" }.should.not.raise }.should fail
+    lambda { lambda { raise "Error" }.should.not.raise(RuntimeError) }.should fail
+
+    lambda { lambda { 1 + 1 }.should.raise }.should fail
+    lambda {
+      lambda { raise "Error" }.should.raise(Interrupt)
+    }.should.raise
+  end
+
+  it "should have should.raise with a block" do
+    lambda { should.raise { raise "Error" } }.should succeed
+    lambda { should.raise(RuntimeError) { raise "Error" } }.should succeed
+    lambda { should.not.raise { raise "Error" } }.should fail
+    lambda { should.not.raise(RuntimeError) { raise "Error" } }.should fail
+
+    lambda { should.raise { 1 + 1 } }.should fail
+    lambda {
+      should.raise(Interrupt) { raise "Error" }
+    }.should.raise
+  end
+
+  it "should have a should.raise should return the exception" do
+    ex = lambda { raise "foo!" }.should.raise
+    ex.should.be.kind_of RuntimeError
+    ex.message.should =~ /foo/
+  end
+  
+  it "should have should.be.an.instance_of" do
+    lambda { "string".should.be.instance_of String }.should succeed
+    lambda { "string".should.be.instance_of Hash }.should fail
+
+    lambda { "string".should.be.an.instance_of String }.should succeed
+    lambda { "string".should.be.an.instance_of Hash }.should fail
+  end
+
+  it "should have should.be.nil" do
+    lambda { nil.should.be.nil }.should succeed
+    lambda { nil.should.not.be.nil }.should fail
+    lambda { "foo".should.be.nil }.should fail
+    lambda { "foo".should.not.be.nil }.should succeed
+  end
+
+  it "should have should.include" do
+    lambda { [1,2,3].should.include 2 }.should succeed
+    lambda { [1,2,3].should.include 4 }.should fail
+
+    lambda { {1=>2, 3=>4}.should.include 1 }.should succeed
+    lambda { {1=>2, 3=>4}.should.include 2 }.should fail
+  end
+
+  it "should have should.be.a.kind_of" do
+    lambda { Array.should.be.kind_of Module }.should succeed
+    lambda { "string".should.be.kind_of Object }.should succeed
+    lambda { 1.should.be.kind_of Comparable }.should succeed
+
+    lambda { Array.should.be.a.kind_of Module }.should succeed
+
+    lambda { "string".should.be.a.kind_of Class }.should fail
+  end
+
+  it "should have should.match" do
+    lambda { "string".should.match(/strin./) }.should succeed
+    lambda { "string".should =~ /strin./ }.should succeed
+
+    lambda { "string".should.match(/slin./) }.should fail
+    lambda { "string".should =~ /slin./ }.should fail
+  end
+
+  it "should have should.not.raise" do
+    lambda { lambda { 1 + 1 }.should.not.raise }.should succeed
+    lambda { lambda { 1 + 1 }.should.not.raise(Interrupt) }.should succeed
+
+    lambda {
+      lambda {
+        lambda {
+          Kernel.raise ZeroDivisionError.new("ArgumentError")
+        }.should.not.raise(RuntimeError, Comparable)
+      }.should.raise ZeroDivisionError
+    }.should succeed
+      
+    lambda { lambda { raise "Error" }.should.not.raise }.should fail
+  end
+
+  it "should have should.throw" do
+    lambda { lambda { throw :foo }.should.throw(:foo) }.should succeed
+    lambda { lambda {       :foo }.should.throw(:foo) }.should fail
+
+    should.throw(:foo) { throw :foo }
+  end
+
+  it "should have should.not.satisfy" do
+    lambda { should.not.satisfy { 1 == 2 } }.should succeed
+    lambda { should.not.satisfy { 1 == 1 } }.should fail
+  end
+
+  it "should have should.not.equal" do
+    lambda { "string1".should.not == "string2" }.should succeed
+    lambda { "string1".should.not == "string1" }.should fail
+  end
+
+  it "should have should.not.match" do
+    lambda { "string".should.not.match(/sling/) }.should succeed
+    lambda { "string".should.not.match(/string/) }.should fail
+#    lambda { "string".should.not.match("strin") }.should fail
+
+    lambda { "string".should.not =~ /sling/ }.should succeed
+    lambda { "string".should.not =~ /string/ }.should fail
+#    lambda { "string".should.not =~ "strin" }.should fail
+  end
+
+  it "should have should.be.identical_to/same_as" do
+    lambda { s = "string"; s.should.be.identical_to s }.should succeed
+    lambda { "string".should.be.identical_to "string" }.should fail
+
+    lambda { s = "string"; s.should.be.same_as s }.should succeed
+    lambda { "string".should.be.same_as "string" }.should fail
+  end
+
+  it "should have should.respond_to" do
+    lambda { "foo".should.respond_to :to_s }.should succeed
+    lambda { 5.should.respond_to :to_str }.should fail
+    lambda { :foo.should.respond_to :nx }.should fail
+  end
+  
+  it "should have should.be.close" do
+    lambda { 1.4.should.be.close 1.4, 0 }.should succeed
+    lambda { 0.4.should.be.close 0.5, 0.1 }.should succeed
+
+    lambda { 0.4.should.be.close 0.5, 0.05 }.should fail
+    lambda { 0.4.should.be.close Object.new, 0.1 }.should fail
+    lambda { 0.4.should.be.close 0.5, -0.1 }.should fail
+  end
+
+  it "should support multiple negation" do
+    lambda { 1.should.equal 1 }.should succeed
+    lambda { 1.should.not.equal 1 }.should fail
+    lambda { 1.should.not.not.equal 1 }.should succeed
+    lambda { 1.should.not.not.not.equal 1 }.should fail
+
+    lambda { 1.should.equal 2 }.should fail
+    lambda { 1.should.not.equal 2 }.should succeed
+    lambda { 1.should.not.not.equal 2 }.should fail
+    lambda { 1.should.not.not.not.equal 2 }.should succeed
+  end
+
+  it "should have should.<predicate>" do
+    lambda { [].should.be.empty }.should succeed
+    lambda { [1,2,3].should.not.be.empty }.should succeed
+
+    lambda { [].should.not.be.empty }.should fail
+    lambda { [1,2,3].should.be.empty }.should fail
+
+    lambda { {1=>2, 3=>4}.should.has_key 1 }.should succeed
+    lambda { {1=>2, 3=>4}.should.not.has_key 2 }.should succeed
+
+    lambda { nil.should.bla }.should.raise(NoMethodError)
+    lambda { nil.should.not.bla }.should.raise(NoMethodError)
+  end
+
+  it "should have should <operator> (>, >=, <, <=, ===)" do
+    lambda { 2.should.be > 1 }.should succeed
+    lambda { 1.should.be > 2 }.should fail
+
+    lambda { 1.should.be < 2 }.should succeed
+    lambda { 2.should.be < 1 }.should fail
+
+    lambda { 2.should.be >= 1 }.should succeed
+    lambda { 2.should.be >= 2 }.should succeed
+    lambda { 2.should.be >= 2.1 }.should fail
+
+    lambda { 2.should.be <= 1 }.should fail
+    lambda { 2.should.be <= 2 }.should succeed
+    lambda { 2.should.be <= 2.1 }.should succeed
+
+    lambda { Array.should === [1,2,3] }.should succeed
+    lambda { Integer.should === [1,2,3] }.should fail
+
+    lambda { /foo/.should === "foobar" }.should succeed
+    lambda { "foobar".should === /foo/ }.should fail
+  end
+
+  it "should allow for custom shoulds" do
+    lambda { (1+1).should equal_string("2") }.should succeed
+    lambda { (1+2).should equal_string("2") }.should fail
+
+    lambda { (1+1).should.be equal_string("2") }.should succeed
+    lambda { (1+2).should.be equal_string("2") }.should fail
+
+    lambda { (1+1).should.not equal_string("2") }.should fail
+    lambda { (1+2).should.not equal_string("2") }.should succeed
+    lambda { (1+2).should.not.not equal_string("2") }.should fail
+
+    lambda { (1+1).should.not.be equal_string("2") }.should fail
+    lambda { (1+2).should.not.be equal_string("2") }.should succeed
+  end
+
+  it "should have should.flunk" do
+    lambda { should.flunk }.should fail
+    lambda { should.flunk "yikes" }.should fail
+  end
+end
+
+describe "before/after" do
+  before do
+    @a = 1
+    @b = 2
+  end
+
+  before do
+    @a = 2
+  end
+
+  after do
+    @a.should.equal 2
+    @a = 3
+  end
+
+  after do
+    @a.should.equal 3
+  end
+  
+  it "should run in the right order" do
+    @a.should.equal 2
+    @b.should.equal 2
+  end
+  
+  describe "when nested" do
+    before do
+      @c = 5
+    end
+    
+    it "should run from higher level" do
+      @a.should.equal 2
+      @b.should.equal 2
+    end
+    
+    it "should run at the nested level" do
+      @c.should.equal 5
+    end
+    
+    before do
+      @a = 5
+    end
+    
+    it "should run in the right order" do
+      @a.should.equal 5
+      @a = 2
+    end
+  end
+  
+  it "should not run from lower level" do
+    @c.should.be.nil
+  end
+  
+  describe "when nested at a sibling level" do
+    it "should not run from sibling level" do
+      @c.should.be.nil
+    end
+  end
+end
+
+shared "a shared context" do
+  it "gets called where it is included" do
+    true.should.be.true
+  end
+end
+
+shared "another shared context" do
+  it "can access data" do
+    @magic.should.be.equal 42
+  end
+end
+
+describe "shared/behaves_like" do
+  behaves_like "a shared context"
+
+  ctx = self
+  it "raises NameError when the context is not found" do
+    lambda {
+      ctx.behaves_like "whoops"
+    }.should.raise NameError
+  end
+
+  behaves_like "a shared context"
+
+  before {
+    @magic = 42
+  }
+  behaves_like "another shared context"
+end
+
+describe 'describe arguments' do
+
+  def check(ctx,name)
+    ctx.should.be.an.instance_of Bacon::Context
+    ctx.instance_variable_get('@name').should == name
+  end
+
+  it 'should work with string' do
+    check(describe('string') {},'string')
+  end
+
+  it 'should work with symbols' do
+    check(describe(:behaviour) {},'behaviour')
+  end
+   
+  it 'should work with modules' do
+    check(describe(Bacon) {},'Bacon')
+  end
+
+  it 'should work with namespaced modules' do
+    check(describe(Bacon::Context) {},'Bacon::Context')
+  end
+
+  it 'should work with multiple arguments' do
+    check(describe(Bacon::Context, :empty) {},'Bacon::Context empty')
+  end
+
+end

data/gems/gems/bacon-1.1.0/test/spec_should.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '../lib/bacon')
+
+describe "#should shortcut for #it('should')" do
+  
+  should "be called" do
+    @called = true
+    @called.should.be == true
+  end
+  
+  should "save some characters by typing should" do
+    lambda { should.satisfy { 1 == 1 } }.should.not.raise
+  end
+
+  should "save characters even on failure" do
+    lambda { should.satisfy { 1 == 2 } }.should.raise Bacon::Error
+  end
+
+  should "work nested" do
+    should.satisfy {1==1}
+  end
+  
+  count = Bacon::Counter[:specifications]
+  should "add new specifications" do
+    # XXX this should +=1 but it's +=2
+    (count+1).should == Bacon::Counter[:specifications]
+  end
+
+  should "have been called" do
+    @called.should.be == true
+  end
+
+end

data/gems/gems/code-cleaner-0.8.1/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 – 2010 Jakub Šťastný aka Botanicus
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/gems/gems/code-cleaner-0.8.1/README.textile

@@ -0,0 +1,87 @@
+h1. About
+
+Remove trailing whitespace, append missing \n and replace tabs by two spaces.
+
+h1. Usage
+
+<pre>
+# edit script.rb and all Ruby scripts in lib directory
+code-cleaner script.rb lib
+
+# normalize standard input and print output to standard output
+cat script.rb | code-cleaner
+
+# add encoding declaration if missing
+code-cleaner --encoding=utf-8
+</pre>
+
+h2. Blacklisting & Whitelisting
+
+Of course you don't want to remove spaces from other files like PDF documents, images etc. You don't even want to remove spaces from all Ruby scripts, you probably want to ignore vendored files and locally installed gems. And this is where blacklisting and whitelisting comes handy.
+
+Default behaviour is to ignore everything from vendor and gems directories and from other directories just files ending with .rb, .rake, .task and .thor are normalized.
+
+You can change this behaviour by setting environment variables @BLACKLIST@ and @WHITELIST@. What you pass to these variables will be treated as a regular expression. The default behaviour respond to @BLACKLIST='/(vendor|gems)/'@ and @WHITELIST='(^bin/[^/]+|Rakefile|Thorfile|Gemfile$)|(^.+\.(rb|rake|nake|thor|task|gemspec)$)'@. Here's an example how you can use it:
+
+<pre>
+WHITELIST=''^(Rakefile|Thorfile|Gemfile|.+\.(rb|rake|nake|thor|task|gemspec))$'' BLACKLIST='/(vendor|gems)/' code-cleaner .
+</pre>
+
+Note that these rules aren't applied for explicit arguments, so if you run @code-cleaner README.textile@, your readme actually will be normalized. It's because blacklisting and whitelisting rules are applied just on directories, so if you run @code-cleaner .@, your readme will stay untouched. Because of this reason @code-cleaner .@ and @code-cleaner *@ will be different.
+
+If you want to force blacklisting resp. whitelisting even for explicitly specified files, use @--apply-rules@ switch. If you want just try it, use @--try-apply-rules@ which will tell you which files will be skipped and exit without any editing. If some files left in ARGV, the exit status will be 0, otherwise it will be 1.
+
+In your Ruby projects, you might add all files in your @bin@ and @script@ directories into whitelist: @WHITELIST='(^bin/[^/]+|Rakefile|Thorfile|Gemfile$)|(^.+\.(rb|rake|nake|thor|task|gemspec)$)'@
+
+h2. Exit statuses
+
+If code-cleaner does any changes, the exit status will be 0, otherwise it will be 10. It means you can use it in commands like:
+
+<pre>
+if code-cleaner "$file" --apply-rules; then # code-cleaner exits with 0 if some changes were made
+  git add "$file" # so the changes will be committed immediately
+fi
+</pre>
+
+Or, better and more safe way is to directly check exit status of last command via @$?@ as is used in the default @pre-commit@ hook:
+
+<pre>
+code-cleaner .
+
+if [ $? -eq 10 ]; then
+  echo Any modifications were made
+else
+  echo File was changed
+fi
+</pre>
+
+h2. Pre-commit hook
+
+The best way how you can ensure your sources are clean is to use pre-commit hook, if your SCM provides this function. Plus, if you are using git, just use @load "code-cleaner.rake"@ in your Rakefile and then run @rake hooks:whitespace:install@. There are also alternatives for "Nake":http://github.com/botanicus/nake (@code-cleaner.nake@) and "Thor":http://github.com/wycats/thor (@code-cleaner.thor@). Second way is to use @rake --rakefile /path/to/code-cleaner/tasks/code-cleaner.rake hooks:whitespace:install@ resp. @nake /path/to/code-cleaner/tasks/code-cleaner.nake hooks:whitespace:install@ directly.
+
+It might force you to remove your @.git/hooks/pre-commit@ if this file exist. If you haven't done any editation in this file, it's safe to do so and if you done some, then you will need to merge your changes manually. You can do it manually, or, if you are using Nake or Thor, just use @--force@ option.
+
+Here's an example how you can integrate code-cleaner to your tasks:
+
+<pre>
+begin
+  load "code-cleaner.nake"
+rescue LoadError
+  warn "If you want to contribute to nake, you have to install code-cleaner gem and then run ./tasks.rb hooks:whitespace:install"
+end
+</pre>
+
+Also, if you project run in bundled environment, make sure you have your @bin@ or @script@ directory in your @$PATH@ or change the pre-commit hook to point to the right path to the @code-cleaner@. If you are using Nake or Thor, just specify @--path=bin@ resp. @--path=script@ as an option for the @hooks:whitespace:install@ If you are using Rake, you will have to do it manually.
+
+
+--encoding=utf-8
+--whitelist=pattern & --blacklist=pattern
+
+<pre>
+Nake::Task["hooks:whitespace:install"].tap do |task|
+  task.config[:path] = "bin"
+  task.config[:encoding] = "utf-8"
+  task.config[:whitelist] = '(^bin/[^/]+|Rakefile|Thorfile|Gemfile$)|(^.+\.(rb|rake|nake|thor|task|gemspec)$)'
+  #task.config[:blacklist]
+end
+</pre>