rjspotter-ramaze 2009.06.29

data/lib/ramaze/cache/sequel.rb

@@ -0,0 +1,82 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'sequel'
+
+module Ramaze
+  class Cache
+
+    # Cache based on a Sequel model using relational databases.
+    #
+    # Please note that this cache might not work perfectly with Sequel 3.0.0,
+    # as the #[] and #[]= methods do not respect serialization.
+    # I'll lobby for a change in that direction.
+    class Sequel
+      include Cache::API
+
+      class Table < ::Sequel::Model(:ramaze_cache)
+        plugin :schema
+        plugin :serialization
+
+        serialize_attributes :marshal, :value
+
+        set_schema do
+          primary_key :id
+          index :key, :unique => true
+
+          String :key
+          String :value
+          Time :expires
+        end
+
+        def [](column)
+          if column == :value
+            deserialized_values[column] = deserialize_value(column, @values[column])
+          else
+            super
+          end
+        end
+      end
+
+      # Setup the table, not suitable for multiple apps yet.
+      def cache_setup(host, user, app, name)
+        @namespace = [host, user, app, name].compact.join(':')
+        Table.create_table?
+        @store = Table
+      end
+
+      # Wipe out _all_ data in the table, use with care.
+      def cache_clear
+        Table.delete
+      end
+
+      # Delete records for given +keys+
+      def cache_delete(*keys)
+        super do |key|
+          record = @store[:key => namespaced(key)]
+          record.delete if record
+        end
+      end
+
+      def cache_fetch(key, default = nil)
+        super{|key| @store[:key => namespaced(key)] }
+      end
+
+      def cache_store(key, value, options = {})
+        key = namespaced(key)
+        ttl = options[:ttl]
+        expires = Time.now + ttl if ttl
+
+        record = @store[:key => key].update(:value => value, :expires => expires)
+        record.value
+      rescue
+        record = @store.create(:key => key, :value => value, :expires => expires)
+        record.value
+      end
+
+      def namespaced(key)
+        [@namespace, key].join(':')
+      end
+    end
+  end
+end

data/lib/ramaze/contrib/addressable_route.rb

@@ -0,0 +1,55 @@
+require "addressable/template"
+
+module Ramaze
+  # This is a simple prototype-implementation of how we could do routing
+  # supported by URI templates.
+  #
+  # Please see the spec for example usage as it's not integrated yet in any way.
+  #
+  # What it does is basically that you can give it any URI template and a final
+  # mapping, and it will extract the variables from the URI and merge them into
+  # the QUERY_STRING, which is parsed again in Ramaze if you issue
+  # Request#params.
+  #
+  # @example given mapping like:
+  #
+  #     map('/customer/{customer_id}/order/{order_id}', '/order/show')
+  #
+  # @example output of request.params at '/order/show'
+  #
+  #     {'customer_id => '12', 'order_id' => '15'}
+  #     
+  # I haven't explored the full capabilities of the templates yet, but the
+  # specs of Addressable::Template suggest that there is a lot to be
+  # discovered.
+  class AddressableRoute
+    ROUTES = {}
+
+    def self.map(from, to)
+      ROUTES[Addressable::Template.new(from)] = to
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      path_info = env['PATH_INFO']
+
+      ROUTES.each do |template, target|
+        extracted = template.extract(path_info)
+        return dispatch(env, target, extracted) if extracted
+      end
+
+      @app.call(env)
+    end
+
+    def dispatch(env, target, extracted)
+      env['PATH_INFO'] = target
+      original = Rack::Utils.parse_query(env['QUERY_STRING'])
+      env['QUERY_STRING'] = Rack::Utils.build_query(original.merge(extracted))
+
+      @app.call(env)
+    end
+  end
+end

data/lib/ramaze/contrib/app_graph.rb

@@ -0,0 +1,64 @@
+require 'set'
+
+# require 'ramaze/contrib/app_graph'
+#
+# graph = AppGraph.new
+# graph.generate
+# graph.show
+
+class AppGraph
+  def initialize
+    @out = Set.new
+  end
+
+  def generate
+    Ramaze::AppMap.to_hash.each do |location, app|
+      connect(location => app.name)
+
+      app.url_map.to_hash.each do |c_location, c_node|
+        connect(app.name => c_node)
+        connect(c_node.mapping => c_node)
+
+        c_node.update_template_mappings
+        c_node.view_templates.each do |wish, mapping|
+          mapping.each do |action_name, template|
+            action_path = File.join(c_node.mapping, action_name)
+            connect(c_node => action_path, action_path => template)
+          end
+        end
+
+        c_node.update_method_arities
+        c_node.method_arities.each do |method, arity|
+          action_path = File.join(c_node.mapping, method.to_s)
+          connect(action_path => "#{c_node}##{method}[#{arity}]", c_node => action_path)
+        end
+      end
+    end
+  end
+
+  def connect(hash)
+    hash.each do |from, to|
+      @out << ("  %p -> %p;" % [from.to_s, to.to_s])
+    end
+  end
+
+  def write_dot
+    File.open('graph.dot', 'w+') do |dot|
+      dot.puts 'digraph appmap {'
+      dot.puts(*@out)
+      dot.puts '}'
+    end
+  end
+
+  def show
+    write_dot
+    options = {
+      'rankdir' => 'LR',
+      'splines' => 'true',
+      'overlap' => 'false',
+    }
+    args = options.map{|k,v| "-G#{k}=#{v}" }
+    system("dot -O -Tpng #{args.join(' ')} graph.dot")
+    system('feh graph.dot.png')
+  end
+end

data/lib/ramaze/contrib/email.rb

@@ -0,0 +1,88 @@
+# 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
+    include Innate::Traited
+
+    # 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.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/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