ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/dispatcher.rb

@@ -1,124 +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/error'
-require 'ramaze/tool/mime'
-
-require 'ramaze/dispatcher/action'
-require 'ramaze/dispatcher/error'
-require 'ramaze/dispatcher/file'
-require 'ramaze/dispatcher/directory'
-
-module Ramaze
-
-  # The Dispatcher receives requests from adapters and sets up the proper environment
-  # to process them and respond.
-
-  module Dispatcher
-
-    # requests are passed to every
-    FILTER = [ Dispatcher::File, Dispatcher::Action ] unless defined?(FILTER)
-
-    # Response codes to cache the output of for repeated requests.
-    trait :shielded => [ STATUS_CODE["Not Found"] ]
-
-    class << self
-      include Trinity
-
-      # Entry point for Adapter#respond, takes a Rack::Request and
-      # Rack::Response, sets up the environment and the goes on to dispatch
-      # for the given path from rack_request.
-      def handle
-        path = request.path_info.squeeze('/')
-
-        case path
-        when *Global.ignore
-          unless ::File.exist?(Dispatcher::File.resolve_path(path))
-            return response.build(Global.ignore_body, Global.ignore_status)
-          end
-        end
-
-        general_dispatch path
-      rescue Object => error
-        meta = { :path => path,
-                 :request => request,
-                 :controller => Thread.current[:controller] }
-        Dispatcher::Error.process(error, meta)
-      end
-
-      # protects against recursive dispatch and reassigns the path_info in the
-      # request, the rest of the request is kept intact.
-      def dispatch_to(path)
-        if request.path_info == path
-          if error = Thread.current[:exception]
-            raise error
-          else
-            raise "Recursive redirect from #{path} to #{path}"
-          end
-        end
-        request.path_info = path
-        general_dispatch path
-      end
-
-      # splits up the dispatch based on Global.shield
-      def general_dispatch(path)
-        if Global.shield
-          shielded_dispatch path
-        else
-          dispatch path
-        end
-      end
-
-      # Protects somewhat against hammering of erroring paths, since error-pages
-      # take a while to build in the default mode it is possible to decrease
-      # overall speed quite a bit by hitting Ramaze with such paths.
-      # shielded_dispatch checks the path and caches erronous responses so they
-      # won't be recreated but simply pushed out again without stopping at the
-      # Controller.
-      # Please note that this is just minor protection and the best option is to
-      # create a performant error-page instead.
-      def shielded_dispatch(path)
-        shield_cache = Cache.shield
-        handled = shield_cache[path]
-        return handled if handled
-
-        dispatched = dispatch(path)
-
-        unless trait[:shielded].include?(dispatched.status)
-          dispatched
-        else
-          shield_cache[path] = dispatched
-        end
-      end
-
-      # filters the path until a response or redirect is thrown or a filter is
-      # successful, builds a response from the returned hash in case of throws.
-      def dispatch(path)
-        catch(:respond){
-          redirected = catch(:redirect){
-            filter(path)
-            throw(:respond)
-          }
-          response.build(*redirected)
-        }
-      end
-
-      # Calls .process(path) on every class in Dispatcher::FILTER until one
-      # returns something else than false/nil.
-
-      def filter(path)
-        result = nil
-        FILTER.each do |dispatcher|
-          result = dispatcher.process(path)
-          return result if result and not result.respond_to?(:exception)
-        end
-
-        meta = {
-          :path => path,
-          :controller => Thread.current[:controller]
-        }
-        Dispatcher::Error.process(result, meta)
-      end
-    end
-  end
-end

data/lib/ramaze/error.rb

@@ -1,24 +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
-
-  # The general Namespace for Ramazes Errorclasses
-
-  class Error < StandardError
-    # No action found on Controller
-    class NoAction < Error; end
-
-    # No Controller found for request
-    class NoFilter < Error; end
-
-    # No Controller found for request
-    class NoController < Error; end
-
-    # Wrong parameter count for action
-    class WrongParameterCount < Error; end
-
-    # Error while transformation in template
-    class Template < Error; end
-  end
-end

data/lib/ramaze/global/dsl.rb

@@ -1,39 +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
-  CLIOption = Struct.new('CLIOption', :name, :default, :doc, :cli, :short)
-  OPTIONS     = {}
-  CLI_OPTIONS = []
-
-  # DSL for specifying Globap options before initializing Global
-
-  module GlobalDSL
-    class << self
-
-      # The method that takes the block containing the DSL, used like in
-      # lib/ramaze/global.rb
-
-      def option_dsl(&block)
-        instance_eval(&block)
-      end
-
-      # Takes a doc-string and then the option as hash, another :cli key can
-      # be given that will expose this option via the bin/ramaze.
-
-      def o(doc, options = {})
-        cli_given = options.has_key?(:cli)
-        cli = options.delete(:cli)
-        short = options.delete(:short)
-        name, default = options.to_a.flatten
-
-        if cli_given
-          option = CLIOption.new(name, default, doc, cli, short)
-          CLI_OPTIONS << option
-        end
-
-        OPTIONS.merge!(options)
-      end
-    end
-  end
-end

data/lib/ramaze/global/globalstruct.rb

@@ -1,147 +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
-  unless defined?(GlobalStruct) # prevent problems for SourceReload
-    class GlobalStruct < Struct.new('Global', *OPTIONS.keys)
-    end
-  end
-
-  # Class for Ramaze::Global instance.
-  class GlobalStruct
-
-    ENV_TRIGGER = {
-      'EVENT' => lambda{ require 'ramaze/adapter/evented_mongrel' },
-      'SWIFT' => lambda{ require 'ramaze/adapter/swiftiplied_mongrel' }
-    }
-
-    # mapping of :adapter => to the right class-name.
-    ADAPTER_ALIAS = {
-      :cgi                 => :Cgi,
-      :fcgi                => :Fcgi,
-      :scgi                => :Scgi,
-      :thin                => :Thin,
-      :ebb                 => :Ebb,
-      :lsws                => :Lsws,
-      :webrick             => :WEBrick,
-      :mongrel             => :Mongrel,
-      :evented_mongrel     => :Mongrel,
-      :swiftiplied_mongrel => :Mongrel,
-    }
-
-    # mapping of :cache => to the right class-name.
-    CACHE_ALIAS = {
-      :memcached => :MemcachedCache,
-      :memory    => :MemoryCache,
-      :yaml      => :YAMLStoreCache,
-    }
-
-    class << self
-      alias setup fill
-    end
-
-    # Called from Ramaze::start, sets all the options.
-    def startup(options = {})
-      options.each do |key, value|
-        if (method(key) rescue false)
-          send("#{key}=", value)
-        else
-          create_member(key, value)
-        end
-      end
-
-      ENV_TRIGGER.values_at(*ENV.keys).compact.each{|l| l.call}
-
-      engines = self[:load_engines]
-      (Symbol === engines ? [engines] : engines).each do |engine|
-        Ramaze::Template.const_get(engine)
-      end
-    end
-
-    # batch-assignment of key/value from hash, yields self if a block is given.
-    def setup(hash = {})
-      hash.each do |key, value|
-        self.send("#{key}=", value)
-      end
-      yield(self) if block_given?
-    end
-
-
-    # Object wraps
-
-    # get right classname, require the file for given adapter and answer with
-    # the actual class.
-    def adapter
-      if internal = self[:adapter]
-        class_name = ADAPTER_ALIAS.fetch(internal.to_sym, internal)
-        unless Ramaze::Adapter.const_defined?(class_name)
-          require("ramaze/adapter"/internal.to_s.downcase)
-        end
-        Ramaze::Adapter.const_get(class_name)
-      end
-    end
-
-    # get right classname, require the file for given cache and answer with
-    # the actual class.
-    def cache
-      cache_name = self[:cache].to_sym
-      class_name = CACHE_ALIAS[cache_name] || cache_name
-      cache = Ramaze.const_get(class_name)
-    end
-
-    # reassigns the interval in the instance of SourceReload that is running or
-    # just waiting.
-    def sourcereload=(interval)
-      self[:sourcereload] = interval
-      sri = Thread.main[:sourcereload]
-      sri.interval = interval if sri
-    end
-
-    def template_root
-      [ tr = self[:template_root],
-        APPDIR/tr,
-        APPDIR/'template',
-      ].find{|path| File.directory?(path) } || self[:template_root]
-    end
-
-    def public_root
-      [ pr = self[:public_root],
-        APPDIR/pr,
-      ].find{|path| File.directory?(path) } || self[:public_root]
-    end
-
-    def list_directories=(active)
-      require 'ramaze/dispatcher'
-      d = Ramaze::Dispatcher
-      self[:list_directories] = active
-      if active
-        d::FILTER.put_within(d::Directory, :after => d::File, :before => d::Action)
-      else
-        d::FILTER.delete(d::Directory)
-      end
-    end
-
-
-    # External helpers
-
-    # Answers with values for given keys by sending each to self
-    def values_at(*keys)
-      keys.map{|key| __send__(key)}
-    end
-
-    # Creates a new attr_accessor like method-pair.
-    def create_member key, value = nil
-      Log.warn "Create #{key}=#{value.inspect} on Global"
-
-      @table ||= {}
-      key = key.to_sym
-
-      (class << self; self; end).class_eval do
-        define_method(key){ @table[key] }
-        define_method("#{key}="){|val| @table[key] = val }
-      end
-
-      @table[key] = value
-    end
-  end
-end

data/lib/ramaze/global.rb

@@ -1,116 +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/global/dsl'
-
-module Ramaze
-  GlobalDSL.option_dsl do
-    o "Set the adapter Ramaze will run on.",
-      :adapter => :webrick, :cli => [:webrick, :mongrel, :thin]
-
-    o "Set the size of Backtrace shown.",
-      :backtrace_size => 10, :cli => 10
-
-    o "Turn benchmarking every request on.",
-      :benchmarking => false, :cli => false, :short => :b
-
-    o "Do not log about these requests to static files, values as in Global.ignore",
-      # Example: [/\.(ico|gif|jpg|png)$/, '/robots.txt']
-      :boring => [ '/favicon.ico' ]
-
-    o "Use this for general caching and as base for Cache.new.",
-      :cache => :memory, :cli => [:memory, :memcached, :yaml]
-
-    o "Alternative caches",
-      :cache_alternative => {}
-
-    o "Turn on naive caching of all requests.",
-      :cache_all => false, :cli => false
-
-    o "Compile Templates",
-      :compile => false, :cli => false
-
-    o "Active contribs ",
-      :contribs => Set.new
-
-    o "All subclasses of Controller are collected here.",
-      :controllers => Set.new
-
-    o "Start Ramaze within an IRB session",
-      :console => false, :cli => false, :short => :c
-
-    o "Turn on customized error pages.",
-      :error_page => true, :cli => true
-
-    o "Caching actions to the filesystem in Global.public_root",
-      :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",
-      # Example: [/\.(ico|gif|jpg|png)$/, '/robots.txt']
-      :ignore => [ '/favicon.ico' ]
-
-    o "Body set on ignored paths",
-      :ignore_body => "File not found"
-
-    o "Status set on ignored paths",
-      :ignore_status => 404
-
-    o "Templating engines to load on startup",
-      :load_engines => []
-
-    o "All paths to controllers are mapped here.",
-      :mapping => {}
-
-    o "For your own modes to decide on",
-      :mode => :live, :cli => [:live, :dev]
-
-    o "The place ramaze was started from, useful mostly for debugging",
-      :origin => :main
-
-    o "Specify port",
-      :port => 7000, :cli => 7000, :short => :p
-
-    o "Specify directory to serve static files",
-      :public_root => 'public', :cli => 'public'
-
-    o "Record all Request objects by assigning a filtering Proc to me.",
-      :record => false
-
-    o "Don't wait until all adapter-threads are finished or killed.",
-      :run_loose => false, :cli => false
-
-    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 background SourceReload",
-      :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",
-      :template_root => 'view', :cli => 'view'
-
-    o "Enable directory listing",
-      :list_directories => false, :cli => false
-
-    o "Disable templates without actions",
-      :actionless_templates => true, :cli => true
-  end
-
-  require 'ramaze/global/globalstruct'
-
-  Global = GlobalStruct.setup(OPTIONS) unless defined?(Global)
-end

data/lib/ramaze/helper/aspect.rb

@@ -1,100 +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
-
-  # A helper that provides the means to wrap actions of the controller with
-  # other methods.
-  #
-  # For examples please look at the spec/ramaze/helper/aspect.rb
-  #
-  # This is not a default helper due to the possible performance-issues.
-  # However, it should be only an overhead of about 6-8 calls, so if you
-  # want this feature it shouldn't have too large impact ;)
-  #
-  # Like every other helper, you can use it in your controller with:
-  #
-  #   helper :aspect
-
-  module Helper::Aspect
-
-    private
-
-    # lazily and smartly inherit copy of aspects trait from parent, or
-    # bootstrap our own 
-    def aspects
-      trait[:aspects] ||= (
-        if hash = ancestral_trait[:aspects]
-          { :before => hash[:before].dup, :after => hash[:after].dup }
-        else
-          { :before => {}, :after => {} }
-        end
-      )
-    end
-
-    # run block before given actions or, if no actions specified, all actions.
-    def before(*meths, &block)
-      return before_all(*meths, &block) if meths.empty?
-      meths.each do |meth|
-        aspects[:before][meth.to_s] = block
-      end
-    end
-    alias pre before
-
-    # Run block before all actions.
-    def before_all(&block)
-      aspects[:before][:all] = block
-    end
-    alias pre_all before_all
-
-    # run block after given actions or, if no actions specified, all actions.
-    def after(*meths, &block)
-      return after_all(*meths, &block) if meths.empty?
-      meths.each do |meth|
-        aspects[:after][meth.to_s] = block
-      end
-    end
-    alias post after
-
-    # Run block after all actions.
-    def after_all(&block)
-      aspects[:after][:all] = block
-    end
-    alias post_all after_all
-
-    # run block before and after given actions, or, if no actions specified.
-    # all actions
-    def wrap(*meths, &block)
-      return wrap_all(*meths, &block) if meths.empty?
-      before(*meths, &block)
-      after(*meths, &block)
-    end
-
-    # run block before and after all actions.
-    def wrap_all(&block)
-      aspects[:before][:all] = block
-      aspects[:after][:all] = block
-    end
-  end
-
-  class Action
-
-    # overwrites the default Action hook and runs the neccesary blocks in its
-    # scope.
-    def before_process
-      return unless path and aspects = controller.ancestral_trait[:aspects]
-      [ aspects[:before][name], aspects[:before][:all] ].compact.map do |block|
-        instance.instance_eval(&block) if block
-      end
-    end
-
-    # overwrites the default Action hook and runs the neccesary blocks in its
-    # scope.
-    def after_process
-      return unless path and aspects = controller.ancestral_trait[:aspects]
-      [ aspects[:after][name], aspects[:after][:all] ].compact.map do |block|
-        instance.instance_eval(&block) if block
-      end
-    end
-  end
-end

data/lib/ramaze/helper/cgi.rb

@@ -1,43 +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
-
-  # Shortcuts to some CGI methods
-
-  module Helper::CGI
-    # shortcut for CGI.escape
-
-    def url_encode(*args)
-      ::CGI.escape(*args.map{|arg| arg.to_s})
-    end
-
-    # shortcut for CGI.unescape
-
-    def url_decode(*args)
-      ::CGI.unescape(*args.map{|arg| arg.to_s})
-    end
-
-    # shortcut for CGI.escapeHTML
-
-    def html_escape(string)
-      ::CGI.escapeHTML(string.to_s)
-    end
-
-    # shortcut for CGI.unescapeHTML
-
-    def html_unescape(string)
-      ::CGI.unescapeHTML(string.to_s)
-    end
-
-    # safely escape all HTML and code
-    def c(string)
-      ::CGI.escapeHTML(string.to_s).gsub(/#/, '#')
-    end
-
-    # one-letter versions help in case like #{h foo.inspect}
-    # ERb/ERuby/Rails compatible
-    alias u url_encode
-    alias h c
-  end
-end

data/lib/ramaze/helper/inform.rb

@@ -1,40 +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
-
-  # Easy access to Log
-
-  module Helper::Log
-    L = Ramaze::Log
-
-    # The various (default) tags you can use are:
-    #
-    # :info  - just outputs whatever you give to it without modification.
-    # :debug - applies #inspect to everything you pass
-    # :error - can take normal strings or exception-objects
-    #
-    #
-    # Usage:
-    #
-    #   inform :info, 'proceeding as planned'
-    #   # [2007-04-04 23:38:39] INFO   proceeding as planned
-    #
-    #   inform :debug, [1,2,3]
-    #   # [2007-04-04 23:38:39] DEBUG  [1, 2, 3]
-    #
-    #   inform :error, 'something bad happened'
-    #   # [2007-04-04 23:38:39] ERROR  something bad happened
-    #
-    #   inform :error, exception
-    #   # [2007-04-04 23:40:59] ERROR  #<RuntimeError: Some exception>
-    #   # [2007-04-04 23:40:59] ERROR  hello.rb:23:in `index'
-    #   # ... rest of backtrace ...
-
-    def log tag, *args
-      L.warn "Helper::Log is being deprecated, use Log directly instead"
-      L.send(tag, *args)
-    end
-    alias inform log
-  end
-end

data/lib/ramaze/helper/nitroform.rb

@@ -1,14 +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 'nitro/helper/form'
-
-module Ramaze
-  module Helper
-
-    # This helper simply includes the Nitro::FormHelper so you can use its methods
-    # in your Controller.
-
-    Nitroform = ::Nitro::FormHelper
-  end
-end