Pistos-ramaze 2009.02 → 2009.04.08

data/lib/ramaze/adapter.rb

@@ -1,97 +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'
-require 'ramaze/adapter/fake'
-
-# for OSX compatibility
-Socket.do_not_reverse_lookup = true
-
-module Ramaze
-
-  # 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} using #{Global.adapter}")
-          end
-
-          adapter.start(host, port)
-        else
-          Fake.start
-          Log.warn("Seems like Global.adapter is turned off", "Continue without adapter.")
-        end
-      rescue LoadError => ex
-        Log.error(ex)
-        Log.warn("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
-          if Global.server.respond_to?(:shutdown)
-            Global.server.shutdown
-          end
-        end
-      rescue Timeout::Error
-        Global.server.kill!
-      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/file.rb

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

@@ -1,69 +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 = 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

@@ -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/file_cache.rb

@@ -1,3 +0,0 @@
-Ramaze::Log.warn("ramaze/contrib/file_cache is now ramaze/cache/file")
-
-require 'ramaze/cache/file'

data/lib/ramaze/contrib/gems.rb

@@ -1,78 +0,0 @@
-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/sequel/fill.rb

@@ -1,12 +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 Sequel
-  class Model
-    class << self
-      def fill request_object = Ramaze::Request.current
-        create(request_object.params)
-      end
-    end
-  end
-end

data/lib/ramaze/contrib/sequel_cache.rb

@@ -1,92 +0,0 @@
-#
-# drop-in replacement for Ramaze's built-in MemoryCache built on the Sequel.
-# to use with sessions do
-#
-#   Ramaze::Global::cache_alternative[:sessions] = Ramaze::SequelCache
-#
-# to use with everything do
-#
-#   Ramaze::Global::cache = Ramaze::SequelCache
-#
-
-class Ramaze::SequelCache
-  class Table < Sequel::Model(:ramaze_cache_t)
-    set_schema do
-      primary_key :id
-      string :key
-      string :value
-      index :key, :unique => true
-    end
-
-    ## use sequel's built-in serialize function if you like execptions: the
-    ## serialized data blows up the sql
-    ## serialize :value, :format => :marshal
-
-    transform :value => [
-      lambda{|value| Marshal.load(Base64.decode64(value))},
-      lambda{|value| Base64.encode64(Marshal.dump(value))},
-    ]
-  end
-
-  def table() Table end
-  def t() Table end
-
-  def self.[] key
-    record = Table.find :key => key
-    record ? record.value : nil
-  end
-
-  def self.[]= key, value
-    begin
-      Table.create :key => key, :value => value
-    rescue
-      Table.filter(:key => key).update :value => value
-      unless Table.find(:key => key)
-        Table.create :key => key, :value => value rescue nil
-      end
-    end
-    # ruby always returns 'value' for []= !
-  rescue
-    nil
-  end
-
-  def self.values_at *keys
-    keys.map{|key| Table[key]}
-  end
-
-  def self.delete *keys
-    keys.map do |key|
-      record = Table[key]
-      record.delete if record
-    end
-  end
-
-  def self.clear
-    Table.delete_all
-  end
-
-  def self.new
-    self
-  end
-
-  def self.to_sym
-    name.split(%r/::/).last.to_sym
-  end
-end
-
-
-
-
-if $0 == __FILE__
-  case ARGV.first
-    when /create|up/
-      Ramaze::SequelCache::Table.create_table!
-    when /drop|down/
-      Ramaze::SequelCache::Table.drop_table
-    else
-      abort "usage: ruby #{ __FILE__ } create/up | drop/down"
-  end
-else
-  Ramaze::SequelCache::Table.create_table! unless
-    Ramaze::SequelCache::Table.table_exists?
-end

data/lib/ramaze/contrib.rb

@@ -1,82 +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
-
-  # Loads and sets up contrib modules.
-  #
-  # For more information @see Ramaze::Contrib.load
-  #
-  # Usage:
-  #
-  #   Ramaze.contrib :gzip_filter
-
-  def self.contrib(*args)
-    Contrib.load(*args)
-  end
-
-  # A module used for loading contrib modules.
-
-  module Contrib
-
-    # Loads and sets up contrib modules from /ramaze/contrib.
-    #
-    # === Usage:
-    #
-    #   Ramaze::Contrib.load :gzip_filter
-    #
-    # === Creating a contrib module:
-    #
-    #   module Ramaze::Contrib::Test
-    #     def self.setup
-    #       Log.info "Test module set up"
-    #     end
-    #   end
-    #   class TestController < Ramaze::Controller
-    #     map '/test'
-    #     def index; "Chunky Bacon!"; end
-    #   end
-    #
-    #   # Save that to your <app dir>/contrib and use like:
-    #   Ramaze.contrib :test
-
-    def self.load(*contribs)
-      contribs.each do |name|
-        mod_name = name.to_s.camel_case
-        begin
-          const = Contrib.const_get(mod_name)
-          Global.contribs << const
-          const.startup if const.respond_to?(:startup)
-          Log.dev "Loaded contrib: #{const}"
-        rescue NameError
-          files = Dir["{contrib,#{BASEDIR}/ramaze/contrib}/#{name}.{so,bundle,rb}"]
-          raise LoadError, "#{mod_name} not found" unless files.any?
-          require(files.first) ? retry : raise
-        end
-      end
-    end
-
-    # Will call .shutdown on all contrib modules which support it.
-    #---
-    # .shudown gets called by Ramaze :essentials.
-    #+++
-
-    def self.shutdown
-      Global.contribs.each do |contrib|
-        contrib.shutdown if contrib.respond_to?(:shutdown)
-      end
-    end
-
-    # Will load all contrib modules from options[:contrib]
-    #---
-    # .startup gets called by Ramaze :essentials.
-    #+++
-
-    def self.startup(options = {})
-      return unless options[:contrib]
-      [options[:contrib]].flatten.each do |contrib|
-        load(contrib)
-      end
-    end
-  end # class Contrib
-end # class Ramaze

data/lib/ramaze/controller/error.rb

@@ -1,46 +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
-  class Controller
-    # The default error-page handler. you can overwrite this method
-    # in your controller and create your own error-template for use.
-    #
-    # Error-pages can be in whatever the templating-engine of your controller
-    # is set to.
-    #   Ramaze::Dispatcher::Error.current
-    # holds the exception thrown.
-
-    def error
-      error = Dispatcher::Error.current
-      title = error.message
-
-      unless Action.current.template
-        response['Content-Type'] = 'text/plain'
-        respond %(
-          #{error.message}
-            #{error.backtrace.join("\n            ")}
-
-          #{PP.pp request, '', 200}
-        ).ui
-      end
-
-      backtrace_size = Global.backtrace_size
-      @backtrace = error.backtrace[0..20].map{|line|
-        file, lineno, meth = *Ramaze.parse_backtrace(line)
-        lines = Ramaze.caller_lines(file, lineno, backtrace_size)
-
-        [ lines, lines.object_id.abs, file, lineno, meth ]
-      }
-
-      # for backwards-compat with old error.zmr
-      @colors = [255] * @backtrace.size
-
-      @title = h(title)
-      @editor = ENV['EDITOR'] || 'vim'
-      title
-    rescue Object => ex
-      Log.error(ex)
-    end
-  end
-end

data/lib/ramaze/controller/main.rb

@@ -1,2 +0,0 @@
-class MainController < Ramaze::Controller
-end