ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/adapter.rb

@@ -1,101 +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/trinity'
-require 'ramaze/tool/record'
-require 'ramaze/adapter/base'
-
-# for OSX compatibility
-Socket.do_not_reverse_lookup = true
-
-module Ramaze
-
-  # Shortcut to the HTTP_STATUS_CODES of Rack::Utils
-  # inverted for easier access
-
-  STATUS_CODE = Rack::Utils::HTTP_STATUS_CODES.invert
-
-  # This module holds all classes and methods related to the adapters like
-  # webrick or mongrel.
-  # It's responsible for starting and stopping them.
-
-  module Adapter
-    class << self
-
-      # Is called by Ramaze.startup and will first call start_adapter and wait
-      # up to 3 seconds for an adapter to appear.
-      # It will then wait for the adapters to finish If Global.run_loose is
-      # set or otherwise pass you on control which is useful for testing or IRB
-      # sessions.
-
-      def startup options = {}
-        start_adapter
-
-        Timeout.timeout(3) do
-          sleep 0.01 until Global.server
-        end
-
-        Global.server.join unless Global.run_loose
-
-      rescue SystemExit
-        Ramaze.shutdown
-      rescue Object => ex
-        Log.error(ex)
-        Ramaze.shutdown
-      end
-
-      # Takes Global.adapter and starts if test_connections is positive that a
-      # connection can be made to the specified host and port.
-      # If you set Global.adapter to false it won't start any but deploy a
-      # dummy which is useful for testing purposes where you just send fake
-      # requests to Dispatcher.
-
-      def start_adapter
-        if adapter = Global.adapter
-          host, port = Global.host, Global.port
-
-          if Global.test_connections
-            test_connection(host, port)
-            Log.info("Ramaze is ready to run on: #{host}:#{port}")
-          end
-
-          adapter.start(host, port)
-        else # run dummy
-          Global.server = Thread.new{ sleep }
-          Log.warn("Seems like Global.adapter is turned off", "Continue without adapter.")
-        end
-      rescue LoadError => ex
-        Log.warn(ex, "Continue without adapter.")
-      end
-
-      # Calls ::shutdown on all running adapters and waits up to 1 second for
-      # them to finish, then goes on to kill them and exit still.
-
-      def shutdown
-        Timeout.timeout(3) do
-          a = Global.server[:adapter]
-          a.shutdown if a.respond_to?(:shutdown)
-        end
-      rescue Timeout::Error
-        Global.server.kill!
-        # Hard exit! because it won't be able to kill Webrick otherwise
-        exit!
-      end
-
-      # Opens a TCPServer temporarily and returns true if a connection is
-      # possible and false if none can be made
-
-      def test_connection(host, port)
-        Timeout.timeout(1) do
-          testsock = TCPServer.new(host, port)
-          testsock.close
-          true
-        end
-      rescue => ex
-        Log.error(ex)
-        Log.error("Cannot open connection on #{host}:#{port}")
-        Ramaze.shutdown
-      end
-    end
-  end
-end

data/lib/ramaze/cache/memcached.rb

@@ -1,70 +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 '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 = SEEED)
-      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
-
-    # out of some reason MemCache sometimes doesn't respond to
-    # get_multi, have to investigate this further.
-    #
-    # for now, i'll just use the dumbed down version and ask it
-    # whether it implements this functionality or not.
-
-    def get_multi(*keys)
-      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
-
-    def clear
-      @cache.flush_all
-    end
-  end
-end

data/lib/ramaze/cache/memory.rb

@@ -1,6 +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.
-
-module Ramaze
-  MemoryCache = Hash
-end

data/lib/ramaze/cache/yaml_store.rb

@@ -1,68 +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 '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/contrib/auto_params/get_args.rb

@@ -1,57 +0,0 @@
-# from merb/core_ext/get_args.rb
-begin
-  require 'ruby2ruby'
-
-  class ParseTreeArray < Array
-    def self.translate(*args)
-      self.new(ParseTree.translate(*args))
-    end
-
-    def deep_array_node(type = nil)
-      each do |node|
-        return ParseTreeArray.new(node) if node.is_a?(Array) && (!type || node[0] == type)
-        next unless node.is_a?(Array)
-        return ParseTreeArray.new(node).deep_array_node(type)
-      end
-      nil
-    end
-
-    def arg_nodes
-      self[1..-1].inject([]) do |sum,item|
-        sum << [item] unless item.is_a?(Array)
-        sum
-      end
-    end
-
-    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
-      lasgns = default_node[1..-1]
-      lasgns.each do |asgn|
-        args.assoc(asgn[1]) << eval(RubyToRuby.new.process(asgn[2]))
-      end
-      args
-    end
-
-  end
-
-  module GetArgs
-    def get_args
-      klass, meth = self.to_s.split(/ /).to_a[1][0..-2].split("#")
-      klass = $` if klass =~ /\(/
-      ParseTreeArray.translate(Object.const_get(klass), meth).get_args
-    end
-  end
-
-  class UnboundMethod
-    include GetArgs
-  end
-
-  class Method
-    include GetArgs
-  end
-rescue LoadError
-end

data/lib/ramaze/contrib/auto_params.rb

@@ -1,135 +0,0 @@
-# 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| CGI.unescape(p.to_s)}
-        when nil
-          nil
-        else
-          CGI.unescape(pa.to_s)
-        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

@@ -1,84 +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
-    # 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
-      end
-    end
-  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