Pistos-ramaze 2008.09

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

@@ -0,0 +1,46 @@
+# suppress load warning message
+verbose = $VERBOSE
+$VERBOSE = nil
+require 'gettext/rgettext'
+$VERBOSE = verbose
+
+module Ramaze::Tool::Gettext::Parser
+  module_function
+
+  TARGETS = Ramaze::Template::ENGINES.values.inject([]) do |exts, list|
+    list += exts
+  end
+
+  def target?(file)
+    TARGETS.include?(File.extname(file)[1..-1])
+  end
+
+  def parse(file, ary)
+    regex = Ramaze::Tool::Gettext.trait[:regex]
+    body = File.read(file)
+    body.gsub!(regex) do
+      msg = $1
+      unless msg.to_s.empty?
+        line_number = body[0..(body.index(msg))].split("\n").size
+        add_message(ary, msg, file, line_number)
+      end
+    end
+    return ary
+  end
+
+  def add_message(ary, msg, file, line_number)
+    loc = message_location(file, line_number)
+    if value = ary.assoc(msg)
+      value << loc
+    else
+      ary << [msg, loc]
+    end
+    return ary
+  end
+
+  def message_location(file, line_number)
+    file + ":line" + line_number.to_s
+  end
+end
+
+GetText::RGetText.add_parser(Ramaze::Tool::Gettext::Parser)

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/gettext.rb

@@ -0,0 +1,113 @@
+#          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/tool/localize'
+require 'ramaze/contrib/gettext/mo'
+require 'ramaze/contrib/gettext/po'
+
+# Gettext helps transforming arbitrary text into localized forms using
+# a simple regular expression and substituting occurences with translations
+# stored in .mo files.
+#
+# == MO generation
+#
+# See http://www.gnu.org/software/gettext/ for a general overview over
+# Gettext.  Generally it's easier to use a graphical translator like Poedit.
+#
+# The default language is en, a .po template file will be saved by default
+# under `conf/locale_en.mo.pot`.  Individual languages are by default looked
+# up at `conf/locale_fi.mo` for localization.
+#
+# == Usage:
+#
+#   Ramaze::Dispatcher::Action::FILTER << Ramaze::Tool::Gettext
+
+module Ramaze
+  class Tool::Gettext < Tool::Localize
+
+    # Enable Localization
+    trait :enable => true
+
+    # Default language that is used if the browser don't suggests otherwise or
+    # the language requested is not available.
+    trait :default_language => 'en'
+
+    # languages supported
+    trait :languages => %w[ en ]
+
+    # YAML files the localizations are saved to and loaded from, %s is
+    # substituted by the values from trait[:languages]
+    trait :file => 'conf/locale_%s.mo'.freeze
+
+    # The pattern that is substituted with the translation of the current locale.
+    trait :regex => /\[\[(.*?)\]\]/
+
+    # Browsers may send different keys for the same language, this allows you to
+    # do some coercion between what you use as keys and what the browser sends.
+    trait :mapping => { 'en-us' => 'en', 'ja' => 'jp'}
+
+    # When this is set to false, it will not save newly collected translatable
+    # strings to disk.  Disable this for production use, as it slows the
+    # application down.
+    trait :collect => true
+
+
+    # Load given locales from disk and save it into the dictionary.
+
+    def self.load(*locales)
+      Log.debug "loading locales: #{locales.inspect}"
+
+      dict = trait[:dictionary] || {}
+
+      locales.each do |locale|
+        begin
+          dict[locale] = ::MOFile.open(trait[:file] % locale)
+        rescue Errno::ENOENT
+          Log.error "couldn't load #{trait[:file] % locale}"
+          dict[locale] = {}
+        end
+      end
+
+      trait[:dictionary] = dict
+    end
+
+    # Reloads given locales from the disk to refresh the dictionary.
+
+    def self.update
+      trait[:dictionary] = nil
+      dictionary.each do |locale, dict|
+        if dict.kind_of?(MOFile)
+          Log.debug("Reloading #{dict.filename}")
+          dict.update!
+        end
+      end
+    end
+
+    # Stores given locales from the dictionary to disk.
+
+    def self.store(*locales)
+      keys = []
+      dictionary.each do |locale, dict|
+        keys.concat dict.keys
+      end
+      keys.delete ""
+
+      data = ::GetText::RGetText.generate(keys.compact.uniq.sort.map {|x| [x] })
+      file = (trait[:file] % trait[:default_language]) + '.pot'
+      File.open(file, File::CREAT|File::TRUNC|File::WRONLY) do |fd|
+        fd.write data
+      end
+    rescue Errno::ENOENT => e
+      Log.error e
+    end
+  end
+end
+
+class Ramaze::Contrib::Gettext
+
+  # Called by Ramaze::Contrib.load, adds Gettext to Action::Filter
+
+  def self.startup
+    Ramaze::Dispatcher::Action::FILTER << Ramaze::Tool::Gettext
+  end
+end

data/lib/ramaze/contrib/gzip_filter.rb

@@ -0,0 +1,69 @@
+#          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
+#
+# Setting options (at any point in your code):
+#
+#   Ramaze::Filter::Gzip.trait(
+#     :threshold    => 1024,
+#     :content_type => /^text\/.+/
+#   )
+
+require 'zlib'
+
+module Ramaze
+  module Filter
+    class Gzip
+
+      trait :enabled => true,
+            :content_type => /^text\/.+/,
+            :threshold => 32768 # bytes
+
+      class << self
+
+        include Ramaze::Trinity
+
+        # Enables being plugged into Dispatcher::Action::FILTER
+
+        def call( response, options = {} )
+          return response unless trait[ :enabled ]
+          return response unless body = response.body
+          return response if body.respond_to?( :read )
+
+          accepts = request.env[ 'HTTP_ACCEPT_ENCODING' ]
+          return response if accepts.nil? || ( accepts !~ /(x-gzip|gzip)/ )
+
+          acceptable_size = body.size >= trait[ :threshold ]
+          acceptable_type = response.content_type =~ trait[:content_type]
+
+          if acceptable_type and acceptable_size
+            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( body )
+            gz.close
+
+            response.body = output.string
+            response.header[ 'Content-encoding' ] = 'gzip'
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/maruku_uv.rb

@@ -0,0 +1,59 @@
+# A hack to make MaRuKu use UltraViolet for highlighting
+# To specify the style to use use for example:
+#     uv_style: amy
+#     html_use_syntax: true
+#     code_lang: ruby
+# In the document header area.
+
+require 'maruku'
+
+module MaRuKu
+  module Out
+    module HTML
+      def uv_highlight(source, lang, style)
+        require 'uv'
+
+        html = Uv.parse(source, 'xhtml', lang, lines = false, style)
+
+        # Prepare <code> containing <pre>
+        code = Document.new(html, :respect_whitespace => :all).root
+        code.name = 'code'
+        code.attributes['class'] = lang
+        code.attributes['lang'] = lang
+
+        # Prepare <pre>
+        pre = Element.new('pre')
+        pre << code
+        pre.attributes['class'] = style
+        pre
+      rescue => ex
+        puts ex
+        to_html_code_using_pre(source)
+      end
+
+      def to_html_code
+        source = self.raw_code
+        use_syntax = get_setting(:html_use_syntax)
+        uv_style = get_setting(:uv_style)
+
+        lang = self.attributes[:lang] || @doc.attributes[:code_lang]
+        lang ||= 'ruby' if attributes[:ruby]
+
+        # we always use syntax highlighting, this is a doc wiki
+        if lang and use_syntax
+          element = uv_highlight(source, lang, uv_style)
+        else
+          element = to_html_code_using_pre(source)
+        end
+
+        color = get_setting(:code_background_color)
+
+        if color != Globals[:code_background_color]
+          element.attributes['style'] = "background-color: #{color};"
+        end
+
+        add_ws element
+      end
+    end # HTML
+  end # Out
+end # MaRuKu

data/lib/ramaze/contrib/profiling.rb

@@ -0,0 +1,36 @@
+require "ruby-prof"
+
+module Ramaze
+  class 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,17 @@
+Ramaze::Rewrite['REST dispatch'] = lambda do |path, request|
+  path << '/' unless path[-1] == '/'
+
+  method = if request.request_method == 'POST' and request.params.has_key?('method')
+             request.params['method'].upcase
+           else
+             request.request_method
+           end
+  
+  case method
+  when 'GET' then path << 'show/'
+  when 'POST' then path << 'create/'
+  when 'PUT' then path << 'update/'
+  when 'DELETE' then path << 'destroy/'
+  else path
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'sequel'
+
+module Sequel
+  class Model
+    # Force join table generation
+    #
+    # Usage:
+    #   User.create_join(Article, 'articles_users')
+    #   # or let the method figure out the correct join table using sequel
+    #   # conventions.
+    #   User.create_join(Article)
+    def self.create_join(to, name = nil)
+      from = self
+      name ||= [table_name.to_s, to.table_name.to_s].sort.join('_')
+      from_key = "#{from.table_name.to_s.singularize}_id"
+      to_key = "#{to.table_name.to_s.singularize}_id"
+
+      db.create_table! name do
+        primary_key :id
+        foreign_key from_key, :class => from
+        foreign_key to_key, :class => to
+      end
+    end
+  end
+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/form_field.rb

@@ -0,0 +1,129 @@
+require 'ramaze/gestalt'
+
+# job = Job[4]
+# puts CGI::pretty(FormField.new(job, :contract, show_errors = true, Job::CONTRACTS).to_s)
+
+class FormField
+  attr_accessor :this, :field, :show_errors, :hint, :db_type, :id, :value
+
+  # show_errors may be a number indicating how many errors it should display at
+  # maximum, 0 displays none, -1 all
+
+  def initialize(this, field, show_errors = true, hint = nil)
+    @this, @field, @show_errors, @hint =
+      this, field.to_sym, show_errors, hint
+    @db_type = db_type
+    @id = "form_#{@field}"
+    @value = this.send(@field)
+  end
+
+  def db_type
+    if field_schema = this.class.db_schema[field]
+      field_schema[:db_type]
+    else
+      nil
+    end
+  end
+
+  def to_s
+    unless label = @this.class::FORM_LABEL[field]
+      raise("No FORM_LABEL for %p on %p" % [field, @this.class])
+    end
+
+    label += ':'
+    id = @id
+    _self = self
+
+    Ramaze::Gestalt.build{
+      div(:class => :pair){
+        label(:for => id){ label }
+        _self.build_tag(self)
+        _self.build_errors(self)
+      }
+    }
+  end
+
+  def password(gestalt)
+    gestalt.input(@args.merge :type => :password, :value => value)
+  end
+
+  def checkbox(gestalt)
+    @args[:checked] = :checked if value
+    gestalt.input(@args.merge :type => :checkbox)
+  end
+
+  def select(gestalt)
+    gestalt.select @args do
+      v = value.to_s
+      hint.each do |h|
+        h = h.to_s
+        if h == v
+          gestalt.option(:value => h, :selected => :selected){ h }
+        else
+          gestalt.option(:value => h){ h }
+        end
+      end
+    end
+  end
+
+  def input(gestalt)
+    gestalt.input(@args.merge :type => :text, :value => value)
+  end
+
+  def file(gestalt)
+    gestalt.input(@args.merge :type => :file)
+  end
+
+  def textarea(gestalt)
+    gestalt.textarea(@args){ value.to_s }
+  end
+
+  def build_tag(gestalt)
+    @args = {:id => id, :name => field}
+
+    case hint
+    when :password
+      password(gestalt)
+    when :boolean, :checkbox
+      checkbox(gestalt)
+    when :textarea
+      textarea(gestalt)
+    when :file
+      file(gestalt)
+    when Array, Range
+      select(gestalt)
+    else
+      case db_type
+      when 'varchar', 'integer'
+        input(gestalt)
+      when 'boolean'
+        checkbox(gestalt)
+      when 'string'
+        textarea(gestalt)
+      else
+        raise "Unsupported type: (#{db_type || hint} : #{field})"
+      end
+    end
+  end
+
+  def build_errors(gestalt)
+    each_error do |error|
+      gestalt.span(:class => :error){ error }
+    end
+  end
+
+  # TODO: suggest 'validated?' feature to sequel
+  def each_error(&block)
+    return unless show_errors
+
+    this.validate if this.errors.empty?
+    this.errors[field].first(show_errors).each(&block)
+  end
+
+  module Model
+    def form_field(field, hint = nil)
+      show_errors = Ramaze::Request.current.post? ? 1 : 0
+      FormField.new(self, field, show_errors, hint).to_s
+    end
+  end
+end