ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/contrib/sequel_cache.rb

@@ -1,92 +0,0 @@
-#
-# drop-in replacement for Ramaze's built-in MemoryCache built on the Sequel.
-# to use with sessions do
-#
-#   Ramaze::Global::cache_alternative[:sessions] = Ramaze::SequelCache
-#
-# to use with everything do
-#
-#   Ramaze::Global::cache = Ramaze::SequelCache
-#
-
-class Ramaze::SequelCache
-  class Table < Sequel::Model(:ramaze_cache_t)
-    set_schema do
-      primary_key :id
-      string :key
-      string :value
-      index :key, :unique => true
-    end
-
-    ## use sequel's built-in serialize function if you like execptions: the
-    ## serialized data blows up the sql
-    ## serialize :value, :format => :marshal
-
-    transform :value => [
-      lambda{|value| Marshal.load(Base64.decode64(value))},
-      lambda{|value| Base64.encode64(Marshal.dump(value))},
-    ]
-  end
-
-  def table() Table end
-  def t() Table end
-
-  def self.[] key
-    record = Table.find :key => key
-    record ? record.value : nil
-  end
-
-  def self.[]= key, value
-    begin
-      Table.create :key => key, :value => value
-    rescue
-      Table.filter(:key => key).update :value => value
-      unless Table.find(:key => key)
-        Table.create :key => key, :value => value rescue nil
-      end
-    end
-    # ruby always returns 'value' for []= !
-  rescue
-    nil
-  end
-
-  def self.values_at *keys
-    keys.map{|key| Table[key]}
-  end
-
-  def self.delete *keys
-    keys.map do |key|
-      record = Table[key]
-      record.delete if record
-    end
-  end
-
-  def self.clear
-    Table.delete_all
-  end
-
-  def self.new
-    self
-  end
-
-  def self.to_sym
-    name.split(%r/::/).last.to_sym
-  end
-end
-
-
-
-
-if $0 == __FILE__
-  case ARGV.first
-    when /create|up/
-      Ramaze::SequelCache::Table.create_table!
-    when /drop|down/
-      Ramaze::SequelCache::Table.drop_table
-    else
-      abort "usage: ruby #{ __FILE__ } create/up | drop/down"
-  end
-else
-  Ramaze::SequelCache::Table.create_table! unless
-    Ramaze::SequelCache::Table.table_exists?
-end

data/lib/ramaze/contrib.rb

@@ -1,82 +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
-
-  # Loads and sets up contrib modules.
-  #
-  # For more information @see Ramaze::Contrib.load
-  #
-  # Usage:
-  #
-  #   Ramaze.contrib :gzip_filter
-
-  def self.contrib(*args)
-    Contrib.load *args
-  end
-
-  # A module used for loading contrib modules.
-
-  module Contrib
-
-    # Loads and sets up contrib modules from /ramaze/contrib.
-    #
-    # === Usage:
-    #
-    #   Ramaze::Contrib.load :gzip_filter
-    #
-    # === Creating a contrib module:
-    #
-    #   module Ramaze::Contrib::Test
-    #     def self.setup
-    #       Log.info "Test module set up"
-    #     end
-    #   end
-    #   class TestController < Ramaze::Controller
-    #     map '/test'
-    #     def index; "Chunky Bacon!"; end
-    #   end
-    #
-    #   # Save that to your <app dir>/contrib and use like:
-    #   Ramaze.contrib :test
-
-    def self.load(*contribs)
-      contribs.each do |name|
-        mod_name = name.to_s.camel_case
-        begin
-          const = Contrib.const_get(mod_name)
-          Global.contribs << const
-          const.startup if const.respond_to?(:startup)
-          Log.dev "Loaded contrib: #{const}"
-        rescue NameError
-          files = Dir["{contrib,#{BASEDIR/:ramaze/:contrib}}/#{name}.{so,bundle,rb}"]
-          raise LoadError, "#{mod_name} not found" unless files.any?
-          require(files.first) ? retry : raise
-        end
-      end
-    end
-
-    # Will call .shutdown on all contrib modules which support it.
-    #---
-    # .shudown gets called by Ramaze :essentials.
-    #+++
-
-    def self.shutdown
-      Global.contribs.each do |contrib|
-        contrib.shutdown if contrib.respond_to?(:shutdown)
-      end
-    end
-
-    # Will load all contrib modules from options[:contrib]
-    #---
-    # .startup gets called by Ramaze :essentials.
-    #+++
-
-    def self.startup(options = {})
-      return unless options[:contrib]
-      [options[:contrib]].flatten.each do |contrib|
-        load(contrib)
-      end
-    end
-  end # class Contrib
-end # class Ramaze

data/lib/ramaze/controller/error.rb

@@ -1,46 +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 Controller
-    # The default error-page handler. you can overwrite this method
-    # in your controller and create your own error-template for use.
-    #
-    # Error-pages can be in whatever the templating-engine of your controller
-    # is set to.
-    #   Ramaze::Dispatcher::Error.current
-    # holds the exception thrown.
-
-    def error
-      error = Dispatcher::Error.current
-      title = error.message
-
-      unless Action.current.template
-        response['Content-Type'] = 'text/plain'
-        respond %(
-          #{error.message}
-            #{error.backtrace.join("\n            ")}
-
-          #{PP.pp request, '', 200}
-        ).ui
-      end
-
-      backtrace_size = Global.backtrace_size
-      @backtrace = error.backtrace[0..20].map do |line|
-        file, lineno, meth = *Ramaze.parse_backtrace(line)
-        lines = Ramaze.caller_lines(file, lineno, backtrace_size)
-
-        [ lines, lines.object_id.abs, file, lineno, meth ]
-      end
-
-      # for backwards-compat with old error.zmr
-      @colors = [255] * @backtrace.size
-
-      @title = ::CGI.escapeHTML(title)
-      @editor = (ENV['EDITOR'] || 'vim')
-      title
-    rescue Object => ex
-      Log.error(ex)
-    end
-  end
-end

data/lib/ramaze/controller/main.rb

@@ -1,2 +0,0 @@
-class MainController < Ramaze::Controller
-end

data/lib/ramaze/controller/resolve.rb

@@ -1,234 +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 Controller
-    FILTER = [ :cached, :default ] unless defined?(FILTER)
-
-    class << self
-
-      # Resolve an absolute path in the application by passing it to each
-      # element of Ramaze::Controller::FILTER.
-      # If an element does not respond to call it will be sent to self
-      # instead, in either case with path as argument.
-
-      def resolve(path, routed = false)
-        @routed = routed
-
-        FILTER.each do |filter|
-          answer = if filter.respond_to?(:call)
-                     filter.call(path)
-                   else
-                     send(filter.to_s, path)
-                   end
-          return answer if answer
-        end
-
-        raise_no_filter(path)
-      end
-
-      # Default element of FILTER.
-      # Looks up the path in Cache.resolved and returns it if found.
-
-      def cached(path)
-        if found = Cache.resolved[path]
-          if found.respond_to?(:relaxed_hash)
-            return found.dup
-          else
-            Log.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
-            Cache.resolved.delete path
-          end
-        end
-
-        nil
-      end
-
-      # Default element of FILTER.
-      # The default handler that tries to find the best match for the given
-      # path in terms of Controller/method/template and given arguments.
-      # If a match is found it will be cached for further use.
-
-      def default(path)
-        mapping     = Global.mapping
-        controllers = Global.controllers
-
-        raise_no_controller(path) if controllers.empty? or mapping.empty?
-
-        patterns = Cache.patterns[path] ||= pattern_for(path)
-        first_controller = nil
-
-        patterns.each do |controller, method, params|
-          if controller = mapping[controller]
-            first_controller ||= controller
-
-            action = controller.resolve_action(method, *params)
-            template = action.template
-
-            valid_action =
-              if Action.stack.size > 0 || Global.actionless_templates
-                action.method or (params.empty? && template)
-              else
-                action.method
-              end
-
-            if valid_action
-              Cache.resolved[path] = action
-              return action.dup
-            end
-          end
-        end
-
-        if !@routed and new_path = Route.resolve(path)
-          Log.dev("Routing from `#{path}' to `#{new_path}'")
-          return resolve(new_path, true)
-        end
-
-        raise_no_action(first_controller, path) if first_controller
-        raise_no_controller(path)
-      end
-
-      # Try to produce an Action from the given path and paremters with the
-      # appropiate template if one exists.
-
-      def resolve_action(path, *parameter)
-        path, parameter = path.to_s, parameter.map{|e| e.to_s}
-        if info = trait["#{path}_template"]
-          template = info[:file]
-          unless template
-            controller, action = info.values_at :controller, :action
-            template = controller.resolve_template(action)
-          end
-        end
-
-        method, params = resolve_method(path, *parameter)
-
-        if method or parameter.empty?
-          template ||= resolve_template(path)
-        end
-
-        Action.create :path       => path,
-                      :method     => method,
-                      :params     => params,
-                      :template   => template,
-                      :controller => self
-      end
-
-      # Search the #template_paths for a fitting template for path.
-      # Only the first found possibility for the generated glob is returned.
-
-      def resolve_template(path)
-        path = path.to_s
-        path_converted = path.split('__').inject{|s,v| s/v}
-        possible_paths = [path, path_converted].compact
-
-        paths = template_paths.map{|pa| possible_paths.map{|a| pa/a } }.flatten.uniq
-        glob = "{#{paths.join(',')}}.{#{extension_order.join(',')}}"
-
-        Dir[glob].first
-      end
-
-      # Composes an array with the template-paths to look up in the right order.
-      # Usually this is composed of Global.template_root and the mapping of the
-      # controller.
-
-      def template_paths
-        if paths = template_root
-          paths
-        else
-          template_root(Global.template_root / Global.mapping.invert[self])
-        end
-      end
-
-      # Based on methodname and arity, tries to find the right method on current controller.
-      def resolve_method(name, *params)
-        if method = [ name, name.gsub('__','/') ].find{|n|
-          cached_action_methods.include?(n) }
-          arity = instance_method(method).arity
-          if params.size == arity or arity < 0
-            return method, params
-          end
-        end
-        return nil, []
-      end
-
-      def cached_action_methods
-        Cache.action_methods[self] ||= action_methods
-      end
-
-      # methodnames that may be used for current controller.
-      def action_methods
-        ancs = ancestors.select{|ancestor|
-          ancestor <= Ramaze::Controller
-        } + Helper::LOOKUP.to_a
-
-        ancs.reverse.inject [] do |meths, anc|
-          meths +
-            anc.public_instance_methods(false).map{|im| im.to_s } -
-            anc.private_instance_methods(false).map{|im| im.to_s }
-        end
-      end
-
-      # Generate all possible permutations for given path.
-      def pattern_for(path)
-        atoms = path.to_s.split('/').grep(/\S/)
-        atoms.unshift('')
-        patterns, joiner = [], '/'
-
-        atoms.size.times do |enum|
-          enum += 1
-          pattern = atoms.dup
-
-          controller = pattern[0, enum].join(joiner)
-          controller.gsub!(/^__/, '/')
-          controller = "/" if controller == ""
-
-          pattern = pattern[enum..-1]
-          args, temp = [], []
-
-          patterns << [controller, 'index', atoms[enum..-1]]
-
-          until pattern.empty?
-            args << pattern.shift
-            joined = args.join('__')
-            patterns << [controller, joined, pattern.dup]
-            patterns << [controller, "#{joined}__index", pattern.dup]
-          end
-        end
-
-        patterns.reverse!
-      end
-
-      # Uses custom defined engines and all available engines and throws it
-      # against the extensions for the template to find the most likely
-      # templating-engine to use ordered by priority and likelyhood.
-      def extension_order
-        t_extensions = Template::ENGINES
-        all_extensions = t_extensions.values.flatten
-
-        if engine = trait[:engine]
-          c_extensions = t_extensions.select{|k,v| k == engine}.map{|k,v| v}.flatten
-          return (c_extensions + all_extensions).uniq
-        end
-
-        all_extensions
-      end
-
-      def raise_no_filter(path)
-        raise Ramaze::Error::NoFilter, "No Filter found for `#{path}'"
-      end
-
-      # Raises Ramaze::Error::NoController
-
-      def raise_no_controller(path)
-        raise Ramaze::Error::NoController, "No Controller found for `#{path}'"
-      end
-
-      # Raises Ramaze::Error::NoAction
-
-      def raise_no_action(controller, path)
-        Thread.current[:controller] = controller
-        raise Ramaze::Error::NoAction, "No Action found for `#{path}' on #{controller}"
-      end
-    end
-  end
-end

data/lib/ramaze/current/request.rb

@@ -1,181 +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 'rack/request'
-
-module Ramaze
-
-  # The purpose of this class is to act as a simple wrapper for Rack::Request
-  # and provide some convinient methods for our own use.
-
-  class Request < ::Rack::Request
-    class << self
-
-      # get the current request out of Thread.current[:request]
-      #
-      # You can call this from everywhere with Ramaze::Request.current
-
-      def current() Current.request end
-    end
-
-    # you can access the original @request via this method_missing,
-    # first it tries to match your method with any of the HTTP parameters
-    # then, in case that fails, it will relay to @request
-
-    def method_missing meth, *args
-      key = meth.to_s.upcase
-      return env[key] if env.has_key?(key)
-      super
-    end
-
-    def request_uri
-      env['REQUEST_URI'] || path_info
-    end
-
-    def ip
-      env['HTTP_X_FORWARDED_FOR'] || env['REMOTE_ADDR']
-    end
-
-    # Request is from a local network?
-    # Checks both IPv4 and IPv6
-
-    ipv4 = %w[ 127.0.0.1/32 192.168.0.0/16 172.16.0.0/12 10.0.0.0/8 169.254.0.0/16 ]
-    ipv6 = %w[ fc00::/7 fe80::/10 fec0::/10 ::1 ]
-    LOCAL = (ipv4 + ipv6).map{|a| IPAddr.new(a)} unless defined?(LOCAL)
-
-    # --
-    # Mongrel somehow puts together multiple IPs when proxy is involved.
-    # ++
-
-    def local_net?(address = ip)
-      address = address.to_s.split(',').first
-      addr = IPAddr.new(address)
-      LOCAL.find{|range| range.include?(addr) }
-    rescue ArgumentError => ex
-      raise ArgumentError, ex unless ex.message == 'invalid address'
-    end
-
-    def [](key, *rest)
-      value = params[key.to_s]
-      return value if rest.empty?
-      keys = rest.flatten.map{|k| k.to_s}
-      Array[value, *params.values_at(*keys)]
-    end
-
-    def to_ivs(*args)
-      instance = Action.current.instance
-      args.each do |arg|
-        next unless value = self[arg]
-        instance.instance_variable_set("@#{arg}", value)
-      end
-    end
-
-    unless method_defined?(:rack_params)
-      alias rack_params params
-
-      # Wrapping Request#params to support a one-level hash notation.
-      # It doesn't support anything really fancy, so be conservative in its use.
-      #
-      # See if following provides something useful for us:
-      # http://redhanded.hobix.com/2006/01/25.html
-      #
-      # Example Usage:
-      #
-      #  # Template:
-      #
-      #  <form action="/paste">
-      #    <input type="text" name="paste[name]" />
-      #    <input type="text" name="paste[syntax]" />
-      #    <input type="submit" />
-      #  </form>
-      #
-      #  # In your Controller:
-      #
-      #  def paste
-      #    name, syntax = request['paste'].values_at('name', 'syntax')
-      #    paste = Paste.create_with(:name => name, :syntax => syntax)
-      #    redirect '/'
-      #  end
-      #
-      #  # Or, easier:
-      #
-      #  def paste
-      #    paste = Paste.create_with(request['paste'])
-      #    redirect '/'
-      #  end
-
-      def params
-        return {} if put?
-        return @ramaze_params if @ramaze_params
-        @rack_params ||= rack_params
-        @ramaze_params = {}
-
-        @rack_params.each do |key, value|
-          if key =~ /^(.*?)(\[.*\])/
-            prim, nested = $~.captures
-            ref = @ramaze_params
-
-            keys = nested.scan(/\[([^\]]+)\]/).flatten
-            keys.unshift prim
-
-            keys.each_with_index do |k, i|
-              if i + 1 >= keys.size
-                ref[k] = value
-              else
-                ref = ref[k] ||= {}
-              end
-            end
-          else
-            @ramaze_params[key] = value
-          end
-        end
-
-        @ramaze_params
-      end
-    end
-
-    # Interesting HTTP variables from env
-
-    def http_vars
-      env.reject{ |k,v|
-        k.to_s !~ /USER|HOST|REQUEST|REMOTE|FORWARD|REFER|PATH|QUERY|VERSION|KEEP|CACHE/
-      }
-    end
-
-    def to_s
-      p, c, e = params.inspect, cookies.inspect, http_vars.inspect
-      %{#<Ramaze::Request params=#{p} cookies=#{c} env=#{e}>}
-    end
-    alias inspect to_s
-
-    def pretty_print pp
-      p, c, e = params, cookies, http_vars
-      pp.object_group(self){
-        { 'params' => params,
-          'cookies' => cookies,
-          'env' => http_vars }.each do |name, hash|
-          pp.breakable
-          pp.text " @#{name}="
-          pp.nest(name.length+3){ pp.pp_hash hash }
-        end
-      }
-    end
-
-    # Answers with a subset of request.params with only the key/value pairs for
-    # which you pass the keys.
-    # Valid keys are objects that respond to :to_s
-    #
-    # Example:
-    #   request.params
-    #   # => {'name' => 'jason', 'age' => '45', 'job' => 'lumberjack'}
-    #   request.sub('name')
-    #   # => {'name' => 'jason'}
-    #   request.sub(:name, :job)
-    #   # => {'name' => 'jason', 'job' => 'lumberjack'}
-
-    def subset(*keys)
-      keys = keys.map{|k| k.to_s }
-      params.reject{|k,v| not keys.include?(k) }
-    end
-  end
-end

data/lib/ramaze/current/response.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
-  class Response < Rack::Response
-    class << self
-      def current() Current.response end
-    end
-
-    def build(body = body, status = status, header = header)
-      header.each do |key, value|
-        self[key] = value
-      end
-
-      self.body, self.status = body, status
-      self
-    end
-  end
-end