manveru-ramaze 2009.01 → 2009.04

data/lib/ramaze/option.rb

@@ -1,156 +0,0 @@
-require 'ramaze/option/dsl'
-require 'ramaze/option/holder'
-
-module Ramaze
-  Global = Option::Holder.new
-
-  Option::DSL.new Global do
-    o "List of aliases for adapters",
-      :adapter_aliases, {
-        "mongrel"             => "Mongrel",
-        "evented_mongrel"     => "Mongrel",
-        "fcgi"                => "Fcgi",
-        "thin"                => "Thin",
-        "ebb"                 => "Ebb",
-        "cgi"                 => "Cgi",
-        "lsws"                => "LSWS",
-        "scgi"                => "SCGI",
-        "webrick"             => "WEBrick",
-        "swiftiplied_mongrel" => "Mongrel",
-      }
-
-    o "Hash of aliases for caches",
-      :cache_aliases, {
-        "memory"    => "MemoryCache",
-        "yaml"      => "YAMLStoreCache",
-        "memcache"  => "MemcachedCache",
-        "memcached" => "MemcachedCache",
-      }
-
-    o "Disable templates without actions",
-      :actionless_templates, true, :cli => true
-
-    o "Set adapter Ramaze will run on.",
-      :adapter, :webrick, :cli => @config[:adapter_aliases][1].keys, :short => :a
-
-    o "Set the size of Backtrace shown.",
-      :backtrace_size, 10, :cli => 10
-
-    o "Turn benchmarking every request on.",
-      :benchmarking, false, :short => :b, :cli => false
-
-    o "Do not log about these requests to static files, values as in Global.ignore",
-      :boring, ["/favicon.ico"]
-
-    o "Use this for general caching and as base for Cache.new.",
-      :cache, :memory, :cli => [:memory, :memcached, :yaml]
-
-    o "Turn on naive caching of all requests.",
-      :cache_all, false, :cli => false
-
-    o "Alternative caches",
-      :cache_alternative, {}
-
-    o "Don't cache action if session flash data is present for a request.",
-      :no_cache_flash, true, :cli => true
-
-    o "Compile Templates",
-      :compile, false, :cli => false
-
-    o "Start Ramaze within an IRB session",
-      :console, false, :short => :c
-
-    o "Active contribs",
-      :contribs, Set.new
-
-    o "Set default Content-Type for responses",
-      :content_type, "text/html"
-
-    o "Set default Accept-Charset for responses. No header set if nil.",
-      :accept_charset, nil
-
-    o "All subclasses of Controller are collected here.",
-      :controllers, Set.new
-
-    o "Instruction for daemonize, only works with bin/ramaze for now",
-      :daemonize, '', :cli => [:start, :stop]
-
-    o "Turn on customized error pages. Use Rack::ShowException otherwise.",
-      :error_page, true, :cli => true
-
-    o "Cache actions to filesystem, uses String as directory name or Global.public_root if other truism",
-      :file_cache, false, :cli => false
-
-    o "Specify what IP Ramaze will respond to - 0.0.0.0 for all",
-      :host, "0.0.0.0", :cli => "0.0.0.0"
-
-    o "Ignore requests to these paths if no file in public_root exists, absolute path or regex",
-      :ignore, ["/favicon.ico"]
-
-    o "Body set on ignored paths",
-      :ignore_body, "File not found"
-
-    o "Status set on ignored paths",
-      :ignore_status, 404
-
-    o "Enable directory listing",
-      :list_directories, false
-
-    o "Templating engines to load on startup",
-      :load_engines, nil
-
-    o "All paths to controllers are mapped here.",
-      :mapping, {}
-
-    o "Activate middleware",
-      :middleware, true
-
-    o "For your own modes to decide on",
-      :mode, :live, :cli => [:live, :dev, :spec]
-
-    o "The place ramaze was started from, useful mostly for debugging",
-      :origin, :main
-
-    o "Specify port",
-      :port, 7000, :short => :p, :cli => 7000
-
-    o "Specify directory to serve static files",
-      :public_root, "public", :cli => "public"
-
-    o "Prefix for incoming and outgoing links",
-      :prefix, '/'
-
-    o "Record all Request objects by assigning a filtering Proc to me.",
-      :record, false
-
-    o "root directory of your application (former APPDIR)",
-      :root, File.dirname(File.expand_path($0))
-
-    o "Don't wait until all adapter-threads are finished or killed.",
-      :run_loose, false, :cli => false
-
-    o "The runner of your application (start.rb)",
-      :runner, "/home/manveru/c/ramaze/examples/hello.rb"
-
-    o "The running server will be put here from Adapter.",
-      :server, nil
-
-    o "Turn on session for all requests.",
-      :sessions, true, :cli => true
-
-    o "Turn on BF/DoS protection for error-responses",
-      :shield, false, :cli => false
-
-    o "What signal to trap to call Ramaze::shutdown",
-      :shutdown_trap, "SIGINT"
-
-    o "Interval in seconds of the Reloader",
-      :sourcereload, 3, :cli => 3
-
-    o "Test before start if adapters will be able to connect",
-      :test_connections, true, :cli => true
-
-    o "Specify directory to serve dynamic files",
-      :view_root, "view", :cli => "view"
-  end
-end

data/lib/ramaze/route.rb

@@ -1,97 +0,0 @@
-#          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
-
-  # Ramaze support simple routing using string, regex and lambda based routers.
-  # Route are stored in a dictionary, which supports hash-like access but
-  # preserves order, so routes are evaluated in the order they are added.
-  #
-  # String routers are the simplest way to route in Ramaze. One path is
-  # translated into another:
-  #
-  #   Ramaze::Route[ '/foo' ] = '/bar'
-  #     '/foo'  =>  '/bar'
-  #
-  # Regex routers allow matching against paths using regex. Matches within
-  # your regex using () are substituted in the new path using printf-like
-  # syntax.
-  #
-  #   Ramaze::Route[ %r!^/(\d+)\.te?xt$! ] = "/text/%d"
-  #     '/123.txt'  =>  '/text/123'
-  #     '/789.text' =>  '/text/789'
-  #
-  # For more complex routing, lambda routers can be used. Lambda routers are
-  # passed in the current path and request object, and must return either a new
-  # path string, or nil.
-  #
-  #   Ramaze::Route[ 'name of route' ] = lambda{ |path, request|
-  #     '/bar' if path == '/foo' and request[:bar] == '1'
-  #   }
-  #     '/foo'        =>  '/foo'
-  #     '/foo?bar=1'  =>  '/bar'
-  #
-  # Lambda routers can also use this alternative syntax:
-  #
-  #   Ramaze::Route('name of route') do |path, request|
-  #     '/bar' if path == '/foo' and request[:bar] == '1'
-  #   end
-
-  class Route
-    trait[:routes] ||= Dictionary.new
-
-    class << self
-      # Retrieve key from trait
-      def [](key)
-        trait[:routes][key]
-      end
-
-      # Set key to value in trait
-      def []=(key, value)
-        trait[:routes][key] = value
-      end
-
-      # remove all routes
-      def clear
-        trait[:routes].clear
-      end
-
-      # Resolve path according to routes.
-      def resolve(path)
-        trait[:routes].each do |key, val|
-          if key.is_a?(Regexp)
-            if md = path.match(key)
-              return val % md.to_a[1..-1]
-            end
-
-          elsif val.respond_to?(:call)
-            if new_path = val.call(path, Request.current)
-              return new_path
-            end
-
-          elsif val.is_a?(String)
-            return val if path == key
-
-          else
-            Log.error "Invalid route #{key} => #{val}"
-          end
-        end
-
-        nil
-      end
-    end
-  end
-
-  class Rewrite < Route
-    trait[:routes] ||= Dictionary.new
-  end
-
-  # Shortcut for defining new routes.
-  def self.Route(name, value = nil, &block)
-    Route[name] = value || block
-  end
-
-  def self.Rewrite(name, value = nil, &block)
-    Rewrite[name] = value || block
-  end
-end

data/lib/ramaze/snippets/object/traits.rb

@@ -1,76 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-Traits = Hash.new{|h,k| h[k] = {}} unless defined?(Traits)
-
-# Extensions for Object
-
-class Object
-
-  # Adds a method to Object to annotate your objects with certain traits.
-  # It's basically a simple Hash that takes the current object as key
-  #
-  # Example:
-  #
-  #   class Foo
-  #     trait :instance => false
-  #
-  #     def initialize
-  #       trait :instance => true
-  #     end
-  #   end
-  #
-  #   Foo.trait[:instance]
-  #   # false
-  #
-  #   foo = Foo.new
-  #   foo.trait[:instance]
-  #   # true
-
-  def trait hash = nil
-    if hash
-      Traits[self].merge! hash
-    else
-      Traits[self]
-    end
-  end
-
-  # builds a trait from all the ancestors, closer ancestors
-  # overwrite distant ancestors
-  #
-  # class Foo
-  #   trait :one => :eins
-  #   trait :first => :erstes
-  # end
-  #
-  # class Bar < Foo
-  #   trait :two => :zwei
-  # end
-  #
-  # class Foobar < Bar
-  #   trait :three => :drei
-  #   trait :first => :overwritten
-  # end
-  #
-  # Foobar.ancestral_trait
-  # {:three=>:drei, :two=>:zwei, :one=>:eins, :first=>:overwritten}
-
-  def ancestral_trait
-    if respond_to?(:ancestors)
-      ancs = ancestors
-    else
-      ancs = self.class.ancestors
-    end
-    ancs.reverse.inject({}){|s,v| s.merge(v.trait)}.merge(trait)
-  end
-
-  # trait for self.class
-
-  def class_trait
-    if respond_to?(:ancestors)
-      trait
-    else
-      self.class.trait
-    end
-  end
-end

data/lib/ramaze/snippets/ramaze/caller_info.rb

@@ -1,30 +0,0 @@
-#          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
-
-  # Gives you back the file, line and method of the caller number i
-  # Example:
-  #   Ramaze.caller_info(1)
-  #   # => ['/usr/lib/ruby/1.8/irb/workspace.rb', '52', 'irb_binding']
-
-  def self.caller_info(i = 1)
-    file, line, meth = *parse_backtrace(caller[i])
-  end
-
-  # Parses one line of backtrace and tries to extract as much information
-  # as possible.
-  #
-  # Example:
-  #   line = "/web/repo/ramaze/lib/ramaze/dispatcher.rb:105:in `respond'"
-  #   Ramaze.parse_backtrace(line)
-  #   #=> ["/web/repo/ramaze/lib/ramaze/dispatcher.rb", "105", "respond"]
-
-  def self.parse_backtrace(line = '')
-    full = line.scan(/(.*?):(\d+):in `(.*?)'/).first
-    return full if full and full.all?
-    partial = line.scan(/(.*?):(\d+)/).first
-    return partial if partial and partial.all?
-    line
-  end
-end

data/lib/ramaze/snippets/ramaze/caller_lines.rb

@@ -1,51 +0,0 @@
-#          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
-
-  # Gives you some context around a specific line in a file.
-  # the size argument works in both directions + the actual line,
-  # size = 2 gives you 5 lines of source, the returned array has the
-  # following format.
-  #   [
-  #     line = [
-  #              lineno           = Integer,
-  #              line             = String,
-  #              is_searched_line = (lineno == initial_lineno)
-  #            ],
-  #     ...,
-  #     ...
-  #   ]
-  # Example:
-  #  caller_lines('/usr/lib/ruby/1.8/debug.rb', 122, 2) # ->
-  #   [
-  #     [ 120, "  def check_suspend",                               false ],
-  #     [ 121, "    return if Thread.critical",                     false ],
-  #     [ 122, "    while (Thread.critical = true; @suspend_next)", true  ],
-  #     [ 123, "      DEBUGGER__.waiting.push Thread.current",      false ],
-  #     [ 124, "      @suspend_next = false",                       false ]
-  #   ]
-
-  def self.caller_lines(file, line, size = 4)
-    return [[0, file, true]] if file == '(eval)'
-    lines = File.readlines(File.expand_path(file)) rescue []
-    current = line.to_i - 1
-
-    first = current - size
-    first = first < 0 ? 0 : first
-
-    last = current + size
-    last = last > lines.size ? lines.size : last
-
-    log = lines[first..last] || []
-
-    area = []
-
-    log.each_with_index do |line, index|
-      index = index + first + 1
-      area << [index, line.chomp, index == current + 1]
-    end
-
-    area
-  end
-end

data/lib/ramaze/snippets/ramaze/state.rb

@@ -1,86 +0,0 @@
-module Ramaze
-  class State
-    def initialize
-      @core = detect
-    end
-
-    def detect
-      require 'fiber'
-      @extract = :resume
-      Ramaze::Fiber
-    rescue LoadError
-      @extract = :value
-      ::Thread
-    end
-
-    def [](key)
-      @core.current[key]
-    end
-
-    def []=(key, value)
-      @core.current[key] = value
-    end
-
-    def key?(key)
-      @core.current.key?(key)
-    end
-
-    def wrap(&block)
-      @core.new(&block).send(@extract)
-    end
-  end
-
-  module StateAccessor
-
-    # Iterate over the names and yield accordingly.
-    # names are either objects responding to #to_sym or hashes.
-    #
-    # It's only used within this module for abstractin-purposes.
-    # Usage below.
-    def self.each(*names)
-      names.each do |name|
-        if name.respond_to?(:to_hash)
-          name.to_hash.each do |key, meth|
-            key, meth = key.to_sym, meth.to_sym
-            yield key, meth
-          end
-        else
-          key = meth = name.to_sym
-          yield key, meth
-        end
-      end
-    end
-
-    # state_writer and state_reader, initializer is a block that may be given
-    # and its result will be the new value in case the reader was never called
-    # before or the value wasn't set before.
-    def state_accessor(*names, &initializer)
-      state_writer(*names)
-      state_reader(*names, &initializer)
-    end
-
-    # Simple writer accessor to STATE[key]=
-    def state_writer(*names)
-      StateAccessor.each(*names) do |key, meth|
-        define_method("#{meth}="){|obj| STATE[key] = obj }
-      end
-    end
-
-    # Reader accessor for STATE[key]
-    def state_reader(*names, &initializer)
-      StateAccessor.each(*names) do |key, meth|
-        if initializer
-          define_method(meth) do
-            unless STATE.key?(key)
-              STATE[key] = instance_eval(&initializer)
-            else
-              STATE[key]
-            end
-          end
-        else
-          define_method(meth){ STATE[key] }
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/snippets/string/each.rb

@@ -1,19 +0,0 @@
-#          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
-  module CoreExtensions
-
-    # Extensions for String
-
-    module String
-      # 1.9 Compatibility with 1.8
-
-      unless ''.respond_to?(:each)
-        def each(*args, &block)
-          each_line(*args, &block)
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/spec/helper/browser.rb

@@ -1,88 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-class Browser
-  attr_reader :cookie, :http
-
-  def initialize(base = '/', &block)
-    @base     = base
-    @history  = []
-    @uri      = URI("http://localhost:#{Ramaze::Global.port}")
-    @http     = SimpleHttp.new(@uri)
-
-    story(&block) if block_given?
-  end
-
-  def story(&block)
-    instance_eval(&block) if block_given?
-  end
-
-  def get path = '/', hash = {}
-    request(:get, path, hash)
-  end
-
-  def post path = '/', hash = {}
-    request(:post, path, hash)
-  end
-
-  def erequest method, path, hash = {}
-    response = request(method, path, hash)
-    eval(response)
-  rescue Object => ex
-    p :response => response
-    ex.message
-  end
-
-  def epost path = '/', hash = {}
-    erequest(:post, path, hash)
-  end
-
-  def eget path = '/', hash = {}
-    erequest(:get, path, hash)
-  end
-
-  def hget(*args)
-    @page = Hpricot(get(*args))
-  end
-
-  def hpost(*args)
-    @page = Hpricot(post(*args))
-  end
-
-  def find_link(text)
-    link = @page.at("a[text()='#{text}']")
-    link.should.not.be.nil if link.respond_to?(:should)
-    link[:href]
-  end
-
-  def follow_link(text)
-    hget find_link(text)
-  end
-
-  def follow_links(*texts)
-    texts.each do |text|
-      follow_link text
-    end
-  end
-
-  def request method, path, hash = {}
-    @http.uri = @uri + "/#{@base}/#{path}".squeeze('/')
-    @http.request_headers['referer'] = @history.last.path rescue '/'
-
-    if method == :get and not hash.empty?
-      @http.uri.query = hash.inject([]){|s,(k,v)| s << "#{k}=#{v}"}.join('&')
-      hash.clear
-    end
-
-    response = @http.send(method, hash).strip
-    @history << @http.uri
-    get_cookie
-
-    response
-  end
-
-  def get_cookie
-    @cookie = @http.response_headers['set-cookie']
-    @http.request_headers['cookie'] = @cookie
-  end
-end

data/lib/ramaze/spec/helper/mock_http.rb

@@ -1,64 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'ramaze'
-require 'ramaze/adapter/fake'
-require 'rack/mock'
-
-module MockHTTP
-  DEFAULTS = {
-    'REMOTE_ADDR' => '127.0.0.1'
-  }
-
-  MOCK_URI = URI::HTTP.build(
-    :host => 'localhost',
-    :port => 80
-  )
-
-  FISHING = {
-    :input => :input,
-    :referrer => 'HTTP_REFERER',
-    :referer => 'HTTP_REFERER',
-    :cookie => 'HTTP_COOKIE',
-    :if_none_match=> 'HTTP_IF_NONE_MATCH',
-    :if_modified_since=> 'HTTP_IF_MODIFIED_SINCE',
-  }
-
-  MOCK_REQUEST = ::Rack::MockRequest.new(Ramaze::Adapter::Fake)
-
-  def get(*args)    mock_request(:get,    *args) end
-  def put(*args)    mock_request(:put,    *args) end
-  def post(*args)   mock_request(:post,   *args) end
-  def delete(*args) mock_request(:delete, *args) end
-
-  def mock_request(meth, path, query = {})
-    uri, options = process_request(path, query)
-    MOCK_REQUEST.send(meth, uri, DEFAULTS.merge(options))
-  end
-
-  def raw_mock_request(meth, uri, options = {})
-    MOCK_REQUEST.send(meth, uri, DEFAULTS.merge(options))
-  end
-
-  def process_request(path, query)
-    options = {}
-    FISHING.each do |key, value|
-      options[value] = query.delete(key) if query.key?(key)
-    end if query.is_a?(Hash)
-    [create_url(path, query), options]
-  end
-
-  def create_url(path, query)
-    uri = MOCK_URI.dup
-    uri.path = path
-    uri.query = make_query(query)
-    uri.to_s
-  end
-
-  def make_query query
-    return query unless query and not query.is_a?(String)
-    query.map{|key, value|
-      "#{Rack::Utils.escape(key)}=#{Rack::Utils.escape(value)}"
-    }.join('&')
-  end
-end