rjspotter-ramaze 2009.06.29

data/spec/snippets/ordered_set.rb

@@ -0,0 +1,63 @@
+require 'lib/ramaze/spec/helper/snippets'
+
+describe 'OrderedSet' do
+  os = OrderedSet.new(1,2,3,1)
+
+  it 'should create sets' do
+    OrderedSet.new.should == []
+    OrderedSet.new(1).should == [1]
+    OrderedSet.new(1,2).should == [1,2]
+    OrderedSet.new([1,2,3]).should == [1,2,3]
+  end
+
+  it 'should compare sets' do
+    os.should == OrderedSet.new(1,2,3,1)
+    os.should == OrderedSet.new([1,2,3,1])
+  end
+
+  it 'should not contain duplicates' do
+    os.should == [1,2,3]
+  end
+
+  it 'should not duplicate entries' do
+    os << 4
+    os.should == [1,2,3,4]
+
+    os << 4
+    os.should == [1,2,3,4]
+  end
+
+  it 'should append with push and prepend with unshift' do
+    os.push 1
+    os.should == [2,3,4,1]
+
+    os.unshift 1
+    os.should == [1,2,3,4]
+
+    os.push [1,2]
+    os.should == [1,2,3,4,[1,2]]
+
+    os.unshift [1,2]
+    os.should == [[1,2],1,2,3,4]
+  end
+
+  it 'should support Array#[]=' do
+    os = OrderedSet.new(1)
+    os.should == [1]
+
+    os[0] = 1
+    os.should == [1]
+
+    os[1,0] = [3,4,5,1]
+    os.should == [3,4,5,1]
+
+    os[0,0] = [1,2]
+    os.should == [1,2,3,4,5]
+
+    os[5..5] = [7,8,1,2]
+    os.should == [3,4,5,7,8,1,2]
+
+    os[1..2] = 3
+    os.should == [3,7,8,1,2]
+  end
+end

data/spec/snippets/ramaze/acquire.rb

@@ -0,0 +1,77 @@
+require 'lib/ramaze/spec/helper/snippets'
+require 'fileutils'
+
+
+# Mock require to only record attempts
+$required = []
+
+module Ramaze
+  def self.require(name)
+    $required << name
+  end
+end
+
+describe 'Ramaze::acquire' do
+  before do
+    dir = 'tmp_dir_for_acquire'
+    FileUtils.mkdir_p(dir + '/sub')
+
+    %w[ foo.rb bar.rb baz.so baz.yml sub/baz.rb ].
+      each do |path|
+      FileUtils.touch("#{dir}/#{path}")
+    end
+
+    $required = []
+  end
+
+  it 'should not load a single file' do
+    Ramaze::acquire 'tmp_dir_for_acquire/foo'
+    $required.should == []
+  end
+
+  it 'should load dir' do
+    Ramaze::acquire 'tmp_dir_for_acquire/sub/*'
+    $required.should == %w[
+      tmp_dir_for_acquire/sub/baz.rb]
+  end
+
+  it 'should be aliased to acquire' do
+    Ramaze::acquire 'tmp_dir_for_acquire/sub/*'
+    $required.should.not.be.empty
+  end
+
+  it 'should load {so,rb}, not others' do
+    Ramaze::acquire 'tmp_dir_for_acquire/*'
+    $required.sort.should == %w[
+      tmp_dir_for_acquire/bar.rb
+      tmp_dir_for_acquire/baz.so
+      tmp_dir_for_acquire/foo.rb]
+  end
+
+  it 'should use globbing' do
+    Ramaze::acquire 'tmp_dir_for_acquire/ba*'
+    $required.sort.should == %w[
+      tmp_dir_for_acquire/bar.rb
+      tmp_dir_for_acquire/baz.so]
+  end
+
+  it 'should use recursive globbing' do
+    Ramaze::acquire 'tmp_dir_for_acquire/**/*'
+    $required.sort.should == %w[
+      tmp_dir_for_acquire/bar.rb
+      tmp_dir_for_acquire/baz.so
+      tmp_dir_for_acquire/foo.rb
+      tmp_dir_for_acquire/sub/baz.rb]
+  end
+
+  it 'should accept multiple arguments' do
+    Ramaze::acquire 'tmp_dir_for_acquire/*', 'tmp_dir_for_acquire/sub/*'
+    $required.sort.should == %w[
+      tmp_dir_for_acquire/bar.rb
+      tmp_dir_for_acquire/baz.so
+      tmp_dir_for_acquire/foo.rb
+      tmp_dir_for_acquire/sub/baz.rb]
+  end
+
+  FileUtils.rm_rf('tmp_dir_for_acquire')
+end

data/spec/snippets/ramaze/dictionary.rb

@@ -0,0 +1,110 @@
+require 'spec/helper'
+
+describe Ramaze::Dictionary do
+  Dictionary = Ramaze::Dictionary
+
+  should 'create' do
+    dict = Dictionary['z', 1, 'a', 2, 'c', 3]
+    dict.keys.should == %w[z a c]
+  end
+
+  should 'store' do
+    dict = Dictionary.new
+    dict['z'] = 1
+    dict['a'] = 2
+    dict['c'] = 3
+    dict.keys.should == %w[z a c]
+
+    dict = Dictionary.new
+    dict[:a] = 1
+    dict[:c] = 3
+    dict.values.should == [1, 3]
+    dict.keys.should == [:a, :c]
+
+    dict[:b, 1] = 2
+    dict.values.should == [1, 2, 3]
+    dict.keys.should == [:a, :b, :c]
+  end
+
+  should 'push' do
+    dict = Dictionary.new
+    dict.push('end', 15).should == true
+    dict['end'].should == 15
+    dict.push('end', 30).should == false
+    dict['end'].should == 15
+  end
+
+  should 'unshift' do
+    dict = Dictionary['a', 1, 'c', 2, 'z', 3]
+    dict.push('end', 15).should == true
+    dict.unshift('begin', 50).should == true
+    dict['begin'].should == 50
+    dict.keys.should == %w[begin a c z end]
+  end
+
+  should 'pop' do
+    dict = Dictionary['a', 1, 'c', 2, 'z', 3]
+    dict.pop.should == ['z', 3]
+    dict.keys.should == %w[a c]
+  end
+
+  should 'shift' do
+    dict = Dictionary['a', 1, 'c', 2, 'z', 3]
+    dict.shift.should == ['a', 1]
+    dict.keys.should == %w[c z]
+  end
+
+  should 'insert' do
+    dict_a = Dictionary['a', 1, 'b', 2, 'c', 3]
+    dict_b = Dictionary['d', 4, 'a', 1, 'b', 2, 'c', 3]
+
+    dict_a.insert(0, 'd', 4).should == 4
+    dict_a.should == dict_b
+
+    dict_c = Dictionary['a', 1, 'b', 2, 'c', 3]
+    dict_d = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+
+    dict_c.insert(-1, 'd', 4)
+    dict_c.should == dict_d
+  end
+
+  should 'update with Dictionary' do
+    left = Dictionary['a', 1, 'b', 2, 'c', 3]
+    right = Dictionary['d', 4]
+    result = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+
+    left.update(right).should == result
+    left.should == result
+  end
+
+  should 'update with Hash' do
+    left = Dictionary['a', 1, 'b', 2, 'c', 3]
+    right = { 'd' => 4 }
+    result = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    left.update(right).should == result
+    left.should == result
+  end
+
+  should 'merge with Dictionary' do
+    left = Dictionary['a', 1, 'b', 2, 'c', 3]
+    right = Dictionary['d', 4]
+    result = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    left.merge(right).should == result
+    left.should.not == result
+  end
+
+  should 'merge with Hash' do
+    left = Dictionary['a', 1, 'b', 2, 'c', 3]
+    right = { 'd' => 4 }
+    result = Dictionary['a', 1, 'b', 2, 'c', 3, 'd', 4]
+    left.merge(right).should == result
+    left.should.not == result
+  end
+
+  should 'order by set order_by' do
+    dict = Dictionary['a', 3, 'b', 2, 'c', 1]
+    dict.order_by{|k,v| v }
+    dict.values.should == [1, 2, 3]
+    dict.keys.should == %w[c b a]
+  end
+end

data/spec/snippets/ramaze/struct.rb

@@ -0,0 +1,12 @@
+require 'spec/helper'
+
+describe Ramaze::Struct do
+  should 'provide #values_at' do
+    Point = Ramaze::Struct.new(:x, :y)
+    point = Point.new(15, 10)
+
+    point.values_at(1, 0).should == [10, 15]
+    point.values_at(0..1).should == [15, 10]
+    point.values_at(:y, :x).should == [10, 15]
+  end
+end

data/spec/snippets/string/camel_case.rb

@@ -0,0 +1,25 @@
+require 'lib/ramaze/spec/helper/snippets'
+
+describe "String#camel_case" do
+
+  it 'should camelize snake_case' do
+    'foo_bar'.camel_case.should == 'FooBar'
+  end
+
+  it 'should camelize snake_case_long' do
+    'foo_bar_baz'.camel_case.should == 'FooBarBaz'
+  end
+
+  it 'should ignore starting _' do
+    '_foo_bar_baz'.camel_case.should == 'FooBarBaz'
+  end
+
+  it 'should ignore trailing _' do
+    'foo_bar_baz_'.camel_case.should == 'FooBarBaz'
+  end
+
+  it 'messes up existing CamelCase' do
+    'foo_barBaz'.camel_case.should == 'FooBarbaz'
+  end
+
+end

data/spec/snippets/string/color.rb

@@ -0,0 +1,11 @@
+require 'lib/ramaze/spec/helper/snippets'
+
+describe 'String#color' do
+  it 'should define methods to return ANSI strings' do
+    %w[reset bold dark underline blink negative
+    black red green yellow blue magenta cyan white].each do |m|
+      "string".respond_to? m
+      "string".send(m).should.match(/\e\[\d+mstring\e\[0m/)
+    end
+  end
+end

data/spec/snippets/string/snake_case.rb

@@ -0,0 +1,24 @@
+require 'lib/ramaze/spec/helper/snippets'
+
+describe "String#snake_case" do
+
+  it 'should snake_case a camelCase' do
+    'CamelCase'.snake_case.should == 'camel_case'
+  end
+
+  it 'should snake_case a CamelCaseLong' do
+    'CamelCaseLong'.snake_case.should == 'camel_case_long'
+  end
+
+  it 'will keep existing _' do
+    'Camel_Case'.snake_case.should == 'camel__case'
+  end
+
+  it 'should replace spaces' do
+    'Linked List'.snake_case.should == 'linked_list'
+  end
+
+  it 'should group uppercase words together' do
+    'CSSController'.snake_case.should == 'css_controller'
+  end
+end

data/spec/snippets/string/unindent.rb

@@ -0,0 +1,43 @@
+require 'lib/ramaze/spec/helper/snippets'
+
+describe "String#unindent" do
+  it "should remove indentation" do
+    %(
+      hello
+        how
+          are
+        you
+      doing
+    ).ui.should == \
+%(hello
+  how
+    are
+  you
+doing)
+  end
+
+  it 'should not break on a single line' do
+    'word'.unindent.should == 'word'
+  end
+
+  it 'should find the first line with indentation' do
+%(  hi
+  there
+    bob).ui.should == \
+%(hi
+there
+  bob)
+  end
+
+  it 'should have destructive version' do
+    str = %(  1\n    2\n  3)
+    str.ui!
+    str.should == %(1\n  2\n3)
+  end
+
+  it 'should use indentation from the last line if first line is not indented' do
+    %(a{
+      abc
+    }).ui.should == %(a{\n  abc\n})
+  end
+end

data/spec/snippets/thread/into.rb

@@ -0,0 +1,9 @@
+require 'spec/helper'
+
+describe 'Thread.into' do
+  it 'should provide access to thread vars' do
+    Thread.current[:foo] = :bar
+    Thread.new{ Thread.current[:foo].should == nil }.join
+    Thread.into{ Thread.current[:foo].should == :bar }.join
+  end
+end

data/tasks/authors.rake

@@ -0,0 +1,30 @@
+# Once git has a fix for the glibc in handling .mailmap and another fix for
+# allowing empty mail address to be mapped in .mailmap we won't have to handle
+# them manually.
+
+desc 'Update doc/AUTHORS'
+task :authors do
+  authors = Hash.new(0)
+
+  `git shortlog -nse`.scan(/(\d+)\s(.+)\s<(.*)>$/) do |count, name, email|
+    case name
+    when "ahoward"
+      name, email = "Ara T. Howard", "ara.t.howard@gmail.com"
+    when "Martin Hilbig blueonyx@dev-area.net"
+      name, email = "Martin Hilbig", "blueonyx@dev-area.net"
+    when "Michael Fellinger m.fellinger@gmail.com"
+      name, email = "Michael Fellinger", "m.fellinger@gmail.com"
+    end
+
+    authors[[name, email]] += count.to_i
+  end
+
+  File.open('doc/AUTHORS', 'w+') do |io|
+    io.puts "Following persons have contributed to #{GEMSPEC.name}."
+    io.puts '(Sorted by number of submitted patches, then alphabetically)'
+    io.puts ''
+    authors.sort_by{|(n,e),c| [-c, n.downcase] }.each do |(name, email), count|
+      io.puts("%6d %s <%s>" % [count, name, email])
+    end
+  end
+end

data/tasks/bacon.rake

@@ -0,0 +1,66 @@
+desc 'Run all bacon specs with pretty output'
+task :bacon => :setup do
+  require 'open3'
+  require 'scanf'
+  require 'matrix'
+
+  specs = PROJECT_SPECS
+
+  some_failed = false
+  specs_size = specs.size
+  len = specs.map{|s| s.size }.sort.last
+  total_tests = total_assertions = total_failures = total_errors = 0
+  totals = Vector[0, 0, 0, 0]
+
+  red, yellow, green = "\e[31m%s\e[0m", "\e[33m%s\e[0m", "\e[32m%s\e[0m"
+  left_format = "%4d/%d: %-#{len + 11}s"
+  spec_format = "%d specifications (%d requirements), %d failures, %d errors"
+
+  specs.each_with_index do |spec, idx|
+    print(left_format % [idx + 1, specs_size, spec])
+
+    Open3.popen3(RUBY, spec) do |sin, sout, serr|
+      out = sout.read.strip
+      err = serr.read.strip
+
+      # this is conventional, see spec/innate/state/fiber.rb for usage
+      if out =~ /^Bacon::Error: (needed .*)/
+        puts(yellow % ("%6s %s" % ['', $1]))
+      else
+        total = nil
+
+        out.each_line do |line|
+          scanned = line.scanf(spec_format)
+
+          next unless scanned.size == 4
+
+          total = Vector[*scanned]
+          break
+        end
+
+        if total
+          totals += total
+          tests, assertions, failures, errors = total_array = total.to_a
+
+          if tests > 0 && failures + errors == 0
+            puts((green % "%6d passed") % tests)
+          else
+            some_failed = true
+            puts(red % "       failed")
+            puts out unless out.empty?
+            puts err unless err.empty?
+          end
+        else
+          some_failed = true
+          puts(red % "       failed")
+          puts out unless out.empty?
+          puts err unless err.empty?
+        end
+      end
+    end
+  end
+
+  total_color = some_failed ? red : green
+  puts(total_color % (spec_format % totals.to_a))
+  exit 1 if some_failed
+end