ptomato-ramaze 2009.02

data/lib/ramaze/contrib/facebook.rb

@@ -0,0 +1,23 @@
+require __DIR__('facebook/facebook')
+
+module Ramaze
+  module Helper::Facebook
+    def self.included(klass)
+      klass.send(:helper, :aspect)
+    end
+
+    def error
+      if Facebook::ADMINS.include? facebook[:user]
+        error = Ramaze::Dispatcher::Error.current
+        [error, *error.backtrace].join '<br/>'
+      end
+    end
+
+    private
+
+    def facebook
+      @facebook ||= Facebook::Client.new
+    end
+    alias fb facebook
+  end
+end

data/lib/ramaze/contrib/file_cache.rb

@@ -0,0 +1,3 @@
+Ramaze::Log.warn("ramaze/contrib/file_cache is now ramaze/cache/file")
+
+require 'ramaze/cache/file'

data/lib/ramaze/contrib/gems.rb

@@ -0,0 +1,78 @@
+module Ramaze
+  module Gems
+    @gems = []
+
+    class << self
+      def gem(name, version = nil, options = {})
+        case version
+        when String
+          options[:version] = version
+        when Hash
+          options.merge!(version)
+        end
+
+        @gems << GemStone.new(name, options)
+      end
+
+      # options include:
+      #  :install_dir => where to install gems
+      #  :extconf     => additional options for building extensions
+
+      def options opts = {}
+        @options ||= {}
+        @options.merge! opts unless opts.empty?
+        @options
+      end
+
+      def setup opts = {}
+        options(opts)
+        @gems.each{|gem| gem.setup }
+      end
+    end
+
+    class GemStone
+      attr_reader :name, :options
+
+      def initialize(name, options = {})
+        @name, @options = name, options
+        require 'rubygems/dependency_installer'
+        @installer = Gem::DependencyInstaller.new(@options)
+      end
+
+      def setup(ran = false)
+        Gem.activate(name, *[options[:version]].compact)
+        require options[:lib] || name
+      rescue LoadError => error
+        puts error
+        return if ran
+        install
+        setup(ran = true)
+      end
+
+      def install
+        if extconf = (options[:extconf] || Gems.options[:extconf])
+          old_argv = ARGV.clone
+          ARGV.replace extconf.split(' ')
+        end
+
+        print "Installing #{name}..."
+        @installer.install name, options[:version]
+        puts "done.\n\n"
+      ensure
+        ARGV.replace old_argv if extconf
+      end
+    end
+  end
+end
+
+__END__
+Usage example:
+
+module Ramaze::Gems
+  gem 'haml'
+  gem 'sequel', '>=1.2.0'
+  gem 'hpricot', :source => 'http://code.whytheluckystiff.net'
+  gem 'aws-s3', :lib => 'aws/s3'
+
+  setup
+end

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

@@ -0,0 +1,155 @@
+=begin
+    mo.rb - A simple class for operating GNU MO file.
+
+    Copyright (C) 2003-2006  Masao Mutoh
+    Copyright (C) 2002  Masahiro Sakai, Masao Mutoh
+    Copyright (C) 2001  Masahiro Sakai
+
+        Masahiro Sakai                  <s01397ms@sfc.keio.ac.jp>
+        Masao Mutoh                     <mutoh@highway.ne.jp>
+
+    You can redistribute this file and/or modify it under the same term
+    of Ruby.  License of Ruby is included with Ruby distribution in
+    the file "README".
+
+    $Id: mo.rb,v 1.7 2006/06/11 15:36:20 mutoh Exp $
+=end
+
+require 'iconv'
+
+class MOFile < Hash
+  class InvalidFormat < RuntimeError; end;
+
+  attr_reader :filename
+
+  Header = Struct.new(:magic,
+                      :revision,
+                      :nstrings,
+                      :orig_table_offset,
+                      :translated_table_offset,
+                      :hash_table_size,
+                      :hash_table_offset)
+
+  MAGIC_BIG_ENDIAN    = "\x95\x04\x12\xde"
+  MAGIC_LITTLE_ENDIAN = "\xde\x12\x04\x95"
+
+  def self.open(arg = nil, output_charset = nil)
+    result = self.new(output_charset)
+    result.load(arg)
+  end
+
+  def initialize(output_charset = nil)
+    @filename = nil
+    @last_modified = nil
+    @little_endian = true
+    @output_charset = output_charset
+    super
+  end
+
+  def update!
+    if FileTest.exist?(@filename)
+      st = File.stat(@filename)
+      load(@filename) unless (@last_modified == [st.ctime, st.mtime])
+    else
+      puts "#{@filename} was lost." if $DEBUG
+      clear
+    end
+    self
+  end
+
+  def load(arg)
+    case arg
+    when String
+      begin
+	      st = File.stat(arg)
+	      @last_modified = [st.ctime, st.mtime]
+      rescue Exception
+      end
+      load_from_file(arg)
+    when IO
+      load_from_stream(arg)
+    end
+    @filename = arg
+    self
+  end
+
+  def load_from_stream(io)
+    magic = io.read(4)
+    case magic
+    when MAGIC_BIG_ENDIAN
+      @little_endian = false
+    when MAGIC_LITTLE_ENDIAN
+      @little_endian = true
+    else
+      raise InvalidFormat.new("Unknown signature %s" % magic.dump)
+    end
+
+    header = Header.new(magic, *(io.read(4 * 6).unpack(@little_endian ? 'V6' : 'N6')))
+    raise InvalidFormat.new(sprintf("file format revision %d isn't supported", header.revision)) if header.revision > 0
+
+    io.pos = header.orig_table_offset
+    orig_table_data = io.read((4 * 2) * header.nstrings).unpack(@little_endian ? 'V*' : 'N*')
+
+    io.pos = header.translated_table_offset
+    trans_table_data = io.read((4 * 2) * header.nstrings).unpack(@little_endian ? 'V*' : 'N*')
+
+    original_strings = Array.new(header.nstrings)
+    for i in 0...header.nstrings
+      io.pos = orig_table_data[i * 2 + 1]
+      original_strings[i] = io.read(orig_table_data[i * 2 + 0])
+    end
+
+    clear
+    for i in 0...header.nstrings
+      io.pos = trans_table_data[i * 2 + 1]
+      str = io.read(trans_table_data[i * 2 + 0])
+
+      if original_strings[i] == ""
+        if str
+          @charset = nil
+          @nplurals = nil
+          @plural = nil
+          str.each_line{|line|
+            if /^Content-Type:/i =~ line and /charset=((?:\w|-)+)/i =~ line
+              @charset = $1
+            elsif /^Plural-Forms:\s*nplurals\s*\=\s*(\d*);\s*plural\s*\=\s*([^;]*)\n?/ =~ line
+              @nplurals = $1
+              @plural = $2
+            end
+            break if @charset and @nplurals
+          }
+          @nplurals = "1" unless @nplurals
+          @plural = "0" unless @plural
+        end
+      else
+        if @output_charset
+          begin
+            str = Iconv.iconv(@output_charset, @charset, str).join if @charset
+          rescue Iconv::Failure
+            if $DEBUG
+              $stderr.print "@charset = ", @charset, "\n"
+              $stderr.print "@output_charset = ", @output_charset, "\n"
+              $stderr.print "msgid = ", original_strings[i], "\n"
+              $stderr.print "msgstr = ", str, "\n"
+            end
+          end
+        end
+      end
+      self[original_strings[i]] = str
+    end
+    self
+  end
+
+  def load_from_file(filename)
+    @filename = filename
+    File.open(filename, 'rb'){|f| load_from_stream(f)}
+  end
+
+  def set_comment(msgid_or_sym, comment)
+    #Do nothing
+  end
+
+
+  attr_accessor :little_endian, :path, :last_modified
+  attr_reader :charset, :nplurals, :plural
+end

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