clivecrous-ramaze 0.3.9.5

data/lib/ramaze/contrib/gettext/po.rb

@@ -0,0 +1,109 @@
+#! /usr/bin/env ruby
+=begin
+  rgettext.rb - Generate a .pot file.
+
+  Copyright (C) 2003-2006  Masao Mutoh
+  Copyright (C) 2001,2002  Yasushi Shoji, Masao Mutoh
+
+      Yasushi Shoji   <yashi at atmark-techno.com>
+      Masao Mutoh     <mutoh at highway.ne.jp>
+
+  You may redistribute it and/or modify it under the same
+  license terms as Ruby.
+=end
+
+
+module GetText
+
+  module RGetText #:nodoc:
+    extend GetText
+
+    MAX_LINE_LEN = 70 unless defined?(MAX_LINE_LEN)
+
+    module_function
+
+    def generate_pot_header # :nodoc:
+      time = Time.now.strftime("%Y-%m-%d %H:%M")
+      off = Time.now.utc_offset
+      sign = off <= 0 ? '-' : '+'
+      time += sprintf('%s%02d%02d', sign, *(off.abs / 60).divmod(60))
+
+      <<EOS
+# SOME DESCRIPTIVE TITLE.
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
+# This file is distributed under the same license as the PACKAGE package.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#
+#, fuzzy
+msgid ""
+msgstr ""
+"Project-Id-Version: PACKAGE VERSION\\n"
+"POT-Creation-Date: #{time}\\n"
+"PO-Revision-Date: #{time}\\n"
+"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
+"Language-Team: LANGUAGE <LL@li.org>\\n"
+"MIME-Version: 1.0\\n"
+"Content-Type: text/plain; charset=UTF-8\\n"
+"Content-Transfer-Encoding: 8bit\\n"
+EOS
+    end
+
+    def generate_pot(ary) # :nodoc:
+      str = ""
+      result = Array.new
+      ary.each do |key|
+	      msgid = key.shift.dup
+	      curr_pos = MAX_LINE_LEN
+	      key.each do |e|
+	        if curr_pos + e.size > MAX_LINE_LEN
+	          str << "\n#:"
+	          curr_pos = 3
+	        else
+	          curr_pos += (e.size + 1)
+	        end
+	        str << " " << e
+      	end
+      	msgid.gsub!(/"/, '\"')
+      	msgid.gsub!(/\r/, '')
+
+      	str << "\nmsgid \"" << msgid << "\"\n"
+    	  str << "msgstr \"\"\n"
+      end
+      str
+    end
+
+    def generate_translated_po(hash)
+      str = generate_pot_header
+      result = Array.new
+
+      hash.keys.sort.each do |msgid|
+        msgid = msgid.dup
+        msgstr = hash[msgid]
+
+        msgid.gsub!(/"/, '\"')
+      	msgid.gsub!(/\r/, '')
+
+      	if msgstr
+      	  msgstr.gsub!(/"/, '\"')
+        	msgstr.gsub!(/\r/, '')
+      	end
+
+      	str << "\nmsgid \"" << msgid << "\"\n"
+    	  str << "msgstr \"" << msgstr << "\"\n"
+      end
+
+      str
+    end
+
+    def generate(array)  # :nodoc:
+      str = ''
+      str << generate_pot_header
+      str << generate_pot(array)
+    end
+  end
+end
+
+if $0 == __FILE__
+  require 'yaml'
+  puts GetText::RGetText.generate_translated_po(YAML.load_file(ARGV[0]))
+end

data/lib/ramaze/contrib/gzip_filter.rb

@@ -0,0 +1,56 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# gzip_filter.rb
+#
+# Use this to compress "large" pages with gzip.  All major browsers support gzipped pages.
+# This filter brought to you by your friends in #ramaze: Pistos, manveru, rikur and Kashia.
+#
+# Usage, in start.rb:
+#
+#   require 'ramaze/contrib/gzip_filter'
+#   Ramaze::Dispatcher::Action::FILTER << Ramaze::Filter::Gzip
+
+require 'zlib'
+
+module Ramaze
+  module Filter
+    class Gzip
+
+      trait :enabled => true
+      trait :threshold => 32768 # bytes
+
+      class << self
+
+        include Ramaze::Trinity
+
+        # Enables being plugged into Dispatcher::Action::FILTER
+
+        def call( response, options = {} )
+          return response if not trait[ :enabled ]
+          return response if response.body.nil?
+          return response if response.body.respond_to?( :read )
+
+          accepts = request.env[ 'HTTP_ACCEPT_ENCODING' ]
+          return response if accepts.nil? || ( accepts !~ /(x-gzip|gzip)/ )
+
+          if response.content_type == 'text/html' && response.body.size > trait[ :threshold ]
+            output = StringIO.new
+            def output.close
+              # Zlib closes the file handle, so we want to circumvent this
+              rewind
+            end
+            gz = Zlib::GzipWriter.new( output )
+            gz.write( response.body )
+            gz.close
+
+            response.body = output.string
+            response.header[ 'Content-encoding' ] = 'gzip'
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/profiling.rb

@@ -0,0 +1,36 @@
+require "ruby-prof"
+
+module Ramaze
+  module Dispatcher
+    class ActionProfiler < Action
+      def self.call(path)
+        if RubyProf.running?
+          super
+        else
+          result = RubyProf.profile { super }
+          output = StringIO.new
+          printer = RubyProf::FlatPrinter.new(result)
+          options = {
+            :min_percent => Contrib::Profiling.trait[:min_percent],
+            :print_file => false
+          }
+          printer.print(output, options)
+          output.string.split("\n").each do |line|
+            Log.info(line)
+          end
+        end
+      end
+    end
+  end
+
+  module Contrib
+    class Profiling
+      trait :min_percent => 1
+
+      def self.startup
+        Dispatcher::FILTER.delete(Dispatcher::Action)
+        Dispatcher::FILTER << Dispatcher::ActionProfiler
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/rest.rb

@@ -0,0 +1,14 @@
+Ramaze::Route['REST dispatch'] = lambda{|path, request|
+  case request.request_method
+  when 'GET'
+    path << 'show/'
+  when 'POST'
+    path << 'create/'
+  when 'PUT'
+    path << 'update/'
+  when 'DELETE'
+    path << 'destroy/'
+  else
+    path
+  end
+}

data/lib/ramaze/contrib/sequel/fill.rb

@@ -0,0 +1,12 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Sequel
+  class Model
+    class << self
+      def fill request_object = Ramaze::Request.current
+        create(request_object.params)
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/sequel_cache.rb

@@ -0,0 +1,92 @@
+#
+# 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/controller.rb

@@ -0,0 +1,281 @@
+#          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/helper'
+require 'ramaze/template'
+require 'ramaze/action'
+
+require 'ramaze/controller/resolve'
+require 'ramaze/controller/error'
+
+module Ramaze
+
+  # The Controller is responsible for combining and rendering actions.
+
+  class Controller
+    include Helper::Methods
+
+    helper :redirect, :link, :sendfile, :flash, :cgi, :partial
+
+    # Whether or not to map this controller on startup automatically
+
+    trait[:automap] ||= true
+
+    # Place to map the Controller to, this is something like '/' or '/foo'
+
+    trait[:map] ||= nil
+
+    # Caches patterns for the given path.
+
+    trait :pattern_cache => Hash.new{|h,k| h[k] = Controller.pattern_for(k) }
+
+    class << self
+      # When Controller is subclassed the resulting class is placed in
+      # Global.controllers and a new trait :actions_cached is set on it.
+
+      def inherited controller
+        controller.trait :actions_cached => {}
+        Global.controllers << controller
+        if map = controller.mapping
+          Log.dev("mapping #{map} => #{controller}")
+          Global.mapping[map] ||= controller
+        end
+      end
+
+      # called from Ramaze.startup, adds Cache.actions and Cache.patterns, walks
+      # all controllers subclassed so far and adds them to the Global.mapping if
+      # they are not assigned yet.
+
+      def startup options = {}
+        Log.dev("found Controllers: #{Global.controllers.inspect}")
+
+        check_path("Public root: '%s' doesn't exist", Global.public_root)
+        check_path("View root: '%s' doesn't exist", Global.view_root)
+
+        require 'ramaze/controller/main' if Global.mapping.empty?
+
+        Log.debug("mapped Controllers: #{Global.mapping.inspect}")
+      end
+
+      # checks paths for existance and logs a warning if it doesn't exist yet.
+
+      def check_path(message, *paths)
+        paths.each do |path|
+          Log.warn(message % path) unless File.directory?(path)
+        end
+      end
+
+      # if trait[:automap] is set and controller is not in Global.mapping yet
+      # this will build a new default mapping-point, MainController is put
+      # at '/' by default.
+
+      def mapping
+        global_mapping = Global.mapping.invert[self]
+        return global_mapping if global_mapping
+        if ancestral_trait[:automap] && self.to_s !~ /#<Class:/
+          name = self.to_s.gsub('Controller', '').gsub('::', '/').clone
+          name == 'Main' ? '/' : "/#{name.snake_case}"
+        end
+      end
+
+      # Map Controller to the given syms or strings.
+      # Replaces old mappings.
+      # If you want to _add_ a mapping, just modify Global.mapping.
+
+      def map(*syms)
+        Global.mapping.delete_if{|k,v| v == self}
+
+        syms.each do |sym|
+          Global.mapping[sym.to_s] = self
+        end
+      end
+
+      # Returns the Controller at a mapped path.
+
+      def at(mapping)
+        Global.mapping[mapping.to_s]
+      end
+
+      # Define a layout for all actions on this controller
+      #
+      # Example:
+      #   class Foo < Ramaze::Controller
+      #     layout :foo
+      #   end
+      #
+      #  This defines the action :foo to be layout of the controller and will
+      #  render the layout after any other action has been rendered, assigns
+      #  @content to the result of the action and then goes on rendering
+      #  the layout-action where @content may or may not be used, returning
+      #  whatever the layout returns.
+
+      def layout(*meth_or_hash)
+        if meth_or_hash.empty?
+          trait[:layout] ||= ( ancestral_trait[:layout] || {:all => nil, :deny => Set.new} ).dup
+        else
+          meth_or_hash = meth_or_hash.first
+          if meth_or_hash.respond_to?(:to_hash)
+            meth_or_hash.each do |layout_name, *actions|
+              actions.flatten.each do |action|
+                layout[action.to_s] = layout_name
+              end
+            end
+          else
+            layout[:all] = meth_or_hash
+          end
+        end
+      end
+
+      # Deny layout for passed names of actions.
+      # Name should be name of the method or template without extension, as
+      # String or Symbol
+      #
+      # Usage:
+      #   class MainController < Ramaze::Controller
+      #     deny_layout :atom
+      #
+      #     def atom
+      #       "I won't have layout"
+      #     end
+      #   end
+
+      def deny_layout(*actions)
+        actions.each do |action|
+          layout[:deny] << action.to_s
+        end
+      end
+
+      # Define a view_root for Controller, returns the current view_root
+      # if no argument is given.
+      # Runs every given path through Controller::check_path
+
+      def view_root *args
+        if args.empty?
+          @view_root
+        else
+          check_path("#{self}.view_root: '%s' doesn't exist", *args)
+          @view_root = args.flatten
+        end
+      end
+
+      def template_root(*args)
+        Ramaze.deprecated("Controller::template_root", "Controller::view_root")
+        view_root(*args)
+      end
+
+      # This is used for template rerouting, takes action, optionally a
+      # controller and action to route to.
+      #
+      # Usage:
+      #   class MainController
+      #     template :index, OtherController, :list
+      #     template :foo, :bar
+      #     template :bar, :file => '/absolute/path'
+      #     template :baz, :file => 'relative/path'
+      #     template :abc, :controller => OtherController
+      #     template :xyz, :controller => OtherController, :action => 'list'
+      #
+      #     def index
+      #       'will use template from OtherController#list'
+      #     end
+      #
+      #     def foo
+      #       'will use template from self#bar'
+      #     end
+      #
+      #     def bar
+      #       'will use template from /absolute/path'
+      #     end
+      #
+      #     def baz
+      #       'will use template from relative/path'
+      #     end
+      #
+      #     def abc
+      #       'will use template from OtherController#index'
+      #     end
+      #
+      #     def xyz
+      #       'will use template from OtherController#list'
+      #     end
+      #   end
+
+      def template(this, *argv)
+        case argv.first
+          when Hash
+            options, *ignored = argv
+            controller = options[:controller] || options['controller']
+            action = options[:action] || options['action']
+            file = options[:file] || options['file']
+            info = {}
+            if file
+              file = file.to_s
+              unless Pathname(file).absolute?
+                root = [view_root || Global.view_root].flatten.first
+                file = File.join(root, file)
+              end
+              info[:file] = file
+            else
+              controller ||= self
+              action = (action || 'index').to_s
+              info[:controller] = controller
+              info[:action] = action
+            end
+            trait "#{this}_template" => info
+          else
+            controller, action, *ignored = argv
+            controller, action = self, controller unless action
+            trait "#{this}_template" => {:controller => controller, :action => action}
+        end
+      end
+
+      # This is a method to specify the templating engine for your controller.
+      # It basically just is sugar for:
+      #   trait :engine => Haml
+      #
+      # Usage:
+      #   class MainController < Ramaze::Controller
+      #     engine :Haml
+      #   end
+
+      def engine(name)
+        name = Template.const_get(name)
+      rescue NameError => ex
+        Log.warn ex
+        Log.warn "Try to use passed engine directly"
+      ensure
+        trait :engine => name
+      end
+
+      # Return Controller of current Action
+
+      def current
+        action = Action.current
+        action.instance || action.controller
+      end
+
+      # Entering point for Dispatcher, first Controller::resolve(path) and then
+      # renders the resulting Action.
+
+      def handle path
+        action = resolve(path)
+        Thread.current[:controller] = action.controller
+        action.render
+      end
+
+      def relevant_ancestors(parent = Ramaze::Controller)
+        ancestors.select do |anc|
+          anc.ancestors.include?(parent)
+        end
+      end
+    end
+
+    private
+
+    # Simplistic render, rerouting to Controller.handle(*args)
+
+    def render *args
+      self.class.handle(*args)
+    end
+  end
+end