merb 0.4.2 → 0.5.0

data/lib/merb/assets.rb

@@ -0,0 +1,119 @@
+module Merb
+  module Assets
+    
+    # Returns true if assets should be bundled (e.g., production mode or
+    # :bundle_assets is explicitly enabled), false if not.
+    def self.bundle?
+      (Merb::Config[:environment] == :production) ||
+      (!!Merb::Config[:bundle_assets])
+    end
+    
+    # Helpers for handling asset files.
+    module AssetHelpers
+      # :nodoc:
+      ASSET_FILE_EXTENSIONS = {
+        :javascript => ".js",
+        :stylesheet => ".css"
+      }
+      
+      # Returns the URI path to a particular asset file. If +local_path+ is
+      # true, returns the path relative to the Merb.root, not the public
+      # directory. Uses the path_prefix, if any is configured.
+      # 
+      #   asset_path(:javascript, :dingo)       #=> "/javascripts/dingo.js"
+      #   asset_path(:javascript, :dingo, true) #=> "public/javascripts/dingo.js"
+      def asset_path(asset_type, filename, local_path = false)
+        filename = filename.to_s
+        if filename !~ /#{'\\' + ASSET_FILE_EXTENSIONS[asset_type]}\Z/
+          filename << ASSET_FILE_EXTENSIONS[asset_type]
+        end
+        filename = "/#{asset_type}s/#{filename}"
+        if local_path
+          return "public#{filename}"
+        else
+          return "#{Merb::Config[:path_prefix]}#{filename}"
+        end
+      end
+    end
+    
+    # An abstract class for bundling text assets into single files.
+    class AbstractAssetBundler
+      class << self
+        
+        # Add a post-bundle callback, for example to run a Javascript or CSS
+        # compressor on the bundled file:
+        # 
+        #   Merb::Assets::JavascriptAssetBundler.add_callback do |filename|
+        #     `yuicompressor #{filename}`
+        #   end
+        def add_callback(&block)
+          callbacks << block
+        end
+        alias_method :after_bundling, :add_callback
+        
+        # An array of any existing callbacks.
+        def callbacks
+          @callbacks ||= []
+          return @callbacks
+        end
+        
+        # The type of asset for which the bundler is responsible.
+        def asset_type
+          raise NotImplementedError, "should return a symbol for the first argument to be passed to asset_path"
+        end
+      end
+      
+      # Create a new asset bundler, which will produce a bundled file containing
+      # the contents of +files+. If +name+ is +true+ (as in, is an instance of
+      # +TrueClass+), the filename is written out as "all", otherwise +name+
+      # is coerced into a string.
+      def initialize(name, *files)
+        @bundle_name = name == true ? :all : name
+        @bundle_filename = asset_path(self.class.asset_type, @bundle_name, true)
+        @files = files.map { |f| asset_path(self.class.asset_type, f, true) }
+      end
+      
+      # Creates the new bundled file, executes all the callbacks, and returns
+      # the name of the bundled file.
+      def bundle!
+        # TODO: Move this file check out into an in-memory cache. Also, push it out to the helper level so we don't have to create the helper object.
+        unless File.exist?(@bundle_filename)
+          bundle_files(@bundle_filename, *@files)
+          self.class.callbacks.each { |c| c.call(@bundle_filename) }
+        end
+        return @bundle_name
+      end
+      
+    protected
+      
+      include Merb::Assets::AssetHelpers # for asset_path
+      
+      # Bundle all the filenames in +files+ into +filename+.
+      def bundle_files(filename, *files)
+        File.open(filename, "w") do |f|
+          files.each { |file| f.puts(File.read(file)) }
+        end
+      end
+      
+    end
+    
+    # Bundles javascripts into a single file:
+    # 
+    #   javascripts/#{name}.js
+    class JavascriptAssetBundler < AbstractAssetBundler
+      def self.asset_type
+        :javascript
+      end
+    end
+    
+    # Bundles stylesheets into a single file:
+    # 
+    #   stylesheets/#{name}.css
+    class StylesheetAssetBundler < AbstractAssetBundler
+      def self.asset_type
+        :stylesheet
+      end
+    end
+    
+  end
+end

data/lib/merb/boot_loader.rb

@@ -0,0 +1,217 @@
+module Merb
+  module GlobalHelper;end
+  
+  module BootLoader
+    class << self
+      
+      def initialize_merb
+        require 'merb'
+        @mtime = Time.now if Merb::Config[:reloader] == true
+        # Register session types before merb_init.rb so that any additional
+        # session stores will be added to the end of the list and become the
+        # default.
+        register_session_type('memory',
+          Merb.framework_root / "merb" / "session" / "memory_session",
+          "Using in-memory sessions; sessions will be lost whenever the server stops.")
+        register_session_type('mem_cache',
+          Merb.framework_root / "merb" / "session" / "mem_cache_session",
+          "Using MemCache distributed memory sessions")
+        register_session_type('cookie', # Last session type becomes the default
+          Merb.framework_root / "merb" / "session" / "cookie_store",
+          "Using 'share-nothing' cookie sessions (4kb limit per client)")
+        require Merb.root / 'config/merb_init.rb'
+        add_controller_mixins
+      end
+      
+      def max_mtime( files = [] )
+        files.map{ |file| File.mtime(file) rescue @mtime }.max
+      end
+      
+      def register_session_type(name, file, description = nil)
+        @registered_session_types ||= YAML::Omap.new
+        @registered_session_types[name] = {
+          :file => file,
+          :description => (description || "Using #{name} sessions")
+        }
+      end
+      
+      def add_controller_mixins
+        types = @registered_session_types
+        Merb::Controller.class_eval do
+          lib = File.join(Merb.framework_root, 'merb')
+          session_store = Merb::Config[:session_store].to_s
+          if ["", "false"].include?(session_store)
+            puts "Not Using Sessions"
+          elsif reg = types[session_store]
+            if session_store == "cookie" 
+              unless Merb::Config[:session_secret_key] && (Merb::Config[:session_secret_key].length >= 16)
+                puts("You must specify a session_secret_key in your merb.yml, and it must be at least 16 characters\nbailing out...")
+                exit! 
+              end
+              Merb::Controller.session_secret_key = Merb::Config[:session_secret_key]
+            end
+            require reg[:file]
+            include ::Merb::SessionMixin
+            puts reg[:description]
+          else
+            puts "Session store not found, '#{Merb::Config[:session_store]}'."
+            puts "Defaulting to CookieStore Sessions"
+            unless Merb::Config[:session_secret_key] && (Merb::Config[:session_secret_key].length >= 16)
+              puts("You must specify a session_secret_key in your merb.yml, and it must be at least 16 characters\nbailing out...")
+              exit! 
+            end            
+            Merb::Controller.session_secret_key = Merb::Config[:session_secret_key]
+            require types['cookie'][:file]
+            include ::Merb::SessionMixin
+            puts "(plugin not installed?)"
+          end
+          
+          if Merb::Config[:basic_auth]
+            require lib + "/mixins/basic_authentication"
+            include ::Merb::AuthenticationMixin
+            puts "Basic Authentication mixed in"
+          end
+        end
+      end
+      
+      def after_app_loads(&block)
+        @after_app_blocks ||= []
+        @after_app_blocks << block
+      end
+      
+      def app_loaded?
+        @app_loaded
+      end
+      
+      def load_action_arguments(klasses = Merb::Controller._subclasses)
+        begin
+          klasses.each do |controller|
+            controller = Object.full_const_get(controller)
+            controller.action_argument_list = {}
+            controller.callable_actions.each do |action, bool|
+              controller.action_argument_list[action.to_sym] = ParseTreeArray.translate(controller, action).get_args
+            end
+          end
+        rescue
+          klasses.each { |controller| Object.full_const_get(controller).action_argument_list = {} }
+        end if defined?(ParseTreeArray)
+      end
+      
+      def template_paths(type = "*[a-zA-Z]")
+        # This gets all templates set in the controllers template roots        
+        template_paths = Merb::AbstractController._abstract_subclasses.map do |klass| 
+          Object.full_const_get(klass)._template_root
+        end.uniq.map do |path| 
+          Dir["#{path}/**/#{type}"] 
+        end
+        
+        # This gets the templates that might be created outside controllers
+        # template roots.  eg app/views/shared/*
+        template_paths << Dir["#{Merb.root}/app/views/**/*[a-zA-Z]"] if type == "*"
+        
+        template_paths.flatten.compact.uniq || []
+      end
+      
+      def load_controller_template_path_cache
+        Merb::AbstractController.reset_template_path_cache!
+      
+        template_paths.each do |template|
+          Merb::AbstractController.add_path_to_template_cache(template)
+        end
+      end
+      
+      def load_inline_helpers
+        partials = template_paths("_*.{erb,haml}")
+        
+        partials.each do |partial|
+          case partial
+          when /erb$/
+            template = Erubis::Eruby.new(File.read(partial))
+            template.def_method(Merb::GlobalHelper, partial.gsub(/[^\.a-zA-Z0-9]/, "__").gsub(/\./, "_"), partial)            
+          when /haml$/
+            if Object.const_defined?(:Haml) and Haml::Engine.instance_methods.include?('def_method')
+              template = Haml::Engine.new(File.read(partial), :filename => partial)
+              template.def_method(Merb::GlobalHelper, partial.gsub(/[^\.a-zA-Z0-9]/, "__").gsub(/\./, "_"))
+            end
+          end
+        end
+      end
+      
+      def load_application
+        $LOAD_PATH.unshift( File.join(Merb.root , '/app/models') )
+        $LOAD_PATH.unshift( File.join(Merb.root , '/app/controllers') )
+        $LOAD_PATH.unshift( File.join(Merb.root , '/lib') )
+        Merb.load_paths.each do |glob|
+          Dir[Merb.root + glob].each { |m| require m }
+        end
+        load_action_arguments
+        load_controller_template_path_cache
+        load_inline_helpers
+        @app_loaded = true
+        (@after_app_blocks || []).each { |b| b.call }
+        require "sass/plugin" if File.directory?(Merb.root / "public" / "stylesheets" / "sass")        
+      end
+      
+      def remove_constant(const)
+        parts = const.to_s.split("::")
+        base = parts.size == 1 ? Object : Object.full_const_get(parts[0..-2].join("::"))
+        object = parts[-1].intern
+        Merb.logger.info("Removing constant #{object} from #{base}")
+        base.send(:remove_const, object) if object
+        Merb::Controller._subclasses.delete(const)
+      end
+      
+      def reload
+        return if !Merb::Config[:reloader] || !Object.const_defined?(:MERB_PATHS)
+        
+        # First we collect all files in the project (this will also grab newly added files)
+        project_files = MERB_PATHS.map { |path| Dir[Merb.root + path] }.flatten.uniq
+        partials = template_paths("_*.*").map { |path| Dir[path] }.flatten.uniq
+        project_mtime = max_mtime(project_files + partials) # Latest changed time of all project files
+      
+        return if @mtime.nil? || @mtime >= project_mtime   # Only continue if a file has changed
+      
+        project_files.each do |file|
+          if File.mtime(file) >= @mtime
+            # If the file has changed or been added since the last project reload time
+            # remove any cannonical constants, based on what type of project file it is
+            # and then reload the file
+            begin
+              constant = case file
+                when %r[/app/(models|controllers|parts|mailers)/(.+)\.rb$]
+                  $2.to_const_string
+                when %r[/app/(helpers)/(.+)\.rb$]
+                  "Merb::" + $2.to_const_string
+                end
+                remove_constant(constant)
+            rescue NameError => e
+              Merb.logger.warn "Couldn't remove constant #{constant}"
+            end
+            
+            begin
+              Merb.logger.info("Reloading file #{file}")
+              old_subclasses = Merb::Controller._subclasses.dup
+              load(file)
+              loaded_classes = Merb::Controller._subclasses - old_subclasses
+              load_action_arguments(loaded_classes)
+            rescue Exception => e
+              puts "Error reloading file #{file}: #{e}"
+              Merb.logger.warn "  Error: #{e}"
+            end
+            
+            # constant = file =~ /\/(controllers|models|mailers|helpers|parts)\/(.*).rb/ ? $2.to_const_string : nil
+            # remove_constant($2.to_const_string, ($1 == "helpers") ? Merb : nil)
+            # load file and puts "loaded file: #{file}"
+          end
+        end        
+      
+        # Rebuild the glob cache and erubis inline helpers
+        load_controller_template_path_cache
+        load_inline_helpers
+      
+        @mtime = project_mtime # As the last action, update the current @mtime
+      end
+    
+    end # class << self
+  end # BootLoader
+end # Merb      

data/lib/merb/caching.rb

@@ -1,4 +1,4 @@
-corelib = __DIR__+'/merb/caching'
+corelib = Merb.framework_root + '/merb/caching'
 
 %w[ action_cache
     fragment_cache

data/lib/merb/caching/action_cache.rb

@@ -62,7 +62,7 @@ module Merb
       private
 
       def _caching_enabled?
-        ::Merb::Server.config[:cache_templates]
+        ::Merb::Config[:cache_templates]
       end
 
       def _get_action_fragment

data/lib/merb/caching/fragment_cache.rb

@@ -25,7 +25,7 @@ module Merb
         end
         
         def determine_cache_store
-          if ::Merb::Server.config[:cache_store].to_s == "file"
+          if ::Merb::Config[:cache_store].to_s == "file"
             require 'merb/caching/store/file_cache'
             ::Merb::Caching::Store::FileCache.new
           else

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

@@ -9,7 +9,7 @@ module Merb
       class FileCache
             
         def initialize(name = "cache", keepalive = nil)
-          @path = File.join(MERB_ROOT, name)
+          @path = File.join(Merb.root, name)
           @keepalive = keepalive  
         end
       

data/lib/merb/config.rb

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