ptomato-ramaze 2009.02

data/lib/ramaze/tool/project_creator.rb

@@ -0,0 +1,111 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'fileutils'
+require 'find'
+
+class ProjectCreator
+  PROTO = []
+  PROTO << '~/.proto/' if ENV["HOME"] # Guard against Windows
+  attr_accessor :name, :options
+
+  def initialize(name, options = {})
+    @name, @options = name, options
+  end
+
+  def target
+    File.expand_path(name)
+  end
+
+  def proto
+    PROTO.map!{|pr| File.expand_path(pr) }
+    proto = options[:proto] ||= PROTO.find{|f| File.directory?(f) }
+    layout = options[:layout] ||= '/'
+    File.expand_path(File.join(proto, layout))
+  end
+
+  def create_root?
+    return true unless File.directory?(target)
+    return true if amend? or force?
+    fatal "%p is a directory, choose different project name or use --amend/--force" % target
+  end
+
+  def got_proto?
+    return true if File.directory?(proto)
+    fatal "Cannot create, %p doesn't exist, use --proto or create the proto directory" % proto
+  end
+
+  def create
+    got_proto?
+
+    puts "Found proto at: %p, proceeding...\n\n" % proto
+    mkdir(relate('/')) if create_root?
+    proceed
+  end
+
+  def proceed
+    files, directories = partition{|path| File.file?(path) }
+    proceed_directories(directories)
+    proceed_files(files)
+  end
+
+  def proceed_files(files)
+    files.each{|file| copy(file, relate(file)) }
+  end
+
+  def proceed_directories(dirs)
+    dirs.each{|dir| mkdir(relate(dir)) }
+  end
+
+  def mkdir(dir)
+    exists = File.directory?(dir)
+    return if exists and amend?
+    return if exists and not force?
+    puts "mkdir(%p)" % dir
+    FileUtils.mkdir_p(dir)
+  end
+
+  def copy(from, to)
+    return unless copy_check(to)
+    puts "copy(%p, %p)" % [from, to]
+    FileUtils.cp(from, to)
+    post_process(to)
+  end
+
+  def copy_check(to)
+    exists = File.file?(to)
+    return if exists and amend?
+    return if exists and not force?
+    return true
+  end
+
+  # Think about a useful way to process the generated files it should be
+  # possible to substitute some things like the project name in the
+  # configuration
+
+  def post_process(file)
+    return
+    source = File.read(file)
+    File.open(file, 'w+') do |io|
+      io.write(source.gsub('$project', "'#@name'"))
+    end
+  end
+
+  def relate(path)
+    File.join(target, path.to_s.sub(proto, ''))
+  end
+
+  def amend?; options[:amend] end
+  def force?; options[:force] end
+
+  def fatal(message)
+    warn message
+    exit 1
+  end
+
+  def each
+    Dir["#{proto}/**/*"].each{|path| yield(path) }
+  end
+
+  include Enumerable
+end

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 = "2009.01"
+end

data/lib/ramaze.rb

@@ -0,0 +1,139 @@
+#          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 = {}
+      options = options.to_hash
+
+      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
+
+    # A shortcut for setting Ramaze.trait[:started] = true.
+
+    def skip_start
+      trait[:started] = true
+    end
+
+    # Forces the startup of Ramaze regardless if trait[:started] is set.
+
+    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