Pistos-ramaze 2008.09

data/lib/ramaze/contrib/auto_params.rb

@@ -0,0 +1,135 @@
+# auto_params.rb
+#
+# AutoParams implements action parameterization ala merb 0.4 and Nitro
+# using ruby2ruby and ParseTree
+#
+# Usage:
+#
+#   Ramaze.contrib :auto_params
+#
+# Then, for example,
+#
+#   def search(query) end
+#
+# can be accessed via
+#
+#   - /search?query=findthis, which calls search('findthis')
+#   - /search/findthis                    search('findthis')
+#   - /search/findthis?query=andthis      search(['findthis', 'andthis'])
+#
+# For more examples, take a look at spec/contrib/auto_params.rb
+#
+# Note: A simpler alternative for similar functionality would be:
+#
+#   def search(query = request['query']) end
+#
+
+require __DIR__/:auto_params/:get_args
+
+module Ramaze
+
+  module Contrib
+    class AutoParams
+      def self.startup
+        Ramaze::Cache.add :args
+      end
+    end
+  end
+
+  class Action
+
+    # with parameterization, params may include
+    #   arrays: /num?n=1&n=2 becomes [['1','2']] for def num(n) end
+    #   nil: /calc?w=10&d=2 becomes ['10', nil, '2'] for def calc(w, h, d) end
+
+    def params=(*par)
+      par = *par
+      self[:params] = par.map{ |pa|
+        case pa
+        when Array
+          pa.map{|p| Rack::Utils.unescape(p)}
+        when nil
+          nil
+        else
+          Rack::Utils.unescape(pa)
+        end
+      } unless par.nil?
+      self[:params] ||= []
+    end
+
+  end
+
+  class Controller
+
+    # ignore cache when request.params is interesting
+
+    def self.cached(path)
+      if found = Cache.resolved[path]
+        if found.respond_to?(:relaxed_hash)
+
+          # don't use cache if we need to add request.params entries to the Action
+          if args = Cache.args[found.method]
+            param_keys = request.params.keys
+            return nil if args.find{|k,v| param_keys.include?(k.to_s) }
+          end
+
+          return found.dup
+        else
+          Log.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
+          Cache.resolved.delete path
+        end
+      end
+
+      nil
+    end
+
+    # use Method#get_args to insert values from request.params into Action#params
+
+    def self.resolve_method(name, *params)
+      if method = [ name, name.gsub('__','/') ].find{|n|
+          cached_action_methods.include?(n) }
+        meth = instance_method(method)
+        arity = meth.arity
+
+        if meth.respond_to? :get_args
+          unless args = Cache.args[name]
+            if args = meth.get_args
+              args = args.select{|e| e.to_s !~ /^\*/}
+            else
+              args = []
+            end
+            Cache.args[name] = args
+          end
+
+          param_keys = request.params.keys
+
+          # if there are missing args, or keys in request.params that match expected args
+          if args.size > params.size or args.find{|k,v| param_keys.include?(k.to_s) }
+            args.each_with_index do |(name, val), i|
+              r_params = request.params[name.to_s]
+              if params[i] and r_params and r_params.size > 0
+                params[i] = [params[i], r_params].flatten
+              else
+                params[i] ||= r_params
+              end
+            end
+
+            # strip trailing nils so default argument values are used
+            params.reverse.each{|e| if e.nil? then params.pop else break end }
+          end
+
+          argity = args.select{|e| e.size==1}.size..args.size
+        else
+          argity = arity..arity
+        end
+
+        if arity < 0 or argity.include? params.size
+          return method, params
+        end
+      end
+      return nil, []
+    end
+
+  end
+
+end

data/lib/ramaze/contrib/email.rb

@@ -0,0 +1,84 @@
+# EmailHelper can be used as a simple way to send basic e-mails from your app.
+#
+# Usage:
+#
+#   require 'ramaze/contrib/email'
+#
+#   # Set the required traits:
+#   Ramaze::EmailHelper.trait :smtp_server      => 'smtp.your-isp.com',
+#                             :smtp_helo_domain => "originating-server.com",
+#                             :smtp_username    => 'username',
+#                             :smtp_password    => 'password',
+#                             :sender_address   => 'no-reply@your-domain.com'
+#
+#   # Optionally, set some other traits:
+#   Ramaze::EmailHelper.trait :smtp_auth_type => :login,
+#                             :bcc_addresses  => [ 'admin@your-domain.com' ],
+#                             :sender_full    => 'MailBot <no-reply@your-domain.com>',
+#                             :id_generator   => lambda { "<#{Time.now.to_i}@your-domain.com>" },
+#                             :subject_prefix => "[SiteName]"
+#
+# To send an e-mail:
+#
+#   Ramaze::EmailHelper.send(
+#     "foo@foobarmail.com",
+#     "Your fooness",
+#     "Hey, you are very fooey!"
+#   )
+
+require 'net/smtp'
+
+module Ramaze
+  class EmailHelper
+    # Required to be set
+    trait :smtp_server => 'smtp.your-isp.com'
+    trait :smtp_helo_domain => 'your.helo.domain.com'
+    trait :smtp_username => 'no-username-set'
+    trait :smtp_password => ''
+    trait :sender_address => 'no-reply@your-domain.com'
+
+    # Optionally set
+    trait :smtp_port => 25
+    trait :smtp_auth_type => :login
+    trait :bcc_addresses => []
+    trait :sender_full => nil
+    trait :id_generator => lambda { "<" + Time.now.to_i.to_s + "@" + trait[ :smtp_helo_domain ] + ">" }
+    trait :subject_prefix => ""
+
+    class << self
+      def send(recipient, subject, message)
+        {:recipient => recipient, :subject => subject, :message => message}.each do |k,v|
+          if v.nil? or v.empty?
+            raise(ArgumentError, "EmailHelper error: Missing or invalid #{k}: #{v.inspect}")
+          end
+        end
+        sender = trait[:sender_full] || "#{trait[:sender_address]} <#{trait[:sender_address]}>"
+        subject = [trait[:subject_prefix], subject].join(' ').strip
+        id = trait[:id_generator].call
+        email = %{From: #{sender}
+To: <#{recipient}>
+Date: #{Time.now.rfc2822}
+Subject: #{subject}
+Message-Id: #{id}
+
+#{message}
+}
+
+        send_smtp( email, recipient, subject )
+      end
+
+      def send_smtp( email, recipient, subject )
+        options = trait.values_at(:smtp_server, :smtp_port, :smtp_helo_domain,
+                                  :smtp_username, :smtp_password, :smtp_auth_type)
+
+        Net::SMTP.start( *options ) do |smtp|
+          smtp.send_message( email, trait[ :sender_address ], Array[ recipient, *trait[ :bcc_addresses ] ] )
+          Log.info "E-mail sent to #{recipient} - '#{subject}'"
+        end
+      rescue => e
+        Log.error "Failed to send e-mail to #{recipient}"
+        Log.error [ e.class.to_s, e.message, *e.backtrace ].join( "\t\n" )
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/facebook/facebook.rb

@@ -0,0 +1,171 @@
+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, Errno::EPIPE
+        @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
+
+      unless method == 'fql.query'
+        ret = ret.first if ret.is_a? Array and ret.size == 1 and ret.first.is_a? Hash
+      end
+
+      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 respond_to?(:request) and not request['fb_sig'].nil?
+      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 respond_to?(: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/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,65 @@
+#
+# drop-in replacement for Ramaze's built-in MemoryCache built on the
+# filesystem.  # to use with sessions do
+#
+#   Ramaze::Global::cache_alternative[:sessions] = Ramaze::FileCache
+#
+# to use with everything do
+#
+#   Ramaze::Global::cache = Ramaze::FileCache
+#
+
+module Ramaze::FileCache
+  require "fileutils"
+  require "socket"
+
+  Host = Socket.gethostname
+  Pid = Process.pid
+  Fu = FileUtils
+  Root = File.join Ramaze::APPDIR, "cache"
+
+  Fu.mkdir_p(Root) rescue nil
+
+  def self.[] key
+    path = File.join Root, key, "data"
+    Marshal.load(IO.read(path))
+  rescue
+    nil
+  end
+
+  def self.[]= key, value
+    tmp = File.join Root, key, "data.#{ Host }.#{ Pid }"
+    dirname = File.join Root, key
+    path = File.join Root, key, "data"
+    data = Marshal.dump value
+    Fu.rm_rf dirname rescue nil
+    Fu.mkdir_p dirname rescue nil
+    open(tmp, 'w'){|fd| fd.write data}
+    Fu.mv tmp, path
+  rescue
+    nil
+  end
+
+  def self.values_at *keys
+    keys.map{|key| self[key]}
+  end
+
+  def self.delete *keys
+    keys.map do |key|
+      dirname = File.join Root, key
+      Fu.rm_rf dirname rescue next
+    end
+  end
+
+  def self.clear
+    Dir["#{ Root }/*"].each{|entry| Fu.rm_rf entry}
+  end
+
+  def self.new
+    self
+  end
+
+  def self.to_sym
+    name.split(%r/::/).last.to_sym
+  end
+end

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