ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/cache/sequel.rb

@@ -0,0 +1,373 @@
+require 'sequel'
+
+module Ramaze
+  class Cache
+    ##
+    # The Sequel cache is a cache system that uses the Sequel database toolkit
+    # to store the data in a DBMS supported by Sequel. Examples of these
+    # databases are MySQL, SQLite3 and so on. In order to use this cache you'd
+    # have to do the following:
+    #
+    #     Ramaze::Cache.options.view = Ramaze::Cache::Sequel.using(
+    #       :connection => Sequel.mysql(
+    #         :host     => 'localhost',
+    #         :user     => 'user',
+    #         :password => 'password',
+    #         :database => 'blog'
+    #       ),
+    #       :table => :blog_sessions
+    #     )
+    #
+    # If you already have an existing connection you can just pass the object to
+    # the :connection option instead of creating a new connection manually.
+    #
+    # Massive thanks to Lars Olsson for patching the original Sequel cache so
+    # that it supports multiple connections and other useful features.
+    #
+    # @example Setting a custom database connection
+    #  Ramaze::Cache.options.names.push(:sequel)
+    #  Ramaze::Cache.options.sequel = Ramaze::Cache::Sequel.using(
+    #    :connection => Sequel.connect(
+    #      :adapter  => 'mysql2',
+    #      :host     => 'localhost',
+    #      :username => 'cache',
+    #      :password => 'cache123',
+    #      :database => 'ramaze_cache'
+    #    )
+    #  )
+    #
+    # @author Lars Olsson
+    # @since  18-04-2011
+    #
+    class Sequel
+      include Cache::API
+      include Innate::Traited
+
+      # Hash containing the default options
+      trait :default => {
+        # The default Sequel connection to use
+        :connection => nil,
+
+        # Whether or not warnings should be displayed
+        :display_warnings => false,
+
+        # The name of the default database table to use
+        :table => 'ramaze_cache',
+
+        # The default TTL to use
+        :ttl => nil
+      }
+
+      # Hash containing all the default options merged with the user specified
+      # ones
+      attr_accessor :options
+
+      class << self
+        attr_accessor :options
+
+        ##
+        # This method returns a subclass of Ramaze::Cache::Sequel with the
+        # provided options set. This is necessary because Ramaze expects a class
+        # and not an instance of a class for its cache option.
+        #
+        # You can provide any parameters you want, but those not used by the
+        # cache will not get stored. No parameters are mandatory. Any missing
+        # parameters will be replaced by default values.
+        #
+        # @example
+        #  ##
+        #  # This will create a mysql session cache in the blog
+        #  # database in the table blog_sessions
+        #  # Please note that the permissions on the database must
+        #  # be set up correctly before you can just create a new table
+        #  #
+        #  Ramaze.options.cache.session = Ramaze::Cache::Sequel.using(
+        #    :connection => Sequel.mysql(
+        #      :host     =>'localhost',
+        #      :user     =>'user',
+        #      :password =>'password',
+        #      :database =>'blog'
+        #    ),
+        #    :table => :blog_sessions
+        #  )
+        #
+        # @author Lars Olsson
+        # @since  18-04-2011
+        # @param  [Object] options A hash containing the options to use
+        # @option options [Object] :connection a Sequel database object
+        #  (Sequel::Database) You can use any parameters that Sequel supports for
+        #  this object. If this option is left unset, a Sqlite memory database
+        #  will be used.
+        # @option options [String] :table The table name you want to use for the
+        #  cache. Can be either a String or a Symbol. If this option is left
+        #  unset, a table called ramaze_cache will be used.
+        # @option options [Fixnum] :ttl Setting this value will override
+        #  Ramaze's default setting for when a particular cache item will be
+        #  invalidated. By default this setting is not used and the cache uses
+        #  the values provided by Ramaze, but if you want to use this setting it
+        #  should be set to an integer representing the number of seconds before
+        #  a cache item becomes invalidated.
+        # @option options [TrueClass] :display_warnings When this option is set
+        #  to true, failure to serialize or de-serialize cache items will produce
+        #  a warning in the Ramaze log. This option is set to false by default.
+        #  Please note that certain objects (for instance Procs) cannot be
+        #  serialized by ruby and therefore cannot be cached by this cache class.
+        #  Setting this option to true is a good way to find out if the stuff you
+        #  are trying to cache is affected by this. Failure to
+        #  serialize/de-serialize a cache item will never raise an exception, the
+        #  item will just remain uncached.
+        # @return [Object]
+        #
+        def using(options = {})
+          merged = Ramaze::Cache::Sequel.trait[:default].merge(options)
+          Class.new(self) { @options = merged }
+        end
+      end
+
+      ##
+      # Creates a new instance of the cache class.
+      #
+      # @author Michael Fellinger
+      # @since  04-05-2011
+      # @param  [Hash] options A hash with custom options, see
+      #  Ramaze::Cache::Sequel.using for all available options.
+      #
+      def initialize(options = {})
+        self.class.options ||= Ramaze::Cache::Sequel.trait[:default].merge(
+          options
+        )
+
+        @options = options.merge(self.class.options)
+      end
+
+      ##
+      # Executed after #initialize and before any other method.
+      #
+      # Some parameters identifying the current process will be passed so caches
+      # that act in one global name-space can use them as a prefix.
+      #
+      # @author Lars Olsson
+      # @since  18-04-2011
+      # @param  [String] hostname  the hostname of the machine
+      # @param  [String] username  user executing the process
+      # @param  [String] appname   identifier for the application
+      # @param  [String] cachename namespace, like 'session' or 'action'
+      #
+      def cache_setup(hostname, username, appname, cachename)
+        @namespace = [hostname, username, appname, cachename].compact.join(':')
+
+        # Create the table if it's not there yet
+        if !options[:connection].table_exists?(options[:table])
+          options[:connection].create_table(
+            options[:table]) do
+            primary_key :id
+            String :key  , :null => false, :unique => true
+            String :value, :text => true
+            Time :expires
+          end
+        end
+
+        @dataset = options[:connection][options[:table].to_sym]
+      end
+
+      ##
+      # Remove all key/value pairs from the cache. Should behave as if #delete
+      # had been called with all +keys+ as argument.
+      #
+      # @author Lars Olsson
+      # @since  18-04-2011
+      #
+      def cache_clear
+        @dataset.delete
+      end
+
+      ##
+      # Remove the corresponding key/value pair for each key passed. If removing
+      # is not an option it should set the corresponding value to nil.
+      #
+      # If only one key was deleted, answer with the corresponding value. If
+      # multiple keys were deleted, answer with an Array containing the values.
+      #
+      # @author Lars Olsson
+      # @since  18-04-2011
+      # @param  [Object] key The key for the value to delete
+      # @param  [Object] keys Any other keys to delete as well
+      # @return [Object/Array/nil]
+      #
+      def cache_delete(key, *keys)
+        # Remove a single key
+        if keys.empty?
+          nkey   = namespaced(key)
+          result = @dataset.select(:value).filter(:key => nkey).limit(1)
+
+          # Ramaze expects nil values
+          if result.empty?
+            result = nil
+          else
+            result = deserialize(result.first[:value])
+          end
+
+          @dataset.filter(:key => nkey).delete
+        # Remove multiple keys
+        else
+          nkeys  = [key, keys].flatten.map! { |n| namespaced(n) }
+          result = dataset.select(:value).filter(:key => nkeys)
+
+          result.map! do |row|
+            deserialize(row[:value])
+          end
+
+          @dataset.filter(:key => nkeys).delete
+        end
+
+        return result
+      end
+
+      ##
+      # Answer with the value associated with the +key+, +nil+ if not found or
+      # expired.
+      #
+      # @author Lars Olsson
+      # @since  18-04-2011
+      # @param  [Object] key The key for which to fetch the value
+      # @param  [Object] default Will return this if no value was found
+      # @return [Object]
+      #
+      def cache_fetch(key, default = nil)
+        nkey = namespaced(key)
+
+        # Delete expired rows
+        @dataset.select.filter(:key => nkey) do
+          expires < Time.now
+        end.delete
+
+        # Get remaining row (if any)
+        result = @dataset.select(:value).filter(:key => nkey).limit(1)
+
+        if result.empty?
+          return default
+        else
+          return deserialize(result.first[:value])
+        end
+      end
+
+      ##
+      # Sets the given key to the given value.
+      #
+      # @example
+      #  Cache.value.store(:num, 3, :ttl => 20)
+      #  Cache.value.fetch(:num)
+      #
+      # @author Lars Olsson
+      # @since  18-04-2011
+      # @param  [Object] key The value is stored with this key
+      # @param  [Object] value The key points to this value
+      # @param  [Hash] options for now, only :ttl => Fixnum is used.
+      # @option options [Fixnum] :ttl The time in seconds after which the cache
+      #  item should be expired.
+      #
+      def cache_store(key, value, options = {})
+        nkey = namespaced(key)
+
+        # Get the time after which the cache should be expired
+        if options[:ttl]
+          ttl = options[:ttl]
+        else
+          ttl = Ramaze::Cache::Sequel.options[:ttl]
+        end
+
+        expires = Time.now + ttl if ttl
+
+        # The row already exists, update it.
+        if @dataset.filter(:key => nkey).count == 1
+          serialized_value = serialize(value)
+
+          if serialized_value
+            @dataset.filter(:key => nkey) \
+              .update(:value => serialize(value), :expires => expires)
+          end
+        # The row doesn't exist yet.
+        else
+          serialized_value = serialize(value)
+
+          if serialized_value
+            @dataset.insert(
+              :key => nkey, :value => serialize(value), :expires => expires
+            )
+          end
+        end
+
+        # Try to deserialize the value. If this fails we'll return a different
+        # value
+        deserialized = deserialize(@dataset.select(:value) \
+          .filter(:key => nkey) \
+          .limit(1).first[:value])
+
+        if deserialized
+          return deserialized
+        else
+          return value
+        end
+      end
+
+      ##
+      # Prefixes the given key with current namespace.
+      #
+      # @author Lars Olsson
+      # @since  18-04-2011
+      # @param  [Object] key Key without namespace.
+      # @return [Object]
+      #
+      def namespaced(key)
+        return [@namespace, key].join(':')
+      end
+
+      ##
+      # Deserialize method, adapted from Sequels serialize plugin
+      # This method will try to deserialize a value using Marshal.load
+      #
+      # @author Lars Olsson
+      # @since  18-04-2011
+      # @param  [Object] value Value to be deserialized
+      # @return [Object nil]
+      #
+      def deserialize(value)
+        begin
+          ::Marshal.load(value.unpack('m')[0])
+        rescue
+          begin
+            ::Marshal.load(value)
+          rescue
+            # Log the error?
+            if options[:display_warnings] === true
+              Ramaze::Log::warn("Failed to deserialize #{value.inspect}")
+            end
+
+            return nil
+          end
+        end
+      end
+
+      ##
+      # Serialize method, adapted from Sequels serialize plugin
+      # This method will try to serialize a value using Marshal.dump
+      #
+      # @author Lars Olsson
+      # @since  18-04-2011
+      # @param  [Object] value Value to be serialized.
+      # @return [Object nil]
+      #
+      def serialize(value)
+        begin
+          [::Marshal.dump(value)].pack('m')
+        rescue
+          if options[:display_warnings] === true
+            Ramaze::Log::warn("Failed to serialize #{value.inspect}")
+          end
+
+          return nil
+        end
+      end
+    end # Sequel
+  end # Cache
+end # Ramaze

data/lib/ramaze/cache.rb

@@ -1,89 +1,49 @@
-#          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'
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+require 'innate/cache'
 
 module Ramaze
-  autoload :YAMLStoreCache, "ramaze/cache/yaml_store.rb"
-  autoload :MemcachedCache, "ramaze/cache/memcached.rb"
-
-  # This is the wrapper of all caches, providing mechanism
-  # for switching caching from one adapter to another.
+  Cache = Innate::Cache
 
+  #:nodoc:
   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, self)
-          add_on(key, klass)
-        }
-        Log.dev("Added caches for: #{keys.join(', ')}")
-      end
-
-      def add_on(key, cache_class)
-        CACHES[key] = new(cache_class)
-        CACHES[key].instance_variable_set("@cache_name", key)
-        self.class.class_eval do
-          define_method(key){ CACHES[key] }
-        end
-      end
-
-    end
-
-    # Initializes the cache, defined by Global.cache
-    def initialize(cache = Global.cache)
-      @cache = cache.new
-    end
-
-    # Get key.
-    def [](key)
-      @cache["#{@cache_name}:#{key}"]
-    end
-
-    # Set key to value.
-    def []=(key, value)
-      @cache["#{@cache_name}:#{key}"] = value
-    end
-
-    # deletes the keys of each argument passed from Cache instance.
-    def delete(*args)
-      args.each do |arg|
-        @cache.delete("#{@cache_name}:#{arg}")
-      end
-    end
-
-    # Empty this cache
-    def clear
-      @cache.clear
+    autoload :LRU,           'ramaze/cache/lru'
+    autoload :LocalMemCache, 'ramaze/cache/localmemcache'
+    autoload :MemCache,      'ramaze/cache/memcache'
+    autoload :Sequel,        'ramaze/cache/sequel'
+    autoload :Redis,         'ramaze/cache/redis'
+    autoload :Moneta,        'ramaze/cache/moneta'
+
+    ##
+    # Overwrites {Innate::Cache#initialize} to make cache classes application
+    # aware. This prevents different applications running on the same host and
+    # user from overwriting eachothers data.
+    #
+    # @since 14-05-2012
+    # @see   Innate::Cache#initialize
+    #
+    def initialize(name, klass = nil)
+      @name      = name.to_s.dup.freeze
+      klass    ||= options[@name.to_sym]
+      @instance  = klass.new
+
+      @instance.cache_setup(
+        ENV['HOSTNAME'],
+        ENV['USER'],
+        Ramaze.options.app.name.to_s,
+        @name
+      )
     end
 
-    # Answers with value for each key.
-    def values_at(*keys)
-      @cache.values_at(*keys.map {|key| "#{@cache_name}:#{key}" })
+    ##
+    # Clears the cache after a file has been reloaded.
+    #
+    # @author Michael Fellinger
+    # @since  17-07-2009
+    #
+    def self.clear_after_reload
+      action.clear if respond_to?(:action)
+      action_value.clear if respond_to?(:action_value)
     end
-  end
-end
+  end # Cache
+end # Ramaze

data/lib/ramaze/controller/default.rb

@@ -0,0 +1,25 @@
+module Ramaze
+  Log.debug "Default controller invoked"
+
+  ##
+  # The default controller that is loaded if no other controllers have been
+  # defined.
+  #
+  # @author Michael Fellinger
+  # @since  30-03-2009
+  #
+  class DefaultController < Ramaze::Controller
+    map '/'
+
+    ##
+    # Shows an ASCII lobster using Rack::Lobster::LobsterString.
+    #
+    # @author Michael Fellinger
+    # @since  06-04-2009
+    #
+    def lobster
+      require 'rack/lobster'
+      respond Rack::Lobster::LobsterString
+    end
+  end # DefaultController
+end # Ramaze