ramaze 2011.01.30 → 2011.07.25

data/lib/ramaze/contrib/addressable_route.rb

@@ -1,56 +0,0 @@
-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
-    def initialize(app, routes = {})
-      @app = app
-      @routes = {}
-
-      routes.each{|from, to| map(from, to) }
-    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 map(from, to)
-      @routes[Addressable::Template.new(from)] = to
-    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

@@ -1,64 +0,0 @@
-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

@@ -1,88 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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/gettext.rb

@@ -1,113 +0,0 @@
-#          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