Pistos-ramaze 2008.09

data/lib/ramaze/tool/record.rb

@@ -0,0 +1,6 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  Record = []
+end

data/lib/ramaze/tool.rb

@@ -0,0 +1,9 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze::Tool
+  autoload :Create, 'ramaze/tool/create'
+  autoload :Localize, 'ramaze/tool/localize'
+  autoload :Mime, 'ramaze/tool/mime'
+  autoload :Record, 'ramaze/tool/record'
+end

data/lib/ramaze/trinity.rb

@@ -0,0 +1,16 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  STATE = State.new
+
+  # The module to be included into the Controller it basically just provides
+  # #request, #response and #session, each accessing Thread.current to
+  # retrieve the demanded object
+
+  module Trinity
+    extend StateAccessor
+
+    state_accessor :request, :response, :session
+  end
+end

data/lib/ramaze/version.rb

@@ -0,0 +1,6 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  VERSION = "2008.09"
+end

data/lib/ramaze.rb

@@ -0,0 +1,133 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# StdLib
+require 'abbrev'
+require 'cgi'
+require 'digest/md5'
+require 'fileutils'
+require 'ipaddr'
+require 'optparse'
+require 'ostruct'
+require 'pathname'
+require 'pp'
+require 'set'
+require 'socket'
+require 'timeout'
+require 'tmpdir'
+require 'yaml'
+
+begin
+  require 'rubygems'
+rescue LoadError
+end
+
+# Rack
+require 'rack'
+require 'rack/utils'
+require 'rack/request'
+require 'rack/response'
+
+# The main namespace for Ramaze
+module Ramaze
+  BASEDIR = File.dirname(File.expand_path(__FILE__))
+  $LOAD_PATH.unshift BASEDIR
+  $LOAD_PATH.uniq!
+
+  # Shortcut to the HTTP_STATUS_CODES of Rack::Utils
+  # inverted for easier access
+
+  STATUS_CODE = Rack::Utils::HTTP_STATUS_CODES.invert
+end
+
+Thread.abort_on_exception = true
+
+# Bootstrap
+require 'ramaze/version'
+require 'ramaze/reloader'
+require 'ramaze/snippets'
+require 'ramaze/log'
+require 'ramaze/trinity'
+require 'ramaze/dispatcher'
+require 'ramaze/current'
+require 'ramaze/adapter'
+require 'ramaze/option'
+require 'ramaze/cache'
+require 'ramaze/tool'
+
+# Startup
+require 'ramaze/controller'
+
+# Complete
+require 'ramaze/template/ezamar'
+require 'ramaze/contrib'
+require 'ramaze/route'
+
+module Ramaze
+
+  # Each of these classes will be called ::startup upon Ramaze.startup
+
+  trait :essentials => [
+    Global, Cache, Contrib, Controller, Session, Adapter
+  ]
+
+  trait :started => false
+
+  class << self
+
+    # The one place to start Ramaze, takes an Hash of options to pass on to
+    # each class in trait[:essentials] by calling ::startup on them.
+
+    def startup options = {}
+      force = options.delete(:force)
+      force ||= !trait[:started]
+
+      options[:runner] ||= caller[0][/^(.*?):\d+/, 1]
+      Global.merge!(options)
+
+      if force
+        Log.info("Starting up Ramaze (Version #{VERSION})")
+        trait[:started] = true
+
+        trait[:essentials].each do |obj|
+          obj.startup(options)
+        end
+      else
+        Log.info "Ramaze already started, skipped start."
+      end
+    end
+
+    def skip_start
+      trait[:started] = true
+    end
+
+    def start!(options = {})
+      trait[:started] = false
+      startup(options)
+    end
+
+    # This will be called when you hit ^C or send SIGINT.
+    # It sends ::shutdown to every class in trait[:essentials] and informs you
+    # when it is done
+
+    def shutdown
+      Log.info "Initiate shutdown"
+
+      Timeout.timeout(5) do
+        trait[:essentials].each do |obj|
+          obj.shutdown if obj.respond_to?(:shutdown)
+        end
+
+        puts "Ramazement is over, have a nice day."
+
+        exit
+      end
+    rescue Timeout::Error
+      puts "Shutdown timed out, issuing exit!"
+      exit!
+    end
+
+    alias start startup
+    alias stop shutdown
+  end
+end

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/conf.rake

@@ -0,0 +1,71 @@
+BASEDIR = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+VERS = Ramaze::VERSION
+COPYRIGHT = [
+  "#          Copyright (c) #{Time.now.year} Michael Fellinger m.fellinger@gmail.com",
+  "# All files in this distribution are subject to the terms of the Ruby license."
+]
+README = 'README.markdown'
+CLEAN.include %w[
+  **/.*.sw?
+  *.gem
+  .config
+  **/*~
+  **/{data.db,cache.yaml}
+  *.yaml
+  pkg
+  rdoc
+]
+RDOC_OPTS = %W[
+  --all
+  --quiet
+  --op rdoc
+  --line-numbers
+  --inline-source
+  --main #{README}
+  --opname index.html
+  --title "Ramaze\ documentation"
+  --exclude "^(spec|examples|bin|pkg)/"
+  --exclude "lib/proto"
+  --include "doc"
+  --accessor "trait"
+]
+RDOC_FILES = %W[
+  lib doc #{README} doc/FAQ doc/CHANGELOG
+]
+POST_INSTALL_MESSAGE = %{
+#{'=' * 60}
+
+Thank you for installing Ramaze!
+You can now do following:
+
+* Create a new project using the `ramaze' command:
+    ramaze --create yourproject
+
+#{'=' * 60}
+}.strip
+
+AUTHOR_MAP = {
+  'andy@tinnedfruit.org'                    => 'Andy Smith',
+  'ahoward'                                 => 'Ara T. Howard',
+  'ara.t.howard@gmail.com'                  => 'Ara T. Howard',
+  'blueonyx@dev-area.net'                   => 'Martin Hilbig',
+  'clive@crous.co.za'                       => 'Clive Crous',
+  'comp.lang.zenix+ramaze@gmail.com'        => 'Colin Shea',
+  'evaryont@gmx.us'                         => 'Colin Shea',
+  'jesusisramazing.10.pistos@geoshell.com'  => 'Pistos',
+  'jesuswasramazing.10.pistos@geoshell.com' => 'Pistos',
+  'keita.yamaguchi@gmail.com'               => 'Keita Yamaguchi',
+  'leo.borisenko@gmail.com'                 => 'Leo Borisenko',
+  'manveru@weez-int.com'                    => 'Michael Fellinger',
+  'm.fellinger@gmail.com'                   => 'Michael Fellinger',
+  'outtenr@gmail.com'                       => 'Richard Outten',
+  'ryan@wonko.com'                          => 'Ryan Grove',
+  'rff.rff@gmail.com'                       => 'Gabriele Renzi',
+  'skaar@waste.org'                         => 'skaar',
+  'stephan@spaceboyz.net'                   => 'Stephan Maka',
+  'samcarr@gmail.com'                       => 'samcarr',
+}
+
+# * Browse and try the Examples in
+#     #{File.join(Gem.path, 'gems', 'ramaze-' + VERS, 'examples')}

data/rake_tasks/coverage.rake

@@ -0,0 +1,46 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'rake'
+require 'lib/ramaze/snippets/divide'
+
+spec_base = File.expand_path('spec/ramaze/')
+example_base = File.expand_path('examples')
+snippets_base = File.expand_path('spec/snippets')
+# ignore files with these paths
+ignores = [ './*', './helper/*', './ramaze/adapter.rb', './ramaze/request.rb', ]
+
+files = Dir[spec_base/'**'/'*.rb'] +
+        Dir[example_base/'**/spec'/'*.rb']
+ignores.each do |ignore|
+  ignore_files = Dir[spec_base/ignore]
+  ignore_files.each do |ignore_file|
+    files.delete File.expand_path(ignore_file)
+  end
+end
+
+files.sort!
+
+last = files.pop
+
+COV_CMD = "rcov --aggregate coverage.data --%shtml -%s -x gem -x rack %s"
+
+def sys(cmd)
+ puts cmd
+ system(cmd)
+end
+
+task :coverage => :clean do
+  # these are the tests that can be run in parallel.
+  # IMHO, ideally we should have
+  # * 100% coverage of ramaze with pure tests
+  # * 100% coverage with non-pure functional tests
+  pure_specs =  Dir[snippets_base/'**/*.rb'].entries
+  sys(COV_CMD % ["no-","t", pure_specs.join(' ')])
+
+  files.each do |file|
+    sys(COV_CMD % ["no-","t", file])
+  end
+  sys(COV_CMD % ["", "t", last] )
+
+end

data/rake_tasks/gem.rake

@@ -0,0 +1,74 @@
+def generate_gemspec(version)
+  Gem::Specification.new{|s|
+    s.name = "ramaze"
+    s.version = version
+    s.summary = "Ramaze is a simple and modular web framework"
+    s.description = s.summary
+
+    s.author = "Michael 'manveru' Fellinger"
+    s.email = "m.fellinger@gmail.com"
+    s.homepage = "http://ramaze.rubyforge.org"
+    s.rubyforge_project = "ramaze"
+
+    s.bindir = "bin"
+    s.require_path = "lib"
+
+    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
+
+    s.add_dependency('rack', '>=0.3.0')
+  }
+end
+
+def update_gemspec(spec)
+  gemspec = <<-OUT.strip
+Gem::Specification.new do |s|
+  s.name = %name%
+  s.version = %version%
+
+  s.summary = %summary%
+  s.description = %description%
+  s.platform = %platform%
+  s.has_rdoc = %has_rdoc%
+  s.author = %author%
+  s.email = %email%
+  s.homepage = %homepage%
+  s.executables = %executables%
+  s.bindir = %bindir%
+  s.require_path = %require_path%
+  s.post_install_message = %post_install_message%
+
+  %dependencies%
+
+  s.files = %files%
+end
+  OUT
+
+  gemspec.gsub!(/%(\w+)%/) do
+    case key = $1
+    when 'version'
+      spec.version.to_s.dump
+    when 'dependencies'
+      spec.dependencies.map{|dep|
+        "s.add_dependency('#{dep.name}', '#{dep.version_requirements}')"
+      }.join("\n  ")
+    else
+      spec.send($1).pretty_inspect.strip
+    end
+  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