merb 0.5.2 → 0.5.3

data/lib/merb/assets.rb.orig

@@ -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].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

@@ -138,12 +138,28 @@ module Merb
       end
       
       def load_application
-        $LOAD_PATH.unshift( File.join(Merb.root , '/app/models') )
-        $LOAD_PATH.unshift( File.join(Merb.root , '/app/controllers') )
+    
+        #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 { |m| require m }
+          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
@@ -152,6 +168,41 @@ module Merb
         (@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
@@ -232,4 +283,4 @@ module Merb
     
     end # class << self
   end # BootLoader
-end # Merb      
+end # Merb      

data/lib/merb/boot_loader.rb.orig

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

data/lib/merb/controller.rb

@@ -138,7 +138,7 @@ module Merb
     end
     
     def cookies
-      request.cookies
+      @_cookies ||= Cookies.new(request.cookies, @_headers)
     end
     
     # Accessor for @_headers. Please use headers and never @_headers directly.

data/lib/merb/cookies.rb

@@ -0,0 +1,95 @@
+module Merb 
+
+# Cookies are read and written through Merb::Controller#cookies. The cookies 
+# you read are those received in request along with those that have been set 
+# during the current request. The cookies you write will be sent out with the 
+# response. Cookies are read by value (so you won't get the cookie object 
+# itself back -- just the value it holds). 
+# 
+# == Writing 
+  # 
+  #   cookies[:user]  = "dave" # => Sets a simple session cookie 
+  #   cookies[:token] = { :value => user.token, :expires => Time.now + 2.weeks } 
+  #     # => Will set a cookie that expires in 2 weeks 
+  # 
+  # == Reading 
+  # 
+  #   cookies[:user] # => "dave" 
+  #   cookies.size   # => 2 (the number of cookies) 
+  # 
+  # == Deleting 
+  # 
+  #   cookies.delete(:user) 
+  # 
+  # == Options 
+  # 
+  # * +value+   - the cookie's value 
+  # * +path+    - the path for which this cookie applies.  Defaults to the root 
+  #               of the application. 
+  # * +expires+ - the time at which this cookie expires, as a +Time+ object. 
+  class Cookies 
+ 
+    def initialize(request_cookies, headers) 
+      @_cookies = request_cookies 
+      @_headers = headers 
+    end 
+ 
+    # Returns the value of the cookie by +name+ or nil if no such cookie 
+    # exists. You set new cookies using cookies[]= 
+    def [](name) 
+      @_cookies[name] 
+    end 
+ 
+    # Sets the value of a cookie. You can set the value directly or pass a hash 
+    # with options. 
+    # 
+    # == Example 
+    # 
+    #   cookies[:user]  = "dave" # => Sets a simple session cookie 
+    #   cookies[:token] = { :value => user.token, :expires => Time.now + 2.weeks } 
+    #     # => Will set a cookie that expires in 2 weeks 
+    # 
+    # == Options 
+    # 
+    # * +value+   - the cookie's value or list of values (as an array). 
+    # * +path+    - the path for which this cookie applies.  Defaults to the root 
+    #               '/' of the application. 
+    # * +expires+ - the time at which this cookie expires, as a +Time+ object. 
+    def []=(name, options) 
+      value = '' 
+      if options.is_a?(Hash) 
+        options = Mash.new(options) 
+        value = Merb::Request.escape(options.delete(:value)) 
+      else 
+        value = Merb::Request.escape(options) 
+        options = Mash.new 
+      end 
+      @_cookies[name] = value 
+      set_cookie(name, value, options) 
+      Merb.logger.info("Cookie set: #{name} => #{value} -- #{options.inspect}") 
+      return options 
+    end 
+ 
+    # Removes the cookie on the client machine by setting the value to an empty string 
+    # and setting its expiration date into the past. 
+    def delete(name, options = {}) 
+      cookie = @_cookies.delete(name) 
+      options = Mash.new(options) 
+      options[:expires] = Time.at(0) 
+      set_cookie(name, "", options) 
+      Merb.logger.info("Cookie deleted: #{name} => #{cookie.inspect}") 
+      return cookie 
+    end 
+ 
+    private 
+      def set_cookie(name, value, options) 
+        options[:path] = '/' unless options[:path] 
+        if expiry = options[:expires] 
+          options[:expires] = expiry.gmtime.strftime(Merb::Const::COOKIE_EXPIRATION_FORMAT) 
+        end 
+        # options are sorted for testing purposes 
+        (@_headers['Set-Cookie'] ||=[]) << "#{name}=#{value}; " + 
+          options.map{|k, v| "#{k}=#{v};"}.sort.join(' ') 
+      end 
+  end 
+end