ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/action/render.rb

@@ -1,163 +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
-  class Action
-
-    def stack
-      Action.stack << self
-      yield self
-    rescue Object => ex
-      Log.error "#{ex} in: #{self}"
-      raise ex
-    ensure
-      Action.stack.pop
-    end
-
-    # Render this instance of Action, this will (eventually) pass itself to
-    # Action#engine.transform
-    # Usage, given that Foo is a Controller and has the method/template
-    # for index:
-    #  > Action(:controller => Foo).render
-    #  #> 'bar'
-
-    def render
-      Log.dev("Action: #{self}")
-
-      stack do
-        if should_cache?
-          cached_render
-        else
-          uncached_render
-        end
-      end
-    end
-
-    private
-
-    # Return the cached output of the action if it exists, otherwise do a
-    # normal Action#uncached_render and store the output in the Cache.actions.
-    # Action#cached_render is only called if Action#should_cache? returns
-    # true.
-
-    def cached_render
-      if Global.file_cache
-        cached_render_file
-      else
-        cached_render_memory
-      end
-    end
-
-    def cached_render_file
-      rendered = uncached_render
-
-      global_epath = Global.public_root/self.controller.mapping/extended_path
-      FileUtils.mkdir_p(File.dirname(global_epath))
-      File.open(global_epath, 'w+') {|fp| fp.print(rendered) }
-
-      rendered
-    end
-
-    def cached_render_memory
-      action_cache = Cache.actions
-      full_path = self.controller.mapping/extended_path
-
-      # backwards compat with trait :actions_cached => []
-      cache_opts = actions_cached.is_a?(Hash) ? actions_cached[path.to_sym] : {}
-
-      if cache_opts[:key]
-        action_cache[full_path] ||= {}
-        cache = action_cache[full_path][ cache_opts[:key].call ] ||= {}
-      else
-        cache = action_cache[full_path] ||= {}
-      end
-
-      if cache.size > 0 and (cache_opts[:ttl].nil? or cache[:time] + cache_opts[:ttl] > Time.now)
-        Log.debug("Using Cached version")
-        Response.current['Content-Type'] = cache[:type]
-      else
-        Log.debug("Compiling Action")
-        cache.replace({ :time => Time.now, :content => uncached_render, :type => Response.current['Content-Type'] })
-      end
-
-      cache[:content]
-    end
-
-    # The 'normal' rendering process. Passes the Action instance to
-    # Action#engine.transform, which returns the output of the action.
-    # Layout will be found and rendered in this step after self was rendered.
-
-    def uncached_render
-      before_process
-
-      content = engine.transform(self)
-
-      if path and tlayout = layout
-        [instance, tlayout.instance].each do |i|
-          i.instance_variable_set("@content", content)
-        end
-
-        content = tlayout.render
-      end
-
-      content
-
-    ensure
-      after_process unless $!
-    end
-
-    # Determine whether or not we have a layout to process and sets it up
-    # correctly to be rendered in the same context as current action.  Will
-    # return false if the layout is the same as current action to avoid
-    # infinite recursion and also if no layout on this controller or its
-    # ancestors was found.
-
-    def layout
-      return false unless layouts = controller.ancestral_trait[:layout]
-
-      possible = [layouts[path], layouts[:all]].compact
-      denied = layouts[:deny].to_a
-
-      if layout = possible.first
-        if layout.to_s !~ /\A\// # late bind layout action to current controller
-          layout = R(controller, layout)
-        end
-        layout_action = Controller.resolve(layout)
-
-        return false if denied.any?{|deny| deny === path} or layout_action.path == path
-
-        if layout_action.controller != controller
-          instance.instance_variables.each do |x|
-            if layout_action.instance.instance_variable_defined?(x)
-              Log.warn "overwriting instance variable #{x} from layout controller with instance variable from action controller."
-            end
-            layout_action.instance.instance_variable_set(x, instance.instance_variable_get(x))
-          end
-        else
-          layout_action.binding = binding
-          layout_action.controller = controller
-          layout_action.instance = instance
-        end
-
-        layout_action.path = nil
-        layout_action
-      end
-    end
-
-    def actions_cached
-      controller.trait[:actions_cached]
-    end
-
-    # return true if the action is flagged for caching. Called by
-    # Action#render.
-
-    def should_cache?
-      ctrait = controller.trait
-
-      [ Global.cache_all,
-        ctrait[:cache_all],
-        actions_cached.map{|k,v| k.to_s}.include?(method),
-      ].any?
-    end
-  end
-end

data/lib/ramaze/action.rb

@@ -1,136 +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?(Action) # prevent problems for SourceReload
-
-    members = %w[method params template controller path binding engine instance]
-
-    # The Action holds information that is essential to render the action for a
-    # request.
-
-    class Action < Struct.new('Action', *members)
-    end
-  end
-
-  require 'ramaze/action/render'
-  require 'ramaze/helper/link'
-
-  class Action
-    include Helper::Link
-
-    class << self
-
-      # Instantiate with given Hash, takes both string/symbol keys.
-      # Only keys that match members of the Action-Struct are used.
-
-      def create(hash = {})
-        i = new
-        members.each do |key|
-          i.send("#{key}=", (hash[key] || hash[key.to_sym]))
-        end
-        i
-      end
-
-      # alias for stack.last, returns the instance of Action you are currently in.
-
-      def current
-        stack.last
-      end
-
-      def stack
-        Thread.current[:action_stack] ||= []
-      end
-    end
-
-    # nicer representation of the Action
-
-    def to_s
-      m, p, t = method.inspect, params.inspect, template.inspect
-      %{#<Action method=#{m}, params=#{p} template=#{t}>}
-    end
-
-    # Set the method, will be converted to a string and set to nil if empty.
-
-    def method=(meth)
-      meth = meth.to_s
-      self[:method] = (meth.empty? ? nil : meth)
-    end
-
-    # runs all parameters assigned through flatten and CGI::unescape
-
-    def params=(*par)
-      self[:params] = par.flatten.compact.map{|pa| CGI.unescape(pa.to_s)}
-    end
-
-    # Use this as key for caches.
-
-    def relaxed_hash
-      [controller, method, params, template, path].hash
-    end
-
-    # A Hash representation of Action
-
-    def to_hash
-      hash = {}
-      members.each{|m| hash[m.to_sym] = send(m)}
-      hash
-    end
-
-    # Determines based on controller.trait[:engine] and the template extensions
-    # which engine has to be used.
-    # Defaults to Template::Ezamar
-
-    def engine
-      return self[:engine] if self[:engine]
-      default = controller.trait.fetch(:engine, Template::Ezamar)
-      return default unless template
-
-      Template::ENGINES.sort_by{|v| v.join}.each do |(engine, exts)|
-        if template =~ /\.(#{Regexp.union(*exts)})$/
-          return self[:engine] = engine
-        end
-      end
-
-      self[:engine] = default
-    end
-
-    # Returns an instance of controller, will be cached on first access.
-
-    def instance
-      self[:instance] ||= controller.new
-    end
-
-    # Returns a binding of the instance, will be cached on first access.
-
-    def binding
-      self[:binding] ||= instance.instance_eval{ binding }
-    end
-
-    def name
-      File.basename((self[:method] || self[:template]).to_s).split('.').first
-    end
-
-    # combined path to current action, from path and params
-    def extended_path
-      @extended_path ||= Array[path, *params].join('/')
-    end
-
-    # Hook for AspectHelper
-
-    def before_process
-    end
-
-    # Hook for AspectHelper
-
-    def after_process
-    end
-  end
-
-  # Shortcut to create new instances of Action via Action::fill
-
-  def self.Action(hash = {})
-    Action.create(hash)
-  end
-end

data/lib/ramaze/adapter/base.rb

@@ -1,59 +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 Adapter
-
-    # This class is holding common behaviour for its subclasses.
-
-    class Base
-      class << self
-
-        # For the specified host and for all given ports call run_server and
-        # add the returned thread to the Global.adapters ThreadGroup.
-        # Afterwards adds a trap for the value of Global.shutdown_trap which
-        # calls Ramaze.shutdown when triggered (usually by SIGINT).
-
-        def start host, port
-          Global.server = run_server(host, port)
-          trap(Global.shutdown_trap){ Ramaze.shutdown }
-        end
-
-        # Does nothing
-
-        def stop
-          Log.debug("Stopping #{self.class}")
-        end
-
-        # This is called by Rack with the usual env, subsequently calls
-        # ::respond with it.
-        #
-        # The method itself acts just as a wrapper for benchmarking and then
-        # calls .finish on the current response after ::respond has finished.
-
-        def call(env)
-          returned = nil
-          if Global.benchmarking
-            time = Benchmark.measure{ returned = respond(env) }
-            Log.debug('request took %.5fs [~%.0f r/s]' % [time.real, 1.0/time.real])
-          else
-            returned = respond env
-          end
-          returned
-        end
-
-        # Initializes Request with env and an empty Response. Records the
-        # request into Ramaze::Record if Global.record is true.
-        # Then goes on and calls Dispatcher::handle with request and response.
-
-        def respond env
-          if Global.server == Thread.current
-            Thread.new{ Current.call(env) }.value
-          else
-            Current.call(env)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/adapter/cgi.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
-  Global.test_connections = false
-
-  module Adapter
-    # Our CGI adapter acts as wrapper for the Rack::Handler::CGI.
-    class Cgi < Base
-      class << self
-
-        # start CGI in a new thread, host and port parameter are only taken
-        # to make it compatible with other adapters but have no influence and
-        # can be omitted
-        def start host = nil, ports = nil
-          Thread.new do
-            Thread.current[:task] = :cgi
-            Rack::Handler::CGI.run(self)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/adapter/ebb.rb

@@ -1,32 +0,0 @@
-require 'ebb'
-
-module Ramaze
-  module Adapter
-    class Ebb < Base
-      class << self
-
-        # start server on given host and port.
-        def run_server host, port
-          server = ::Ebb::Server.new(self, :port => port)
-
-          thread = Thread.new{ server.start }
-          thread[:adapter] = server
-          thread
-        end
-      end
-    end
-  end
-
-  class Response
-    def finish(&block)
-      @block = block
-
-      if [201, 204, 304].include?(status.to_i)
-        header.delete "Content-Type"
-        [status.to_i, header.to_hash, '']
-      else
-        [status.to_i, header.to_hash, [body].flatten.join]
-      end
-    end
-  end
-end

data/lib/ramaze/adapter/evented_mongrel.rb

@@ -1,7 +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.
-
-Ramaze::Log.debug "Using Evented Mongrel"
-
-require 'swiftcore/evented_mongrel'
-require 'ramaze/adapter/mongrel'

data/lib/ramaze/adapter/fcgi.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
-  Global.test_connections = false
-
-  module Adapter
-    # Our Fcgi adapter acts as wrapper for the Rack::Handler::FastCGI.
-    class Fcgi < Base
-      class << self
-
-        # start FastCGI in a new thread, host and port parameter are only taken
-        # to make it compatible with other adapters but have no influence and
-        # can be omitted
-        def run_server host = nil, ports = nil
-          Thread.new do
-            Thread.current[:task] = :cgi
-            Rack::Handler::FastCGI.run(self)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/adapter/lsws.rb

@@ -1,23 +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
-  Global.test_connections = false
-
-  module Adapter
-    # Our Lsws adapter acts as wrapper for the Rack::Handler::LSWS.
-    class Lsws < Base
-      class << self
-
-        # start Lsws in a new thread, host and port parameter are only taken
-        # to make it compatible with other adapters but have no influence and
-        # can be omitted
-        def run_server host = nil, ports = nil
-          Thread.new do
-            Rack::Handler::LSWS.run(self)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/adapter/mongrel.rb

@@ -1,25 +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 'mongrel'
-require 'rack/handler/mongrel'
-
-module Ramaze
-  module Adapter
-
-    # Our Mongrel adapter acts as wrapper for the Rack::Handler::Mongrel.
-    class Mongrel < Base
-      class << self
-
-        # start server on given host and port.
-        def run_server host, port
-          server = ::Mongrel::HttpServer.new(host, port)
-          server.register('/', ::Rack::Handler::Mongrel.new(self))
-          thread = server.run
-          thread[:adapter] = server
-          thread
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/adapter/scgi.rb

@@ -1,22 +0,0 @@
-#          Copyright (c) 2008 Jeremy Evans  code@jeremyevans.net
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'rack/handler/scgi'
-
-module Ramaze
-  module Adapter
-    # Our Scgi adapter acts as wrapper for the Rack::Handler::SCGI.
-    class Scgi < Base
-      class << self
-
-        # start SCGI in a new thread
-        def run_server host, port
-          Thread.new do
-            Thread.current[:task] = :cgi
-            Rack::Handler::SCGI.run(self, :Host=>host, :Port=>port)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/adapter/swiftiplied_mongrel.rb

@@ -1,7 +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.
-
-Ramaze::Log.debug "Using Swiftiplied Mongrel"
-
-require 'swiftcore/swiftiplied_mongrel'
-require 'ramaze/adapter/mongrel'

data/lib/ramaze/adapter/thin.rb

@@ -1,22 +0,0 @@
-require 'thin'
-require 'rack/handler/thin'
-
-module Ramaze
-  module Adapter
-    class Thin < Base
-      class << self
-
-        # start server on given host and port.
-        def run_server host, port
-          server = ::Thin::Server.new(host, port, self)
-          ::Thin::Logging.silent = true
-          server.timeout = 3
-
-          thread = Thread.new{ server.start }
-          thread[:adapter] = server
-          thread
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/adapter/webrick.rb

@@ -1,52 +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 'webrick'
-require 'rack/handler/webrick'
-
-module Ramaze
-  module Adapter
-    # Our WEBrick adapter acts as wrapper for the Rack::Handler::WEBrick.
-    class WEBrick < Base
-      class << self
-
-        # start server on given host and port, see below for possible options.
-        def run_server host, port, options = {}
-          options = {
-            :Port        => port,
-            :BindAddress => host,
-            :Logger      => Log,
-            :AccessLog   => [
-              [Log, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
-              [Log, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]
-            ]
-          }.merge(options)
-
-
-          server = ::WEBrick::HTTPServer.new(options)
-          server.mount("/", ::Rack::Handler::WEBrick, self)
-          thread = Thread.new(server) do |adapter|
-            Thread.current[:adapter] = adapter
-            adapter.start
-          end
-        end
-      end
-    end
-  end
-end
-
-# Extending on WEBrick module
-module WEBrick
-
-  # Extending on HTTPServlet
-  module HTTPServlet
-
-    # Extending on ProcHandler
-    #
-    # We alias PUT to GET and DELETE to GET so WEBrick handles them as well.
-    class ProcHandler
-      alias do_PUT do_GET
-      alias do_DELETE do_GET
-    end
-  end
-end