merb 0.5.3 → 0.9.2

data/lib/merb/assets.rb.orig

@@ -1,119 +0,0 @@
-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].to_s == '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

@@ -1,286 +0,0 @@
-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
-    
-        #Magic Class Loading => Not failing on missing parent due to alphabetical loading
-        # Does a reverse alphaebetical search if classes failed in first pass
-        # Will continue to reverse the list of failures until the size does change between
-        # two passes
-
-        orphaned_paths = []
-        $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 do |m| 
-            begin
-              require m 
-            rescue NameError
-              orphaned_paths.unshift(m)
-            end
-          end
-        end
-        
-        load_classes_with_requirements(orphaned_paths)
-        
-        load_action_arguments
-        load_controller_template_path_cache
-        load_inline_helpers
-        @app_loaded = true
-        load_libraries
-        (@after_app_blocks || []).each { |b| b.call }
-      end
-      
-      
-      def load_classes_with_requirements(orphaned_paths)
-        
-        #Make the list unique
-        orphaned_paths.uniq!
-        
-        while orphaned_paths.size > 0
-          #Take the size for comparison later
-          size_at_start = orphaned_paths.size
-
-          fail_list = [] #List of failures
-          
-          # Try to load each path again, this time the order is reversed
-          (orphaned_paths).each do |m|
-            # Remove the path from the list
-            orphaned_paths.delete(m)
-            begin
-              require m
-            rescue NameError
-              # Add it back on if it failed to load due to NameError
-              fail_list.push(m)
-            end
-          end
-
-          orphaned_paths.concat(fail_list)
-
-          # Stop processing if everything loaded (size == 0) or if the size didn't change 
-          # (ie something couldn't be loaded)
-          break if(orphaned_paths.size == size_at_start || orphaned_paths.size == 0)
-        end
-        
-        return orphaned_paths
-      end
-      
-      
-      def load_libraries
-        # Load the Sass plugin of /public/stylesheets/sass exists
-        begin
-          require "sass/plugin" if File.directory?(Merb.root / "public" / "stylesheets" / "sass")  
-        rescue LoadError
-        end
-        # If you don't use the JSON gem, disable auto-parsing of json params too
-        if Merb::Config[:disable_json_gem]
-          Merb::Request::parse_json_params = false
-        else
-          begin
-            require 'json/ext'
-          rescue LoadError
-            require 'json/pure'
-          end
-        end
-      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]
-        
-        # First we collect all files in the project (this will also grab newly added files)
-        project_files = Merb.load_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/boot_loader.rb.orig

@@ -1,235 +0,0 @@
-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
-        load_libraries
-        (@after_app_blocks || []).each { |b| b.call }
-      end
-      
-      def load_libraries
-        # Load the Sass plugin of /public/stylesheets/sass exists
-        begin
-          require "sass/plugin" if File.directory?(Merb.root / "public" / "stylesheets" / "sass")  
-        rescue LoadError
-        end
-        # If you don't use the JSON gem, disable auto-parsing of json params too
-        if Merb::Config[:disable_json_gem]
-          Merb::Request::parse_json_params = false
-        else
-          begin
-            require 'json/ext'
-          rescue LoadError
-            require 'json/pure'
-          end
-        end
-      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]
-        
-        # First we collect all files in the project (this will also grab newly added files)
-        project_files = Merb.load_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