merb 0.5.3 → 0.9.2

data/lib/merb/caching.rb

@@ -1,5 +0,0 @@
-corelib = Merb.framework_root + '/merb/caching'
-
-%w[ action_cache
-    fragment_cache
-  ].each {|fn| require File.join(corelib, fn)}

data/lib/merb/caching/action_cache.rb

@@ -1,92 +0,0 @@
-module Merb
-  module Caching
-    
-    
-    # Action caching provides the ability to cache the output of individual actions.  This output will be stored using fragment caching 
-    # (Merb::Caching::Fragment).  The output is stored based on a multipart key, which is comprised of the following pieces, in this order:
-    # * controller
-    # * action
-    # * parameters  (represented as a list of parameter name/value pairs, sorted by name)
-    # 
-    #
-    # === Examples
-    #
-    #  class UserController < Merb::Controller 
-    #    cache_action(:show, :index) 
-    # 
-    #    def show 
-    #       ... do some work to show a user ... 
-    #    end  
-    #    
-    #    def index
-    #       ... get the list of users ...
-    #    end
-    #  end 
-    #
-    # In this case, we would expect show to take an :id parameter, and index to take no parameters, so the fragment stored for this action 
-    # will be represented thus:
-    #   get :show, :id => 25    => [:user_controller, :show, :id, 25]
-    #   get :index => [:user_controller, :index]
-    # 
-    # Action caches are expired based on the action alone (TODO: We need to modify expire action to allow expiration for specific parameter values).
-    #   expire_action(:show)  => This will expire all cached show actions (i.e. All users, in this case)    
-     
-    module Actions 
-  
-      def self.included(base) # :nodoc: 
-
-        base.extend(ClassMethods)
-      end
-  
-      module ClassMethods
-  
-        # Cache the specific actions.  If those actions take parameters, then those parameters will be considered part of the key.
-        # 
-        def cache_action(*actions)
-          before :_get_action_fragment, :only => actions        
-          after :_store_action_fragment, :only => actions
-        end
-        
-      end
-
-      
-      # Expire all cached content for the specific action, or array of actions.  
-      def expire_action(*actions)
-        return unless _caching_enabled?        
-        for action in [actions].flatten
-          ::Merb::Caching::Fragment.expire_fragment(params_key(:action => action))
-        end
-      end
-
-      
-      private
-
-      def _caching_enabled?
-        ::Merb::Config[:cache_templates]
-      end
-
-      def _get_action_fragment
-        return unless _caching_enabled?        
-        if fragment = ::Merb::Caching::Fragment.get(params_key)
-          throw :halt, fragment
-        end
-      end
-      
-      def _store_action_fragment        
-        return unless _caching_enabled?
-        ::Merb::Caching::Fragment.put(params_key, body)
-      end
-      
-      
-      def params_key(overrides = {})
-        key = []
-        additional_parameters = params.clone.merge(overrides)
-        key << additional_parameters.delete(:controller).to_s.snake_case        
-        key << additional_parameters.delete(:action).to_s.snake_case        
-        key << additional_parameters.keys.sort{|a,b| a.to_s <=> b.to_s}.collect{|k| [k.to_s, additional_parameters[k].to_s]}.flatten
-        key.flatten
-      end
-  
-    end
-  end
-end  

data/lib/merb/caching/fragment_cache.rb

@@ -1,39 +0,0 @@
-module Merb
-  module Caching
-    module Fragment
-      class << self
-        def cache
-          @cache ||= determine_cache_store
-        end
-        
-        def clear
-          cache.clear
-          @cache = nil
-        end
-        
-        def get(name)
-          cache.get(name)
-        end
-        
-        def put(name, content = nil)          
-          cache.put(name, content)
-          content
-        end
-        
-        def expire_fragment(name)
-          cache.delete(name)
-        end
-        
-        def determine_cache_store
-          if ::Merb::Config[:cache_store].to_s == "file"
-            require 'merb/caching/store/file_cache'
-            ::Merb::Caching::Store::FileCache.new
-          else
-            require 'merb/caching/store/memory_cache'
-            ::Merb::Caching::Store::MemoryCache.new
-          end
-        end  
-      end
-    end
-  end
-end

data/lib/merb/caching/store/file_cache.rb

@@ -1,90 +0,0 @@
-require 'uri'
-require 'fileutils'
-require 'tmpdir'
-
-module Merb
-  module Caching
-    module Store
- 
-      class FileCache
-            
-        def initialize(name = "cache", keepalive = nil)
-          @path = File.join(Merb.root, name)
-          @keepalive = keepalive  
-        end
-      
-        def []=(key,val)
-          key = escape_filenames([key].flatten)
-          FileUtils.mkdir_p(File.join(@path, *key[0..-2]), :mode => 0700)
-          fn = File.join(@path, *key )
-          encode_file(fn, val)
-        end
-        alias :put :[]=
-        alias :write :[]=
-        
-        def [](key)          
-          key = escape_filenames([key].flatten)          
-          fn = File.join(@path, *key )
-          return nil unless File.exists?(fn)
-          decode_file(fn)
-        end
-        alias :get :[]
-        alias_method :read, :[]
-      
-        def delete(key)          
-          key = escape_filenames([key].flatten)
-          f = File.join(@path, *key)
-          FileUtils.rm_rf(f) 
-        end
-        
-        def gc!
-          return unless @keepalive
-      
-          now = Time.now
-          all.each do |fn|
-            expire_time = File.stat(fn).atime + @keepalive 
-            File.delete(fn) if now > expire_time
-          end
-        end
-        
-        def clear
-          all.each{|file| delete(File.basename(file)) }
-        end
-
-        private
-      
-        def decode_file(fn)
-          val = nil
-          File.open(fn,"r+b") do |f|
-            f.flock(File::LOCK_EX)
-            val = Marshal.load( f.read )
-            f.flock(File::LOCK_UN)
-          end
-          return val
-        end
-      
-        def encode_file(fn, value)
-          File.open(fn, "wb") do |f| 
-            f.flock(File::LOCK_EX)
-            f.chmod(0600)
-            f.write(Marshal.dump(value))
-            f.flock(File::LOCK_UN)
-          end
-        end
-        
-        def all
-          Dir.glob( File.join(@path, '*' ) )
-        end
-        # need this for fat filesystems
-        def escape_filenames(fns)
-          fns.collect do |fn|
-            URI.escape(fn.to_s, /["\/:;|=,\[\]]/)            
-          end
-        end
-      
-      end
-      
-    end
-  end
-end
-

data/lib/merb/caching/store/memory_cache.rb

@@ -1,85 +0,0 @@
-module Merb
-  module Caching
-    module Store
-      
-      class MemoryCache
-      
-        def initialize(opts={})
-          @opts = opts
-          @cache = Hash.new
-          @timestamps = Hash.new
-          @mutex = Mutex.new
-          @cache_ttl = @opts.fetch(:session_ttl, 30*60) # default 30 minutes
-        end
-        
-        def [](key)
-          key = [key].flatten.collect{|k| k.to_s}
-          @mutex.synchronize {
-            @timestamps[key] = Time.now
-            sub_cache = @cache
-            key[0..-2].each do |subkey|
-              sub_cache = (sub_cache[subkey] ||= {})
-            end
-            sub_cache[key[-1]]
-          }
-        end
-        alias_method :get, :[]
-        alias_method :read, :[]
-         
-        def []=(key, val)     
-          key = [key].flatten.collect{|k| k.to_s}
-          @mutex.synchronize {
-            sub_cache = @cache
-            key[0..-2].each do |subkey|
-              sub_cache = (sub_cache[subkey] ||= {})
-            end
-            sub_cache[key[-1]] = val
-            @timestamps[key] = Time.now
-          } 
-        end
-        alias_method :put, :[]=
-        alias_method :write, :[]=
-        
-        def delete(key)
-          key = [key].flatten.collect{|k| k.to_s}
-          @mutex.synchronize {
-            sub_cache = @cache
-            key[0..-2].each do |subkey|
-              sub_cache = (sub_cache[subkey] ||= {})
-            end
-            sub_cache.delete(key[-1])
-          }
-        end
-        alias_method :remove, :delete
-        
-        def delete_if(&block)
-          @hash.delete_if(&block)
-        end
-        
-        def reap_old_caches
-          @timestamps.each do |key,stamp|
-            if stamp + @cache_ttl < Time.now
-              delete(key)
-            end  
-          end
-          GC.start
-        end  
-        
-        def cache
-          @cache
-        end  
-        
-        def keys
-          @cache.keys 
-        end  
-        
-        def clear
-          @cache = Hash.new
-          @timestamps = Hash.new
-          @mutex = Mutex.new          
-        end
-              
-      end 
-    end
-  end   
-end  

data/lib/merb/config.rb

@@ -1,290 +0,0 @@
-require File.join(File.dirname(__FILE__), 'erubis_ext')
-require File.join(File.dirname(__FILE__), 'version')
-require File.join(File.dirname(__FILE__), 'boot_loader')
-module Merb
-  class Config
-    class << self
-      
-      def defaults
-        @defaults ||= {
-          :host                   => "0.0.0.0",
-          :port                   => "4000",
-          :reloader               => true,
-          :cache_templates        => false,
-          :merb_root              => Dir.pwd,
-          :use_mutex              => true,
-          :session_id_cookie_only => true,
-          :query_string_whitelist => [],
-          :mongrel_x_sendfile     => true
-        }
-      end
-      
-      def [](key)
-        (@configuration||={})[key]
-      end
-      
-      def []=(key,val)
-        @configuration[key] = val
-      end
-      def delete(key)
-        @configuration.delete key
-      end
-      
-      def fetch(key, default)
-        @configuration.fetch key, default
-      end
-      
-      def to_yaml
-        @configuration.to_yaml  
-      end
-      
-      def setup(global_merb_yml = nil)
-        @configuration ||= {}
-        if FileTest.exist? "#{defaults[:merb_root]}/framework"
-          $LOAD_PATH.unshift( "#{defaults[:merb_root]}/framework" )
-        end
-        global_merb_yml ||= "#{defaults[:merb_root]}/config/merb.yml"
-        apply_configuration_from_file defaults, global_merb_yml
-      end
-
-      def apply_configuration_from_file(configuration, file)
-        if File.exists?(file)
-          configuration.merge(Erubis.load_yaml_file(file))
-        else
-          configuration
-        end
-      end
-      
-      def parse_args(argv = ARGV)
-         @configuration ||= {}
-         # Our primary configuration hash for the length of this method
-         options = {}
-
-         # Environment variables always win
-         options[:environment] = ENV['MERB_ENV'] if ENV['MERB_ENV']
-
-         # Build a parser for the command line arguments
-         opts = OptionParser.new do |opts|
-           opts.version = Merb::VERSION
-           opts.release = Merb::RELEASE
-
-           opts.banner = "Usage: merb [fdcepghmisluMG] [argument]"
-           opts.define_head "Merb Mongrel+ Erb. Lightweight replacement for ActionPack."
-           opts.separator '*'*80
-           opts.separator 'If no flags are given, Merb starts in the foreground on port 4000.'
-           opts.separator '*'*80
-
-           opts.on("-u", "--user USER", "This flag is for having merb run as a user other than the one currently logged in. Note: if you set this you must also provide a --group option for it to take effect.") do |config|
-             options[:user] = config
-           end
-
-           opts.on("-G", "--group GROUP", "This flag is for having merb run as a group other than the one currently logged in. Note: if you set this you must also provide a --user option for it to take effect.") do |config|
-             options[:group] = config
-           end
-
-           opts.on("-f", "--config-file FILENAME", "This flag is for adding extra config files for things like the upload progress module.") do |config|
-             options[:config] = config
-           end
-
-           opts.on("-d", "--daemonize", "This will run a single merb in the background.") do |config|
-             options[:daemonize] = true
-           end
-
-           opts.on("-c", "--cluster-nodes NUM_MERBS", "Number of merb daemons to run.") do |nodes|
-             options[:cluster] = nodes
-           end
-
-           opts.on("-p", "--port PORTNUM", "Port to run merb on, defaults to 4000.") do |port|
-             options[:port] = port
-           end
-
-           opts.on("-h", "--host HOSTNAME", "Host to bind to (default is all IP's).") do |host|
-             options[:host] = host
-           end
-
-           opts.on("-m", "--merb-root Merb.root", "The path to the Merb.root for the app you want to run (default is current working dir).") do |Merb.root|
-             options[:merb_root] = File.expand_path(Merb.root)
-           end
-
-           opts.on("-i", "--irb-console", "This flag will start merb in irb console mode. All your models and other classes will be available for you in an irb session.") do |console|
-             ::Merb::BootLoader.initialize_merb
-             _merb = Class.new do
-               class << self
-                 include Merb::GeneralControllerMixin
-                 def params() {} end
-               end  
-               def self.show_routes(all_opts = false)
-                 seen = []
-                 unless Merb::Router.named_routes.empty?
-                   puts "Named Routes"
-                   Merb::Router.named_routes.each do |name,route|
-                     puts "  #{name}: #{route}"
-                     seen << route
-                   end
-                 end
-                 puts "Anonymous Routes"
-                 (Merb::Router.routes - seen).each do |route|
-                   puts "  #{route}"
-                 end
-                 nil
-               end
-             end
-
-             Object.send(:define_method, :merb) {
-               _merb
-             }  
-             ARGV.clear # Avoid passing args to IRB 
-             require 'irb' 
-             require 'irb/completion' 
-             def exit
-               exit!
-             end   
-             if File.exists? ".irbrc"
-               ENV['IRBRC'] = ".irbrc"
-             end
-             IRB.start
-             exit!
-           end
-
-           opts.on("-s", "--start-drb PORTNUM", "This is the port number to run the drb daemon on for sessions and upload progress monitoring.") do |drb_port|
-             puts "Starting merb drb server on port: #{Merb::Config[:drb_server_port]}"
-             Merb::Server.start(drb_port, :drbserver_start)
-             exit if Merb::Config[:only_drb]
-           end
-
-           opts.on("-l", "--log-level LEVEL", "Log levels can be set to any of these options: DEBUG < INFO < WARN < ERROR < FATAL < UNKNOWN") do |loglevel|
-             options[:log_level] = loglevel
-           end
-
-           opts.on("-e", "--environment STRING", "Run merb in the correct mode(development, production, testing)") do |env|
-             options[:environment] ||= env
-           end
-
-           opts.on("-r", "--script-runner ['RUBY CODE'| FULL_SCRIPT_PATH]", 
-             "Command-line option to run scripts and/or code in the merb app.") do |code_or_file|
-               ::Merb::BootLoader.initialize_merb
-               if File.exists?(code_or_file)
-                 eval(File.read(code_or_file))
-               else
-                 eval(code_or_file)
-               end
-               exit!
-           end
-
-           opts.on("-P","--generate-plugin PATH", "Generate a fresh merb plugin at PATH.") do |path|
-             require 'merb/generators/merb_plugin'
-             ::Merb::PluginGenerator.run path || Dir.pwd
-             exit
-           end
-
-           opts.on("-K", "--graceful PORT or all", "Gracefully kill one merb proceses by port number.  Use merb -K all to gracefully kill all merbs.") do |ports|
-             @configuration = defaults.merge(options)
-             Merb::Server.kill(ports, 1)
-           end
-           
-           opts.on("-k", "--kill PORT or all", "Kill one merb proceses by port number.  Use merb -k all to kill all merbs.") do |ports|
-             @configuration = defaults.merge(options)
-             Merb::Server.kill(ports, 9)
-           end
-
-           opts.on("-M", "--merb-config FILENAME", "This flag is for explicitly declaring the merb app's config file.") do |config|
-             options[:merb_config] = config
-           end
-
-           opts.on("-w", "--webrick", "Run merb using Webrick Rack Adapter instead of mongrel.") do |webport|
-             puts "Starting merb webrick server on port: #{Merb::Config[:port]}"
-             trap('TERM') { exit }
-             Merb::Server.webrick_start(Merb::Config[:port])
-           end
-
-           opts.on("-F", "--fastcgi", "Run merb using FastCGI Rack Adapter instead of mongrel.") do
-             trap('TERM') { exit }
-             Merb::Server.fastcgi_start
-           end
-
-           opts.on("-X", "--mutex on/off", "This flag is for turning the mutex lock on and off.") do |mutex|
-             if mutex == 'off'
-               options[:use_mutex] = false
-             else
-               options[:use_mutex] = true
-             end   
-           end
-
-           opts.on("-D", "--debugger", "Run merb using rDebug.") do
-             begin
-              require 'ruby-debug'
-              Debugger.start
-              Debugger.settings[:autoeval] = true if Debugger.respond_to?(:settings)
-              puts "Debugger enabled"
-             rescue LoadError
-              puts "You need to install ruby-debug to run the server in debugging mode. With gems, use 'gem install ruby-debug'"
-              exit
-             end
-           end
-
-           opts.on("-?", "-H", "--help", "Show this help message") do
-             puts opts  
-             exit
-           end
-         end
-
-         # If we run merb with no arguments and we are not inside a merb root
-         # show the help message
-         if !defined?(Merb.framework_root) && (argv.size == 0) && !File.exists?("#{options[:merb_root] || Merb::Config.defaults[:merb_root]}/config/merb_init.rb") 
-           puts "You are not in the root of a merb application...\n"
-           puts opts 
-           exit 
-         end
-
-         # Parse what we have on the command line
-         opts.parse!(argv)
-
-         # merb <argument> is same as merb -g <argument>
-         if argv.size == 1
-           require 'merb/generators/merb_app/merb_app'
-           ::Merb::AppGenerator.run File.expand_path(argv.last)
-           exit!
-         end
-
-         # Load up the configuration from file, but keep the command line
-         # options that may have been chosen. Also, pass-through if we have
-         # a new merb_config path.
-         options = Merb::Config.setup(options[:merb_config]).merge(options)
-
-         # Finally, if all else fails... set the environment to 'development'
-         options[:environment] ||= 'development'
-
-         environment_merb_yml = "#{options[:merb_root]}/config/environments/#{options[:environment]}.yml"        
-
-         @configuration = Merb::Config.apply_configuration_from_file options, environment_merb_yml
-         
-         case Merb::Config[:environment].to_s
-         when 'production'
-           Merb::Config[:reloader] = Merb::Config.fetch(:reloader, false)
-           Merb::Config[:exception_details] = Merb::Config.fetch(:exception_details, false)
-           Merb::Config[:cache_templates] = true
-         else
-           Merb::Config[:reloader] = Merb::Config.fetch(:reloader, true)
-           Merb::Config[:exception_details] = Merb::Config.fetch(:exception_details, true)
-         end
-
-         Merb::Config[:reloader_time] ||= 0.5 if Merb::Config[:reloader] == true
-
-
-         if Merb::Config[:reloader]
-           Thread.abort_on_exception = true
-           Thread.new do
-             loop do
-               sleep( Merb::Config[:reloader_time] )
-               ::Merb::BootLoader.reload if ::Merb::BootLoader.app_loaded?
-             end
-             Thread.exit
-           end
-         end
-         @configuration
-       end
-       
-    end # class << self
-  end # Config
-  
-end