ramaze 0.2.1 → 0.3.0

data/lib/ramaze/contrib/auto_params/get_args.rb

@@ -25,6 +25,7 @@ begin
 
     def get_args
       arg_node = deep_array_node(:args)
+      return nil unless arg_node
       args = arg_node.arg_nodes
       default_node = arg_node.deep_array_node(:block)
       return args unless default_node

data/lib/ramaze/contrib/facebook.rb

@@ -0,0 +1,23 @@
+require __DIR__/:facebook/:facebook
+
+module Ramaze
+  module FacebookHelper
+    def self.included(klass)
+      klass.send(:helper, :aspect, :inform)
+    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/facebook/facebook.rb

@@ -0,0 +1,168 @@
+require 'rubygems'
+require 'socket'
+require 'digest'
+require 'json'
+require 'cgi'
+
+module Facebook
+  class Error < StandardError
+  end
+
+  class APIProxy
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+
+    def initialize name, client
+      @name, @client = name, client
+    end
+
+    def method_missing method, opts = {}
+      @client.call "#{@name}.#{method}", opts
+    end
+  end
+
+  class Client
+    include Ramaze::Trinity if defined? Ramaze
+
+    def initialize keepalive = true
+      @keepalive = keepalive
+      @proxies = {}
+    end
+
+    %w[ auth fbml feed fql friends notifications profile users pages events groups photos marketplace ].each do |n|
+      define_method(n){ @proxies[n] ||= APIProxy.new(n, self) }
+    end
+
+    def call method, opts = {}
+      args = { :api_key => KEY,
+               :call_id => Time.now.to_f,
+               :format => 'JSON',
+               :v => '1.0',
+               :session_key => params[:session_key] || SESSION,
+               :method => method }.merge(opts).map{ |k,v|
+                                                    "#{k}=" + case v
+                                                              when Hash
+                                                                v.to_json
+                                                              when Array
+                                                                v.join(',')
+                                                              else
+                                                                v.to_s
+                                                              end
+                                               }.sort
+
+      data = Array["sig=#{Digest::MD5.hexdigest(args.join+SECRET)}", *args].join('&')
+
+      begin
+        ret = post(data)
+      rescue Errno::ECONNRESET
+        @server = connect
+        retry
+      end while ret.empty? and @server = connect
+
+      ret = case
+            when ret == 'true':    true
+            when ret == 'false':   false
+            when ret[0..0] == '"': ret[1..-2]
+            else
+              begin
+                JSON::parse(ret)
+              rescue JSON::ParserError
+                puts "Error parsing #{ret.inspect}"
+                raise
+              end
+            end
+
+      ret = ret.first if ret.is_a? Array and ret.size == 1 and ret.first.is_a? Hash
+      raise Facebook::Error, ret['error_msg'] if ret.is_a? Hash and ret['error_code']
+
+      ret
+    ensure
+      unless @keepalive
+        @server.close
+        @server = nil
+      end
+    end
+
+    def valid?
+      return false unless private_methods.include? 'request' and not request['fb_sig'].empty?
+      request['facebook.valid?'] ||= \
+        request['fb_sig'] == Digest::MD5.hexdigest(request.params.map{|k,v| "#{$1}=#{v}" if k =~ /^fb_sig_(.+)$/ }.compact.sort.join+SECRET)
+    end
+
+    def [] key
+      params[key]
+    end
+
+    def redirect url
+      url[0,0] = URL unless url =~ /^http/
+      if private_methods.include? 'response'
+        response.build "<fb:redirect url='#{url}'/>"
+        throw :respond
+      else
+        "<fb:redirect url='#{url}'/>"
+      end
+    end
+
+    def addurl goto = '/'
+      "http://apps.facebook.com/add.php?api_key=#{KEY}&next=#{CGI.escape '?next='+goto}"
+    end
+
+    def params
+      return {} unless valid?
+      request['facebook'] ||= \
+        request.params.inject({}) { |h,(k,v)|
+          next h unless k =~ /^fb_sig_(.+)$/
+          k = $1.to_sym
+
+          case k.to_s
+          when 'friends'
+            h[k] = v.split(',').map{|e|e.to_i}
+          when /time$/
+            h[k] = Time.at(v.to_f)
+          when 'expires'
+            v = v.to_i
+            h[k] = v>0 ? Time.at(v) : v
+          when 'user'
+            h[k] = v.to_i
+          when /^(position_|in_|is_|added)/
+            h[k] = v=='1'
+          else
+            h[k] = v
+          end
+          h
+        }
+    end
+
+    private
+
+    def connect
+      @socket.close if @socket
+      TCPSocket.new('api.facebook.com', 80)
+    end
+
+    def post data
+      @server ||= connect
+
+      @server.puts "POST /restserver.php HTTP/1.1\r\n"
+      @server.puts "Host: api.facebook.com\r\n"
+      @server.puts "Connection: keep-alive\r\n" if @keepalive
+      @server.puts "Content-Type: application/x-www-form-urlencoded\r\n"
+      @server.puts "Content-Length: #{data.length}\r\n"
+      @server.puts "\r\n#{data}\r\n"
+      @server.puts "\r\n\r\n"
+
+      buf = ''
+      while @server.gets
+        if $_ == "\r\n"
+          @server.gets
+          if $_.strip! == '0'
+            @server.gets
+            break
+          end
+          buf << @server.read($_.to_i(16))
+        end
+      end
+
+      buf
+    end
+  end
+end

data/lib/ramaze/contrib/gettext.rb

@@ -0,0 +1,111 @@
+#          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
+
+class Ramaze::Tool::Gettext < Ramaze::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)
+    Ramaze::Inform.debug "loading locales: #{locales.inspect}"
+
+    dict = trait[:dictionary] || {}
+
+    locales.each do |locale|
+      begin
+        dict[locale] = ::MOFile.open(trait[:file] % locale)
+      rescue Errno::ENOENT
+        Ramaze::Inform.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)
+        Ramaze::Inform.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
+
+    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
+    Ramaze::Inform.error e
+  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/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