ramaze 2008.06 → 2008.11

data/lib/vendor/bacon.rb

@@ -0,0 +1,323 @@
+# Bacon -- small RSpec clone.
+#
+# "Truth will sooner come out from error than from confusion." ---Francis Bacon
+
+# Copyright (C) 2007, 2008 Christian Neukirchen <purl.org/net/chneukirchen>
+#
+# Bacon is freely distributable under the terms of an MIT-style license.
+# See COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+module Bacon
+  VERSION = "0.9"
+
+  Counter = Hash.new(0)
+  ErrorLog = ""
+  Shared = Hash.new { |_, name|
+    raise NameError, "no such context: #{name.inspect}"
+  }
+
+  RestrictName    = //  unless defined? RestrictName
+  RestrictContext = //  unless defined? RestrictContext
+
+  def self.summary_on_exit
+    return  if Counter[:installed_summary] > 0
+    at_exit {
+      handle_summary
+      if $!
+        raise $!
+      elsif Counter[:errors] + Counter[:failed] > 0
+        exit 1
+      end
+    }
+    Counter[:installed_summary] += 1
+  end
+
+  module SpecDoxOutput
+    def handle_specification(name)
+      puts name
+      yield
+      puts
+    end
+
+    def handle_requirement(description)
+      print "- #{description}"
+      error = yield
+      puts error.empty? ? "" : " [#{error}]"
+    end
+
+    def handle_summary
+      print ErrorLog
+      puts "%d specifications (%d requirements), %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+
+  module TestUnitOutput
+    def handle_specification(name)  yield  end
+
+    def handle_requirement(description)
+      error = yield
+      if error.empty?
+        print "."
+      else
+        print error[0..0]
+      end
+    end
+
+    def handle_summary
+      puts "", ErrorLog
+      puts "%d tests, %d assertions, %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+
+  module TapOutput
+    def handle_specification(name)  yield  end
+
+    def handle_requirement(description)
+      ErrorLog.replace ""
+      error = yield
+      if error.empty?
+        printf "ok %-3d - %s\n" % [Counter[:specifications], description]
+      else
+        printf "not ok %d - %s: %s\n" %
+          [Counter[:specifications], description, error]
+        puts ErrorLog.strip.gsub(/^/, '# ')
+      end
+    end
+
+    def handle_summary
+      puts "1..#{Counter[:specifications]}"
+      puts "# %d tests, %d assertions, %d failures, %d errors" %
+        Counter.values_at(:specifications, :requirements, :failed, :errors)
+    end
+  end
+
+  extend SpecDoxOutput          # default
+
+  class Error < RuntimeError
+    attr_accessor :count_as
+
+    def initialize(count_as, message)
+      @count_as = count_as
+      super message
+    end
+  end
+
+  class Context
+    def initialize(name, &block)
+      @name = name
+      @before, @after = [], []
+
+      return  unless name =~ RestrictContext
+      Bacon.handle_specification(name) { instance_eval(&block) }
+    end
+
+    def before(&block); @before << block; end
+    def after(&block);  @after << block; end
+
+    def behaves_like(*names)
+      names.each { |name| instance_eval(&Shared[name]) }
+    end
+
+    def it(description, &block)
+      return  unless description =~ RestrictName
+      block ||= lambda { should.flunk "not implemented" }
+      Counter[:specifications] += 1
+      run_requirement description, block
+    end
+
+    def should(*args, &block)
+      if Counter[:depth]==0
+        it('should '+args.first,&block)
+      else
+        super(*args,&block)
+      end
+    end
+
+    def run_requirement(description, spec)
+      Bacon.handle_requirement description do
+        begin
+          Counter[:depth] += 1
+          rescued = false
+          begin
+            @before.each { |block| instance_eval(&block) }
+            prev_req = Counter[:requirements]
+            instance_eval(&spec)
+          rescue Object => e
+            rescued = true
+            raise e
+          ensure
+            if Counter[:requirements] == prev_req and not rescued
+              raise Error.new(:missing,
+                              "empty specification: #{@name} #{description}")
+            end
+            begin
+              @after.each { |block| instance_eval(&block) }
+            rescue Object => e
+              raise e  unless rescued
+            end
+          end
+        rescue Object => e
+          ErrorLog << "#{e.class}: #{e.message}\n"
+          e.backtrace.find_all { |line| line !~ /bin\/bacon|\/bacon\.rb:\d+/ }.
+            each_with_index { |line, i|
+            ErrorLog << "\t#{line}#{i==0 ? ": #@name - #{description}" : ""}\n"
+          }
+          ErrorLog << "\n"
+
+          if e.kind_of? Error
+            Counter[e.count_as] += 1
+            e.count_as.to_s.upcase
+          else
+            Counter[:errors] += 1
+            "ERROR: #{e.class}"
+          end
+        else
+          ""
+        ensure
+          Counter[:depth] -= 1
+        end
+      end
+    end
+
+    def raise?(*args, &block); block.raise?(*args); end
+    def throw?(*args, &block); block.throw?(*args); end
+    def change?(*args, &block); block.change?(*args); end
+  end
+end
+
+
+class Object
+  def true?; false; end
+  def false?; false; end
+end
+
+class TrueClass
+  def true?; true; end
+end
+
+class FalseClass
+  def false?; true; end
+end
+
+class Proc
+  def raise?(*exceptions)
+    exceptions = [RuntimeError]  if exceptions.empty?
+    call
+
+  # Only to work in 1.9.0, rescue with splat doesn't work there right now
+  rescue Object => e
+    case e
+    when *exceptions
+      e
+    else
+      raise e
+    end
+  else
+    false
+  end
+
+  def throw?(sym)
+    catch(sym) {
+      call
+      return false
+    }
+    return true
+  end
+
+  def change?
+    pre_result = yield
+    called = call
+    post_result = yield
+    pre_result != post_result
+  end
+end
+
+class Numeric
+  def close?(to, delta)
+    (to.to_f - self).abs <= delta.to_f  rescue false
+  end
+end
+
+
+class Object
+  def should(*args, &block)   Should.new(self).be(*args, &block)  end
+end
+
+module Kernel
+  private
+
+  def describe(*args, &block)  Bacon::Context.new(args.join(' '), &block) end
+  def shared(name, &block)    Bacon::Shared[name] = block           end
+end
+
+
+class Should
+  # Kills ==, ===, =~, eql?, equal?, frozen?, instance_of?, is_a?,
+  # kind_of?, nil?, respond_to?, tainted?
+  instance_methods.each { |method|
+    undef_method method  if method =~ /\?|^\W+$/
+  }
+
+  def initialize(object)
+    @object = object
+    @negated = false
+  end
+
+  def not(*args, &block)
+    @negated = !@negated
+
+    if args.empty?
+      self
+    else
+      be(*args, &block)
+    end
+  end
+
+  def be(*args, &block)
+    if args.empty?
+      self
+    else
+      block = args.shift  unless block_given?
+      satisfy(*args, &block)
+    end
+  end
+
+  alias a  be
+  alias an be
+
+  def satisfy(*args, &block)
+    if args.size == 1 && String === args.first
+      description = args.shift
+    else
+      description = ""
+    end
+
+    r = yield(@object, *args)
+    if Bacon::Counter[:depth] > 0
+      Bacon::Counter[:requirements] += 1
+      raise Bacon::Error.new(:failed, description)  unless @negated ^ r
+    end
+    @negated ^ r ? r : false
+  end
+
+  def method_missing(name, *args, &block)
+    name = "#{name}?"  if name.to_s =~ /\w[^?]\z/
+
+    desc = @negated ? "not " : ""
+    desc << @object.inspect << "." << name.to_s
+    desc << "(" << args.map{|x|x.inspect}.join(", ") << ") failed"
+
+    satisfy(desc) { |x| x.__send__(name, *args, &block) }
+  end
+
+  def equal(value)         self == value      end
+  def match(value)         self =~ value      end
+  def identical_to(value)  self.equal? value  end
+  alias same_as identical_to
+
+  def flunk(reason="Flunked")
+    raise Bacon::Error.new(:failed, reason)
+  end
+end

data/rake_tasks/gem.rake

@@ -16,8 +16,10 @@ def generate_gemspec(version)
     s.executables = Dir["#{s.bindir}/*"].map{|f| File.basename(f) }
     s.files = FileList.new('**/*'){|fl|
       fl.exclude(/^pkg\//)
-    }
+      fl.exclude(/^tags$/)
+    }.sort
 
+    s.platform = Gem::Platform::RUBY
     s.has_rdoc = true
     s.post_install_message = POST_INSTALL_MESSAGE
 
@@ -33,6 +35,7 @@ Gem::Specification.new do |s|
 
   s.summary = %summary%
   s.description = %description%
+  s.platform = %platform%
   s.has_rdoc = %has_rdoc%
   s.author = %author%
   s.email = %email%
@@ -63,3 +66,9 @@ end
 
   File.open("ramaze.gemspec", 'w+'){|file| file.puts(gemspec) }
 end
+
+spec = generate_gemspec(version_today)
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/rake_tasks/maintenance.rake

@@ -114,6 +114,44 @@ namespace :maintenance do
     File.open(basefile + '.html', 'w+'){|io| io << doc.to_s }
   end
 
+  # This task is so full of hacks, it may break any second, but it just feels
+  # good to have proper highlighting for sh, ezamar and ruby generated from
+  # markdown without any external CSS to worry about.
+  desc 'Rebuild doc/tutorial/todolist.html using UltraViolet'
+  task 'tutorial-uv' do
+    require 'maruku'
+    require 'uv'
+    require 'hpricot'
+    require 'ramaze/contrib/maruku_uv'
+
+    # Inject ezamar syntax
+    Uv.init_syntaxes
+    ezamar = 'lib/ramaze/template/ezamar/textpow.syntax'
+    syntaxes = Uv.instance_variable_get('@syntaxes')
+    syntaxes['ezamar'] = Textpow::SyntaxNode.load(ezamar)
+
+    base = 'doc/tutorial/todolist'
+    original = File.read(base + '.mkd')
+    maruku = Maruku.new(original)
+    style = maruku.attributes[:uv_style]
+
+    html = maruku.to_html_document
+
+    uv_lib = Gem::latest_load_paths.grep(/ultraviolet/).first
+    uv_root = File.dirname(uv_lib)
+    css = Dir["#{uv_root}/**/#{style}.css"].first
+
+    doc = Hpricot(html)
+    css = %(<style type="text/css">
+              pre { margin: 1em; padding: 1em; }
+              #{File.read(css)}
+            </style>)
+
+    doc.at('title').after(css)
+
+    File.open(base + '.html', 'w+'){|io| io << doc.to_s }
+  end
+
   def existing_authors
     authors = {}
 
@@ -337,12 +375,12 @@ namespace :maintenance do
   desc "list all undocumented methods"
   task 'undocumented' do
     $VERBOSE = false
-    Rake::Task['undocumented-module'].invoke
+    Rake::Task['maintenance:undocumented-module'].invoke
   end
 
   desc "list all undocumented methods verbosely"
   task 'undocumented-verbose' do
     $VERBOSE = true
-    Rake::Task['undocumented-module'].invoke
+    Rake::Task['maintenance:undocumented-module'].invoke
   end
 end

data/rake_tasks/metric.rake

@@ -0,0 +1,24 @@
+namespace :metric do
+  desc 'changes per file according to git'
+  task :churn do
+    $stdout.sync = true
+    out = lambda{|changes, rb| puts("%4d %s" % [changes, rb]) }
+    churn = {}
+
+    print 'churning '
+
+    Dir['lib/**/*.rb'].each do |rb|
+      changes = `git-log --pretty=oneline '#{rb}'`.count("\n")
+      print '.'
+      # out[changes, rb]
+      churn[rb] = changes
+    end
+    puts ' done.'
+
+    sorted = churn.sort_by{|r,c| c }.reverse
+    puts "Top 20:"
+    sorted.first(20).each{|(r,c)| out[c,r] }
+    puts "Bottom 20:"
+    sorted.last(20).each{|(r,c)| out[c,r] }
+  end
+end

data/rake_tasks/release.rake

@@ -37,12 +37,12 @@ namespace :release do
   task 'nightly' do
     prepare_package(version_today)
 
-    location = '/srv/www/gems/gems'
+    location = 'web/gems/'
 
-    sh "scp pkg/*.{gem,tgz,zip} ramaze.net:#{location}"
-    sh "ssh ramaze.net '
+    sh "scp pkg/*.{gem,tgz,zip} ramaze@ramaze.net:#{location}"
+    sh "ssh ramaze@ramaze.net '
 source ~/.zsh/export.sh
-cd #{location}/../
+cd #{location}
 gem generate_index'"
   end
 
@@ -60,4 +60,17 @@ gem generate_index'"
       sh "rubyforge add_file ramaze ramaze #{release_id} '#{file}'"
     end
   end
+
+  desc 'Prepare and push gemspec to github'
+  task 'gemspec' => 'gemspec-prepare' do
+    sh "git commit -m 'Update ramaze.gemspec' ramaze.gemspec"
+    sh 'git fetch'
+    sh 'git rebase origin/master'
+    sh 'git push'
+  end
+
+  desc 'Prepare gemspec for push to github'
+  task 'gemspec-prepare' do
+    update_gemspec(generate_gemspec(version_month))
+  end
 end