lib/merb-core/core_ext/virtual_file.rb lib/merb-core/rack/adapter/swiftiplied_mongrel.rb lib/merb-core/rack/middleware/path_prefix.rb lib/merb-core/rack/middleware/profiler.rb lib/merb-core/rack/middleware/static.rb spec/public/abstract_controller/controllers/cousins.rb spec/public/abstract_controller/controllers/views/partial/with_absolute_partial/_partial.erb spec/public/abstract_controller/controllers/views/partial/with_absolute_partial/index.erb spec/public/controller/controllers/views/layout/custom_arg.json.erb spec/public/core_ext/fixtures/core_ext_dependency.rb spec/public/core_ext/kernel_spec.rb spec/public/core_ext/spec_helper.rb @@ -1,4 +1,4 @@ -Copyright (c) 2008 Ezra Zygmuntowicz +Copyright (c) 2008 Engine Yard Inc. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the LICENSE @@ -15,7 +15,7 @@ Goals of this release: To familiarize yourself with how a merb-core application might look, use merb-gen (from merb-more) to generate a few apps: -$ merb-gen myapp # a "normal" merb app -$ merb-gen myapp --flat # a flattened app -$ merb-gen myapp --very-flat # a single-file app +$ merb-gen app myapp # a "normal" merb app +$ merb-gen app myapp --flat # a flattened app +$ merb-gen app myapp --very-flat # a single-file app README @@ -26,8 +26,8 @@ require 'lib/merb-core/tasks/merb_rake_helper' ############################################################################## CLEAN.include ["**/.*.sw?", "pkg", "lib/*.bundle", "*.gem", "doc/rdoc", ".config", "coverage", "cache"] -desc "Packages up Merb." -task :default => :package +desc "Run the specs." +task :default => :specs task :merb => [:clean, :rdoc, :package] Rakefile @@ -5,10 +5,8 @@ module Merb # def self.subclasses #--- # @semipublic - cattr_accessor :subclasses, :after_load_callbacks, :before_load_callbacks - self.subclasses = [] - self.after_load_callbacks = [] - self.before_load_callbacks = [] + cattr_accessor :subclasses, :after_load_callbacks, :before_load_callbacks, :finished + self.subclasses, self.after_load_callbacks, self.before_load_callbacks, self.finished = [], [], [], [] class << self @@ -65,9 +63,21 @@ module Merb bootloader = subclasses.shift Merb.logger.debug!("Loading: #{bootloader}") if ENV['DEBUG'] Object.full_const_get(bootloader).run + self.finished << bootloader end self.subclasses = subklasses end + + # Determines whether or not a specific bootloader has finished yet. + # + # ==== Parameters + # bootloader<String, Class>:: The name of the bootloader to check. + # + # ==== Returns + # Boolean:: Whether or not the bootloader has finished. + def finished?(bootloader) + self.finished.include?(bootloader.to_s) + end # Set up the default framework # @@ -77,7 +87,7 @@ module Merb #--- # @public def default_framework - %w[view model controller helper mailer part].each do |component| + %w[view model helper controller mailer part].each do |component| Merb.push_path(component.to_sym, Merb.root_path("app/#{component}s")) end Merb.push_path(:application, Merb.root_path("app/controllers/application.rb")) @@ -155,7 +165,10 @@ end # Setup some useful defaults class Merb::BootLoader::Defaults < Merb::BootLoader def self.run - Merb::Request.browser_method_workarounds << "_method" + Merb::Request.http_method_overrides.concat([ + proc { |c| c.params[:_method] }, + proc { |c| c.env['HTTP_X_HTTP_METHOD_OVERRIDE'] } + ]) end end @@ -185,9 +198,11 @@ end # # ==== Example # Merb::Config[:framework] = { -# :view => Merb.root / "views" -# :model => Merb.root / "models" -# :lib => Merb.root / "lib" +# :view => Merb.root / "views", +# :model => Merb.root / "models", +# :lib => Merb.root / "lib", +# :public => [Merb.root / "public", nil] +# :router => [Merb.root / "config", "router.rb"] # } # # That will set up a flat directory structure with the config files and @@ -212,8 +227,8 @@ class Merb::BootLoader::BuildFramework < Merb::BootLoader Merb::BootLoader.default_framework end (Merb::Config[:framework] || {}).each do |name, path| - path = [path].flatten - Merb.push_path(name, Merb.root_path(path.first), path[1]) + path = Array(path) + Merb.push_path(name, path.first, path.length == 2 ? path[1] : "**/*.rb") end end end @@ -369,6 +384,7 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader # Reload the router to regenerate all routes. def reload_router! if File.file?(router_file = Merb.dir_for(:router) / Merb.glob_for(:router)) + Merb::Router.reset! reload router_file end end @@ -465,14 +481,14 @@ class Merb::BootLoader::Templates < Merb::BootLoader # Loads the templates into the Merb::InlineTemplates module. def run template_paths.each do |path| - Merb::Template.inline_template(path) + Merb::Template.inline_template(File.open(path)) end end # ==== Returns # Array[String]:: Template files found. def template_paths - extension_glob = "{#{Merb::Template::EXTENSIONS.keys.join(',')}}" + extension_glob = "{#{Merb::Template.template_extensions.join(',')}}" # This gets all templates set in the controllers template roots # We separate the two maps because most of controllers will have @@ -550,10 +566,8 @@ class Merb::BootLoader::MixinSessionContainer < Merb::BootLoader if ["", "false", "none"].include?(session_store) Merb.logger.warn "Not Using Sessions" elsif reg = Merb.registered_session_types[session_store] - if session_store == "cookie" - Merb::BootLoader::MixinSessionContainer.check_for_secret_key - Merb::BootLoader::MixinSessionContainer.check_for_session_id_key - end + Merb::BootLoader::MixinSessionContainer.check_for_secret_key if session_store == "cookie" + Merb::BootLoader::MixinSessionContainer.check_for_session_id_key require reg[:file] include ::Merb::SessionMixin Merb.logger.warn reg[:description] lib/merb-core/bootloader.rb @@ -1,5 +1,15 @@ -# Note that the over-use of "_" in Controller methods is to avoid collisions -# with helpers, which will be pulled directly into controllers from now on. +# ==== Why do we use Underscores? +# In Merb, views are actually methods on controllers. This provides +# not-insignificant speed benefits, as well as preventing us from +# needing to copy over instance variables, which we think is proof +# that everything belongs in one class to begin with. +# +# Unfortunately, this means that view helpers need to be included +# into the <strong>Controller</strong> class. To avoid causing confusion +# when your helpers potentially conflict with our instance methods, +# we use an _ to disambiguate. As long as you don't begin your helper +# methods with _, you only need to worry about conflicts with Merb +# methods that are part of the public API. # # ==== Filters # #before is a class method that allows you to specify before filters in @@ -71,7 +81,8 @@ class Merb::AbstractController include Merb::RenderMixin include Merb::InlineTemplates - class_inheritable_accessor :_before_filters, :_after_filters, :_layout, :_template_root + class_inheritable_accessor :_layout, :_template_root + class_inheritable_array :_before_filters, :_after_filters FILTER_OPTIONS = [:only, :exclude, :if, :unless, :with] @@ -121,6 +132,18 @@ class Merb::AbstractController controller ? "#{controller}/#{context}" : context end + # The location to look for a template - stub method for particular behaviour. + # + # ==== Parameters + # template<String>:: The absolute path to a template - without template extension. + # type<~to_s>:: + # The mime-type of the template that will be rendered. Defaults to nil. + # + # @public + def _absolute_template_location(template, type) + template + end + # ==== Returns # roots<Array[Array]>:: # Template roots as pairs of template root path and template location @@ -429,6 +452,27 @@ class Merb::AbstractController request.protocol + request.host + url(name, rparams) end + # Calls the capture method for the selected template engine. + # + # ==== Parameters + # *args:: Arguments to pass to the block. + # &block:: The template block to call. + # + # ==== Returns + # String:: The output of the block. + def capture(*args, &block) + send("capture_#{@_engine}", *args, &block) + end + + # Calls the concatenate method for the selected template engine. + # + # ==== Parameters + # str<String>:: The string to concatenate to the buffer. + # binding<Binding>:: The binding to use for the buffer. + def concat(str, binding) + send("concat_#{@_engine}", str, binding) + end + private # ==== Parameters # filters<Array[Filter]>:: The filter list that this should be added to. @@ -503,27 +547,6 @@ class Merb::AbstractController return opts end - # Calls the capture method for the selected template engine. - # - # ==== Parameters - # *args:: Arguments to pass to the block. - # &block:: The template block to call. - # - # ==== Returns - # String:: The output of the block. - def capture(*args, &block) - send("capture_#{@_engine}", *args, &block) - end - - # Calls the concatenate method for the selected template engine. - # - # ==== Parameters - # str<String>:: The string to concatenate to the buffer. - # binding<Binding>:: The binding to use for the buffer. - def concat(str, binding) - send("concat_#{@_engine}", str, binding) - end - # Attempts to return the partial local variable corresponding to sym. # # ==== Paramteres lib/merb-core/controller/abstract_controller.rb @@ -24,8 +24,8 @@ class Merb::Controller < Merb::AbstractController # The Merb::Controller inheriting from the base class. def inherited(klass) _subclasses << klass.to_s - self._template_root = Merb.dir_for(:view) unless self._template_root super + klass._template_root = Merb.dir_for(:view) unless self._template_root end # Hide each of the given methods from being callable as actions. @@ -157,6 +157,23 @@ class Merb::Controller < Merb::AbstractController def _template_location(context, type = nil, controller = controller_name) controller ? "#{controller}/#{context}.#{type}" : "#{context}.#{type}" end + + # The location to look for a template and mime-type. This is overridden + # from AbstractController, which defines a version of this that does not + # involve mime-types. + # + # ==== Parameters + # template<String>:: + # The absolute path to a template - without mime and template extension. + # The mime-type extension is optional - it will be appended from the + # current content type if it hasn't been added already. + # type<~to_s>:: + # The mime-type of the template that will be rendered. Defaults to nil. + # + # @public + def _absolute_template_location(template, type) + template.match(/\.#{type.to_s.escape_regexp}$/) ? template : "#{template}.#{type}" + end # Build a new controller. # @@ -176,7 +193,7 @@ class Merb::Controller < Merb::AbstractController # @semipublic def initialize(request, status=200, headers={'Content-Type' => 'text/html; charset=utf-8'}) super() - @request, @status, @headers = request, status, headers + @request, @_status, @headers = request, status, headers end # Dispatch the action. @@ -202,7 +219,10 @@ class Merb::Controller < Merb::AbstractController end attr_reader :request, :headers - attr_reader :status + + def status + @_status + end # Set the response status code. # @@ -210,9 +230,9 @@ class Merb::Controller < Merb::AbstractController # s<Fixnum, Symbol>:: A status-code or named http-status def status=(s) if s.is_a?(Symbol) && STATUS_CODES.key?(s) - @status = STATUS_CODES[s] + @_status = STATUS_CODES[s] elsif s.is_a?(Fixnum) - @status = s + @_status = s else raise ArgumentError, "Status should be of type Fixnum or Symbol, was #{s.class}" end lib/merb-core/controller/merb_controller.rb @@ -103,11 +103,18 @@ module Merb::RenderMixin # Do we have a template to try to render? if thing.is_a?(Symbol) || opts[:template] - template_method, template_location = _template_for(thing, content_type, controller_name, opts) - + template_method, template_location = + _template_for(thing, content_type, controller_name, opts[:template]) + # Raise an error if there's no template - raise TemplateNotFound, "No template found at #{template_location}.*" \ - unless template_method && self.respond_to?(template_method) + unless template_method && self.respond_to?(template_method) + template_files = Merb::Template.template_extensions.map { |ext| "#{template_location}.#{ext}" } + raise TemplateNotFound, "Oops! No template found. Merb was looking for #{template_files.join(', ')}" + + "for content type '#{content_type}'. You might have mispelled the template or file name. " + + "Registered template extensions: #{Merb::Template.template_extensions.join(', ')}. " + + "If you use Haml or some other template plugin, make sure you required Merb plugin dependency " + + "in your init file." + end # Call the method in question and throw the content for later consumption by the layout throw_content(:for_layout, self.send(template_method)) @@ -120,8 +127,7 @@ module Merb::RenderMixin end # If we find a layout, use it. Otherwise, just render the content thrown for layout. - layout = opts[:layout] != false && _get_layout(opts[:layout]) - layout ? send(layout) : catch_content(:for_layout) + (layout = _get_layout(opts[:layout])) ? send(layout) : catch_content(:for_layout) end # Renders an object using to registered transform method based on the @@ -172,7 +178,7 @@ module Merb::RenderMixin # # :template a template to use for rendering # :layout a layout to use for rendering - + # # all other options options that will be pass to serialization method # like #to_json or #to_xml # @@ -181,13 +187,13 @@ module Merb::RenderMixin # explicitly passed in the opts. # def display(object, thing = nil, opts = {}) - # display @object, "path/to/foo" means display @object, nil, :template => "path/to/foo" - # display @object, :template => "path/to/foo" means display @object, nil, :template => "path/to/foo" template_opt = opts.delete(:template) case thing + # display @object, "path/to/foo" means display @object, nil, :template => "path/to/foo" when String template_opt, thing = thing, nil + # display @object, :template => "path/to/foo" means display @object, nil, :template => "path/to/foo" when Hash opts, thing = thing, nil end @@ -198,6 +204,7 @@ module Merb::RenderMixin # If the render fails (i.e. a template was not found) rescue TemplateNotFound => e # Merge with class level default render options + # @todo can we find a way to refactor this out so we don't have to do it everywhere? opts = self.class.default_render_options.merge(opts) # Figure out what to transform and raise NotAcceptable unless there's a transform method assigned @@ -208,29 +215,9 @@ module Merb::RenderMixin raise NotAcceptable, "#{e.message} and your object does not respond to ##{transform}" end - # Only use a layout if one was specified layout_opt = opts.delete(:layout) - - if layout_opt - # Look for the layout under the default layout directly. If it's not found, reraise - # the TemplateNotFound error - template = _template_location(layout_opt, layout.index(".") ? content_type : nil, "layout") - layout = _template_for(_template_root / template) || - (raise TemplateNotFound, "No layout found at #{_template_root / template}.*") - - # If the layout was found, call it - send(layout) - - # Otherwise, just render the transformed object - else - unless opts.empty? - # there are options for serialization method - throw_content(:for_layout, object.send(transform, opts)) - else - throw_content(:for_layout, object.send(transform)) - end - catch_content(:for_layout) - end + throw_content(:for_layout, opts.empty? ? object.send(transform) : object.send(transform, opts)) + layout_opt ? send(_get_layout(layout_opt)) : catch_content(:for_layout) end # Render a partial template. @@ -238,9 +225,9 @@ module Merb::RenderMixin # ==== Parameters # template<~to_s>:: # The path to the template, relative to the current controller or the - # template root. If the template contains a "/", Merb will search for it - # relative to the template root; otherwise, Merb will search for it - # relative to the current controller. + # template root; absolute path will work too. If the template contains a "/", + # Merb will search for it relative to the template root; otherwise, + # Merb will search for it relative to the current controller. # opts<Hash>:: A hash of options (see below) # # ==== Options (opts) @@ -262,33 +249,36 @@ module Merb::RenderMixin # partial :foo becomes "#{controller_name}/_foo" # partial "foo/bar" becomes "foo/_bar" template = template.to_s - kontroller = (m = template.match(/.*(?=\/)/)) ? m[0] : controller_name - template = "_#{File.basename(template)}" - - template_method, template_location = _template_for(template, opts.delete(:format) || content_type, kontroller) + if template =~ %r{^/} + template_path = File.dirname(template) / "_#{File.basename(template)}" + else + kontroller = (m = template.match(/.*(?=\/)/)) ? m[0] : controller_name + template = "_#{File.basename(template)}" + end + template_method, template_location = + _template_for(template, opts.delete(:format) || content_type, kontroller, template_path) (@_old_partial_locals ||= []).push @_merb_partial_locals - - if opts.key?(:with) - with = opts.delete(:with) - as = opts.delete(:as) || template_location.match(%r[.*/_([^\.]*)])[1] - @_merb_partial_locals = opts - sent_template = [with].flatten.map do |temp| - @_merb_partial_locals[as.to_sym] = temp - if template_method && self.respond_to?(template_method) - send(template_method) - else - raise TemplateNotFound, "Could not find template at #{template_location}.*" - end - end.join - else - @_merb_partial_locals = opts + + # This handles no :with as well + with = [opts.delete(:with)].flatten + as = opts.delete(:as) || template_location.match(%r[.*/_([^\.]*)])[1] + + @_merb_partial_locals = opts + + # this handles an edge-case where the name of the partial is _foo.* and your opts + # have :foo as a key. + named_local = @_merb_partial_locals.key?(as.to_sym) + + sent_template = with.map do |temp| + @_merb_partial_locals[as.to_sym] = temp unless named_local if template_method && self.respond_to?(template_method) - sent_template = send(template_method) + send(template_method) else raise TemplateNotFound, "Could not find template at #{template_location}.*" end - end + end.join + @_merb_partial_locals = @_old_partial_locals.pop sent_template end @@ -306,34 +296,7 @@ module Merb::RenderMixin # Hash:: The options hash that was passed in. def _handle_options!(opts) self.status = opts[:status].to_i if opts[:status] - _handle_location!(opts) - opts - end - - # Handle the :location option appropriately - # - # ==== Parameters - # opts<Hash>:: The options hash that was passed to the render - # - # ==== Options - # :location - # Sets headers['Location'] to the provided URL - # - # ==== Returns - # Hash:: The options hash that was passed in. - def _handle_location!(opts) - if header_location = opts.delete(:location) - # scope it - use_header_url = nil - if header_location.is_a? String - # Hope they know what they're doing - use_header_url = header_location - # Removed magic url :klass, @obj detection. Reconsider adding it? - end - # If we couldn't figure anything out, best let the user know - raise "Unable to determine `:location' given #{header_location.inspect}" if use_header_url.nil? - headers['Location'] = use_header_url - end + headers["Location"] = opts.delete(:location) if opts[:location] opts end @@ -355,12 +318,16 @@ module Merb::RenderMixin # one in to this method), and not found. No error will be raised if no # layout was specified, and the default layouts were not found. def _get_layout(layout = nil) + return false if layout == false + layout = layout.instance_of?(Symbol) && self.respond_to?(layout, true) ? send(layout) : layout layout = layout.to_s if layout # If a layout was provided, throw an error if it's not found - if layout - template_method, template_location = _template_for(layout, layout.index(".") ? nil : content_type, "layout") + if layout + template_method, template_location = + _template_for(layout, layout.index(".") ? nil : content_type, "layout") + raise TemplateNotFound, "No layout found at #{template_location}" unless template_method template_method @@ -376,7 +343,7 @@ module Merb::RenderMixin # and template location of the first match. # # ==== Parameters - # context<Object>:: The controller action or template basename. + # context<Object>:: The controller action or template (basename or absolute path). # content_type<~to_s>:: The content type (like html or json). # controller<~to_s>:: The name of the controller. Defaults to nil. # @@ -388,24 +355,47 @@ module Merb::RenderMixin # ==== Returns # Array[Symbol, String]:: # A pair consisting of the template method and location. - def _template_for(context, content_type, controller=nil, opts={}) - template_method = nil - template_location = nil - - self.class._template_roots.reverse_each do |root, template_location| - if opts[:template] # use the given template as the location context - template_location = root / self.send(template_location, opts[:template], content_type, nil) - template_method = Merb::Template.template_for(template_location) - break if template_method && self.respond_to?(template_method) - end + def _template_for(context, content_type, controller=nil, template=nil) + template_method, template_location = nil, nil + + # absolute path to a template (:template => "/foo/bar") + if template.is_a?(String) && template =~ %r{^/} + template_location = self._absolute_template_location(template, content_type) + return [_template_method_for(template_location), template_location] + end - template_location = root / (opts[:template] || self.send(template_location, context, content_type, controller)) - template_method = Merb::Template.template_for(template_location) - break if template_method && self.respond_to?(template_method) + self.class._template_roots.reverse_each do |root, template_meth| + # :template => "foo/bar.html" where root / "foo/bar.html.*" exists + if template && template.is_a?(String) && template.index("/") + template_location = root / template + + # :template => :tmpl where root / "tmpl.html.*" exists + elsif template + template_location = root / self.send(template_meth, template, content_type, nil) + + # :layout => "foo" where root / "layouts" / "#{controller}.html.*" exists + else + template_location = root / self.send(template_meth, context, content_type, controller) + end + + break if template_method = _template_method_for(template_location) end [template_method, template_location] end + + # Return the template method for a location, and check to make sure the current controller + # actually responds to the method. + # + # ==== Parameters + # template_location<String>:: The phyical path of the template + # + # ==== Returns + # String:: The method, if it exists. Otherwise return nil. + def _template_method_for(template_location) + meth = Merb::Template.template_for(template_location) + meth && self.respond_to?(meth) ? meth : nil + end # Called in templates to get at content thrown in another template. The # results of rendering a template are automatically thrown into :for_layout, lib/merb-core/controller/mixins/render.rb @@ -29,6 +29,27 @@ module Merb::Template path.gsub(/[^\.a-zA-Z0-9]/, "__").gsub(/\./, "_") end + # For a given path, get an IO object that responds to #path. + # + # This is so that plugins can override this if they provide + # mechanisms for specifying templates that are not just simple + # files. The plugin is responsible for ensuring that the fake + # path provided will work with #template_for, and thus the + # RenderMixin in general. + # + # ==== Parameters + # path<String>:: A full path to find a template for. This is the + # path that the RenderMixin assumes it should find the template + # in. + # + # ==== Returns + # IO#path:: An IO object that responds to path (File or VirtualFile). + #--- + # @semipublic + def load_template_io(path) + File.open(path) + end + # Get the name of the template method for a particular path. # # ==== Parameters @@ -45,11 +66,11 @@ module Merb::Template ret = if Merb::Config[:reload_templates] file = Dir["#{path}.{#{template_extensions.join(',')}}"].first - METHOD_LIST[path] = file ? inline_template(file) : nil + METHOD_LIST[path] = file ? inline_template(load_template_io(file)) : nil else METHOD_LIST[path] ||= begin file = Dir["#{path}.{#{template_extensions.join(',')}}"].first - file ? inline_template(file) : nil + file ? inline_template(load_template_io(file)) : nil end end @@ -70,9 +91,8 @@ module Merb::Template # adds it to the METHOD_LIST table to speed lookup later. # # ==== Parameters - # path<String>:: - # The full path of the template (minus the templating specifier) to - # inline. + # io<#path>:: + # An IO that responds to #path (File or VirtualFile) # mod<Module>:: # The module to put the compiled method into. Defaults to # Merb::InlineTemplates @@ -82,10 +102,10 @@ module Merb::Template # must be available to instances of AbstractController that will use it. #--- # @public - def inline_template(path, mod = Merb::InlineTemplates) - path = File.expand_path(path) + def inline_template(io, mod = Merb::InlineTemplates) + path = File.expand_path(io.path) METHOD_LIST[path.gsub(/\.[^\.]*$/, "")] = - engine_for(path).compile_template(path, template_name(path), mod) + engine_for(path).compile_template(io, template_name(path), mod) end # Finds the engine for a particular path. @@ -132,12 +152,12 @@ module Merb::Template class Erubis # ==== Parameters - # path<String>:: A full path to the template. + # io<#path>:: An IO containing the full path of the template. # name<String>:: The name of the method that will be created. # mod<Module>:: The module that the compiled method will be placed into. - def self.compile_template(path, name, mod) - template = ::Erubis::Eruby.new(File.read(path)) - template.def_method(mod, name, path) + def self.compile_template(io, name, mod) + template = ::Erubis::Eruby.new(io.read) + template.def_method(mod, name, File.expand_path(io.path)) name end lib/merb-core/controller/template.rb @@ -10,4 +10,4 @@ require corelib/:object require corelib/:object_space require corelib/:rubygems require corelib/:set - +require corelib/:virtual_file lib/merb-core/core_ext.rb @@ -30,6 +30,12 @@ class Class # Defines class-level and instance-level attribute reader. # # @param *syms<Array> Array of attributes to define reader for. + # @return <Array[#to_s]> List of attributes that were made into cattr_readers + # + # @api public + # + # @todo Is this inconsistent in that it does not allow you to prevent + # an instance_reader via :instance_reader => false def cattr_reader(*syms) syms.flatten.each do |sym| next if sym.is_a?(Hash) @@ -51,13 +57,15 @@ class Class # Defines class-level (and optionally instance-level) attribute writer. # - # @param *syms<Array> Array of attributes to define writer for. + # @param <Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define writer for. + # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined. + # @return <Array[#to_s]> List of attributes that were made into cattr_writers # - # @option * :instance_writer<Boolean> if true, instance-level attribute writer is defined. + # @api public def cattr_writer(*syms) options = syms.last.is_a?(Hash) ? syms.pop : {} syms.flatten.each do |sym| - class_eval(<<-EOS, __FILE__, __LINE__) + class_eval(<<-RUBY, __FILE__, __LINE__) unless defined? @@#{sym} @@#{sym} = nil end @@ -65,22 +73,25 @@ class Class def self.#{sym}=(obj) @@#{sym} = obj end - - #{" - - def #{sym}=(obj) - @@#{sym} = obj - end - " unless options[:instance_writer] == false } - EOS + RUBY + + unless options[:instance_writer] == false + class_eval(<<-RUBY, __FILE__, __LINE__) + def #{sym}=(obj) + @@#{sym} = obj + end + RUBY + end end end # Defines class-level (and optionally instance-level) attribute accessor. # - # @param *syms<Array> Array of attributes to define accessor for. + # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define accessor for. + # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined. + # @return <Array[#to_s]> List of attributes that were made into accessors # - # @option * :instance_writer<Boolean> if true, instance-level attribute writer is defined. + # @api public def cattr_accessor(*syms) cattr_reader(*syms) cattr_writer(*syms) @@ -89,7 +100,16 @@ class Class # Defines class-level inheritable attribute reader. Attributes are available to subclasses, # each subclass has a copy of parent's attribute. # - # @param *syms<Array> Array of attributes to define inheritable reader for. + # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for. + # @return <Array[#to_s]> Array of attributes converted into inheritable_readers. + # + # @api public + # + # @todo Do we want to block instance_reader via :instance_reader => false + # @todo It would be preferable that we do something with a Hash passed in + # (error out or do the same as other methods above) instead of silently + # moving on). In particular, this makes the return value of this function + # less useful. def class_inheritable_reader(*syms) syms.each do |sym| next if sym.is_a?(Hash) @@ -109,25 +129,30 @@ class Class # Defines class-level inheritable attribute writer. Attributes are available to subclasses, # each subclass has a copy of parent's attribute. # - # @param *syms<Array> Array of attributes to define inheritable writer for. + # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to + # define inheritable writer for. + # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined. + # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers. + # + # @api public # - # @option * :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined. + # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it + # class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere. def class_inheritable_writer(*syms) options = syms.last.is_a?(Hash) ? syms.pop : {} syms.each do |sym| - class_eval <<-EOS, __FILE__, __LINE__ - + class_eval(<<-RUBY, __FILE__, __LINE__) def self.#{sym}=(obj) write_inheritable_attribute(:#{sym}, obj) end - - #{" - - def #{sym}=(obj) - self.class.#{sym} = obj - end - " unless options[:instance_writer] == false } - EOS + RUBY + unless options[:instance_writer] == false + class_eval <<-RUBY, __FILE__, __LINE__ + def #{sym}=(obj) + self.class.#{sym} = obj + end + RUBY + end end end @@ -135,26 +160,29 @@ class Class # each subclass has a copy of parent's array. Difference between other inheritable # attributes is that array is recreated every time it is written. # - # @param *syms<Array> Array of array attribute names to define inheritable writer for. - # - # @option * :instance_writer<Boolean> if true, instance-level inheritable array + # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of array attribute + # names to define inheritable writer for. + # @option syms :instance_writer<Boolean> if true, instance-level inheritable array # attribute writer is defined. + # @return <Array[#to_s]> An array of the attributes that were made into inheritable + # array writers. + # + # @api public def class_inheritable_array_writer(*syms) options = syms.last.is_a?(Hash) ? syms.pop : {} syms.each do |sym| - class_eval <<-EOS, __FILE__, __LINE__ - + class_eval(<<-RUBY, __FILE__, __LINE__) def self.#{sym}=(obj) write_inheritable_array(:#{sym}, obj) end - - #{" - - def #{sym}=(obj) - self.class.#{sym} = obj - end - " unless options[:instance_writer] == false } - EOS + RUBY + unless options[:instance_writer] == false + class_eval(<<-RUBY, __FILE__, __LINE__) + def #{sym}=(obj) + self.class.#{sym} = obj + end + RUBY + end end end @@ -162,35 +190,40 @@ class Class # each subclass has a copy of parent's hash. Difference between other inheritable # attributes is that hash is recreated every time it is written. # - # @param *syms<Array>:: Array of hash attribute names to define inheritable writer for. - # - # @option * :instance_writer<Boolean>:: if true, instance-level inheritable hash + # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]>:: Array of hash + # attribute names to define inheritable writer for. + # @option syms :instance_writer<Boolean>:: if true, instance-level inheritable hash # attribute writer is defined. + # @return <Array[#to_s]> An Array of attributes turned into hash_writers. + # + # @api public def class_inheritable_hash_writer(*syms) options = syms.last.is_a?(Hash) ? syms.pop : {} syms.each do |sym| - class_eval <<-EOS, __FILE__, __LINE__ - + class_eval(<<-RUBY, __FILE__, __LINE__) def self.#{sym}=(obj) write_inheritable_hash(:#{sym}, obj) end - - #{" - - def #{sym}=(obj) - self.class.#{sym} = obj - end - " unless options[:instance_writer] == false } - EOS + RUBY + unless options[:instance_writer] == false + class_eval(<<-RUBY, __FILE__, __LINE__) + def #{sym}=(obj) + self.class.#{sym} = obj + end + RUBY + end end end # Defines class-level inheritable attribute accessor. Attributes are available to subclasses, # each subclass has a copy of parent's attribute. # - # @param *syms<Array> Array of attributes to define inheritable accessor for. + # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to + # define inheritable accessor for. + # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined. + # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors. # - # @option * :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined. + # @api public def class_inheritable_accessor(*syms) class_inheritable_reader(*syms) class_inheritable_writer(*syms) @@ -200,10 +233,13 @@ class Class # each subclass has a copy of parent's array. Difference between other inheritable # attributes is that array is recreated every time it is written. # - # @param *syms<Array> Array of array attribute names to define inheritable accessor for. - # - # @option * :instance_writer<Boolean> if true, instance-level inheritable array + # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of array attribute + # names to define inheritable accessor for. + # @option syms :instance_writer<Boolean> if true, instance-level inheritable array # attribute writer is defined. + # @return <Array[#to_s]> An Array of attributes turned into inheritable arrays. + # + # @api public def class_inheritable_array(*syms) class_inheritable_reader(*syms) class_inheritable_array_writer(*syms) @@ -213,23 +249,30 @@ class Class # each subclass has a copy of parent's hash. Difference between other inheritable # attributes is that hash is recreated every time it is written. # - # @param *syms<Array> Array of hash attribute names to define inheritable accessor for. - # - # @option * :instance_writer<Boolean> if true, instance-level inheritable hash attribute writer is defined. + # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of hash attribute + # names to define inheritable accessor for. + # @option syms :instance_writer<Boolean> if true, instance-level inheritable hash + # attribute writer is defined. + # @return <Array[#to_s]> An Array of attributes turned into inheritable hashes. def class_inheritable_hash(*syms) class_inheritable_reader(*syms) class_inheritable_hash_writer(*syms) end # @return <Hash> inheritable attributes hash or it's default value, new frozen Hash. + # + # @api private def inheritable_attributes @inheritable_attributes ||= EMPTY_INHERITABLE_ATTRIBUTES end # Sets the attribute which copy is available to subclasses. # - # @param key<#to_s, String, Symbol> inheritable attribute name + # @param key<#to_s> inheritable attribute name # @param value<not(Array, Hash)> value of inheritable attribute + # @return <not(Array, Hash)> the value that was set + # + # @api private # # @note # If inheritable attributes storage has it's default value, @@ -243,8 +286,11 @@ class Class # Sets the array attribute which copy is available to subclasses. # - # @param key<#to_s, String, Symbol> inheritable attribute name - # value<Array> value of inheritable attribute + # @param key<#to_s> inheritable attribute name + # @param elements<Array> value of inheritable attribute + # @return <Array> the Array that was set + # + # @api private # # @note # Inheritable array is re-created on each write. @@ -255,8 +301,12 @@ class Class # Sets the hash attribute which copy is available to subclasses. # - # @param key<#to_s, String, Symbol> inheritable attribute name + # @param key<#to_s> inheritable attribute name # @param value<Hash> value of inheritable attribute + # @return <Hash> the new hash that resulted from merging the new values + # with the inherited values. + # + # @api private # # @note # Inheritable hash is re-created on each write. @@ -267,14 +317,24 @@ class Class # Reads value of inheritable attributes. # + # @param key<#to_s> the key of the attribute to read # @return <Object> # Inheritable attribute value. Subclasses store copies of values. + # + # @api private def read_inheritable_attribute(key) inheritable_attributes[key] end - # Resets inheritable attributes to either EMPTY_INHERITABLE_ATTRIBUTES - # if it is defined or it's default value, new frozen Hash. + # Resets inheritable attributes. + # + # @return <Object> the empty inheritable attributes. By default, this + # is a frozen, empty Hash. You can override this for a class by defining + # EMPTY_INHERITABLE_ATTRIBUTES + # + # @api private + # + # @todo do we need this? def reset_inheritable_attributes @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES end @@ -283,6 +343,7 @@ class Class # Prevent this constant from being created multiple times EMPTY_INHERITABLE_ATTRIBUTES = {}.freeze unless const_defined?(:EMPTY_INHERITABLE_ATTRIBUTES) + # @todo document this def inherited_with_inheritable_attributes(child) inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes) lib/merb-core/core_ext/class.rb @@ -126,7 +126,9 @@ class Hash # { :one => 1, :two => 2, :three => 3 }.only(:one) # #=> { :one => 1 } def only(*allowed) - reject { |k,v| !allowed.include?(k) } + hash = {} + allowed.each {|k| hash[k] = self[k] if self.has_key?(k) } + hash end # @param *rejected<Array[(String, Symbol)] The hash keys to exclude. @@ -137,7 +139,9 @@ class Hash # { :one => 1, :two => 2, :three => 3 }.except(:one) # #=> { :two => 2, :three => 3 } def except(*rejected) - reject { |k,v| rejected.include?(k) } + hash = self.dup + rejected.each {|k| hash.delete(k) } + hash end # @return <String> The hash as attributes for an XML tag. lib/merb-core/core_ext/hash.rb @@ -1,12 +1,26 @@ module Kernel - # Loads the given string as a gem. Execution is deferred to - # the Merb::BootLoader::Dependencies.run during bootup. - # + # Loads the given string as a gem. Execution is deferred until + # after the logger has been instantiated and the framework directory + # structure is defined. + # + # If that has already happened, the gem will be activated + # immediately. + # + # ==== Parameters # @param name<String> The name of the gem to load. # @param *ver<Gem::Requirement, Gem::Version, Array, #to_str> # Version requirements to be passed to Gem.activate. + # + # ==== Returns + # Array[String, Array[Gem::Requirement, Gem::Version, Array, #to_str]]:: + # The name and version information that was passed in. def dependency(name, *ver) - Merb::BootLoader::Dependencies.dependencies << [name, ver] + if Merb::BootLoader.finished?(Merb::BootLoader::Dependencies) + load_dependency(name, *ver) + else + Merb::BootLoader::Dependencies.dependencies << [name, ver] + end + [name, ver] end # Loads the given string as a gem. lib/merb-core/core_ext/kernel.rb @@ -1,3 +1,5 @@ +require 'tempfile' + module Merb class Request @@ -12,12 +14,14 @@ module Merb self.parse_json_params = true self.parse_xml_params = true - # Most web browsers can't send PUT or DELETE requests - # Any Strings stored in this array will be used as paramaters - # to find the real method. Common examples are _method and - # fb_sig_request_method - cattr_accessor :browser_method_workarounds - self.browser_method_workarounds = [] + # Flash, and some older browsers can't use arbitrary + # request methods -- i.e., are limited to GET/POST. + # These user-agents can make POST requests in combination + # with these overrides to participate fully in REST + # Common examples are _method or fb_sig_request_method + # in the params, or an X-HTTP-Method-Override header + cattr_accessor :http_method_overrides + self.http_method_overrides = [] # Initial the request object. # @@ -36,9 +40,10 @@ module Merb # Symbol:: The name of the request method, e.g. :get. # # ==== Notes - # If the method is post, then the params specified in - # browser_method_workarounds will be checked for the masquerading method. - # The first matching workaround wins. + # If the method is post, then the blocks specified in + # http_method_overrides will be checked for the masquerading method. + # The block will get the controller yielded to it. The first matching workaround wins. + # To disable this behavior, set http_method_overrides = [] def method @method ||= begin request_method = @env['REQUEST_METHOD'].downcase.to_sym @@ -46,17 +51,9 @@ module Merb when :get, :head, :put, :delete request_method when :post - if self.class.parse_multipart_params - p = body_and_query_params.merge(multipart_params) - else - p = body_and_query_params - end m = nil - self.class.browser_method_workarounds.each do |workaround| - if p.include?(workaround.to_s) - m = p[workaround.to_s] - break - end + self.class.http_method_overrides.each do |o| + m ||= o.call(self); break if m end m.downcase! if m METHODS.include?(m) ? m.to_sym : :post @@ -115,9 +112,9 @@ module Merb def multipart_params @multipart_params ||= begin - # if the content-type is multipart and there's stuff in the body, + # if the content-type is multipart # parse the multipart. Otherwise return {} - if (Merb::Const::MULTIPART_REGEXP =~ content_type && @body.size > 0) + if (Merb::Const::MULTIPART_REGEXP =~ content_type) self.class.parse_multipart(@body, $1, content_length) else {} @@ -396,7 +393,7 @@ module Merb class << self # ==== Parameters - # value<Array, Hash, ~to_s>:: The value for the query string. + # value<Array, Hash, Dictionary ~to_s>:: The value for the query string. # prefix<~to_s>:: The prefix to add to the query string keys. # # ==== Returns @@ -420,7 +417,7 @@ module Merb value.map { |v| params_to_query_string(v, "#{prefix}[]") } * "&" - when Hash + when Hash, Dictionary value.map { |k, v| params_to_query_string(v, prefix ? "#{prefix}[#{Merb::Request.escape(k)}]" : Merb::Request.escape(k)) } * "&" @@ -454,18 +451,21 @@ module Merb # ==== Parameters # qs<String>:: The query string. # d<String>:: The query string divider. Defaults to "&". + # preserve_order<Boolean>:: Preserve order of args. Defaults to false. # # ==== Returns - # Mash:: The parsed query string. + # Mash:: The parsed query string (Dictionary if preserve_order is set). # # ==== Examples # query_parse("bar=nik&post[body]=heya") # # => { :bar => "nik", :post => { :body => "heya" } } - def query_parse(qs, d = '&;') - (qs||'').split(/[#{d}] */n).inject({}) { |h,p| + def query_parse(qs, d = '&;', preserve_order = false) + qh = preserve_order ? Dictionary.new : {} + (qs||'').split(/[#{d}] */n).inject(qh) { |h,p| key, value = unescape(p).split('=',2) normalize_params(h, key, value) - }.to_mash + } + preserve_order ? qh : qh.to_mash end NAME_REGEX = /Content-Disposition:.* name="?([^\";]*)"?/ni.freeze @@ -494,6 +494,7 @@ module Merb bufsize = 16384 content_length -= boundary_size status = input.read(boundary_size) + return {} if status == nil || status.empty? raise ControllerExceptions::MultiPartParseError, "bad content body:\n'#{status}' should == '#{boundary + EOL}'" unless status == boundary + EOL rx = /(?:#{EOL})?#{Regexp.quote(boundary,'n')}(#{EOL}|--)/ loop { lib/merb-core/dispatch/request.rb @@ -31,6 +31,11 @@ module Merb cattr_accessor :routes, :named_routes class << self + + # Clear all routes. + def reset! + self.routes, self.named_routes = [], {} + end # Appends the generated routes to the current routes. # @@ -66,6 +71,18 @@ module Merb compile end + # Capture any new routes that have been added within the block. + # + # This utility method lets you track routes that have been added; + # it doesn't affect how/which routes are added. + # + # &block:: A context in which routes are generated. + def capture(&block) + routes_before, named_route_keys_before = self.routes.dup, self.named_routes.keys + yield + [self.routes - routes_before, self.named_routes.except(*named_route_keys_before)] + end + # ==== Returns # String:: A routing lambda statement generated from the routes. def compiled_statement lib/merb-core/dispatch/router.rb @@ -477,7 +477,7 @@ module Merb # # ==== Examples # - # r.resources :account # will result in the typical RESTful CRUD + # r.resource :account # will result in the typical RESTful CRUD # # GET /account/new :action => "new" # # POST /account/?(\.:format)?, :action => "create" # # GET /account/(\.:format)? :action => "show" @@ -635,6 +635,10 @@ module Merb def redirects? @redirects end + + def ancestors + @ancestors ||= find_ancestors + end protected @@ -743,12 +747,12 @@ module Merb # # ==== Returns # Array:: All the ancestor behaviors of this behavior. - def ancestors(list = []) + def find_ancestors(list = []) if parent.nil? list else list.push parent - parent.ancestors list + parent.find_ancestors list list end end lib/merb-core/dispatch/router/behavior.rb @@ -132,7 +132,7 @@ module Merb # ==== Returns # String:: The route as a string, e.g. "admin/:controller/:id". def to_s - segments.inject('') do |str,seg| + (segments || []).inject('') do |str,seg| str << (seg.is_a?(Symbol) ? ":#{seg}" : seg) end end @@ -148,7 +148,7 @@ module Merb # ==== Returns # Array:: All the symbols in the segments array. def symbol_segments - segments.select{ |s| s.is_a?(Symbol) } + (segments || []).select{ |s| s.is_a?(Symbol) } end # Turn a path into string and symbol segments so it can be reconstructed, @@ -189,7 +189,7 @@ module Merb # True if this route is a regexp, i.e. its behavior or one of the # behavior's ancestors is a regexp. def regexp? - behavior.regexp? || behavior.send(:ancestors).any? { |a| a.regexp? } + @regexp ||= behavior.regexp? || behavior.ancestors.any? { |a| a.regexp? } end # Generates URL using route segments and given parameters. lib/merb-core/dispatch/router/route.rb @@ -1,6 +1,16 @@ module Merb module SessionMixin + # Sets the session id cookie, along with the correct + # expiry and domain -- used for new or reset sessions + def set_session_id_cookie(key) + options = {} + options[:value] = key + options[:expires] = Time.now + _session_expiry if _session_expiry > 0 + options[:domain] = _session_cookie_domain if _session_cookie_domain + cookies[_session_id_key] = options + end + @_finalize_session_exception_callbacks = [] @_persist_exception_callbacks = [] @@ -43,4 +53,4 @@ module Merb module_function :rand_uuid, :needs_new_cookie!, :finalize_session_exception_callbacks, :persist_exception_callbacks end -end \ No newline at end of file +end lib/merb-core/dispatch/session.rb @@ -8,10 +8,13 @@ module Merb # ==== Parameters # base<Class>:: The class to which the SessionMixin is mixed into. def setup_session - before = cookies[_session_id_key] - request.session, cookies[_session_id_key] = Merb::MemCacheSession.persist(cookies[_session_id_key]) + orig_key = cookies[_session_id_key] + session, key = Merb::MemCacheSession.persist(orig_key) + request.session = session @_fingerprint = Marshal.dump(request.session.data).hash - @_new_cookie = cookies[_session_id_key] != before + if key != orig_key + set_session_id_cookie(key) + end end # Finalizes the session by storing the session ID in a cookie, if the @@ -25,9 +28,9 @@ module Merb Merb::SessionMixin::finalize_session_exception_callbacks.each {|x| x.call(err) } end end - options = {:expires => (Time.now + _session_expiry)} - options[:domain] = _session_cookie_domain if _session_cookie_domain - set_cookie(_session_id_key, request.session.session_id, options) if (@_new_cookie || request.session.needs_new_cookie) + if request.session.needs_new_cookie or @_new_cookie + set_session_id_cookie(request.session.session_id) + end end # ==== Returns lib/merb-core/dispatch/session/memcached.rb @@ -8,17 +8,20 @@ module Merb # ==== Parameters # base<Class>:: The class to which the SessionMixin is mixed into. def setup_session - before = cookies[_session_id_key] - request.session , cookies[_session_id_key] = Merb::MemorySession.persist(cookies[_session_id_key]) - @_new_cookie = cookies[_session_id_key] != before + orig_key = cookies[_session_id_key] + session, key = Merb::MemorySession.persist(orig_key) + request.session = session + if key != orig_key + set_session_id_cookie(key) + end end # Finalizes the session by storing the session ID in a cookie, if the # session has changed. def finalize_session - options = {:expires => (Time.now + _session_expiry)} - options[:domain] = _session_cookie_domain if _session_cookie_domain - set_cookie(_session_id_key, request.session.session_id, options) if (@_new_cookie || request.session.needs_new_cookie) + if request.session.needs_new_cookie or @_new_cookie + set_session_id_cookie(request.session.session_id) + end end # ==== Returns @@ -233,4 +236,4 @@ module Merb end # end MemorySessionContainer end -Merb::MemorySessionContainer.setup(Merb::Config[:memory_session_ttl]) \ No newline at end of file +Merb::MemorySessionContainer.setup(Merb::Config[:memory_session_ttl]) lib/merb-core/dispatch/session/memory.rb @@ -1,18 +1,20 @@ require 'rack' module Merb module Rack - autoload :Application, "merb-core/rack/application" - autoload :Adapter, "merb-core/rack/adapter" - autoload :Ebb, "merb-core/rack/adapter/ebb" - autoload :EventedMongrel, "merb-core/rack/adapter/evented_mongrel" - autoload :FastCGI, "merb-core/rack/adapter/fcgi" - autoload :Irb, "merb-core/rack/adapter/irb" - autoload :Middleware, "merb-core/rack/middleware" - autoload :Mongrel, "merb-core/rack/adapter/mongrel" - autoload :Runner, "merb-core/rack/adapter/runner" - autoload :Thin, "merb-core/rack/adapter/thin" - autoload :WEBrick, "merb-core/rack/adapter/webrick" - autoload :PathPrefix, "merb-core/rack/apps/path_prefix" - autoload :Static, "merb-core/rack/apps/static" + autoload :Application, "merb-core/rack/application" + autoload :Adapter, "merb-core/rack/adapter" + autoload :Ebb, "merb-core/rack/adapter/ebb" + autoload :EventedMongrel, "merb-core/rack/adapter/evented_mongrel" + autoload :FastCGI, "merb-core/rack/adapter/fcgi" + autoload :Irb, "merb-core/rack/adapter/irb" + autoload :Middleware, "merb-core/rack/middleware" + autoload :Mongrel, "merb-core/rack/adapter/mongrel" + autoload :Runner, "merb-core/rack/adapter/runner" + autoload :SwiftipliedMongrel, "merb-core/rack/adapter/swiftiplied_mongrel" + autoload :Thin, "merb-core/rack/adapter/thin" + autoload :WEBrick, "merb-core/rack/adapter/webrick" + autoload :PathPrefix, "merb-core/rack/middleware/path_prefix" + autoload :Static, "merb-core/rack/middleware/static" + autoload :Profiler, "merb-core/rack/middleware/profiler" end # Rack end # Merb \ No newline at end of file lib/merb-core/rack.rb @@ -28,14 +28,15 @@ module Merb end # Adapter # Register some Rack adapters - Adapter.register %w{ebb}, :Ebb - Adapter.register %w{emongrel}, :EventedMongrel - Adapter.register %w{fastcgi fcgi}, :FastCGI - Adapter.register %w{irb}, :Irb - Adapter.register %w{mongrel}, :Mongrel - Adapter.register %w{runner}, :Runner - Adapter.register %w{thin}, :Thin - Adapter.register %w{webrick}, :WEBrick + Adapter.register %w{ebb}, :Ebb + Adapter.register %w{emongrel}, :EventedMongrel + Adapter.register %w{fastcgi fcgi}, :FastCGI + Adapter.register %w{irb}, :Irb + Adapter.register %w{mongrel}, :Mongrel + Adapter.register %w{runner}, :Runner + Adapter.register %w{smongrel swift}, :SwiftipliedMongrel + Adapter.register %w{thin}, :Thin + Adapter.register %w{webrick}, :WEBrick end # Rack end # Merb lib/merb-core/rack/adapter.rb @@ -99,9 +99,9 @@ module Merb def dispatch_to(controller_klass, action, params = {}, env = {}, &blk) action = action.to_s request_body = { :post_body => env[:post_body], :req => env[:req] } - request = fake_request(env.merge( - :query_string => Merb::Request.params_to_query_string(params)), request_body) - + params = Merb::Request.params_to_query_string(params) + env[:query_string] = env["QUERY_STRING"] ? "#{env["QUERY_STRING"]}&#{params}" : params + request = fake_request(env, request_body) dispatch_request(request, controller_klass, action, &blk) end @@ -239,7 +239,8 @@ module Merb # @semi-public def request(path, params = {}, env= {}, &block) env[:request_method] ||= "GET" - env[:request_uri] = path + env[:request_uri], env[:query_string] = path.split('?') + multipart = env.delete(:test_with_multipart) request = fake_request(env) lib/merb-core/test/helpers/request_helper.rb @@ -17,10 +17,12 @@ end describe Hash, "only" do before do - @hash = { :one => 'ONE', 'two' => 'TWO', 3 => 'THREE' } + @hash = { :one => 'ONE', 'two' => 'TWO', 3 => 'THREE', 4 => nil } end it "should return a hash with only the given key(s)" do + @hash.only(:not_in_there).should == {} + @hash.only(4).should == {4 => nil} @hash.only(:one).should == { :one => 'ONE' } @hash.only(:one, 3).should == { :one => 'ONE', 3 => 'THREE' } end spec/private/core_ext/hash_spec.rb @@ -48,18 +48,6 @@ describe "Kernel#debugger" do end -describe "Kernel#dependency" do - it "adds dependency to the list" do - lambda { dependency("dm_merb", ">= 0.9") }.should change(Merb::BootLoader::Dependencies.dependencies, :size) - end - - it "deferres load to boot loader run" do - Object.should_not_receive(:full_const_get) - dependency("dm_merb", ">= 0.9") - end -end - - describe "Kernel#load_dependency" do before :each do spec/private/core_ext/kernel_spec.rb @@ -14,6 +14,10 @@ describe Merb::Router::Route, "initially" do @r5 = Merb::Router.routes[4] end + after :each do + Merb::Router.reset! + end + it "has reader for conditions" do @r1.conditions end @@ -47,7 +51,6 @@ describe Merb::Router::Route, "initially" do end end - describe Merb::Router::Route, "#fixatable" do predicate_matchers[:allow_fixation] = :allow_fixation? @@ -60,6 +63,10 @@ describe Merb::Router::Route, "#fixatable" do @route = Merb::Router.routes[4] end + + after :each do + Merb::Router.reset! + end it "allows fixation when called with true" do @route.fixatable(true) @@ -94,6 +101,10 @@ describe Merb::Router::Route, "#to_s" do @route = Merb::Router.routes[4] end + + after :each do + Merb::Router.reset! + end it "concatenates route segments" do @route.stub!(:segments).and_return(["continents/", "new"]) @@ -118,6 +129,10 @@ describe Merb::Router::Route, "#register" do @route = Merb::Router.routes[4] end + + after :each do + Merb::Router.reset! + end it "adds route to Merb routes set" do Merb::Router.routes = [] @@ -153,7 +168,7 @@ describe Merb::Router::Route, "#symbol_segments" do end after :each do - Merb::Router.routes = [] + Merb::Router.reset! end it "cherrypicks segments that are Symbols" do @@ -176,7 +191,7 @@ describe Merb::Router::Route, "#segments_from_path" do end after :each do - Merb::Router.routes = [] + Merb::Router.reset! end it "turns path into string and symbol segments" do @@ -200,7 +215,7 @@ describe Merb::Router::Route, "#name" do end after :each do - Merb::Router.routes = [] + Merb::Router.reset! end it "places the route into named routes collection" do @@ -212,10 +227,10 @@ describe Merb::Router::Route, "#name" do it "only accepts Symbols" do lambda { @route.name("home") }.should raise_error(ArgumentError) end + end - describe Merb::Router::Route, "#regexp?" do before :each do Merb::Router.prepare do |r| @@ -251,7 +266,7 @@ describe Merb::Router::Route, "#regexp?" do end after :each do - Merb::Router.routes = [] + Merb::Router.reset! end end @@ -267,6 +282,10 @@ describe Merb::Router::Route, "#generate" do @regexp_route = Merb::Router.named_routes[:regexpy] @non_regexp_route = Merb::Router.named_routes[:non_regexpy] end + + after :each do + Merb::Router.reset! + end it "does not work for regexp routes" do lambda { @regexp_route.generate({ :token => "apitoken" }) }.should raise_error(RuntimeError, /regexp/) @@ -304,6 +323,10 @@ describe Merb::Router::Route, "#if_conditions" do @non_regexp_route = Merb::Router.named_routes[:non_regexpy] @two_symbol_route = Merb::Router.named_routes[:two_symbol_segments] end + + after :each do + Merb::Router.reset! + end it "returns array with =~ statements" do # just to show you what it looks like @@ -328,8 +351,6 @@ describe Merb::Router::Route, "#if_conditions" do end end - - describe Merb::Router::Route, "#if_conditions" do before :each do Merb::Router.prepare do |r| @@ -342,6 +363,10 @@ describe Merb::Router::Route, "#if_conditions" do @non_regexp_route = Merb::Router.named_routes[:non_regexpy] @two_symbol_route = Merb::Router.named_routes[:two_symbol_segments] end + + after :each do + Merb::Router.reset! + end it "uses if in compiled statement when argument is false" do @regexp_route.compile(false).should =~ /\s*elsif/ @@ -355,3 +380,35 @@ describe Merb::Router::Route, "#if_conditions" do @regexp_route.compile.should =~ /\s*elsif/ end end + +describe "Merb::Router::Route.capture" do + + after :each do + Merb::Router.reset! + end + + it "should capture routes that have been added in the block context" do + routes, named, route = [], {}, nil + Merb::Router.prepare do |r| + routes, named = Merb::Router.capture do + route = r.match("/overview").to(:controller => "home", :action => 'overview') + end + r.match("/").to(:controller => "home").name(:home) + end + routes.should include(route) + named.should_not include(route) + end + + it "should capture named routes that have been added in the block context" do + routes, named, route = [], {}, nil + Merb::Router.prepare do |r| + r.match("/overview").to(:controller => "home", :action => 'overview') + routes, named = Merb::Router.capture do + route = r.match("/").to(:controller => "home").name(:home) + end + end + routes.should include(route) + named[:home].should == route + end + +end spec/private/router/route_spec.rb @@ -11,7 +11,7 @@ module Merb::Test::Fixtures "partial/#{File.basename(controller)}/#{context}" end end - + class BasicPartial < RenderIt def index @@ -19,6 +19,14 @@ module Merb::Test::Fixtures end end + class WithAbsolutePartial < RenderIt + + def index + @absolute_partial_path = File.expand_path(File.dirname(__FILE__)) / 'views' / 'partial' / 'with_absolute_partial' / 'partial' + render + end + end + class WithPartial < RenderIt def index spec/public/abstract_controller/controllers/partial.rb @@ -76,11 +76,19 @@ module Merb::Test::Fixtures end end + class RenderTemplateAbsolutePath < RenderTemplate + + def index + render :template => File.expand_path(self._template_root) / 'wonderful' / 'index' + end + + end + class RenderTemplateMultipleRoots < RenderTemplate self._template_roots << [File.dirname(__FILE__) / "alt_views", :_template_location] def show - render :layout=>false + render :layout => false end end spec/public/abstract_controller/controllers/render.rb @@ -94,4 +94,13 @@ describe Merb::AbstractController, " should support before and after filters" do it "should support passing arguments to a before filter method" do dispatch_should_make_body("TestBeforeFilterWithArguments", "index action") end + + it "should inherit before filters" do + dispatch_should_make_body("FilterChild2", "Before Limited", :limited) + end + + it "should not get contaminated by cousins" do + pending + dispatch_should_make_body("FilterChild2", "Before Index") + end end \ No newline at end of file spec/public/abstract_controller/filter_spec.rb @@ -50,4 +50,8 @@ describe Merb::AbstractController, " Partials" do dispatch_should_make_body("BasicPartialWithMultipleRoots", "Base Index: Alt Partial") end + it "should render a partial using an absolute path" do + dispatch_should_make_body("WithAbsolutePartial", "Index Absolute Partial") + end + end \ No newline at end of file spec/public/abstract_controller/partial_spec.rb @@ -63,6 +63,10 @@ describe Merb::AbstractController, " rendering templates" do dispatch_should_make_body("RenderTemplateCustomLocation", "Wonderful") end + it "should support rendering templates from an absolute path location" do + dispatch_should_make_body("RenderTemplateAbsolutePath", "Wonderful") + end + it "should support rendering templates with multiple roots" do dispatch_should_make_body("RenderTemplateMultipleRoots", "App: Multiple") end spec/public/abstract_controller/render_spec.rb @@ -2,6 +2,7 @@ __DIR__ = File.dirname(__FILE__) require File.join(__DIR__, "..", "..", "spec_helper") require File.join(__DIR__, "controllers", "filters") +require File.join(__DIR__, "controllers", "cousins") require File.join(__DIR__, "controllers", "render") require File.join(__DIR__, "controllers", "partial") require File.join(__DIR__, "controllers", "display") spec/public/abstract_controller/spec_helper.rb @@ -21,7 +21,16 @@ module Merb::Test::Fixtures::Controllers def index @obj = SomeModel.new display @obj - end + end + end + + class DisplayWithLayout < Testing + provides :json + + def index + @obj = SomeModel.new + display @obj, :layout => :custom_arg + end end class DisplayHtmlDefault < Display; end @@ -46,9 +55,16 @@ module Merb::Test::Fixtures::Controllers def no_layout render :layout => false end + + def absolute_without_mime + render :template => File.expand_path(self._template_root) / "merb/test/fixtures/controllers/html_default/index" + end + + def absolute_with_mime + render :template => File.expand_path(self._template_root) / "merb/test/fixtures/controllers/html_default/index.html" + end end - - + class DisplayWithTemplateArgument < Display def index @obj = SomeModel.new @@ -61,7 +77,6 @@ module Merb::Test::Fixtures::Controllers end end - class DisplayWithStringLocation < Display provides :json def index spec/public/controller/controllers/display.rb @@ -23,15 +23,28 @@ describe Merb::Controller, " displaying objects based on mime type" do it "overrides layout settings with render :layout => false" do dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplate, :no_layout).body.should_not match(/Custom: Template/) end + + it "should accept an absolute template path argument - with the mimetype extension" do + dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplate, :absolute_with_mime).body.should == "Custom: HTML: Default" + end + + it "should accept an absolute template path argument - without the mimetype extension" do + dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplate, :absolute_without_mime).body.should == "Custom: HTML: Default" + end - it "should accept a layout argument" do + it "should accept a layout argument when calling to_*" do + dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithLayout, :index, {}, + :http_accept => "application/json").body.should == "{custom_arg: { 'include': '', 'exclude': '' }}" + end + + it "should accept a layout argument with a template" do dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplateArgument, :index).body.should == "Custom Arg: Template" end it "should accept a template path argument" do dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplateArgument, :index_by_arg).body.should == "Template" end - + it "should use other mime-types if they are provided on the class level" do controller = dispatch_to(Merb::Test::Fixtures::Controllers::DisplayClassProvides, :index, {}, :http_accept => "application/xml") controller.body.should == "<XML:Model />" spec/public/controller/display_spec.rb @@ -12,4 +12,30 @@ describe Merb::Request do request.params[:file][:tempfile].class.should == Tempfile request.params[:file][:content_type].should == 'text/plain' end + + it "should accept env['rack.input'] as IO object (instead of StringIO)" do + file = Struct.new(:read, :filename, :path). + new("This is a text file with some small content in it.", "sample.txt", "sample.txt") + m = Merb::Test::MultipartRequestHelper::Post.new :file => file + body, head = m.to_multipart + + t = Tempfile.new("io") + t.write(body) + t.close + + fd = IO.sysopen(t.path) + io = IO.for_fd(fd,"r") + request = Merb::Test::RequestHelper::FakeRequest.new({:request_method => "POST", :content_type => 'multipart/form-data, boundary=----------0xKhTmLbOuNdArY', :content_length => body.length},io) + + running {request.params}.should_not raise_error + request.params[:file].should_not be_nil + request.params[:file][:tempfile].class.should == Tempfile + request.params[:file][:content_type].should == 'text/plain' + end + + it "should handle GET with a content_type but an empty body (happens in some browsers such as safari after redirect)" do + request = fake_request({:request_method => "GET", :content_type => 'multipart/form-data, boundary=----------0xKhTmLbOuNdArY', :content_length => 0}, :req => '') + running {request.params}.should_not raise_error + end + end \ No newline at end of file spec/public/request/multipart_spec.rb @@ -23,11 +23,11 @@ module Merb::Test::Fixtures class MyTemplateEngine - def self.compile_template(path, name, mod) - text = File.read(path) + def self.compile_template(io, name, mod) + text = io.read table = { "\r"=>"\\r", "\n"=>"\\n", "\t"=>"\\t", '"'=>'\\"', "\\"=>"\\\\" } text = (text.split("\n").map {|x| '"' + (x.gsub(/[\r\n\t"\\]/) { |m| table[m] }) + '"'}).join(" +\n") - mod.class_eval <<-EOS, path + mod.class_eval <<-EOS, File.expand_path(io.path) def #{name} #{text} end @@ -58,7 +58,7 @@ describe Merb::Template do # @semipublic def rendering_template(template_path) - Merb::Template.inline_template(template_path, Merb::Test::Fixtures::MyHelpers) + Merb::Template.inline_template(File.open(template_path), Merb::Test::Fixtures::MyHelpers) Merb::Test::Fixtures::Environment.new. send(Merb::Template.template_name(template_path)) end @@ -74,6 +74,17 @@ describe Merb::Template do rendering_template(template_path).should == "Hello world!" end + it "should compile and inline templates that comes through via VirtualFile" do + Merb::Template.inline_template(VirtualFile.new("Hello", + File.dirname(__FILE__) / "templates" / "template.html.erb"), + Merb::Test::Fixtures::MyHelpers) + + res = Merb::Test::Fixtures::Environment.new. + send(Merb::Template.template_name(File.dirname(__FILE__) / "templates" / "template.html.erb")) + + res.should == "Hello" + end + it "should know how to correctly report errors" do template_path = File.dirname(__FILE__) / "templates" / "error.html.erb" running { render_template(template_path) }.should raise_error(NameError, /`foo'/) @@ -86,7 +97,7 @@ describe Merb::Template do it "should find the full template name for a path via #template_for" do template_path = File.dirname(__FILE__) / "templates" / "template.html.erb" - name = Merb::Template.inline_template(template_path, Merb::Test::Fixtures::MyHelpers) + name = Merb::Template.inline_template(File.open(template_path), Merb::Test::Fixtures::MyHelpers) Merb::Test::Fixtures::Environment.new.should respond_to(name) end spec/public/template/template_spec.rb @@ -26,6 +26,15 @@ describe Merb::Test::RequestHelper do controller.params[:name].should == "Fred" end + it "should dispatch to the given controller and action with the query string merged into the params" do + Merb::Test::ControllerAssertionMock.should_receive(:called).with(:show) + controller = dispatch_to(@controller_klass, :show, {:name => "Fred"}, {'QUERY_STRING' => "last_name=Jones&age=42"} ) + + controller.params[:name].should == "Fred" + controller.params[:last_name].should == "Jones" + controller.params[:age].should == "42" + end + it "should not hit the router to match its route" do Merb::Router.should_not_receive(:match) dispatch_to(@controller_klass, :index) @@ -85,6 +94,14 @@ describe Merb::Test::RequestHelper do controller = get("/spec_helper_controller", :name => "Harry") controller.params[:name].should == "Harry" end + + it "should perform the index action and have params available from the query string" do + Merb::Test::ControllerAssertionMock.should_receive(:called).with(:index) + controller = get("/spec_helper_controller?last_name=Oswald&age=25", :name => "Harry") + controller.params[:name].should == "Harry" + controller.params[:last_name].should == "Oswald" + controller.params[:age].should == "25" + end it "should evaluate in the context of the controller in the block" do get("/spec_helper_controller") do |controller| spec/public/test/request_helper_spec.rb deps/rack/lib/rack.rbc deps/rack/lib/rack/builder.rbc lib/merb-core/rack/apps/path_prefix.rb lib/merb-core/rack/apps/static.rb 9238c0a2d1cce49beafb165bab8ad6513821b83e 8ceb03e11d386feadfa9dd47b57d72c99e36ee6a Michael D. Ivey ivey@gweezlebur.com http://github.com/wycats/merb-core/commit/6155eae38811b4a8676530786fdedf48ba46cdea 6155eae38811b4a8676530786fdedf48ba46cdea 2008-06-20T12:51:37-07:00 2008-06-20T12:51:37-07:00 Merge branch 'master' of git@github.com:wycats/merb-core * 'master' of git@github.com:wycats/merb-core: (50 commits) add Merb::Rack::Profiler middleware. to use add the following to your config/rack.rb file: update license Missing require require 'stringio' Add support for non-standard template reloading. Plugin authors need to override load_template_io to handle special reloading logic. Add support for IO templates instead of just paths. See PLUGIN_API_CHANGELOG for details. add swiftiplied mongrel rack adapter. Swapped the order of helper and controller in the default_framework Why should capture be private? Merb::Config[:framework] now needs absolute paths to work (breaks BC) Merb::Config[:framework] paths now pickup files using glob **/*.rb unless specified otherwise Don't automatically use Facebook signature Fixes failing spec. make the default rake task 'specs' so running rake in merb-core just runs the specs Rename @status to @_status Avoid adding nil values in place of missing keys for Hash#only Fix issue with null segments Fixed session cookie expires value [#366 state:resolved] Made HTTP method override proc-based and pluggable. [#364] siiiiiigh. ... cce28fdf0484ff88c3acf36df2e9e9f552dd8637 Michael D. Ivey ivey@gweezlebur.com