ptomato-ramaze 2009.02

data/lib/ramaze/cache/file.rb

@@ -0,0 +1,71 @@
+module Ramaze
+  # Persist cache contents to the filesystem.
+  # By default this will create a `/cache` directory in your APPDIR
+  #
+  # Usage for sessions only:
+  #
+  #     Ramaze::Global::cache_alternative[:sessions] = Ramaze::FileCache
+  #
+  # Usage for everything:
+  #
+  #     Ramaze::Global::cache = Ramaze::FileCache
+
+  class FileCache
+    attr_accessor :root, :subdir
+    attr_reader :host, :pid
+
+    def initialize(root = Ramaze::Global.root, subdir = 'cache')
+      @root, @subdir = root, subdir
+      @host = Socket.gethostname
+      @pid = $$
+
+      FileUtils.mkdir_p(dir)
+    end
+
+    def dir(*further)
+      File.join(root, subdir, *further)
+    end
+
+    def [](key)
+      Marshal.load(File.read(dir(key.to_s, 'data')))
+    rescue
+      nil
+    end
+
+    def []=(key, value)
+      key = key.to_s
+      tmp_name = dir(key, "data.#{host}.#{pid}")
+      key_name = dir(key, 'data')
+      dir_name = dir(key)
+
+      data = Marshal.dump(value)
+
+      FileUtils.rm_rf(dir_name)
+      FileUtils.mkdir_p(dir_name)
+
+      File.open(tmp_name, 'w'){|fd| fd.write(data) }
+
+      FileUtils.mv(tmp_name, key_name)
+
+      return value
+    end
+
+    def values_at(*keys)
+      keys.map{|key| self[key] }
+    end
+
+    def delete(*keys)
+      keys.map do |key|
+        FileUtils.rm_rf(dir(key.to_s))
+      end
+    end
+
+    def clear
+      Dir[dir('*')].each{|entry| FileUtils.rm_rf(entry) }
+    end
+
+    def to_sym
+      name.split('::').last.to_sym
+    end
+  end
+end

data/lib/ramaze/cache/memcached.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.
+require 'memcache'
+
+module Ramaze
+
+  # Cache based on the memcache library which utilizes the memcache-daemon to
+  # store key/value pairs in namespaces.
+
+  class MemcachedCache
+
+    # Create a new MemcachedCache with host, port and a namespace that defaults
+    # to 'ramaze'
+    #
+    # For your own usage you should use another namespace.
+
+    def initialize(host = 'localhost', port = '11211', namespace = Global.runner)
+      namespace = Digest::SHA1.hexdigest(namespace)[0..16]
+      @cache = MemCache.new(["#{host}:#{port}"], :namespace => namespace, :multithread => true)
+    end
+
+    # please read the documentation of memcache-client for further methods.
+    # also, it is highly recommended to install memcache-client_extensions
+    # for a bit of speedup and more functionality
+    # Some examples:
+    #
+    # [key]                       #=> get a key
+    # [key] = value               #=> set a key
+    # delete(key)                 #=> delete key
+    # set_many :x => :y, :n => :m #=> set many key/value pairs
+    # get_hash :x, :y             #=> return a hash with key/value pairs
+    # stats                       #=> get some statistics about usage
+    # namespace                   #=> get the current namespace
+    # namespace = 'ramaze'        #=> set a different namespace ('ramaze' is default)
+    # flush_all                   #=> flush the whole cache (deleting all)
+    # compression                 #=> see if compression is true/false
+    # compression = false         #=> turn off compression (it's by default true)
+
+    def method_missing(*args, &block)
+      @cache.__send__(*args, &block)
+    rescue MemCache::MemCacheError => e
+      Log.error e.to_s
+      nil
+    end
+
+    # Fetch for multiple keys at once.
+
+    def get_multi(*keys)
+      # MemCache only responds to get_multi if the memcache-client_extensions gem
+      # is installed, so we check first and resort to another approach if not.
+      if @cache.respond_to?(:get_multi)
+        @cache.get_multi(*keys)
+      else
+        @cache.get_hash(*keys)
+      end
+    end
+
+    # same as get_multi, but returns only the values (in order)
+
+    def values_at(*keys)
+      get_multi(*keys).values_at(*keys)
+    end
+
+    # Flush everything, dangerous!
+    def clear
+      @cache.flush_all
+    end
+  end
+end

data/lib/ramaze/cache/memory.rb

@@ -0,0 +1,6 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  MemoryCache = Hash
+end

data/lib/ramaze/cache/yaml_store.rb

@@ -0,0 +1,68 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+require 'yaml/store'
+
+module Ramaze
+
+  # Cache based on _whys YAML::Store, which uses PStore to serialize objects
+  # as YAML in a thread-safe manner.
+
+  class YAMLStoreCache
+
+    attr_accessor :file
+
+    # create a new YAML::Store with the given file (which will be created if it
+    # is not already there).
+
+    def initialize(file = 'cache.yaml')
+      @file = file
+      @cache = YAML::Store.new(file)
+    end
+
+    # return the values for given keys.
+
+    def values_at(*keys)
+      transaction do |y|
+        keys.map{|k| y[k]}
+      end
+    end
+
+    # Loads @file into memory via YAML::load_file
+
+    def underlying_yaml
+      YAML.load_file(@file)
+    end
+
+    # clears the YAML::Store based cache, by emptying the YAML file.
+
+    def clear
+      transaction do |y|
+        File.open(@file, 'w+'){|f| f.puts({}.to_yaml)}
+      end
+    end
+
+    # Deletes the key from YAML::Store based cache.
+
+    def delete(key)
+      transaction do |y|
+        y.delete(key)
+      end
+    end
+
+    # just a helper to use transactions.
+
+    def transaction(&block)
+      @cache.transaction do
+        yield(@cache)
+      end
+    end
+
+    # catch everything else and use a transaction to send it.
+
+    def method_missing(*args, &block)
+      transaction do |y|
+        y.send(*args, &block)
+      end
+    end
+  end
+end

data/lib/ramaze/cache.rb

@@ -0,0 +1,114 @@
+#          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/cache/memory'
+
+module Ramaze
+  autoload :YAMLStoreCache, "ramaze/cache/yaml_store.rb"
+  autoload :MemcachedCache, "ramaze/cache/memcached.rb"
+  autoload :FileCache, "ramaze/cache/file.rb"
+
+  # This is the wrapper of all caches, providing mechanism
+  # for switching caching from one adapter to another.
+
+  class Cache
+    include Enumerable
+
+    # Holds all the instances of Cache that are being added.
+    CACHES = {} unless defined?(CACHES)
+
+    attr_accessor :cache
+
+    class << self
+
+      # Initializes the Cache for the general caches Ramaze uses.
+      # Cache#startup is called by Ramaze#startup, when initializing the
+      # Ramaze.trait(:essentials).
+
+      def startup(options)
+        Cache.add :compiled, :actions, :patterns,
+                  :resolved, :shield, :action_methods
+      end
+
+      # This will define a method to access a new cache directly over
+      # singleton-methods on Cache.
+      #---
+      # The @cache_name is internally used for caches which do not save
+      # different caches in different namespaces, for example memcached.
+      #+++
+
+      def add *keys
+        keys.each{|key|
+          klass = Global.cache_alternative.fetch(key, Global.cache)
+          add_on(key, klass)
+        }
+        Log.dev("Added caches for: #{keys.join(', ')}")
+      end
+
+      # Define a new cache available by Cache::key
+      def add_on(key, cache_class)
+        CACHES[key] = new(cache_class)
+        CACHES[key].instance_variable_set("@cache_name", key)
+        eval("def self.%s; CACHES[%p]; end" % [key, key])
+      end
+
+    end
+
+    # Initializes the cache, defined by Global.cache
+    def initialize(cache = Global.cache)
+      @cache = cache.new
+    end
+
+    # Gets the value for the given key, or +nil+ if not found.
+    def [](key)
+      fetch(key)
+    end
+
+    # Sets _key_ to _value_ with an infinite time to live.
+    def []=(key, value)
+      store(key, value)
+    end
+
+    # Empties this cache.
+    def clear
+      @cache.clear
+    end
+
+    # Deletes each passed key from this cache.
+    def delete(*args)
+      args.each do |arg|
+        @cache.delete("#{@cache_name}:#{arg}")
+      end
+    end
+
+    # Gets the value of the given key, or _default_ if not found.
+    def fetch(key, default = nil)
+      return default unless entry = @cache["#{@cache_name}:#{key}"]
+      return entry[:value] if entry[:expires].nil? || entry[:expires] > Time.now
+      @cache.delete("#{@cache_name}:#{key}")
+      default
+    end
+
+    alias get fetch
+
+    # Sets key to value. Supports the following options:
+    #   [+:ttl+] time to live in seconds
+    def store(key, value, opts = {})
+      opts = {:ttl => opts} if opts.is_a?(Integer)
+      @cache["#{@cache_name}:#{key}"] = {
+        :expires => opts[:ttl] ? Time.now + opts[:ttl].to_i : nil,
+        :value   => value
+      }
+      value
+    end
+
+    alias set store
+
+    # Answers with value for each key.
+    def values_at(*keys)
+      values = []
+      keys.each {|key| values << fetch(key) }
+      values
+    end
+  end
+end

data/lib/ramaze/contrib/email.rb

@@ -0,0 +1,86 @@
+# 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
+
+      # the raw mail sending method used by Ramaze::EmailHelper
+
+      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