docs/merb-core-call-stack-diagram.mmap docs/merb-core-call-stack-diagram.pdf docs/merb-core-call-stack-diagram.png lib/merb-core/rack/apps/path_prefix.rb lib/merb-core/rack/apps/static.rb lib/merb-core/rack/middleware.rb lib/merb-core/tasks/audit.rake lib/merb-core/tasks/merb.rb lib/merb-core/tasks/merb_rake_helper.rb lib/merb-core/test/test_ext/string.rb simple_benches/to_proc.rb spec/private/dispatch/session_mixin_spec.rb spec/private/router/behavior_spec.rb spec/private/router/route_spec.rb spec/private/router/router_spec.rb spec/private/vendor/facets/plural_spec.rb spec/private/vendor/facets/singular_spec.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/controller/controllers/views/merb/test/fixtures/controllers/display_with_template/no_layout.html.erb spec/public/core_ext/fixtures/core_ext_dependency.rb spec/public/core_ext/kernel_spec.rb spec/public/core_ext/spec_helper.rb spec/public/router/fixation_spec.rb spec/public/router/nested_matches_spec.rb @@ -1,3 +1,78 @@ +== 0.9.3 "We Sold Our Soul for Rock 'n' Roll" 2008-05-03 +* Added render(template_path) feature to view specs. +* add mutex around compiled statement generation in the router so reloading doesn't step +* BootLoader::LoadClasses now logs the actual exceptions +* Added String#unescape_regexp for usage in Router::Route#generate +* Added Time#to_json to Core Extensions so JSON formatted output for Time is ISO 8601 compatible +* redo stream_file to (hopefully) work +* _dispatch returns @body +* Refactored Merb::AbstractController.layout class method +* Fixed lurking infinite loop with not so common formats and ExceptionController +* HTTP Basic authentication based on Rack +* added dispatch helper for http basic authentication +* added support and specs for http basic authorization +* modified specs to test a route restriction based on the request method +* Added ability to specify :format in url() for named routes +* Added thrown_content? predicate method for use in templates. +* pass arguments to filters +* Fix cookie sessions bug where you could not properly delete a cookie +* Standardises the call to set_cookie to use the set_cookie method in cookies.rb by default +* added HasContent matcher +* Added \- to String.unescape_regexp +* Changed the display method to handle options properly, so that passing :layout => :false works. +* Added error message for when a content_type is requested but not provided +* added delete action to docs +* deferred?(env) now works with thin and ebb. +* If deferred_actions are empty? we want a regex that will never match. +* Fix example in Merb::Test::RequestHelper#request documentation. +* Unify &block documentation across Merb::Test::RequestHelper +* Add spec command run options to run_specs. Add tasks for profiled spec run. +* Report total spec suite run time. +* Use RSPEC_OPTS environment variable to override default spec run options. +* Better formatting of spec suite run benchmark with good old sprintf. +* Fix a nasty String#camel_case bug revealed but new shiny spec for String extensions. +* Remove helper that duplicated String#camel_case functionality, update the rest of spec suite. +* Split 'misc' examples group in Kernel extensions spec: each method should have a separate group +* Split Kernel#use_orm guts into a bunch of smaller methods. Document those. +* Kernel#already_registred_orm? is a sucky name. Make it Kernel#registred_orm?. Yay. +* Split Kernel#use_test into smaller methos. Document them. Add specs for them beforehand. +* Use a constant for sleep time in reloading specs +* Use @ in publicity markers in RDoc. +* Remove InvalidPathConversion exception: it is used nowhere in the core. +* A bit clearer --init-file option description. +* Be clear about what is the default init file Merb uses in RDoc. +* hopefully the last fix for session fixation, woot woot +* Provide hook for param filtering +* Give useful information when no template is found for a partial +* Adds a question method to determine environment. eg Merb.env?(:production) +* Make #display method pass all 'unknown' options to serialization method. +* Add Object#in? for checking array inclusion +* Update Kernel#__profile__ documentation. +* Adding support for pidfile setting with cluster nodes setting. +* Updating pidfile cluster fix to handle any extension. +* Fix for kill so that cli options are read and handled before kill is actually called. +* Refactored Exception status handling/inheritance (it actually works now!) +* Replaced remaining ::STATUS constant references to .status method calls +* Append the content_type to the given :template option for render() +* Fix bug in --very-flat (allow direct inheritance from Merb::Controller) +* Show merb usage if first argument is not a switch +* Adding missing info about ebb adapter. +* completed spec to Merb::Logger#new +* Added Provide matcher class, so you can do "controller.should provide( :xml )" in your specs. +* Added support for multiple keys to designate a resource. For use with Datamapper composite keys +* Ensure that Merb::Logger doesn't try to close terminal streams. +* Remove redundant unescape for cookie string +* Added handling of INT signal for Merb server in foreground mode +* params array serialization +* Fixing pidfiles glob on cluster and pidfile argument +* test request helpers support namespaced routes +* Testing Merb::Test::RequestHelper#request method to properly handle namespaced routes +* Provide opts for alternate rackup config path. +* Add new -R/--rackup option to the full(-ish) list of options. +* Make change_priveledge actually work +* Allow http status to be a symbol - refactored String snake_case method +* removing __app_file_trace__ since it doesn't work. + == 0.9.2 "appropriate response to reality" 2008-03-24 * removed Merb.logger calls due to the fact the bootloader did not ran by now and it is not initialized. * use __send__ rather than send CHANGELOG @@ -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 @@ -19,16 +19,13 @@ NAME = "merb-core" require "lib/merb-core/version" require "lib/merb-core/test/run_specs" +require 'lib/merb-core/tasks/merb_rake_helper' ############################################################################## # Packaging & Installation ############################################################################## CLEAN.include ["**/.*.sw?", "pkg", "lib/*.bundle", "*.gem", "doc/rdoc", ".config", "coverage", "cache"] -windows = (PLATFORM =~ /win32|cygwin/) rescue nil - -SUDO = windows ? "" : "sudo" - desc "Packages up Merb." task :default => :package @@ -59,7 +56,6 @@ spec = Gem::Specification.new do |s| s.add_dependency "json_pure" s.add_dependency "rspec" s.add_dependency "rack" - s.add_dependency "hpricot" s.add_dependency "mime-types" # Requirements s.requirements << "install the json gem to get faster json parsing" @@ -72,17 +68,17 @@ end desc "Run :package and install the resulting .gem" task :install => :package do - sh %{#{SUDO} gem install --local pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri} + sh %{#{sudo} gem install #{install_home} --local pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri} end desc "Run :package and install the resulting .gem with jruby" task :jinstall => :package do - sh %{#{SUDO} jruby -S gem install pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri} + sh %{#{sudo} jruby -S gem install #{install_home} pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri} end desc "Run :clean and uninstall the .gem" task :uninstall => :clean do - sh %{#{SUDO} gem uninstall #{NAME}} + sh %{#{sudo} gem uninstall #{NAME}} end namespace :github do @@ -90,14 +86,14 @@ namespace :github do task :update_gemspec do skip_fields = %w(new_platform original_platform) integer_fields = %w(specification_version) - + result = "Gem::Specification.new do |s|\n" - spec.instance_variables.each do |ivar| + spec.instance_variables.each do |ivar| value = spec.instance_variable_get(ivar) name = ivar.split("@").last next if skip_fields.include?(name) || value.nil? || value == "" || (value.respond_to?(:empty?) && value.empty?) if name == "dependencies" - value.each do |d| + value.each do |d| dep, *ver = d.to_s.split(" ") result << " s.add_dependency #{dep.inspect}, #{ver.join(" ").inspect.gsub(/[()]/, "")}\n" end @@ -143,7 +139,7 @@ namespace :doc do desc "rdoc to rubyforge" task :rubyforge do # sh %{rake doc} - sh %{#{SUDO} chmod -R 755 doc} unless windows + sh %{#{sudo} chmod -R 755 doc} unless windows? sh %{/usr/bin/scp -r -p doc/rdoc/* ezmobius@rubyforge.org:/var/www/gforge-projects/merb} end Rakefile @@ -55,3 +55,4 @@ deflist: MimeTypes. \:xml: to_xml, application/xml or text/xml or application/x-xml, adds "Encoding: UTF-8" response header \:js: to_json, text/javascript ot application/javascript or application/x-javascript \:json: to_json, application/json or text/x-json + docs/bootloading.dox @@ -9,10 +9,61 @@ $LOAD_PATH.unshift File.dirname(__FILE__) unless $LOAD_PATH.include?(File.dirname(__FILE__)) || $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__))) +require 'merb-core/vendor/facets' + module Merb module GlobalHelpers; end class << self + # Merge environment settings + # Can allow you to have a "localdev" that runs like your "development" + # OR + # A "staging" environment that runs like your "production" + # + # ==== Examples + # From any environment config file (ie, development.rb, custom.rb, localdev.rb, etc) + # staging.rb: + # Merb.merge_env "production" #We want to use all the settings production uses + # Merb::Config.use { |c| + # c[:log_level] = "debug" #except we want debug log level + # c[:exception_details] = true #and we want to see exception details + # } + # + # ==== Parameters + # env<~String>:: Environment to run like + # use_db<~Boolean>:: Should Merb use the merged environments DB connection + # Defaults to +false+ + def merge_env(env,use_db=false) + if Merb.environment_info.nil? + Merb.environment_info = { + :real_env => Merb.environment, + :merged_envs => [], + :db_env => Merb.environment + } + end + + #Only load if it hasn't been loaded + unless Merb.environment_info[:merged_envs].member? env + Merb.environment_info[:merged_envs] << env + + env_file = Merb.dir_for(:config) / "environments" / ("#{env}.rb") + if File.exists?(env_file) + load(env_file) + else + Merb.logger.warn! "Environment file does not exist! #{env_file}" + end + + end + + # Mark specific environment to load when ORM loads, + # if multiple environments are loaded, the last one + # with use_db as TRUE will be loaded + if use_db + Merb.environment_info[:db_env] = env + end + end + + # Startup Merb by setting up the Config and starting the server. # This is where Merb application environment and root path are set. # @@ -59,11 +110,11 @@ module Merb start_environment(Merb::Config.to_hash.merge(argv)) end - attr_accessor :environment, :load_paths, :adapter + attr_accessor :environment, :load_paths, :adapter, :environment_info alias :env :environment - Merb.load_paths = Hash.new { [Merb.root] } unless Merb.load_paths.is_a?(Hash) + Merb.load_paths = Dictionary.new { [Merb.root] } unless Merb.load_paths.is_a?(Dictionary) # This is the core mechanism for setting up your application layout. # There are three application layouts in Merb: @@ -103,10 +154,10 @@ module Merb # uses to simplify transition of legacy application, you can # set it up like this: # - # Merb.push_path(:models, Merb.root / "app" / "models", "**/*.rb") - # Merb.push_path(:mailers, Merb.root / "app" / "models", "**/*.rb") - # Merb.push_path(:controllers, Merb.root / "app" / "controllers", "**/*.rb") - # Merb.push_path(:views, Merb.root / "app" / "views", "**/*.rb") + # Merb.push_path(:model, Merb.root / "app" / "models", "**/*.rb") + # Merb.push_path(:mailer, Merb.root / "app" / "models", "**/*.rb") + # Merb.push_path(:controller, Merb.root / "app" / "controllers", "**/*.rb") + # Merb.push_path(:view, Merb.root / "app" / "views", "**/*.rb") # # ==== Parameters # type<Symbol>:: The type of path being registered (i.e. :view) @@ -132,8 +183,8 @@ module Merb # application components. # # Merb.root = "path/to/legacy/app/root" - # Merb.remove_paths(:mailers) - # Merb.push_path(:mailers, Merb.root / "app" / "models", "**/*.rb") + # Merb.remove_paths(:mailer) + # Merb.push_path(:mailer, Merb.root / "app" / "models", "**/*.rb") # # Will make Merb use app/models for mailers just like Ruby on Rails does. def remove_paths(*args) @@ -245,8 +296,35 @@ module Merb end # Set up default variables under Merb - attr_accessor :generator_scope, :klass_hashes - Merb.generator_scope = [:merb_default, :merb, :rspec] + attr_accessor :generator_scope, :klass_hashes, :orm_generator_scope, :test_framework_generator_scope + + # Returns registered ORM generators as symbols, + # for instance, :datamapper. + # + # ==== Returns + # <Array(Symbol>:: registered ORM generators. + def orm_generator_scope + @orm_generator_scope ||= :merb_default + end + + # Returns registered test framework generators. + # + # ==== Returns + # <Array(Symbol>:: registred test framework generators. + def test_framework_generator_scope + @test_framework_generator_scope ||= :rspec + end + + # Returns all registered generators plus Merb generator. + # + # ==== Returns + # <Array(Symbol>:: + # all registered generators, inc. needed by Merb itself. + def generator_scope + [:merb, orm_generator_scope, test_framework_generator_scope] + end + + Merb.klass_hashes = [] attr_reader :registered_session_types @@ -322,6 +400,9 @@ module Merb # :session_id_key<String>:: session identifier, # default is _session_id # + # :session_store<String>:: session store to use (one of cookies, + # memcache or memory) + # # :log_delimiter<String>:: what Merb logger uses as delimiter # between message sections, default is " ~ " # @@ -359,7 +440,7 @@ module Merb load_config(options) Merb::BootLoader::BuildFramework.run Merb::BootLoader::Dependencies.run - Merb::BootLoader::BeforeAppRuns.run + Merb::BootLoader::BeforeAppLoads.run end # Reload application and framework classes. @@ -475,7 +556,6 @@ require 'merb-core/gem_ext/erubis' require 'merb-core/logger' require 'merb-core/version' require 'merb-core/controller/mime' -require 'merb-core/vendor/facets' # Set the environment if it hasn't already been set. Merb.environment ||= ENV['MERB_ENV'] || Merb::Config[:environment] || (Merb.testing? ? 'test' : 'development') lib/merb-core.rb @@ -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 # @@ -128,9 +138,20 @@ class Merb::BootLoader::Logger < Merb::BootLoader # Sets Merb.logger to a new logger created based on the config settings. def self.run Merb.logger = Merb::Logger.new(Merb.log_file, Merb::Config[:log_level], Merb::Config[:log_delimiter], Merb::Config[:log_auto_flush]) + print_warnings + end + + def self.print_warnings + if Gem::Version.new(Gem::RubyGemsVersion) < Gem::Version.new("1.1") + Merb.logger.warn! "Please upgrade your Rubygems to the latest version" + end end end +# Stores pid file. +# +# Only run if daemonization or clustering options specified on start. +# Port is taken from Merb::Config and must be already set at this point. class Merb::BootLoader::DropPidFile < Merb::BootLoader class << self @@ -141,6 +162,14 @@ class Merb::BootLoader::DropPidFile < Merb::BootLoader end end +# Setup some useful defaults +class Merb::BootLoader::Defaults < Merb::BootLoader + def self.run + Merb::Request.browser_method_workarounds << "_method" + end +end + + # Build the framework paths. # # By default, the following paths will be used: @@ -272,7 +301,7 @@ class Merb::BootLoader::Dependencies < Merb::BootLoader end -class Merb::BootLoader::BeforeAppRuns < Merb::BootLoader +class Merb::BootLoader::BeforeAppLoads < Merb::BootLoader # Call any before_app_loads hooks that were registered via before_app_loads # in any plugins. @@ -295,21 +324,42 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader class << self - # Load all classes inside the load paths. + # Load all classes from Merb's native load paths. def run - orphaned_classes = [] # Add models, controllers, and lib to the load path $LOAD_PATH.unshift Merb.dir_for(:model) $LOAD_PATH.unshift Merb.dir_for(:controller) $LOAD_PATH.unshift Merb.dir_for(:lib) + # Load application file if it exists - for flat applications load_file Merb.dir_for(:application) if File.file?(Merb.dir_for(:application)) + + # Load classes and their requirements + Merb.load_paths.each do |component, path| + next unless path.last && component != :application + load_classes(path.first / path.last) + end - # Require all the files in the registered load paths - Merb.load_paths.each do |name, path| - next unless path.last && name != :application - Dir[path.first / path.last].each do |file| - + Merb::Controller.send :include, Merb::GlobalHelpers + end + + # ==== Parameters + # file<String>:: The file to load. + def load_file(file) + klasses = ObjectSpace.classes.dup + load file + LOADED_CLASSES[file] = ObjectSpace.classes - klasses + MTIMES[file] = File.mtime(file) + end + + # Load classes from given paths - using path/glob pattern. + # + # *paths<Array>:: + # Array of paths to load classes from - may contain glob pattern + def load_classes(*paths) + orphaned_classes = [] + paths.flatten.each do |path| + Dir[path].each do |file| begin load_file file rescue NameError => ne @@ -317,19 +367,62 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader end end end - Merb::Controller.send :include, Merb::GlobalHelpers - load_classes_with_requirements(orphaned_classes) end # ==== Parameters - # file<String>:: The file to load. - def load_file(file) - klasses = ObjectSpace.classes.dup - load file - LOADED_CLASSES[file] = ObjectSpace.classes - klasses - MTIMES[file] = File.mtime(file) + # file<String>:: The file to reload. + def reload(file) + remove_file(file) { |f| load_file(f) } + end + + # 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 + + # ==== Parameters + # file<String>:: The file to remove classes for. + # &block:: A block to call with the file that has been removed. + def remove_file(file, &block) + Merb.klass_hashes.each {|x| x.protect_keys!} + if klasses = LOADED_CLASSES.delete(file) + klasses.each { |klass| remove_constant(klass) unless klass.to_s =~ /Router/ } + end + yield file if block_given? + Merb.klass_hashes.each {|x| x.unprotect_keys!} + end + + # ==== Parameters + # const<Class>:: The class to remove. + def remove_constant(const) + # This is to support superclasses (like AbstractController) that track + # their subclasses in a class variable. Classes that wish to use this + # functionality are required to alias it to _subclasses_list. Plugins + # for ORMs and other libraries should keep this in mind. + superklass = const + until (superklass = superklass.superclass).nil? + if superklass.respond_to?(:_subclasses_list) + superklass.send(:_subclasses_list).delete(klass) + superklass.send(:_subclasses_list).delete(klass.to_s) + end + end + + parts = const.to_s.split("::") + base = parts.size == 1 ? Object : Object.full_const_get(parts[0..-2].join("::")) + object = parts[-1].to_s + begin + base.send(:remove_const, object) + Merb.logger.debug("Removed constant #{object} from #{base}") + rescue NameError + Merb.logger.debug("Failed to remove constant #{object} from #{base}") + end end + + private # "Better loading" of classes. If a class fails to load due to a NameError # it will be added to the failed_classs stack. @@ -373,43 +466,6 @@ class Merb::BootLoader::LoadClasses < Merb::BootLoader end end - # ==== Parameters - # file<String>:: The file to reload. - def reload(file) - Merb.klass_hashes.each {|x| x.protect_keys!} - if klasses = LOADED_CLASSES.delete(file) - klasses.each { |klass| remove_constant(klass) unless klass.to_s =~ /Router/ } - end - load_file file - Merb.klass_hashes.each {|x| x.unprotect_keys!} - end - - # ==== Parameters - # const<Class>:: The class to remove. - def remove_constant(const) - # This is to support superclasses (like AbstractController) that track - # their subclasses in a class variable. Classes that wish to use this - # functionality are required to alias it to _subclasses_list. Plugins - # for ORMs and other libraries should keep this in mind. - superklass = const - until (superklass = superklass.superclass).nil? - if superklass.respond_to?(:_subclasses_list) - superklass.send(:_subclasses_list).delete(klass) - superklass.send(:_subclasses_list).delete(klass.to_s) - end - end - - parts = const.to_s.split("::") - base = parts.size == 1 ? Object : Object.full_const_get(parts[0..-2].join("::")) - object = parts[-1].to_s - begin - base.send(:remove_const, object) - Merb.logger.debug("Removed constant #{object} from #{base}") - rescue NameError - Merb.logger.debug("Failed to remove constant #{object} from #{base}") - end - end - end end @@ -427,15 +483,18 @@ class Merb::BootLoader::Templates < Merb::BootLoader # ==== 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 # the same _template_root, so it's silly to be globbing the same # path over and over. - template_paths = Merb::AbstractController._abstract_subclasses.map do |klass| - Object.full_const_get(klass)._template_root - end.uniq.compact.map {|path| Dir["#{path}/**/*.#{extension_glob}"] } + controller_view_paths = [] + Merb::AbstractController._abstract_subclasses.each do |klass| + next if (const = Object.full_const_get(klass))._template_root.blank? + controller_view_paths += const._template_roots.map { |pair| pair.first } + end + template_paths = controller_view_paths.uniq.compact.map { |path| Dir["#{path}/**/*.#{extension_glob}"] } # This gets the templates that might be created outside controllers # template roots. eg app/views/shared/* @@ -453,7 +512,7 @@ end # :yaml:: to_yaml, application/x-yaml or text/yaml # :text:: to_text, text/plain # :html:: to_html, text/html or application/xhtml+xml or application/html -# :xml:: to_xml, application/xml or text/xml or application/x-xml, adds "Encoding: UTF-8" response header +# :xml:: to_xml, application/xml or text/xml or application/x-xml # :js:: to_json, text/javascript ot application/javascript or application/x-javascript # :json:: to_json, application/json or text/x-json class Merb::BootLoader::MimeTypes < Merb::BootLoader @@ -461,12 +520,12 @@ class Merb::BootLoader::MimeTypes < Merb::BootLoader # Registers the default MIME types. def self.run Merb.add_mime_type(:all, nil, %w[*/*]) - Merb.add_mime_type(:yaml, :to_yaml, %w[application/x-yaml text/yaml]) - Merb.add_mime_type(:text, :to_text, %w[text/plain]) - Merb.add_mime_type(:html, :to_html, %w[text/html application/xhtml+xml application/html]) - Merb.add_mime_type(:xml, :to_xml, %w[application/xml text/xml application/x-xml], :Encoding => "UTF-8") - Merb.add_mime_type(:js, :to_json, %w[text/javascript application/javascript application/x-javascript]) - Merb.add_mime_type(:json, :to_json, %w[application/json text/x-json]) + Merb.add_mime_type(:yaml, :to_yaml, %w[application/x-yaml text/yaml], :charset => "utf-8") + Merb.add_mime_type(:text, :to_text, %w[text/plain], :charset => "utf-8") + Merb.add_mime_type(:html, :to_html, %w[text/html application/xhtml+xml application/html], :charset => "utf-8") + Merb.add_mime_type(:xml, :to_xml, %w[application/xml text/xml application/x-xml], :charset => "utf-8") + Merb.add_mime_type(:js, :to_json, %w[text/javascript application/javascript application/x-javascript], :charset => "utf-8") + Merb.add_mime_type(:json, :to_json, %w[application/json text/x-json], :charset => "utf-8") end end @@ -502,10 +561,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] @@ -556,6 +613,7 @@ class Merb::BootLoader::RackUpApplication < Merb::BootLoader # the context of a Rack::Builder.new { } block. Allows for mounting # additional apps or middleware. def self.run + require 'rack' if File.exists?(Merb.dir_for(:config) / "rack.rb") Merb::Config[:rackup] ||= Merb.dir_for(:config) / "rack.rb" end @@ -564,25 +622,40 @@ class Merb::BootLoader::RackUpApplication < Merb::BootLoader rackup_code = File.read(Merb::Config[:rackup]) Merb::Config[:app] = eval("::Rack::Builder.new {( #{rackup_code}\n )}.to_app", TOPLEVEL_BINDING, Merb::Config[:rackup]) else - Merb::Config[:app] = ::Merb::Rack::Application.new + Merb::Config[:app] = ::Rack::Builder.new { + if prefix = ::Merb::Config[:path_prefix] + use Merb::Rack::PathPrefix, prefix + end + use Merb::Rack::Static, Merb.dir_for(:public) + run Merb::Rack::Application.new + }.to_app end end end class Merb::BootLoader::ReloadClasses < Merb::BootLoader + class TimedExecutor + def self.every(seconds, &block) + Thread.abort_on_exception = true + Thread.new do + loop do + sleep( seconds ) + block.call + end + Thread.exit + end + end + end + # Setup the class reloader if it's been specified in config. def self.run return unless Merb::Config[:reload_classes] - Thread.abort_on_exception = true - Thread.new do - loop do - sleep( Merb::Config[:reload_time] || 0.5 ) - reload - end - Thread.exit + TimedExecutor.every(Merb::Config[:reload_time] || 0.5) do + reload end + end # Reloads all files. lib/merb-core/bootloader.rb @@ -22,7 +22,8 @@ module Merb :log_delimiter => " ~ ", :log_auto_flush => false, :disabled_components => [], - :deferred_actions => [] + :deferred_actions => [], + :verbose => false } end @@ -226,6 +227,10 @@ module Merb end end + opts.on("-V", "--verbose", "Print extra information") do + options[:verbose] = true + end + opts.on("-?", "-H", "--help", "Show this help message") do puts opts exit @@ -237,7 +242,7 @@ module Merb Merb::Config.setup(options) end - attr_accessor :configuration #:nodoc: + attr_accessor :configuration # Set configuration parameters from a code block, where each method # evaluates to a config parameter. @@ -261,7 +266,7 @@ module Merb # ==== Parameters # method<~to_s>:: Method name as hash key value. # *args:: Value to set the configuration parameter to. - def method_missing(method, *args) #:nodoc: + def method_missing(method, *args) if method.to_s[-1,1] == '=' @configuration[method.to_s.tr('=','').to_sym] = *args else @@ -271,14 +276,14 @@ module Merb end # class << self - class ConfigBlock #:nodoc: + class ConfigBlock - def initialize(klass, &block) #:nodoc: + def initialize(klass, &block) @klass = klass instance_eval(&block) end - def method_missing(method, *args) #:nodoc: + def method_missing(method, *args) @klass[method] = *args end lib/merb-core/config.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,10 @@ 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] # ==== Returns # String:: The controller name in path form, e.g. "admin/items". @@ -119,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 @@ -152,10 +177,11 @@ class Merb::AbstractController # klass<Merb::AbstractController>:: # The controller that is being inherited from Merb::AbstractController def inherited(klass) - _abstract_subclasses << klass.to_s - Object.make_module "Merb::#{klass}Helper" unless klass.to_s =~ /^Merb::/ + _abstract_subclasses << klass.to_s + helper_module_name = klass.to_s =~ /^(#|Merb::)/ ? "#{klass}Helper" : "Merb::#{klass}Helper" + Object.make_module helper_module_name klass.class_eval <<-HERE - include Object.full_const_get("Merb::#{klass}Helper") rescue nil + include Object.full_const_get("#{helper_module_name}") rescue nil HERE super end @@ -435,8 +461,8 @@ class Merb::AbstractController # # ==== Raises # ArgumentError:: - # Both :only and :exclude, or :if and :unless given, or filter is not a - # Symbol, String or Proc. + # Both :only and :exclude, or :if and :unless given, if filter is not a + # Symbol, String or Proc, or if an unknown option is passed. def self.add_filter(filters, filter, opts={}) raise(ArgumentError, "You can specify either :only or :exclude but @@ -445,6 +471,10 @@ class Merb::AbstractController raise(ArgumentError, "You can specify either :if or :unless but not both at the same time for the same filter.") if opts.key?(:if) && opts.key?(:unless) + + opts.each_key do |key| raise(ArgumentError, + "You can only specify known filter options, #{key} is invalid.") unless FILTER_OPTIONS.include?(key) + end opts = normalize_filters!(opts) lib/merb-core/controller/abstract_controller.rb @@ -90,7 +90,7 @@ module Merb # <p>You tried to access <%= @tried_to_access %> but that URL is # restricted to administrators.</p> # - module ControllerExceptions #:nodoc: all + module ControllerExceptions # Mapping of status code names to their numeric value. STATUS_CODES = {} @@ -294,7 +294,7 @@ module Merb # Required to show exceptions in the log file # # e<Exception>:: The exception that a message is being generated for - def self.exception(e) #:nodoc: + def self.exception(e) "#{ e.message } - (#{ e.class })\n" << "#{(e.backtrace or []).join("\n")}" end lib/merb-core/controller/exceptions.rb @@ -1,7 +1,7 @@ class Merb::Controller < Merb::AbstractController class_inheritable_accessor :_hidden_actions, :_shown_actions - cattr_accessor :_subclasses, :_session_id_key, :_session_secret_key, :_session_expiry + cattr_accessor :_subclasses, :_session_id_key, :_session_secret_key, :_session_expiry, :_session_cookie_domain self._subclasses = Set.new def self.subclasses_list() _subclasses end @@ -9,6 +9,7 @@ class Merb::Controller < Merb::AbstractController self._session_secret_key = nil self._session_id_key = Merb::Config[:session_id_key] || '_session_id' self._session_expiry = Merb::Config[:session_expiry] || Merb::Const::WEEK * 2 + self._session_cookie_domain = Merb::Config[:session_cookie_domain] include Merb::ResponderMixin include Merb::ControllerMixin @@ -23,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. @@ -101,16 +102,7 @@ class Merb::Controller < Merb::AbstractController # ==== Returns # SimpleSet[String]:: A set of actions that should be callable. def callable_actions - unless @callable_actions - callables = [] - klass = self - begin - callables << (klass.public_instance_methods(false) + klass._shown_actions) - klass._hidden_actions - klass = klass.superclass - end until klass == Merb::AbstractController || klass == Object - @callable_actions = Merb::SimpleSet.new(callables.flatten) - end - @callable_actions + @callable_actions ||= Merb::SimpleSet.new(_callable_methods) end # This is a stub method so plugins can implement param filtering if they want. @@ -126,6 +118,22 @@ class Merb::Controller < Merb::AbstractController params end + private + + # All methods that are callable as actions. + # + # ==== Returns + # Array:: A list of method names that are also actions + def _callable_methods + callables = [] + klass = self + begin + callables << (klass.public_instance_methods(false) + klass._shown_actions) - klass._hidden_actions + klass = klass.superclass + end until klass == Merb::AbstractController || klass == Object + callables.flatten.reject{|action| action =~ /^_.*/} + end + end # class << self # The location to look for a template for a particular controller, context, @@ -149,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. # @@ -227,7 +252,10 @@ class Merb::Controller < Merb::AbstractController # ==== Returns # Hash:: The session that was extracted from the request object. def session() request.session end - + + # Hide any methods that may have been exposed as actions before. + hide_action(*_callable_methods) + private # Create a default cookie jar, and pre-set a fixation cookie lib/merb-core/controller/merb_controller.rb @@ -28,17 +28,23 @@ module Merb # The associated method to call on objects to convert them to the # appropriate mime-type. For instance, :json would use :to_json as its # transform_method. - # values<Array[String]>:: + # mimes<Array[String]>:: # A list of possible values sent in the Accept header, such as text/html, # that should be associated with this content-type. # new_response_headers<Hash>:: - # The response headers to set for the the mime type. - def add_mime_type(key, transform_method, values, new_response_headers = {}) - enforce!(key => Symbol, values => Array) + # The response headers to set for the the mime type. For example: + # 'Content-Type' => 'application/json; charset=utf-8'; As a shortcut for + # the common charset option, use :charset => 'utf-8', which will be + # correctly appended to the mimetype itself. + # &block:: a block which recieves the current controller when the format + # is set (in the controller's #content_type method) + def add_mime_type(key, transform_method, mimes, new_response_headers = {}, &block) + enforce!(key => Symbol, mimes => Array) ResponderMixin::TYPES.update(key => - {:request_headers => values, + {:accepts => mimes, :transform_method => transform_method, - :response_headers => new_response_headers }) + :response_headers => new_response_headers, + :response_block => block }) Merb::RenderMixin.class_eval <<-EOS, __FILE__, __LINE__ def render_#{key}(thing = nil, opts = {}) @@ -81,7 +87,7 @@ module Merb # ==== Returns # Hash:: The mime type information. def mime_by_request_header(header) - available_mime_types.find {|key,info| info[request_headers].include?(header)}.first + available_mime_types.find {|key,info| info[:accepts].include?(header)}.first end end lib/merb-core/controller/mime.rb @@ -51,7 +51,7 @@ module Merb::AuthenticationMixin BasicAuthentication.new(self, realm, &authenticator) end - class BasicAuthentication #:nodoc: + class BasicAuthentication # So we can have access to the status codes include Merb::ControllerExceptions lib/merb-core/controller/mixins/authentication.rb @@ -92,6 +92,8 @@ module Merb # ==== Parameters # url<String>:: # URL to redirect to. It can be either a relative or fully-qualified URL. + # permanent<Boolean>:: + # When true, return status 301 Moved Permanently # # ==== Returns # String:: Explanation of redirect. @@ -99,9 +101,10 @@ module Merb # ==== Examples # redirect("/posts/34") # redirect("http://www.merbivore.com/") - def redirect(url) - Merb.logger.info("Redirecting to: #{url}") - self.status = 302 + # redirect("http://www.merbivore.com/", true) + def redirect(url, permanent = false) + self.status = permanent ? 301 : 302 + Merb.logger.info("Redirecting to: #{url} (#{self.status})") headers['Location'] = url "<html><body>You are being <a href=\"#{url}\">redirected</a>.</body></html>" end lib/merb-core/controller/mixins/controller.rb @@ -1,7 +1,7 @@ module Merb::RenderMixin # So we can do raise TemplateNotFound include Merb::ControllerExceptions - + # ==== Parameters # base<Module>:: Module that is including RenderMixin (probably a controller) def self.included(base) @@ -10,9 +10,9 @@ module Merb::RenderMixin class_inheritable_accessor :_default_render_options end end - + module ClassMethods - + # Return the default render options. # # ==== Returns @@ -20,7 +20,7 @@ module Merb::RenderMixin def default_render_options self._default_render_options ||= {} end - + # Set default render options at the class level. # # ==== Parameters @@ -28,53 +28,57 @@ module Merb::RenderMixin def render_options(opts) self._default_render_options = opts end - + # Set the default layout to use or nil/false to disable layout rendering. - # This is a shortcut for render_options :layout => false. + # This is a shortcut for render_options :layout => false. # # ==== Parameters - # layout<~to_s>:: The layout that should be used for this class - # + # layout<~to_s>:: The layout that should be used for this class. + # + # ==== Notes + # You can override by passing :layout => true to render method. + # # ==== Returns # Hash:: The default render options. def layout(layout) self.default_render_options.update(:layout => (layout ? layout : false)) end - + # Enable the default layout logic - reset the layout option. def default_layout self.default_render_options.delete(:layout) end - + end - + # Render the specified item, with the specified options. # # ==== Parameters - # thing<String, Symbol, nil>:: + # thing<String, Symbol, nil>:: # The thing to render. This will default to the current action # opts<Hash>:: An options hash (see below) # # ==== Options (opts) # :format<Symbol>:: A registered mime-type format - # :template<String>:: + # :template<String>:: # The path to the template relative to the template root - # :status<~to_i>:: + # :status<~to_i>:: # The status to send to the client. Typically, this would be an integer # (200), or a Merb status code (Accepted) - # :layout<~to_s>:: + # :layout<~to_s, FalseClass>:: # A layout to use instead of the default. This should be relative to the # layout root. By default, the layout will be either the controller_name or # application. If you want to use an alternative content-type than the one # that the base template was rendered as, you will need to do :layout => - # "foo.#{content_type}" (i.e. "foo.json") + # "foo.#{content_type}" (i.e. "foo.json"). If you want to render without + # layout, use :layout => false. This overrides layout set by +layout+ method. # # ==== Returns # String:: The rendered template, including layout, if appropriate. # # ==== Raises # TemplateNotFound:: There is no template for the specified location. - # + # # ==== Alternatives # If you pass a Hash as the first parameter, it will be moved to opts and # "thing" will be the current action @@ -83,59 +87,65 @@ module Merb::RenderMixin def render(thing = nil, opts = {}) # render :format => :xml means render nil, :format => :xml opts, thing = thing, nil if thing.is_a?(Hash) - + # Merge with class level default render options opts = self.class.default_render_options.merge(opts) - + # If you don't specify a thing to render, assume they want to render the current action thing ||= action_name.to_sym # Content negotiation - opts[:format] ? (self.content_type = opts[:format]) : content_type - + opts[:format] ? (self.content_type = opts[:format]) : content_type + # Handle options (:status) - _handle_options!(opts) - + _handle_options!(opts) + # 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)) - + # Do we have a string to render? elsif thing.is_a?(String) - + # Throw it for later consumption by the layout throw_content(:for_layout, thing) 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 # negotiated content-type, if a template does not exist. For instance, if the # content-type is :json, Merb will first look for current_action.json.*. # Failing that, it will run object.to_json. # # ==== Parameter - # object<Object>:: + # object<Object>:: # An object that responds_to? the transform method registered for the # negotiated mime-type. # thing<String, Symbol>:: # The thing to attempt to render via #render before calling the transform # method on the object. Defaults to nil. - # opts<Hash>:: + # opts<Hash>:: # An options hash that will be used for rendering # (passed on to #render or serialization methods like #to_json or #to_xml) - # + # # ==== Returns # String:: # The rendered template or if no template is found, the transformed object. @@ -144,10 +154,10 @@ module Merb::RenderMixin # NotAcceptable:: # If there is no transform method for the specified mime-type or the object # does not respond to the transform method. - # + # # ==== Alternatives # A string in the second parameter will be interpreted as a template: - # display @object, "path/to/foo" + # display @object, "path/to/foo" # #=> display @object, nil, :template => "path/to/foo" # # A hash in the second parameters will be interpreted as opts: @@ -157,18 +167,18 @@ module Merb::RenderMixin # If you need to pass extra parameters to serialization method, for instance, # to exclude some of attributes or serialize associations, just pass options # for it. - # For instance, + # For instance, + # + # display @locations, :except => [:locatable_type, :locatable_id], :include => [:locatable] # - # display @locations, :except => [:locatable_type, :locatable_id], :include => [:locatable] + # serializes object with polymorphic association, not raw locatable_* attributes. # - # serializes object with polymorphic association, not raw locatable_* attributes. # - # # ==== Options # # :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 # @@ -177,62 +187,47 @@ 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 - + # Try to render without the object render(thing || action_name.to_sym, opts.merge(:template => template_opt)) - + # If the render fails (i.e. a template was not found) - rescue TemplateNotFound + 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 transform = Merb.mime_transform_method(content_type) - raise NotAcceptable unless transform && object.respond_to?(transform) + if !transform + raise NotAcceptable, "#{e.message} and there was no transform method registered for #{content_type.inspect}" + elsif !object.respond_to?(transform) + 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. # # ==== 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. + # The path to the template, relative to the current controller or the + # 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) @@ -254,46 +249,50 @@ 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 - send(template_method) - 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 + + sent_template = with.map do |temp| + @_merb_partial_locals[as.to_sym] = temp 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 - + end + # Take the options hash and handle it as appropriate. - # + # # ==== Parameters # opts<Hash>:: The options hash that was passed into render. - # + # # ==== Options # :status<~to_i>:: # The status of the response will be set to opts[:status].to_i - # + # # ==== Returns # Hash:: The options hash that was passed in. def _handle_options!(opts) self.status = opts[:status].to_i if opts[:status] + headers["Location"] = opts.delete(:location) if opts[:location] opts end @@ -305,22 +304,26 @@ module Merb::RenderMixin # # ==== Parameters # layout<~to_s>:: A layout, relative to the layout root. Defaults to nil. - # + # # ==== Returns # String:: The method name that corresponds to the found layout. - # + # # ==== Raises # TemplateNotFound:: # If a layout was specified (either via layout in the class or by passing # 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 @@ -331,13 +334,13 @@ module Merb::RenderMixin template end end - - # Iterate over the template roots in reverse order, and return the template + + # Iterate over the template roots in reverse order, and return the template # and template location of the first match. # # ==== Parameters - # context<Object>:: The controller action or template basename. - # content_type<~to_s>:: The content type. Defaults to nil. + # 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. # # ==== Options (opts) @@ -348,25 +351,48 @@ 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) + 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 + + 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 - 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) + 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, # so catch_content or catch_content(:for_layout) can be used inside layouts @@ -379,7 +405,7 @@ module Merb::RenderMixin def catch_content(obj = :for_layout) @_caught_content[obj] end - + # Called in templates to test for the existence of previously thrown content. # # ==== Parameters @@ -389,7 +415,7 @@ module Merb::RenderMixin def thrown_content?(obj = :for_layout) @_caught_content.key?(obj) end - + # Called in templates to store up content for later use. Takes a string # and/or a block. First, the string is evaluated, and then the block is # captured using the capture() helper provided by the template languages. The @@ -414,5 +440,5 @@ module Merb::RenderMixin end @_caught_content[obj] = string.to_s << (block_given? ? capture(&block) : "") end - + end lib/merb-core/controller/mixins/render.rb @@ -103,7 +103,7 @@ module Merb # ==== Parameters # base<Module>:: The module that ResponderMixin was mixed into - def self.included(base) # :nodoc: + def self.included(base) base.extend(ClassMethods) base.class_eval do class_inheritable_accessor :class_provided_formats @@ -285,7 +285,7 @@ module Merb # 3. If it's */*, use the first provided format # 4. Look for one that is provided, in order of request # 5. Raise 406 if none found - def _perform_content_negotiation # :nodoc: + def _perform_content_negotiation raise Merb::ControllerExceptions::NotAcceptable if _provided_formats.empty? if (fmt = params[:format]) && !fmt.empty? accepts = [fmt.to_sym] @@ -350,8 +350,26 @@ module Merb def content_type=(type) unless Merb.available_mime_types.has_key?(type) raise Merb::ControllerExceptions::NotAcceptable.new("Unknown content_type for response: #{type}") - end - headers['Content-Type'] = Merb.available_mime_types[type][:request_headers].first + end + # set the Content-Type header - defaults to first accepted mime + if Merb.available_mime_types[type][:response_headers]['Content-Type'] + headers['Content-Type'] = Merb.available_mime_types[type][:response_headers]['Content-Type'] + else + headers['Content-Type'] = Merb.available_mime_types[type][:accepts].first + # explicitly append the character set to the Content-Type header + if Merb.available_mime_types[type][:response_headers][:charset] + headers['Content-Type'] += "; charset=#{Merb.available_mime_types[type][:response_headers][:charset]}" + end + end + # merge any format specific response headers + Merb.available_mime_types[type][:response_headers].each do |key, value| + next if key == :charset || headers.key?(key) + headers[key] = value + end + # if given, use a block to finetune any runtime headers + if Merb.available_mime_types[type][:response_block].respond_to?(:call) + Merb.available_mime_types[type][:response_block].call(self) + end @_content_type = type end @@ -440,7 +458,7 @@ module Merb # All Accept header values, such as "text/html", that match this type. def synonyms @syns ||= Merb.available_mime_types.values.map do |e| - e[:request_headers] if e[:request_headers].include?(@media_range) + e[:accepts] if e[:accepts].include?(@media_range) end.compact.flatten end @@ -456,7 +474,7 @@ module Merb # Symbol: The type as a symbol, e.g. :html. def to_sym Merb.available_mime_types.select{|k,v| - v[:request_headers] == synonyms || v[:request_headers][0] == synonyms[0]}.flatten.first + v[:accepts] == synonyms || v[:accepts][0] == synonyms[0]}.flatten.first end # ==== Returns lib/merb-core/controller/mixins/responder.rb @@ -44,11 +44,11 @@ module Merb::Template ret = if Merb::Config[:reload_templates] - file = Dir["#{path}.{#{Merb::Template::EXTENSIONS.keys.join(',')}}"].first + file = Dir["#{path}.{#{template_extensions.join(',')}}"].first METHOD_LIST[path] = file ? inline_template(file) : nil else METHOD_LIST[path] ||= begin - file = Dir["#{path}.{#{Merb::Template::EXTENSIONS.keys.join(',')}}"].first + file = Dir["#{path}.{#{template_extensions.join(',')}}"].first file ? inline_template(file) : nil end end @@ -56,6 +56,16 @@ module Merb::Template ret end + # Get all known template extensions + # + # ==== Returns + # Array:: Extension strings. + #--- + # @semipublic + def template_extensions + EXTENSIONS.keys + end + # Takes a template at a particular path and inlines it into a module and # adds it to the METHOD_LIST table to speed lookup later. # lib/merb-core/controller/template.rb @@ -1,3 +1,25 @@ +# Copyright (c) 2004-2008 David Heinemeier Hansson +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be +# included in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + + # Allows attributes to be shared within an inheritance hierarchy, but where # each descendant gets a copy of their parents' attributes, instead of just a # pointer to the same. This means that the child can add elements to, for @@ -7,8 +29,13 @@ class Class # Defines class-level and instance-level attribute reader. # - # ==== Parameters - # *syms<Array>:: Array of attributes to define reader for. + # @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) @@ -30,15 +57,15 @@ class Class # Defines class-level (and optionally instance-level) attribute writer. # - # ==== Parameters - # *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 # - # ==== Options - # :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 @@ -46,24 +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. # - # ==== Parameters - # *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 # - # ==== Options - # :instance_writer<Boolean>:: if true, instance-level attribute writer is defined. + # @api public def cattr_accessor(*syms) cattr_reader(*syms) cattr_writer(*syms) @@ -72,8 +100,16 @@ class Class # Defines class-level inheritable attribute reader. Attributes are available to subclasses, # each subclass has a copy of parent's attribute. # - # ==== Parameters - # *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) @@ -93,27 +129,30 @@ class Class # Defines class-level inheritable attribute writer. Attributes are available to subclasses, # each subclass has a copy of parent's attribute. # - # ==== Parameters - # *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 # - # ==== Options - # :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 @@ -121,27 +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. # - # ==== Parameters - # *syms<Array>:: Array of array attribute names to define inheritable writer for. - # - # ==== Options - # :instance_writer<Boolean>:: if true, instance-level inheritable array attribute writer is defined. + # @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 @@ -149,38 +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. # - # ==== Parameters - # *syms<Array>:: Array of hash attribute names to define inheritable writer for. + # @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. # - # ==== Options - # :instance_writer<Boolean>:: if true, instance-level inheritable hash attribute writer is defined. + # @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. # - # ==== Parameters - # *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. # - # ==== Options - # :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) @@ -190,11 +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. # - # ==== Parameters - # *syms<Array>:: Array of array attribute names to define inheritable accessor for. - # - # ==== Options - # :instance_writer<Boolean>:: if true, instance-level inheritable array attribute writer is defined. + # @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) @@ -204,31 +249,34 @@ 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. # - # ==== Parameters - # *syms<Array>:: Array of hash attribute names to define inheritable accessor for. - # - # ==== Options - # :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 - # ==== Returns - # <Hash>:: inheritable attributes hash or it's default value, new frozen Hash. + # @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. # - # ==== Parameters - # key<~to_s, String, Symbol>:: inheritable attribute name - # value<Anything but Array or Hash>:: value of inheritable attribute + # @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 # - # ==== Notes - # If inheritable attributes storage has it's default value, - # a new frozen hash, it is set to new Hash that is not frozen. + # @note + # If inheritable attributes storage has it's default value, + # a new frozen hash, it is set to new Hash that is not frozen. def write_inheritable_attribute(key, value) if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES) @inheritable_attributes = {} @@ -238,12 +286,14 @@ class Class # Sets the array attribute which copy is available to subclasses. # - # ==== Parameters - # 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 # - # ==== Notes - # Inheritable array is re-created on each write. + # @note + # Inheritable array is re-created on each write. def write_inheritable_array(key, elements) write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil? write_inheritable_attribute(key, read_inheritable_attribute(key) + elements) @@ -251,12 +301,15 @@ class Class # Sets the hash attribute which copy is available to subclasses. # - # ==== Parameters - # key<~to_s, String, Symbol>:: inheritable attribute name - # value<Hash>:: value of inheritable attribute + # @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. # - # ==== Notes - # Inheritable hash is re-created on each write. + # @api private + # + # @note + # Inheritable hash is re-created on each write. def write_inheritable_hash(key, hash) write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil? write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash)) @@ -264,14 +317,24 @@ class Class # Reads value of inheritable attributes. # - # ==== Returns - # Inheritable attribute value. Subclasses store copies of values. + # @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 @@ -280,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) @@ -287,7 +351,7 @@ class Class new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES else new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)| - memo.update(key => (value.dup rescue value)) + memo.update(key => ((value.is_a?(Module) ? value : value.dup) rescue value)) end end lib/merb-core/core_ext/class.rb @@ -4,28 +4,24 @@ class Hash class << self # Converts valid XML into a Ruby Hash structure. # - # ==== Paramters - # xml<String>:: A string representation of valid XML. + # @param xml<String> A string representation of valid XML. # - # ==== Notes - # * Mixed content is treated as text and any tags in it are left unparsed - # * Any attributes other than type on a node containing a text node will be + # @note Mixed content is treated as text and any tags in it are left unparsed + # @note Any attributes other than type on a node containing a text node will be # discarded # - # ===== Typecasting - # Typecasting is performed on elements that have a +type+ attribute: - # integer:: - # boolean:: Anything other than "true" evaluates to false. - # datetime:: - # Returns a Time object. See Time documentation for valid Time strings. - # date:: - # Returns a Date object. See Date documentation for valid Date strings. + # @details [Typecasting] + # Typecasting is performed on elements that have a +type+ attribute: + # integer:: + # boolean:: Anything other than "true" evaluates to false. + # datetime:: + # Returns a Time object. See Time documentation for valid Time strings. + # date:: + # Returns a Date object. See Date documentation for valid Date strings. # # Keys are automatically converted to +snake_case+ # - # ==== Examples - # - # ===== Standard + # @example [Simple] # <user gender='m'> # <age type='integer'>35</age> # <name>Home Simpson</name> @@ -34,7 +30,7 @@ class Hash # <is-cool type='boolean'>true</is-cool> # </user> # - # evaluates to + # evaluates to # # { "user" => { # "gender" => "m", @@ -46,50 +42,48 @@ class Hash # } # } # - # ===== Mixed Content + # @example [Mixed Content] # <story> # A Quick <em>brown</em> Fox # </story> # - # evaluates to + # evaluates to # # { "story" => "A Quick <em>brown</em> Fox" } # - # ====== Attributes other than type on a node containing text + # @details [Attributes other than type on a node containing text] # <story is-good='false'> # A Quick <em>brown</em> Fox # </story> # - # evaluates to + # evaluates to # # { "story" => "A Quick <em>brown</em> Fox" } # # <bicep unit='inches' type='integer'>60</bicep> # - # evaluates with a typecast to an integer. But unit attribute is ignored. + # evaluates with a typecast to an integer. But unit attribute is ignored. # - # { "bicep" => 60 } + # { "bicep" => 60 } def from_xml( xml ) ToHashParser.from_xml(xml) end end - - # ==== Returns - # Mash:: This hash as a Mash for string or symbol key access. - # + # This class has semantics of ActiveSupport's HashWithIndifferentAccess # and we only have it so that people can write # params[:key] instead of params['key']. + # + # @return <Mash> This hash as a Mash for string or symbol key access. def to_mash hash = Mash.new(self) hash.default = default hash end - # ==== Returns - # String:: This hash as a query string + # @return <String> This hash as a query string # - # ==== Examples + # @example # { :name => "Bob", # :address => { # :street => '111 Ruby Ave.', @@ -124,36 +118,35 @@ class Hash params end - # ==== Parameters - # *allowed:: The hash keys to include. + # @param *allowed<Array[(String, Symbol)]> The hash keys to include. # - # ==== Returns - # Hash:: A new hash with only the selected keys. + # @return <Hash> A new hash with only the selected keys. # - # ==== Examples + # @example # { :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] } + hash end - # ==== Parameters - # *rejected:: The hash keys to exclude. + # @param *rejected<Array[(String, Symbol)] The hash keys to exclude. # - # ==== Returns - # Hash:: A new hash without the selected keys. + # @return <Hash> A new hash without the selected keys. # - # ==== Examples + # @example # { :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 - # ==== Returns - # String:: The hash as attributes for an XML tag. + # @return <String> The hash as attributes for an XML tag. # - # ==== Examples + # @example # { :one => 1, "two"=>"TWO" }.to_xml_attributes # #=> 'one="1" two="TWO"' def to_xml_attributes @@ -164,17 +157,15 @@ class Hash alias_method :to_html_attributes, :to_xml_attributes - # ==== Parameters - # html_class<~to_s>:: + # @param html_class<#to_s> # The HTML class to add to the :class key. The html_class will be # concatenated to any existing classes. # - # ==== Examples - # hash[:class] #=> nil - # hash.add_html_class!(:selected) - # hash[:class] #=> "selected" - # hash.add_html_class!("class1 class2") - # hash[:class] #=> "selected class1 class2" + # @example hash[:class] #=> nil + # @example hash.add_html_class!(:selected) + # @example hash[:class] #=> "selected" + # @example hash.add_html_class!("class1 class2") + # @example hash[:class] #=> "selected class1 class2" def add_html_class!(html_class) if self[:class] self[:class] = "#{self[:class]} #{html_class}" @@ -186,7 +177,9 @@ class Hash # Converts all keys into string values. This is used during reloading to # prevent problems when classes are no longer declared. # - # === Examples + # @return <Array> An array of they hash's keys + # + # @example # hash = { One => 1, Two => 2 }.proctect_keys! # hash # => { "One" => 1, "Two" => 2 } def protect_keys! @@ -196,7 +189,7 @@ class Hash # Attempts to convert all string keys into Class keys. We run this after # reloading to convert protected hashes back into usable hashes. # - # === Examples + # @example # # Provided that classes One and Two are declared in this scope: # hash = { "One" => 1, "Two" => 2 }.unproctect_keys! # hash # => { One => 1, Two => 2 } @@ -209,10 +202,9 @@ class Hash # Destructively and non-recursively convert each key to an uppercase string, # deleting nil values along the way. # - # ==== Returns - # Hash:: The newly environmentized hash. + # @return <Hash> The newly environmentized hash. # - # ==== Examples + # @example # { :name => "Bob", :contact => { :email => "bob@bob.com" } }.environmentize_keys! # #=> { "NAME" => "Bob", "CONTACT" => { :email => "bob@bob.com" } } def environmentize_keys! @@ -234,7 +226,7 @@ require 'rexml/light/node' # It's mainly just adding vowels, as I ht cd wth n vwls :) # This represents the hard part of the work, all I did was change the # underlying parser. -class REXMLUtilityNode # :nodoc: +class REXMLUtilityNode attr_accessor :name, :attributes, :children, :type cattr_accessor :typecasts, :available_typecasts @@ -324,27 +316,25 @@ class REXMLUtilityNode # :nodoc: # +node+ has #type == "integer", # {{[node.typecast_value("12") #=> 12]}} # - # ==== Parameters - # value<String>:: The value that is being typecast. + # @param value<String> The value that is being typecast. # - # ==== :type options - # "integer":: - # converts +value+ to an integer with #to_i - # "boolean":: - # checks whether +value+, after removing spaces, is the literal - # "true" - # "datetime":: - # Parses +value+ using Time.parse, and returns a UTC Time - # "date":: - # Parses +value+ using Date.parse + # @details [:type options] + # "integer":: + # converts +value+ to an integer with #to_i + # "boolean":: + # checks whether +value+, after removing spaces, is the literal + # "true" + # "datetime":: + # Parses +value+ using Time.parse, and returns a UTC Time + # "date":: + # Parses +value+ using Date.parse # - # ==== Returns - # Integer, true, false, Time, Date, Object:: + # @return <Integer, TrueClass, FalseClass, Time, Date, Object> # The result of typecasting +value+. # - # ==== Notes - # If +self+ does not have a "type" key, or if it's not one of the - # options specified above, the raw +value+ will be returned. + # @note + # If +self+ does not have a "type" key, or if it's not one of the + # options specified above, the raw +value+ will be returned. def typecast_value(value) return value unless @type proc = self.class.typecasts[@type] @@ -353,13 +343,9 @@ class REXMLUtilityNode # :nodoc: # Convert basic XML entities into their literal values. # - # ==== Parameters - # value<~gsub>:: - # An XML fragment. + # @param value<#gsub> An XML fragment. # - # ==== Returns - # ~gsub:: - # The XML fragment after converting entities. + # @return <#gsub> The XML fragment after converting entities. def translate_xml_entities(value) value.gsub(/&lt;/, "<"). gsub(/&gt;/, ">"). @@ -383,21 +369,19 @@ class REXMLUtilityNode # :nodoc: # Converts the node into a readable HTML node. # - # ==== Returns - # String:: The HTML node in text form. + # @return <String> The HTML node in text form. def to_html attributes.merge!(:type => @type ) if @type "<#{name}#{attributes.to_xml_attributes}>#{@nil_element ? '' : inner_html}</#{name}>" end - # ==== Alias - # #to_html + # @alias #to_html #to_s def to_s to_html end end -class ToHashParser # :nodoc: +class ToHashParser def self.from_xml(xml) stack = [] lib/merb-core/core_ext/hash.rb @@ -1,29 +1,41 @@ 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 - # name<String>:: The name of the gem to load. - # *ver<Gem::Requirement, Gem::Version, Array, ~to_str>:: + # @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. # - # ==== Parameters - # name<String>:: The name of the gem to load. - # *ver<Gem::Requirement, Gem::Version, Array, ~to_str>:: - # Version requirements to be passed to Gem.activate. - # - # ==== Notes - # If the gem cannot be found, the method will attempt to require the string - # as a library. - # # This new version tries to load the file via ROOT/gems first before moving # off to the system gems (so if you have a lower version of a gem in # ROOT/gems, it'll still get loaded). + # + # @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. + # + # @note + # If the gem cannot be found, the method will attempt to require the string + # as a library. def load_dependency(name, *ver) try_framework = Merb.frozen? begin @@ -52,8 +64,7 @@ module Kernel # Loads both gem and library dependencies that are passed in as arguments. # Execution is deferred to the Merb::BootLoader::Dependencies.run during bootup. # - # ==== Parameters - # *args<String, Hash, Array>:: The dependencies to load. + # @param *args<String, Hash, Array> The dependencies to load. def dependencies(*args) args.each do |arg| case arg @@ -66,20 +77,18 @@ module Kernel # Loads both gem and library dependencies that are passed in as arguments. # - # ==== Parameters - # *args<String, Hash, Array>:: The dependencies to load. - # - # ==== Notes - # Each argument can be: - # String:: Single dependency. - # Hash:: - # Multiple dependencies where the keys are names and the values versions. - # Array:: Multiple string dependencies. - # - # ==== Examples - # dependencies "RedCloth" # Loads the the RedCloth gem - # dependencies "RedCloth", "merb_helpers" # Loads RedCloth and merb_helpers - # dependencies "RedCloth" => "3.0" # Loads RedCloth 3.0 + # @param *args<String, Hash, Array> The dependencies to load. + # + # @note + # Each argument can be: + # String:: Single dependency. + # Hash:: + # Multiple dependencies where the keys are names and the values versions. + # Array:: Multiple string dependencies. + # + # @example dependencies "RedCloth" # Loads the the RedCloth gem + # @example dependencies "RedCloth", "merb_helpers" # Loads RedCloth and merb_helpers + # @example dependencies "RedCloth" => "3.0" # Loads RedCloth 3.0 def load_dependencies(*args) args.each do |arg| case arg @@ -92,9 +101,8 @@ module Kernel # Does a basic require, and prints a message if an error occurs. # - # ==== Parameters - # library<~to_s>:: The library to attempt to include. - # message<String>:: The error to add to the log upon failure. Defaults to nil. + # @param library<to_s> The library to attempt to include. + # @param message<String> The error to add to the log upon failure. Defaults to nil. def rescue_require(library, message = nil) require library rescue LoadError, RuntimeError @@ -105,20 +113,19 @@ module Kernel # Mapper) you wish to use. Currently Merb has plugins to support # ActiveRecord, DataMapper, and Sequel. # - # ==== Parameters - # orm<~to_s>:: The ORM to use. + # @param orm<#to_s> The ORM to use. # - # ==== Examples - # # This line goes in dependencies.yml + # @example # use_orm :datamapper # # # This will use the DataMapper generator for your ORM - # $ ruby script/generate model MyModel + # $ merb-gen model ActivityEvent + # + # @note + # If for some reason this is called more than once, latter + # call takes over other. def use_orm(orm) - raise "Don't call use_orm more than once" if registred_orm?(orm) - begin - Merb.generator_scope.delete(:merb_default) register_orm(orm) orm_plugin = "merb_#{orm}" Kernel.dependency(orm_plugin) @@ -128,46 +135,28 @@ module Kernel end end - # Use to check whether given ORM already registred at generator scope - # - # ==== Parameters - # orm<~to_sym>:: - # ORM alias, like :activerecord, :datamapper or :sequel. - # - # ==== Returns - # Boolean:: - # true if ORM is already registred, false otherwise - # - #-- - # @semi-public - def registred_orm?(orm) - !Merb.generator_scope.include?(:merb_default) && !Merb.generator_scope.include?(orm.to_sym) - end # Registers ORM at generator scope. # - # ==== Parameters - # orm<~to_sym>:: + # @param orm<#to_sym> # ORM alias, like :activerecord, :datamapper or :sequel. - #-- - # @private + # + # @api private def register_orm(orm) - Merb.generator_scope.unshift(orm.to_sym) unless Merb.generator_scope.include?(orm.to_sym) + Merb.orm_generator_scope = orm end # Used in Merb.root/config/init.rb to tell Merb which testing framework to # use. Currently Merb has plugins to support RSpec and Test::Unit. # - # ==== Parameters - # test_framework<Symbol>:: + # @param test_framework<Symbol> # The test framework to use. Currently only supports :rspec and :test_unit. # - # ==== Examples - # # This line goes in dependencies.yml + # @example # use_test :rspec # # # This will now use the RSpec generator for tests - # $ ruby script/generate controller MyController + # $ merb-gen model ActivityEvent def use_test(test_framework, *test_dependencies) raise "use_test only supports :rspec and :test_unit currently" unless supported_test_framework?(test_framework) register_test_framework(test_framework) @@ -177,63 +166,55 @@ module Kernel # Check whether Merb supports test framework. Currently Merb has plugins to support RSpec and Test::Unit. # - # ==== Parameters - # test_framework<Symbol>:: + # @param test_framework<Symbol> # The test framework to check. Currently only supports :rspec and :test_unit. - #-- - # @semi-public + # + # @api plugin def supported_test_framework?(test_framework) [:rspec, :test_unit].include?(test_framework.to_sym) end # Register test framework at generator scope. Currently Merb has plugins to support RSpec and Test::Unit. # - # ==== Parameters - # test_framework<Symbol>:: - # The test framework to check. Currently only supports :rspec and :test_unit but the check is performed before registration if you use API. - #-- - # @private + # @param test_framework<Symbol> + # The test framework to check. Currently only supports :rspec and :test_unit but the + # check is performed before registration if you use API. + # + # @api private def register_test_framework(test_framework) - Merb.generator_scope.delete(:rspec) - Merb.generator_scope.delete(:test_unit) - - Merb.generator_scope.push(test_framework.to_sym) + Merb.test_framework_generator_scope = test_framework end - # ==== Parameters - # i<Fixnum>:: The caller number. Defaults to 1. + # @param i<Fixnum> The caller number. Defaults to 1. # - # ==== Returns - # Array[Array]:: The file, line and method of the caller. + # @return <Array[Array]> The file, line and method of the caller. # - # ==== Examples + # @example # __caller_info__(1) # # => ['/usr/lib/ruby/1.8/irb/workspace.rb', '52', 'irb_binding'] def __caller_info__(i = 1) file, line, meth = caller[i].scan(/(.*?):(\d+):in `(.*?)'/).first end - # ==== Parameters - # file<String>:: The file to read. - # line<Fixnum>:: The line number to look for. - # size<Fixnum>:: + # @param file<String> The file to read. + # @param line<Fixnum> The line number to look for. + # @param size<Fixnum> # Number of lines to include above and below the the line to look for. # Defaults to 4. # - # ==== Returns - # Array[Array]:: + # @return <Array[Array]> # Triplets containing the line number, the line and whether this was the # searched line. # - # ==== Examples - # __caller_lines__('/usr/lib/ruby/1.8/debug.rb', 122, 2) # => - # [ - # [ 120, " def check_suspend", false ], - # [ 121, " return if Thread.critical", false ], - # [ 122, " while (Thread.critical = true; @suspend_next)", true ], - # [ 123, " DEBUGGER__.waiting.push Thread.current", false ], - # [ 124, " @suspend_next = false", false ] - # ] + # @example + # __caller_lines__('/usr/lib/ruby/1.8/debug.rb', 122, 2) # => + # [ + # [ 120, " def check_suspend", false ], + # [ 121, " return if Thread.critical", false ], + # [ 122, " while (Thread.critical = true; @suspend_next)", true ], + # [ 123, " DEBUGGER__.waiting.push Thread.current", false ], + # [ 124, " @suspend_next = false", false ] + # ] def __caller_lines__(file, line, size = 4) return [['Template Error!', "problem while rendering", false]] if file =~ /\(erubis\)/ lines = File.readlines(file) @@ -260,29 +241,28 @@ module Kernel # Takes a block, profiles the results of running the block # specified number of times and generates HTML report. # - # ==== Parameters - # name<~to_s>:: + # @param name<#to_s> # The file name. The result will be written out to # Merb.root/"log/#{name}.html". - # min<Fixnum>:: + # @param min<Fixnum> # Minimum percentage of the total time a method must take for it to be # included in the result. Defaults to 1. # - # ==== Returns - # String:: The result of the profiling. + # @return <String> + # The result of the profiling. # - # ==== Notes - # Requires ruby-prof (<tt>sudo gem install ruby-prof</tt>) + # @note + # Requires ruby-prof (<tt>sudo gem install ruby-prof</tt>) # - # ==== Examples + # @example # __profile__("MyProfile", 5, 30) do # rand(10)**rand(10) # puts "Profile run" # end # - # Assuming that the total time taken for #puts calls was less than 5% of the - # total time to run, #puts won't appear in the profile report. - # The code block will be run 30 times in the example above. + # Assuming that the total time taken for #puts calls was less than 5% of the + # total time to run, #puts won't appear in the profile report. + # The code block will be run 30 times in the example above. def __profile__(name, min=1, iter=100) require 'ruby-prof' unless defined?(RubyProf) return_result = '' @@ -301,10 +281,9 @@ module Kernel # Extracts an options hash if it is the last item in the args array. Used # internally in methods that take *args. # - # ==== Parameters - # args<Array>:: The arguments to extract the hash from. + # @param args<Array> The arguments to extract the hash from. # - # ==== Examples + # @example # def render(*args,&blk) # opts = extract_options_from_args!(args) || {} # # [...] @@ -315,13 +294,12 @@ module Kernel # Checks that the given objects quack like the given conditions. # - # ==== Parameters - # opts<Hash>:: + # @param opts<Hash> # Conditions to enforce. Each key will receive a quacks_like? call with the # value (see Object#quacks_like? for details). # - # ==== Raises - # ArgumentError:: An object failed to quack like a condition. + # @raise <ArgumentError> + # An object failed to quack like a condition. def enforce!(opts = {}) opts.each do |k,v| raise ArgumentError, "#{k.inspect} doesn't quack like #{v.inspect}" unless k.quacks_like?(v) lib/merb-core/core_ext/kernel.rb @@ -2,13 +2,12 @@ # params[:key] instead of params['key']. class Mash < Hash - # ==== Parameters - # constructor<Object>:: + # @param constructor<Object> # The default value for the mash. Defaults to an empty hash. # - # ==== Alternatives - # If constructor is a Hash, a new mash will be created based on the keys of - # the hash and no default value will be set. + # @details [Alternatives] + # If constructor is a Hash, a new mash will be created based on the keys of + # the hash and no default value will be set. def initialize(constructor = {}) if constructor.is_a?(Hash) super() @@ -18,12 +17,11 @@ class Mash < Hash end end - # ==== Parameters - # key<Object>:: The default value for the mash. Defaults to nil. + # @param key<Object> The default value for the mash. Defaults to nil. # - # ==== Alternatives - # If key is a Symbol and it is a key in the mash, then the default value will - # be set to the value matching the key. + # @details [Alternatives] + # If key is a Symbol and it is a key in the mash, then the default value will + # be set to the value matching the key. def default(key = nil) if key.is_a?(Symbol) && include?(key = key.to_s) self[key] @@ -35,21 +33,21 @@ class Mash < Hash alias_method :regular_writer, :[]= unless method_defined?(:regular_writer) alias_method :regular_update, :update unless method_defined?(:regular_update) - # ==== Parameters - # key<Object>:: The key to set. This will be run through convert_key. - # value<Object>:: - # The value to set the key to. This will be run through convert_value. + # @param key<Object> The key to set. + # @param value<Object> + # The value to set the key to. + # + # @see Mash#convert_key + # @see Mash#convert_value def []=(key, value) regular_writer(convert_key(key), convert_value(value)) end - # ==== Parameters - # other_hash<Hash>:: - # A hash to update values in the mash with. The keys and the values will be - # converted to Mash format. + # @param other_hash<Hash> + # A hash to update values in the mash with. The keys and the values will be + # converted to Mash format. # - # ==== Returns - # Mash:: The updated mash. + # @return <Mash> The updated mash. def update(other_hash) other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) } self @@ -57,90 +55,81 @@ class Mash < Hash alias_method :merge!, :update - # ==== Parameters - # key<Object>:: The key to check for. This will be run through convert_key. + # @param key<Object> The key to check for. This will be run through convert_key. # - # ==== Returns - # Boolean:: True if the key exists in the mash. + # @return <TrueClass, FalseClass> True if the key exists in the mash. def key?(key) super(convert_key(key)) end # def include? def has_key? def member? - alias_method :include?, :key? - alias_method :has_key?, :key? + alias_method :include?, :key? + alias_method :has_key?, :key? alias_method :member?, :key? - # ==== Parameters - # key<Object>:: The key to fetch. This will be run through convert_key. - # extras:: Default value. + # @param key<Object> The key to fetch. This will be run through convert_key. + # @param *extras<Array> Default value. # - # ==== Returns - # Object:: The value at key or the default value. + # @return <Object> The value at key or the default value. def fetch(key, *extras) super(convert_key(key), *extras) end - # ==== Parameters - # indices<Array>:: + # @param *indices<Array> # The keys to retrieve values for. These will be run through +convert_key+. + # + # @return <Array> The values at each of the provided keys def values_at(*indices) indices.collect {|key| self[convert_key(key)]} end - # ==== Returns - # Mash:: A duplicate of this mash. + # @return <Mash> A duplicate of this mash. def dup Mash.new(self) end - # ==== Parameters - # hash<Hash>:: The hash to merge with the mash. + # @param hash<Hash> The hash to merge with the mash. # - # ==== Returns - # Mash:: A new mash with the hash values merged in. + # @return <Mash> A new mash with the hash values merged in. def merge(hash) self.dup.update(hash) end - # ==== Parameters - # key<Object>:: - # The key to delete from the mash. This will be run through convert_key. + # @param key<Object> + # The key to delete from the mash.\ def delete(key) super(convert_key(key)) end # Used to provide the same interface as Hash. # - # ==== Returns - # Mash:: This mash unchanged. + # @return <Mash> This mash unchanged. def stringify_keys!; self end - # ==== Returns - # Hash:: The mash as a Hash with string keys. + # @return <Hash> The mash as a Hash with string keys. def to_hash Hash.new(default).merge(self) end protected - # ==== Parameters - # key<Object>:: The key to convert. + # @param key<Object> The key to convert. # - # ==== Returns - # Object:: + # @param <Object> # The converted key. If the key was a symbol, it will be converted to a # string. + # + # @api private def convert_key(key) key.kind_of?(Symbol) ? key.to_s : key end - # ==== Parameters - # value<Object>:: The value to convert. + # @param value<Object> The value to convert. # - # ==== Returns - # Object:: + # @return <Object> # The converted value. A Hash or an Array of hashes, will be converted to # their Mash equivalents. + # + # @api private def convert_value(value) case value when Hash lib/merb-core/core_ext/mash.rb @@ -1,10 +1,9 @@ class Object # Extracts the singleton class, so that metaprogramming can be done on it. # - # ==== Returns - # Class:: The meta class. + # @return <Class> The meta class. # - # ==== Examples + # @example [Setup] # class MyString < String; end # # MyString.instance_eval do @@ -27,47 +26,51 @@ class Object # end # end # + # @example # MyString.new("Hello").foo #=> "Hello" + # @example # MyString.new("Hello").bar # #=> NoMethodError: undefined method `bar' for "Hello":MyString + # @example # MyString.foo # #=> NoMethodError: undefined method `foo' for MyString:Class + # @example # MyString.bar # #=> MyString + # @example # String.bar # #=> NoMethodError: undefined method `bar' for String:Class - # + # @example # MyString.add_meta_var(:x) # MyString.x #=> HELLO # - # As you can see, using #meta_class allows you to execute code (and here, - # define a method) on the metaclass itself. It also allows you to define - # class methods that can be run on subclasses, and then be able to execute - # code on the metaclass of the subclass (here MyString). + # @details [Description of Examples] + # As you can see, using #meta_class allows you to execute code (and here, + # define a method) on the metaclass itself. It also allows you to define + # class methods that can be run on subclasses, and then be able to execute + # code on the metaclass of the subclass (here MyString). # - # In this case, we were able to define a class method (add_meta_var) on - # String that was executable by the MyString subclass. It was then able to - # define a method on the subclass by adding it to the MyString metaclass. + # In this case, we were able to define a class method (add_meta_var) on + # String that was executable by the MyString subclass. It was then able to + # define a method on the subclass by adding it to the MyString metaclass. # - # For more information, you can check out _why's excellent article at: - # http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html + # For more information, you can check out _why's excellent article at: + # http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html def meta_class() class << self; self end end - # ==== Returns - # Boolean:: + # @return <TrueClass, FalseClass> # True if the empty? is true or if the object responds to strip (e.g. a # String) and strip.empty? is true, or if !self is true. # - # ==== Examples - # [].blank? #=> true - # [1].blank? #=> false - # [nil].blank? #=> false - # nil.blank? #=> true - # true.blank? #=> false - # false.blank? #=> true - # "".blank? #=> true - # " ".blank? #=> true - # " hey ho ".blank? #=> false + # @example [].blank? #=> true + # @example [1].blank? #=> false + # @example [nil].blank? #=> false + # @example nil.blank? #=> true + # @example true.blank? #=> false + # @example false.blank? #=> true + # @example "".blank? #=> true + # @example " ".blank? #=> true + # @example " hey ho ".blank? #=> false def blank? if respond_to?(:empty?) && respond_to?(:strip) empty? or strip.empty? @@ -78,26 +81,40 @@ class Object end end - # ==== Parameters - # name<String>:: The name of the constant to get, e.g. "Merb::Router". + # @param name<String> The name of the constant to get, e.g. "Merb::Router". # - # ==== Returns - # Object:: The constant corresponding to the name. + # @return <Object> The constant corresponding to the name. def full_const_get(name) list = name.split("::") - obj = Object - list.each {|x| obj = obj.const_get(x) } + list.shift if list.first.blank? + obj = self + list.each do |x| + # This is required because const_get tries to look for constants in the + # ancestor chain, but we only want constants that are HERE + obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x) + end obj end + + # @param name<String> The name of the constant to get, e.g. "Merb::Router". + # @param value<Object> The value to assign to the constant. + # + # @return <Object> The constant corresponding to the name. + def full_const_set(name, value) + list = name.split("::") + toplevel = list.first.blank? + list.shift if toplevel + last = list.pop + obj = list.empty? ? Object : Object.full_const_get(list.join("::")) + obj.const_set(last, value) if obj && !obj.const_defined?(last) + end # Defines module from a string name (e.g. Foo::Bar::Baz) - # If method already exists, no exception raised. + # If module already exists, no exception raised. # - # ==== Parameters - # name<String>:: The name of the full module name to make + # @param name<String> The name of the full module name to make # - # ==== Returns - # nil + # @return <NilClass> def make_module(str) mod = str.split("::") start = mod.map {|x| "module #{x}"}.join("; ") @@ -108,19 +125,18 @@ class Object HERE end - # ==== Parameters - # duck<Symbol, Class, Array>:: The thing to compare the object to. - # - # ==== Notes - # The behavior of the method depends on the type of duck as follows: - # Symbol:: Check whether the object respond_to?(duck). - # Class:: Check whether the object is_a?(duck). - # Array:: - # Check whether the object quacks_like? at least one of the options in the - # array. - # - # ==== Returns - # Boolean:: True if the object quacks like duck. + # @param duck<Symbol, Class, Array> The thing to compare the object to. + # + # @note + # The behavior of the method depends on the type of duck as follows: + # Symbol:: Check whether the object respond_to?(duck). + # Class:: Check whether the object is_a?(duck). + # Array:: + # Check whether the object quacks_like? at least one of the options in the + # array. + # + # @return <TrueClass, FalseClass> + # True if the object quacks like duck. def quacks_like?(duck) case duck when Symbol @@ -134,12 +150,14 @@ class Object end end - # ==== Parameters - # arrayish<Array>:: Container to check, to see if it includes the object. - # more<Objects>:: additional args, will be flattened into arrayish + # @param arrayish<#include?> Container to check, to see if it includes the object. + # @param *more<Array>:: additional args, will be flattened into arrayish + # + # @return <TrueClass, FalseClass> + # True if the object is included in arrayish (+ more) # - # ==== Returns - # Boolean: True if the object is included in arrayish (+ more) + # @example 1.in?([1,2,3]) #=> true + # @example 1.in?(1,2,3) #=> true def in?(arrayish,*more) arrayish = more.unshift(arrayish) unless more.empty? arrayish.include?(self) lib/merb-core/core_ext/object.rb @@ -2,8 +2,7 @@ module ObjectSpace class << self - # ==== Returns - # Array[Class]:: All the classes in the object space. + # @return <Array[Class]> All the classes in the object space. def classes klasses = [] ObjectSpace.each_object(Class) {|o| klasses << o} lib/merb-core/core_ext/object_space.rb @@ -3,14 +3,25 @@ require 'rubygems' module Gem class SourceIndex - # Overwrite this so that a gem of the same name and version won't push one - # from the gems directory out entirely. - # - # ==== Parameters - # gem_spec<Gem::Specification>:: The specification of the gem to add. - def add_spec(gem_spec) - @gems[gem_spec.full_name] = gem_spec unless @gems[gem_spec.full_name].is_a?(Gem::Specification) && @gems[gem_spec.full_name].installation_path == File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems") + # This is resolved in 1.1 + if Version.new(RubyGemsVersion) < Version.new("1.1") + + # Overwrite this so that a gem of the same name and version won't push one + # from the gems directory out entirely. + # + # @param gem_spec<Gem::Specification> The specification of the gem to add. + def add_spec(gem_spec) + unless gem_spec.instance_variable_get("@loaded_from") && + @gems[gem_spec.full_name].is_a?(Gem::Specification) && + @gems[gem_spec.full_name].installation_path == + File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems") + + @gems[gem_spec.full_name] = gem_spec + end + end + end + end class Specification @@ -19,8 +30,7 @@ module Gem # from any other location. If there are two gems of different versions in # the gems directory, the later one will load as usual. # - # ==== Returns - # Array[Array]:: The object used for sorting gem specs. + # @return <Array[Array]> The object used for sorting gem specs. def sort_obj [@name, installation_path == File.join(defined?(Merb) && Merb.respond_to?(:root) ? Merb.root : Dir.pwd,"gems") ? 1 : -1, @version.to_ints, @new_platform == Gem::Platform::RUBY ? -1 : 1] end lib/merb-core/core_ext/rubygems.rb @@ -6,35 +6,28 @@ module Merb # a set of callable actions of controller. class SimpleSet < Hash - # ==== Parameters - # arr<Array>:: Initial set values. + # @param arr<Array> Initial set values. # - # ==== Returns - # Array:: The array the Set was initialized with + # @return <Array> The array the Set was initialized with def initialize(arr = []) arr.each {|x| self[x] = true} end - # ==== Parameters - # value<Object>:: Value to add to set. + # @param value<Object> Value to add to set. # - # ==== Returns - # true + # @return <TrueClass> def <<(value) self[value] = true end - # ==== Parameters - # arr<Array>:: Values to merge with set. + # @param arr<Array> Values to merge with set. # - # ==== Returns - # SimpleSet:: The set after the Array was merged in. + # @return <SimpleSet> The set after the Array was merged in. def merge(arr) super(arr.inject({}) {|s,x| s[x] = true; s }) end - # ==== Returns - # String:: A human readable version of the set. + # @return <String> A human readable version of the set. def inspect "#<SimpleSet: {#{keys.map {|x| x.inspect}.join(", ")}}>" end lib/merb-core/core_ext/set.rb @@ -1,31 +1,33 @@ require "pathname" class String - - # ==== Returns - # String:: The string with all regexp special characters escaped. + + ## + # @return <String> The string with all regexp special characters escaped. # - # ==== Examples + # @example # "*?{}.".escape_regexp #=> "\\*\\?\\{\\}\\." def escape_regexp Regexp.escape self end - - # ==== Returns - # String:: The string with all regexp special characters unescaped. + + ## + # @return String The string with all regexp special characters unescaped. # - # ==== Examples + # @example # "\\*\\?\\{\\}\\.".unescape_regexp #=> "*?{}." def unescape_regexp self.gsub(/\\([\.\?\|\(\)\[\]\{\}\^\$\*\+\-])/, '\1') end - - # ==== Returns - # String:: The string converted to snake case. + + ## + # @return <String> The string converted to snake case. # - # ==== Examples + # @example # "FooBar".snake_case #=> "foo_bar" + # @example # "HeadlineCNNNews".snake_case #=> "headline_cnn_news" + # @example # "CNN".snake_case #=> "cnn" def snake_case return self.downcase if self =~ /^[A-Z]+$/ @@ -33,57 +35,56 @@ class String return $+.downcase end - # ==== Returns - # String:: The string converted to camel case. + ## + # @return <String> The string converted to camel case. # - # ==== Examples + # @example # "foo_bar".camel_case #=> "FooBar" def camel_case return self if self !~ /_/ && self =~ /[A-Z]+.*/ split('_').map{|e| e.capitalize}.join end - # ==== Returns - # String:: The path string converted to a constant name. + ## + # @return <String> The path string converted to a constant name. # - # ==== Examples + # @example # "merb/core_ext/string".to_const_string #=> "Merb::CoreExt::String" def to_const_string gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase } end - # ==== Returns - # String:: + ## + # @return <String> # The path that is associated with the constantized string, assuming a # conventional structure. # - # ==== Examples + # @example # "FooBar::Baz".to_const_path # => "foo_bar/baz" def to_const_path snake_case.gsub(/::/, "/") end - # ==== Parameters - # o<String>:: The path component to join with the string. + ## + # @param o<String> The path component to join with the string. # - # ==== Returns - # String:: The original path concatenated with o. + # @return <String> The original path concatenated with o. # - # ==== Examples + # @example # "merb"/"core_ext" #=> "merb/core_ext" def /(o) File.join(self, o.to_s) end - # ==== Parameters ==== - # other<String>:: Base path to calculate against + ## + # @param other<String> Base path to calculate against # - # ==== Returns ==== - # String:: Relative path from between the two + # @return <String> Relative path from between the two # - # ==== Example ==== - # "/opt/local/lib".relative_path_from("/opt/local/lib/ruby/site_ruby") # => "../.." + # @example + # "/opt/local/lib".relative_path_from("/opt/local/lib/ruby/site_ruby") # => "../.." def relative_path_from(other) Pathname.new(self).relative_path_from(Pathname.new(other)).to_s end + end lib/merb-core/core_ext/string.rb @@ -1,10 +1,9 @@ class Time - # ==== Returns - # String:: + # @return <String> # ISO 8601 compatible rendering of the Time object's properties. # - # ==== Examples + # @example # Time.now.to_json # => "\"2008-03-28T17:54:20-05:00\"" def to_json self.xmlschema.to_json lib/merb-core/core_ext/time.rb @@ -27,6 +27,7 @@ class Merb::Dispatcher def handle(rack_env) start = Time.now request = Merb::Request.new(rack_env) + Merb.logger.info "Start: #{start.to_s}" route_index, route_params = Merb::Router.match(request) @@ -71,7 +72,8 @@ class Merb::Dispatcher end controller = dispatch_action(klass, action, request) - controller._benchmarks[:dispatch_time] = Time.now - start + controller._benchmarks[:dispatch_time] = Time.now - start + controller.route = route Merb.logger.info controller._benchmarks.inspect Merb.logger.flush lib/merb-core/dispatch/dispatcher.rb @@ -195,10 +195,16 @@ <tr><th width="25%">Key</th><th width="75%">Value</th></tr> </thead> <tbody> - <% params[:original_session].each_with_index do |param_value, i| %> - <tr class="<%= i % 2 == 0 ? "even" : "odd" %>"><td><%= param_value.first %></td><td><%= param_value.last.inspect %></td></tr> - <% end %> - <%= "<tr class='odd'><td colspan='2'>None</td></tr>" if params[:original_session].empty? %> + <% if params[:original_session].respond_to?( :data )%> + <% params[:original_session].data.each_with_index do |param_value, i| %> + <tr class="<%= i % 2 == 0 ? "even" : "odd" %>"><td><%= param_value.first %></td><td><%= param_value.last.inspect %></td></tr> + <% end %> + <% else %> + <% params[:original_session].each_with_index do |param_value, i| %> + <tr class="<%= i % 2 == 0 ? "even" : "odd" %>"><td><%= param_value.first %></td><td><%= param_value.last.inspect %></td></tr> + <% end %> + <%= "<tr class='odd'><td colspan='2'>None</td></tr>" if params[:original_session].empty? %> + <% end %> </tbody> </table> lib/merb-core/dispatch/exceptions.html.erb @@ -1,15 +1,26 @@ +require 'tempfile' + module Merb class Request # def env def session def route_params attr_accessor :env, :session, :route_params - # by setting these to false, auto-parsing is disabled; this way you can do your own parsing instead - cattr_accessor :parse_multipart_params, :parse_json_params, :parse_xml_params + # by setting these to false, auto-parsing is disabled; this way you can + # do your own parsing instead + cattr_accessor :parse_multipart_params, :parse_json_params, + :parse_xml_params self.parse_multipart_params = true 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 = [] + # Initial the request object. # # ==== Parameters @@ -27,8 +38,9 @@ module Merb # Symbol:: The name of the request method, e.g. :get. # # ==== Notes - # If the method is post, then the +_method+ param will be checked for - # masquerading method. + # 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. def method @method ||= begin request_method = @env['REQUEST_METHOD'].downcase.to_sym @@ -37,9 +49,16 @@ module Merb request_method when :post if self.class.parse_multipart_params - m = body_and_query_params.merge(multipart_params)['_method'] + p = body_and_query_params.merge(multipart_params) else - m = body_and_query_params['_method'] + 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 end m.downcase! if m METHODS.include?(m) ? m.to_sym : :post @@ -98,9 +117,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 {} @@ -113,10 +132,17 @@ module Merb # ==== Returns # Hash:: Parameters from body if this is a JSON request. + # + # ==== Notes + # If the JSON object parses as a Hash, it will be merged with the + # parameters hash. If it parses to anything else (such as an Array, or + # if it inflates to an Object) it will be accessible via the inflated_object + # parameter. def json_params @json_params ||= begin if Merb::Const::JSON_MIME_TYPE_REGEXP.match(content_type) - JSON.parse(raw_post) + jobj = JSON.parse(raw_post) + jobj.kind_of?(Hash) ? jobj : { :inflated_object => jobj } end end end @@ -211,9 +237,15 @@ module Merb end # ==== Returns + # String:: The full URI, including protocol and host + def full_uri + protocol + host + uri + end + + # ==== Returns # String:: The request URI. def uri - @env['REQUEST_URI'] || @env['REQUEST_PATH'] + @env['REQUEST_PATH'] || @env['REQUEST_URI'] end # ==== Returns @@ -366,7 +398,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 @@ -390,7 +422,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)) } * "&" @@ -424,18 +456,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 @@ -464,6 +499,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 @@ -3,18 +3,39 @@ require 'merb-core/dispatch/router/behavior' require 'merb-core/dispatch/router/route' require 'merb-core/controller/mixins/responder' module Merb + # Router stores route definitions and finds first + # that matches incoming request URL. + # + # Then information from route is used by dispatcher to + # call action on the controller. + # + # ==== Routes compilation. + # + # Most interesting method of Router (and heart of + # route matching machinery) is match method generated + # on fly from routes definitions. It is called routes + # compilation. Generated match method body contains + # one if/elsif statement that picks first matching route + # definition and sets values to named parameters of the route. + # + # Compilation is synchronized by mutex. class Router SEGMENT_REGEXP = /(:([a-z_][a-z0-9_]*|:))/ SEGMENT_REGEXP_WITH_BRACKETS = /(:[a-z_]+)(\[(\d+)\])?/ JUST_BRACKETS = /\[(\d+)\]/ PARENTHETICAL_SEGMENT_STRING = "([^\/.,;?]+)".freeze - + @@named_routes = {} @@routes = [] @@compiler_mutex = Mutex.new 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. # @@ -50,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 @@ -68,14 +101,14 @@ module Merb # compiled_statement. def compile puts "compiled route: #{compiled_statement}" if $DEBUG - eval(compiled_statement, binding, __FILE__, __LINE__) + eval(compiled_statement, binding, "Generated Code for Router#match(#{__FILE__}:#{__LINE__})", 1) end # Generates a URL based on passed options. # # ==== Parameters # name<~to_sym, Hash>:: The name of the route to generate. - # params<Hash>:: The params to use in the route generation. + # params<Hash, Fixnum, Object>:: The params to use in the route generation. # fallback<Hash>:: Parameters for generating a fallback URL. # # ==== Returns @@ -85,7 +118,9 @@ module Merb # If name is a hash, it will be merged with params and passed on to # generate_for_default_route along with fallback. def generate(name, params = {}, fallback = {}) + params.reject! { |k,v| v.nil? } if params.is_a? Hash if name.is_a? Hash + name.reject! { |k,v| v.nil? } return generate_for_default_route(name.merge(params), fallback) end name = name.to_sym @@ -139,6 +174,6 @@ module Merb url end end # self - + end -end \ No newline at end of file +end lib/merb-core/dispatch/router.rb @@ -108,8 +108,19 @@ module Merb # within the regular expression syntax. # +path+ is optional. # conditions<Hash>:: - # This optional hash helps refine the settings for the route. - # When combined with a block it can help keep your routes DRY + # Addational conditions that the request must meet in order to match. + # the keys must be methods that the Merb::Request instance will respond + # to. The value is the string or regexp that matched the returned value. + # Conditions are inherited by child routes. + # + # The Following have special meaning: + # * :method -- Limit this match based on the request method. (GET, + # POST, PUT, DELETE) + # * :path -- Used internally to maintain URL form information + # * :controller and :action -- These can be used here instead of '#to', and + # will be inherited in the block. + # * :params -- Sets other key/value pairs that are placed in the params + # hash. The value must be a hash. # &block:: # Passes a new instance of a Behavior object into the optional block so # that sub-matching and routes nesting may occur. @@ -124,20 +135,28 @@ module Merb # ==== Examples # # # registers /foo/bar to controller => "foo", :action => "bar" - # # and /foo/baz to controller => "foo", :action => "caz" - # r.match "/foo", :controller => "foo" do |f| + # # and /foo/baz to controller => "foo", :action => "baz" + # r.match "/foo", :controller=>"foo" do |f| # f.match("/bar").to(:action => "bar") # f.match("/baz").to(:action => "caz") # end # - # r.match "/foo", :controller => "foo" do |f| - # f.match("/bar", :action => "bar") - # f.match("/baz", :action => "caz") - # end # => doesn't register any routes at all + # #match only of the browser string contains MSIE or Gecko + # r.match ('/foo', :user_agent => /(MSIE|Gecko)/ ) + # .to({:controller=>'foo', :action=>'popular') + # + # # Route GET and POST requests to different actions (see also #resources) + # r.match('/foo', :method=>:get).to(:action=>'show') + # r.mathc('/foo', :method=>:post).to(:action=>'create') # # # match also takes regular expressions + # # r.match(%r[/account/([a-z]{4,6})]).to(:controller => "account", # :action => "show", :id => "[1]") + # + # r.match(/\/?(en|es|fr|be|nl)?/).to(:language => "[1]") do |l| + # l.match("/guides/:action/:id").to(:controller => "tour_guides") + # end #--- # @public def match(path = '', conditions = {}, &block) @@ -161,8 +180,10 @@ module Merb # ==== Returns # Behavior:: The new behavior. def match_without_path(conditions = {}) - new_behavior = self.class.new(conditions, {}, self) - conditions.delete :path if ['', '^$'].include?(conditions[:path]) + params = conditions.delete(:params) || {} #parents params will be merged in Route#new + params[:controller] = conditions.delete(:controller) if conditions[:controller] + params[:action] = conditions.delete(:action) if conditions[:action] + new_behavior = self.class.new(conditions, params, self) yield new_behavior if block_given? new_behavior end @@ -178,6 +199,22 @@ module Merb Route.new compiled_conditions, compiled_params, self, &conditional_block end + # Combines common case of match being used with + # to({}). + # + # ==== Returns + # <Route>:: route that uses params from named path segments. + # + # ==== Examples + # r.match!("/api/:token/:controller/:action/:id") + # + # is the same thing as + # + # r.match!("/api/:token/:controller/:action/:id").to({}) + def match!(path = '', conditions = {}, &block) + self.match(path, conditions, &block).to({}) + end + # Creates a Route from one or more Behavior objects, unless a +block+ is # passed in. # @@ -286,11 +323,11 @@ module Merb # admin.resources :accounts # admin.resource :email # end - # + # # # /super_admin/accounts # r.namespace(:admin, :path=>"super_admin") do |admin| # admin.resources :accounts - # end + # end #--- # @public def namespace(name_or_path, options={}, &block) @@ -470,11 +507,11 @@ module Merb if name_prefix.nil? && !namespace.nil? name_prefix = namespace_to_name_prefix namespace end - + unless @@parent_resource.empty? parent_resource = namespace_to_name_prefix @@parent_resource.join('_') end - + routes = next_level.to_resource options route_name = "#{name_prefix}#{name}" @@ -586,6 +623,23 @@ module Merb @conditions_have_regexp end + def redirect(url, permanent = true) + @redirects = true + @redirect_url = url + @redirect_status = permanent ? 301 : 302 + + # satisfy route compilation + self.to({}) + end + + def redirects? + @redirects + end + + def ancestors + @ancestors ||= find_ancestors + end + protected # ==== Parameters @@ -693,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 @@ -749,7 +803,7 @@ module Merb compiled = {} params.each_pair do |key, value| unless value.is_a? String - raise ArgumentError, "param value must be string (#{value.inspect})" + raise ArgumentError, "param value for #{key.to_s} must be string (#{value.inspect})" end result = [] value = value.dup lib/merb-core/dispatch/router/behavior.rb @@ -1,8 +1,98 @@ require 'merb-core/controller/mixins/responder' module Merb - - class Router + class Router + # Route instances incapsulate information about particular route + # definition. Route definition ties + # number of conditions (URL match, HTTP request method) with + # resulting hash of route parameters: + # controller, action, format and named parameters + # from the URL. + # + # The following routes definition: + # + # Merb::Router.prepare do |r| + # r.match("api/:action/:token.:format").to(:controller => "dev").fixatable + # end + # + # maps URL matching pattern to controller named "dev" + # and specifies fixation for that route. Path and request method are + # route conditions, controller name, action name, format and + # value of segment we decided to call :token are route parameters. + # + # ==== How route definitions are used. + # + # When routes are compiled, each route produces + # a string with eval-able if/elsif condition statement. + # This statement together with others constructs body + # of Merb::Router.match method. + # Condition statements are Ruby code in form of string. + # + # ==== Segments. + # + # Route definitions use conventional syntax for named parameters. + # This splits route path into segments. Static (not changing) segments + # represented internally as strings, named parameters are stored + # as symbols and called symbol segments. Symbol segments + # map to groups in regular expression in resulting condition statement. + # + # ==== Route conditions. + # + # Because route conditions include path matching, + # regular expression is created from string that uses + # :segment format to fetch groups and assign them to + # named parameters. This regular expression is used + # to produce compiled statement mentioned above. + # + # Route conditions may also include + # user agent. Symbol segments + # + # Here is example of Route conditions: + # { + # :path => /^\/continents\/?(\.([^\/.,;?]+))?$/, + # :method => /^get$/ + # } + # + # + # ==== Route parameters. + # + # Route parameters is a Hash with controller name, + # action name and parameters key/value pairs. + # It is then merged with request.params hash. + # + # Example of route parameters: + # + # { + # :action => "\"index\"", + # :format => "path2", + # :controller => "\"continents\"" + # } + # + # Router takes first matching route and uses it's parameters + # to dispatch request to certain controller and action. + # + # ==== Behavior + # + # Each route has utility collaborator called behavior + # that incapsulates additional information about route + # (like namespace or if route is deferred) and also + # provides utility methods. + # + # ==== Route registration. + # + # When route is added to set of routes, it is called route + # registration. Registred route knows it's index in routes set. + # + # ==== Fixation + # Fixatable routes allow setting of session key from GET params + # found in incoming request. This is very useful to allow certain + # URLs to be used by rich media applications and other kinds + # of clients that have no other way of passing session identifier. + # + # ==== Conditional block. + # Conditional block is anonymous function that is evaluated + # when deferred routes are processed. Unless route is deferred, + # it has no condition block. class Route attr_reader :conditions, :conditional_block attr_reader :params, :behavior, :segments, :index, :symbol @@ -13,7 +103,7 @@ module Merb # behavior<Merb::Router::Behavior>:: # The associated behavior. Defaults to nil. # &conditional_block:: - # A block with the conditions to be met for the route to take effect. + # A block with the conditions to be met for the route to take effect. def initialize(conditions, params, behavior = nil, &conditional_block) @conditions, @params, @behavior = conditions, params, behavior @conditional_block = conditional_block @@ -25,17 +115,20 @@ module Merb # ==== Returns # Boolean:: True if fixation is allowed. - def allow_fixation? + def allow_fixation? @fixation - end - + end + # ==== Parameters # enabled<Boolean>:: True enables fixation on the route. - def fixatable(enable=true) - @fixation = enable + def fixatable(enable=true) + @fixation = enable self end + # Concatenates all route segments and returns result. + # Symbol segments have colon preserved. + # # ==== Returns # String:: The route as a string, e.g. "admin/:controller/:id". def to_s @@ -43,20 +136,21 @@ module Merb str << (seg.is_a?(Symbol) ? ":#{seg}" : seg) end end - + # Registers the route in the Router.routes array. + # After registration route has index. def register @index = Router.routes.size Router.routes << self self end - + # ==== Returns # Array:: All the symbols in the segments array. def symbol_segments segments.select{ |s| s.is_a?(Symbol) } end - + # Turn a path into string and symbol segments so it can be reconstructed, # as in the case of a named route. # @@ -77,8 +171,8 @@ module Merb segments << strip[path] unless path.empty? segments end - - # Names this route in Router. + + # Names this route in Router. Name must be a Symbol. # # ==== Parameters # symbol<Symbol>:: The name of the route. @@ -95,9 +189,12 @@ 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. + # If parameter value responds to :to_param, it is called. + # # ==== Parameters # params<Hash>:: Optional parameters for the route. # fallback<Hash>:: Optional parameters for the fallback route. @@ -116,7 +213,7 @@ module Merb params[segment] || fallback[segment] query_params.delete segment else - if segment == :id && params.respond_to?(:to_param) + if segment == :id && params.respond_to?(:to_param) params.to_param elsif segment == :id && params.is_a?(Fixnum) params @@ -143,6 +240,9 @@ module Merb url end + # Generates and returns if statement used to + # construct final condition statement of the route. + # # ==== Params # params_as_string<String>:: # The params hash as a string, e.g. ":foo => 'bar'". @@ -158,7 +258,7 @@ module Merb " (#{value.inspect} =~ #{regexp_string}) #{" && (" + captures + ")" unless captures.empty?}" end @conditions.each_pair do |key, value| - + # Note: =~ is slightly faster than .match cond << case key when :path then condition_string[key, value, "cached_path"] @@ -174,7 +274,8 @@ module Merb cond end - # Compiles the route to a form used by Merb::Router. + # Compiles the route to a form used by Merb::Router. This form sometimes + # referred as condition statement of the route. # # ==== Parameters # first<Boolean>:: @@ -214,4 +315,4 @@ module Merb end end # Route end -end \ No newline at end of file +end lib/merb-core/dispatch/router/route.rb @@ -1,7 +1,9 @@ module Merb module SessionMixin - + @_finalize_session_exception_callbacks = [] + @_persist_exception_callbacks = [] + # ==== Returns # String:: A random 32 character string for use as a unique session ID. def rand_uuid @@ -22,7 +24,23 @@ module Merb @_new_cookie = true end - module_function :rand_uuid, :needs_new_cookie! + def finalize_session_exception_callbacks(&block) + if block_given? + @_finalize_session_exception_callbacks << block + else + @_finalize_session_exception_callbacks + end + end + + def persist_exception_callbacks(&block) + if block_given? + @_persist_exception_callbacks << block + else + @_persist_exception_callbacks + end + end + + module_function :rand_uuid, :needs_new_cookie!, :finalize_session_exception_callbacks, :persist_exception_callbacks end end \ No newline at end of file lib/merb-core/dispatch/session.rb @@ -3,7 +3,7 @@ require 'openssl' # to generate the HMAC message digest # Most of this code is taken from bitsweat's implementation in rails module Merb - module SessionMixin #:nodoc: + module SessionMixin # Adds a before and after dispatch hook for setting up the cookie session # store. @@ -20,7 +20,9 @@ module Merb def finalize_session new_session = request.session.read_cookie if @original_session != new_session - cookies.set_cookie(_session_id_key, new_session, :expires => (Time.now + _session_expiry)) + options = {:expires => (Time.now + _session_expiry)} + options[:domain] = _session_cookie_domain if _session_cookie_domain + cookies.set_cookie(_session_id_key, new_session, options) end end lib/merb-core/dispatch/session/cookie.rb @@ -1,6 +1,6 @@ module Merb - module SessionMixin #:nodoc: + module SessionMixin # Adds a before and after dispatch hook for setting up the memcached # session store. @@ -16,15 +16,18 @@ module Merb # Finalizes the session by storing the session ID in a cookie, if the # session has changed. - def finalize_session + def finalize_session if @_fingerprint != Marshal.dump(request.session.data).hash begin CACHE.set("session:#{request.session.session_id}", request.session.data) rescue => err Merb.logger.debug("MemCache Error: #{err.message}") + Merb::SessionMixin::finalize_session_exception_callbacks.each {|x| x.call(err) } end end - set_cookie(_session_id_key, request.session.session_id, Time.now + _session_expiry) if (@_new_cookie || request.session.needs_new_cookie) + 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) end # ==== Returns @@ -82,12 +85,17 @@ module Merb # Array:: # A pair consisting of a MemCacheSession and the session's ID. If no # sessions matched session_id, a new MemCacheSession will be generated. + # + # ==== Notes + # If there are persiste exceptions callbacks to execute, they all get executed + # when Memcache library raises an exception. def persist(session_id) unless session_id.blank? begin session = CACHE.get("session:#{session_id}") rescue => err Merb.logger.debug("MemCache Error: #{err.message}") + Merb::SessionMixin::persist_exception_callbacks.each {|x| x.call(err) } end if session.nil? # Not in memcached, but assume that cookie exists @@ -108,27 +116,27 @@ module Merb end # Don't try to reload in dev mode. - def reloadable? #:nodoc: + def reloadable? false end end # Regenerate the session ID. - def regenerate - @session_id = Merb::SessionMixin::rand_uuid - self.needs_new_cookie=true - end - + def regenerate + @session_id = Merb::SessionMixin::rand_uuid + self.needs_new_cookie=true + end + # Recreates the cookie with the default expiration time. Useful during log # in for pushing back the expiration date. - def refresh_expiration - self.needs_new_cookie=true - end - + def refresh_expiration + self.needs_new_cookie=true + end + # Deletes the session by emptying stored data. - def delete - @data = {} + def delete + @data = {} end # ==== Returns @@ -136,11 +144,11 @@ module Merb def loaded? !! @data end - + # ==== Parameters # k<~to_s>:: The key of the session parameter to set. # v<~to_s>:: The value of the session parameter to set. - def []=(k, v) + def []=(k, v) @data[k] = v end @@ -149,18 +157,18 @@ module Merb # # ==== Returns # String:: The value of the session parameter. - def [](k) - @data[k] + def [](k) + @data[k] end # Yields the session data to an each block. # # ==== Parameter # &b:: The block to pass to each. - def each(&b) - @data.each(&b) + def each(&b) + @data.each(&b) end - + private # Attempts to redirect any messages to the data object. @@ -170,4 +178,4 @@ module Merb end -end \ No newline at end of file +end lib/merb-core/dispatch/session/memcached.rb @@ -1,6 +1,6 @@ module Merb - module SessionMixin #:nodoc: + module SessionMixin # Adds a before and after dispatch hook for setting up the memory session # store. @@ -16,7 +16,9 @@ module Merb # Finalizes the session by storing the session ID in a cookie, if the # session has changed. def finalize_session - set_cookie(_session_id_key, request.session.session_id, Time.now + _session_expiry) if (@_new_cookie || request.session.needs_new_cookie) + 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) end # ==== Returns lib/merb-core/dispatch/session/memory.rb @@ -33,7 +33,7 @@ require "time" # httpdate # Merb::Logger.new(log{String, IO},level{Symbol, String}) module Merb - class << self #:nodoc: + class << self attr_accessor :logger end lib/merb-core/logger.rb @@ -7,9 +7,12 @@ module Merb 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" end # Rack end # Merb \ No newline at end of file lib/merb-core/rack.rb @@ -9,33 +9,43 @@ module Merb # String:: The generated URL. # # ==== Alternatives - # If name is a hash, it will be merged with params. + # If name is a hash, it will be merged with params. def url(name, params={}) Merb::Router.generate(name, params) end - + # Reloads classes using Merb::BootLoader::ReloadClasses. def reload! Merb::BootLoader::ReloadClasses.reload end - + # Prints all routes for the application. def show_routes seen = [] unless Merb::Router.named_routes.empty? - puts "Named Routes" + puts "==== Named routes" Merb::Router.named_routes.each do |name,route| - puts " #{name}: #{route}" + # something weird happens when you combine sprintf and irb + puts "Helper : #{name}" + meth = $1.upcase if route.conditions[:method].to_s =~ /(get|post|put|delete)/ + puts "HTTP method: #{meth || 'GET'}" + puts "Route : #{route}" + puts "Params : #{route.params.inspect}" + puts seen << route end end - puts "Anonymous Routes" + puts "==== Anonymous routes" (Merb::Router.routes - seen).each do |route| - puts " #{route}" + meth = $1.upcase if route.conditions[:method].to_s =~ /(get|post|put|delete)/ + puts "HTTP method: #{meth || 'GET'}" + puts "Route : #{route}" + puts "Params : #{route.params.inspect}" + puts end nil end - + # Starts a sandboxed session (delegates to any Merb::Orms::* modules). # # An ORM should implement Merb::Orms::MyOrm#open_sandbox! to support this. @@ -45,7 +55,7 @@ module Merb puts "Any modifications you make will be rolled back on exit" orm_modules.each { |orm| orm.open_sandbox! if orm.respond_to?(:open_sandbox!) } end - + # Ends a sandboxed session (delegates to any Merb::Orms::* modules). # # An ORM should implement Merb::Orms::MyOrm#close_sandbox! to support this. @@ -54,14 +64,14 @@ module Merb orm_modules.each { |orm| orm.close_sandbox! if orm.respond_to?(:close_sandbox!) } puts "Modifications have been rolled back" end - + # Explictly show logger output during IRB session def trace_log! Merb.logger.auto_flush = true end - + private - + # ==== Returns # Array:: All Merb::Orms::* modules. def orm_modules @@ -71,7 +81,7 @@ module Merb [] end end - + end class Irb @@ -85,11 +95,11 @@ module Merb def self.start(opts={}) m = Merb::Rack::Console.new m.extend Merb::Test::RequestHelper - Object.send(:define_method, :merb) { m } - ARGV.clear # Avoid passing args to IRB + Object.send(:define_method, :merb) { m } + ARGV.clear # Avoid passing args to IRB m.open_sandbox! if sandboxed? - require 'irb' - require 'irb/completion' + require 'irb' + require 'irb/completion' if File.exists? ".irbrc" ENV['IRBRC'] = ".irbrc" end @@ -97,12 +107,12 @@ module Merb at_exit do merb.close_sandbox! if sandboxed? end exit end - + private - + def self.sandboxed? Merb::Config[:sandbox] - end + end end end -end \ No newline at end of file +end lib/merb-core/rack/adapter/irb.rb @@ -1,93 +1,18 @@ -module Merb - +module Merb module Rack - class Application - # ==== Parameters - # options<Hash>:: - # Options for creating a new application. Currently ignored. - def initialize(options={}) - @static_server = ::Rack::File.new Merb.dir_for(:public) - if prefix = ::Merb::Config[:path_prefix] - @path_prefix = /^#{Regexp.escape(prefix)}/ - end - end - # ==== Parameters - # env<Hash>:: Environment variables to pass on to the application. - # - # ==== Returns - # true or false:: - def deferred?(env) - strip_path_prefix(env) if @path_prefix # Strip out the path_prefix if one was set - path = env['PATH_INFO'] ? env['PATH_INFO'].chomp('/') : "" - if path =~ Merb.deferred_actions - Merb.logger.info! "Deferring Request: #{path}" - true - else - false - end - end - - # ==== Parameters - # env<Hash>:: Environment variables to pass on to the application. - # - # ==== Returns - # Array[Array]:: - # A 3 element tuple consisting of response status, headers and body. def call(env) - strip_path_prefix(env) if @path_prefix # Strip out the path_prefix if one was set - path = env['PATH_INFO'] ? env['PATH_INFO'].chomp('/') : "" - cached_path = (path.empty? ? 'index' : path) + '.html' - Merb.logger.info "Request: #{path}" - if file_exist?(path) && env['REQUEST_METHOD'] =~ /GET|HEAD/ # Serve the file if it's there and the request method is GET or HEAD - serve_static(env) - elsif file_exist?(cached_path) && env['REQUEST_METHOD'] =~ /GET|HEAD/ # Serve the page cache if it's there and the request method is GET or HEAD - env['PATH_INFO'] = cached_path - serve_static(env) - else # No static file, let Merb handle it - if path =~ /favicon\.ico/ - return [404, {"Content-Type"=>"text/html"}, "404 Not Found."] - end - begin - controller = ::Merb::Dispatcher.handle(env) - rescue Object => e - return [500, {"Content-Type"=>"text/html"}, e.message + "<br/>" + e.backtrace.join("<br/>")] - end - Merb.logger.info "\n\n" - Merb.logger.flush - [controller.status, controller.headers, controller.body] - end - end - - # ==== Parameters - # path<String>:: The path to the file relative to the server root. - # - # ==== Returns - # Boolean:: True if file exists under the server root and is readable. - def file_exist?(path) - full_path = ::File.join(@static_server.root, ::Merb::Request.unescape(path)) - ::File.file?(full_path) && ::File.readable?(full_path) - end - - # ==== Parameters - # env<Hash>:: Environment variables to pass on to the server. - def serve_static(env) - env["PATH_INFO"] = ::Merb::Request.unescape(env["PATH_INFO"]) - @static_server.call(env) - end - - # ==== Parameters - # env<Hash>:: Environment variables to pass on to the server. - def strip_path_prefix(env) - ['PATH_INFO', 'REQUEST_URI'].each do |path_key| - if env[path_key] =~ @path_prefix - env[path_key].sub!(@path_prefix, '') - env[path_key] = '/' if env[path_key].empty? - end + begin + controller = ::Merb::Dispatcher.handle(env) + rescue Object => e + return [500, {"Content-Type"=>"text/html"}, e.message + "<br/>" + e.backtrace.join("<br/>")] end + Merb.logger.info "\n\n" + Merb.logger.flush + [controller.status, controller.headers, controller.body] end end end -end \ No newline at end of file +end lib/merb-core/rack/application.rb @@ -22,25 +22,34 @@ module Merb @cluster = cluster if @cluster @port.to_i.upto(@port.to_i + @cluster.to_i-1) do |port| + pidfile = pid_file(port) + pid = IO.read(pidfile).chomp.to_i if File.exist?(pidfile) + unless alive?(port) remove_pid_file(port) - puts "Starting merb server on port: #{port}" + puts "Starting merb server on port #{port}, pid file: #{pidfile} and process id is #{pid}" if Merb::Config[:verbose] daemonize(port) else - raise "Merb is already running on port: #{port}" + raise "Merb is already running: port is #{port}, pid file: #{pidfile}, process id is #{pid}" end end elsif Merb::Config[:daemonize] + pidfile = pid_file(port) + pid = IO.read(pidfile).chomp.to_i if File.exist?(pidfile) + unless alive?(@port) remove_pid_file(@port) + puts "Daemonizing..." if Merb::Config[:verbose] daemonize(@port) else - raise "Merb is already running on port: #{port}" + raise "Merb is already running: port is #{port}, pid file: #{pidfile}, process id is #{pid}" end else trap('TERM') { exit } trap('INT') { puts "\nExiting"; exit } + puts "Running bootloaders..." if Merb::Config[:verbose] BootLoader.run + puts "Starting Rack adapter..." if Merb::Config[:verbose] Merb.adapter.start(Merb::Config.to_hash) end end @@ -52,8 +61,11 @@ module Merb # Boolean:: # True if Merb is running on the specified port. def alive?(port) + puts "About to check if port #{port} is alive..." if Merb::Config[:verbose] pidfile = pid_file(port) + puts "Pidfile is #{pidfile}..." if Merb::Config[:verbose] pid = IO.read(pidfile).chomp.to_i + puts "Process id is #{pid}" if Merb::Config[:verbose] Process.kill(0, pid) true rescue @@ -72,8 +84,8 @@ module Merb begin pidfiles = port == "all" ? pid_files : [ pid_file(port) ] - - pidfiles.each do |f| + + pidfiles.each do |f| pid = IO.read(f).chomp.to_i begin Process.kill(sig, pid) @@ -98,6 +110,7 @@ module Merb # ==== Parameters # port<~to_s>:: The port of the Merb process to daemonize. def daemonize(port) + puts "About to fork..." if Merb::Config[:verbose] fork do Process.setsid exit if fork @@ -117,13 +130,15 @@ module Merb def change_privilege if Merb::Config[:user] if Merb::Config[:group] + puts "About to change privilege to group #{Merb::Config[:group]} and user #{Merb::Config[:user]}" if Merb::Config[:verbose] _change_privilege(Merb::Config[:user], Merb::Config[:group]) else + puts "About to change privilege to user #{Merb::Config[:user]}" if Merb::Config[:verbose] _change_privilege(Merb::Config[:user]) end end end - + # Removes a PID file used by the server from the filesystem. # This uses :pid_file options from configuration when provided # or merb.<port>.pid in log directory by default. @@ -137,6 +152,7 @@ module Merb # instead of the port based PID file. def remove_pid_file(port) pidfile = pid_file(port) + puts "Removing pid file #{pidfile} (port is #{port})..." FileUtils.rm(pidfile) if File.exist?(pidfile) end @@ -153,10 +169,12 @@ module Merb # instead of the port based PID file. def store_pid(port) pidfile = pid_file(port) + puts "Storing pid file to #{pidfile}..." FileUtils.mkdir_p(File.dirname(pidfile)) unless File.directory?(File.dirname(pidfile)) + puts "Created directory, writing process id..." if Merb::Config[:verbose] File.open(pidfile, 'w'){ |f| f.write("#{Process.pid}") } end - + # Gets the pid file for the specified port. # # ==== Parameters @@ -202,8 +220,8 @@ module Merb else Dir[Merb.log_path / "merb.*.pid"] end - end - + end + # Change privileges of the process to the specified user and group. # # ==== Parameters lib/merb-core/server.rb @@ -2,6 +2,7 @@ require "hpricot" require 'merb-core/test/test_ext/hpricot' require 'merb-core/test/test_ext/object' +require 'merb-core/test/test_ext/string' module Merb; module Test; end; end lib/merb-core/test.rb @@ -97,8 +97,8 @@ module Merb::Test::MultipartRequestHelper # &blk:: The block is executed in the context of the controller. # # ==== Example - # dispatch_multipart_to(MyController, :create, :my_file => @a_file ) do - # self.stub!(:current_user).and_return(@user) + # dispatch_multipart_to(MyController, :create, :my_file => @a_file ) do |controller| + # controller.stub!(:current_user).and_return(@user) # end # # ==== Notes @@ -172,4 +172,4 @@ module Merb::Test::MultipartRequestHelper :content_length => body.length), :post_body => body) end end -end \ No newline at end of file +end lib/merb-core/test/helpers/multipart_request_helper.rb @@ -87,8 +87,8 @@ module Merb # the action being dispatched. # # ==== Example - # dispatch_to(MyController, :create, :name => 'Homer' ) do - # self.stub!(:current_user).and_return(@user) + # dispatch_to(MyController, :create, :name => 'Homer' ) do |controller| + # controller.stub!(:current_user).and_return(@user) # end # # ==== Notes @@ -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 @@ -126,8 +126,8 @@ module Merb # the action being dispatched. # # ==== Example - # dispatch_with_basic_authentication_to(MyController, :create, 'Fred', 'secret', :name => 'Homer' ) do - # self.stub!(:current_user).and_return(@user) + # dispatch_with_basic_authentication_to(MyController, :create, 'Fred', 'secret', :name => 'Homer' ) do |controller| + # controller.stub!(:current_user).and_return(@user) # end # # ==== Notes @@ -228,8 +228,8 @@ module Merb # the action being dispatched. # # ==== Example - # request(path, { :name => 'Homer' }, { :request_method => "PUT" }) do - # self.stub!(:current_user).and_return(@user) + # request(path, { :name => 'Homer' }, { :request_method => "PUT" }) do |controller| + # controller.stub!(:current_user).and_return(@user) # end # # ==== Notes @@ -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 @@ -48,7 +48,7 @@ module Merb::Test::Rspec::RouteMatchers # If parameters is an object, then a new expected hash will be constructed # with the key :id set to parameters.to_param. def with(parameters) - @paramter_matcher = ParameterMatcher.new(parameters) + @parameter_matcher = ParameterMatcher.new(parameters) self end @@ -56,17 +56,26 @@ module Merb::Test::Rspec::RouteMatchers # ==== Returns # String:: The failure message. def failure_message - "expected the request to route to #{@expected_controller.camel_case}##{@expected_action}, but was #{@target_controller.camel_case}##{@target_action}" + "expected the request to route to #{@expected_controller.camel_case}##{@expected_action}#{expected_parameters_message}, but was #{@target_controller.camel_case}##{@target_action}#{actual_parameters_message}" end # ==== Returns # String:: The failure message to be displayed in negative matches. def negative_failure_message - "expected the request not to route to #{@expected_controller.camel_case}##{@expected_action}, but it did" + "expected the request not to route to #{@expected_controller.camel_case}##{@expected_action}#{expected_parameters_message}, but it did" + end + + def expected_parameters_message + " with #{@parameter_matcher.expected.inspect}" if @parameter_matcher + end + + def actual_parameters_message + " with #{(@parameter_matcher.actual || {}).inspect}" if @parameter_matcher end end class ParameterMatcher + attr_accessor :expected, :actual # ==== Parameters # hash_or_object<Hash, ~to_param>:: The parameters to match. lib/merb-core/test/matchers/route_matchers.rb @@ -251,13 +251,13 @@ module Merb::Test::Rspec::ViewMatchers # ==== Returns # String:: The failure message. def failure_message - "expected the following element's content to #{content_message}:\n#{@element.inner_content}" + "expected the following element's content to #{content_message}:\n#{@element.inner_text}" end # ==== Returns # String:: The failure message to be displayed in negative matches. def negative_failure_message - "expected the following element's content to not #{content_message}:\n#{@element.inner_content}" + "expected the following element's content to not #{content_message}:\n#{@element.inner_text}" end def content_message @@ -332,4 +332,4 @@ module Merb::Test::Rspec::ViewMatchers def contain(content) HasContent.new(content) end -end \ No newline at end of file +end lib/merb-core/test/matchers/view_matchers.rb @@ -1,3 +1,4 @@ +require 'rubygems' require 'open3' require 'benchmark' lib/merb-core/test/run_specs.rb @@ -56,5 +56,6 @@ namespace :spec do t.spec_files = Dir['spec/**/*_spec.rb'].sort t.libs = ['lib', 'server/lib' ] t.rcov = true + t.rcov_opts = ["--exclude 'config,spec,#{Gem::path.join(',')}'"] end end \ No newline at end of file lib/merb-core/test/tasks/spectasks.rb @@ -166,6 +166,7 @@ module English return result.dup end result = word.dup + return result if singular_of.value? result singularization_rules.each do |(match, replacement)| break if result.gsub!(match, replacement) end @@ -216,6 +217,10 @@ module English word 'sheep' word 'moose' word 'hovercraft' + word 'grass' + word 'news' + word 'rain' + word 'milk' # Two arguments defines a singular and plural exception. @@ -237,7 +242,7 @@ module English word 'torpedo' , 'torpedoes' word 'quiz' , 'quizes' word 'matrix' , 'matrices' - word 'vertex' , 'vetices' + word 'vertex' , 'vertices' word 'index' , 'indices' word 'ox' , 'oxen' word 'mouse' , 'mice' @@ -245,10 +250,16 @@ module English word 'thesis' , 'theses' word 'thief' , 'thieves' word 'analysis' , 'analyses' + word 'erratum' , 'errata' + word 'phenomenon', 'phenomena' + word 'octopus' , 'octopi' + word 'thesaurus' , 'thesauri' + word 'movie' , 'movies' + word 'cactus' , 'cacti' # One-way singularization exception (convert plural to singular). - singular_word 'cactus', 'cacti' + # singular_word 'cactus', 'cacti' # General rules. lib/merb-core/vendor/facets/inflect.rb @@ -1,5 +1,5 @@ module Merb - VERSION = '0.9.3' unless defined?(Merb::VERSION) + VERSION = '0.9.4' unless defined?(Merb::VERSION) # Merb::RELEASE meanings: # 'dev' : unreleased lib/merb-core/version.rb @@ -1,93 +1,70 @@ Gem::Specification.new do |s| - s.authors = ["Ezra Zygmuntowicz"] - s.bindir = "bin" - s.required_rubygems_version = ">= 0" - s.requirements = ["install the json gem to get faster json parsing"] s.has_rdoc = "true" s.specification_version = "2" - s.name = "merb-core" s.loaded = "false" + s.bindir = "bin" s.email = "ez@engineyard.com" s.required_ruby_version = ">= 1.8.4" - s.extra_rdoc_files = ["README", "LICENSE", "TODO"] - s.require_paths = ["lib"] s.rubygems_version = "1.1.0" s.homepage = "http://merbivore.com" - s.executables = ["merb"] s.platform = "ruby" s.summary = "Merb. Pocket rocket web framework." + s.extra_rdoc_files = ["README", "LICENSE", "TODO"] + s.description = "Merb. Pocket rocket web framework." + s.add_dependency "erubis", ">= 0" + s.add_dependency "rake", ">= 0" + s.add_dependency "json_pure", ">= 0" + s.add_dependency "rspec", ">= 0" + s.add_dependency "rack", ">= 0" + s.add_dependency "hpricot", ">= 0" + s.add_dependency "mime-types", ">= 0" + s.executables = ["merb"] + s.date = "Thu May 08 00:00:00 +0300 2008" + s.version = "0.9.3" s.files = ["LICENSE", "README", "Rakefile", "TODO", + "docs/merb-core-call-stack-diagram.mmap", + "docs/setting-up-merb-application-structure.markdown", + "docs/new_render_api", + "docs/merb-core-call-stack-diagram.png", "docs/bootloading.dox", + "docs/merb-core-call-stack-diagram.pdf", "docs/documentation_standards", - "docs/new_render_api", "bin/merb", "bin/merb-specs", - "spec/private", - "spec/private/config", - "spec/private/config/adapter_spec.rb", - "spec/private/config/config_spec.rb", - "spec/private/config/environment_spec.rb", - "spec/private/config/spec_helper.rb", - "spec/private/core_ext", - "spec/private/core_ext/class_spec.rb", - "spec/private/core_ext/hash_spec.rb", - "spec/private/core_ext/kernel_spec.rb", - "spec/private/core_ext/object_spec.rb", - "spec/private/core_ext/set_spec.rb", - "spec/private/core_ext/string_spec.rb", - "spec/private/core_ext/time_spec.rb", - "spec/private/dispatch", - "spec/private/dispatch/cookies_spec.rb", - "spec/private/dispatch/dispatch_spec.rb", - "spec/private/dispatch/fixture", - "spec/private/dispatch/fixture/app", - "spec/private/dispatch/fixture/app/controllers", - "spec/private/dispatch/fixture/app/controllers/application.rb", - "spec/private/dispatch/fixture/app/controllers/exceptions.rb", - "spec/private/dispatch/fixture/app/controllers/foo.rb", - "spec/private/dispatch/fixture/app/helpers", - "spec/private/dispatch/fixture/app/helpers/global_helpers.rb", - "spec/private/dispatch/fixture/app/views", - "spec/private/dispatch/fixture/app/views/exeptions", - "spec/private/dispatch/fixture/app/views/exeptions/client_error.html.erb", - "spec/private/dispatch/fixture/app/views/exeptions/internal_server_error.html.erb", - "spec/private/dispatch/fixture/app/views/exeptions/not_acceptable.html.erb", - "spec/private/dispatch/fixture/app/views/exeptions/not_found.html.erb", - "spec/private/dispatch/fixture/app/views/foo", - "spec/private/dispatch/fixture/app/views/foo/bar.html.erb", - "spec/private/dispatch/fixture/app/views/layout", - "spec/private/dispatch/fixture/app/views/layout/application.html.erb", - "spec/private/dispatch/fixture/config", - "spec/private/dispatch/fixture/config/environments", - "spec/private/dispatch/fixture/config/environments/development.rb", - "spec/private/dispatch/fixture/config/environments/production.rb", - "spec/private/dispatch/fixture/config/environments/test.rb", - "spec/private/dispatch/fixture/config/init.rb", - "spec/private/dispatch/fixture/config/rack.rb", - "spec/private/dispatch/fixture/config/router.rb", - "spec/private/dispatch/fixture/log", - "spec/private/dispatch/fixture/log/merb.4000.pid", - "spec/private/dispatch/fixture/log/merb_test.log", - "spec/private/dispatch/fixture/merb.4000.pid", - "spec/private/dispatch/fixture/public", - "spec/private/dispatch/fixture/public/images", - "spec/private/dispatch/fixture/public/images/merb.jpg", - "spec/private/dispatch/fixture/public/merb.fcgi", - "spec/private/dispatch/fixture/public/stylesheets", - "spec/private/dispatch/fixture/public/stylesheets/master.css", - "spec/private/dispatch/route_params_spec.rb", - "spec/private/dispatch/spec_helper.rb", - "spec/private/plugins", - "spec/private/plugins/plugin_spec.rb", - "spec/private/rack", - "spec/private/rack/application_spec.rb", "spec/public", + "spec/public/template", + "spec/public/template/templates", + "spec/public/template/templates/template.html.myt", + "spec/public/template/templates/error.html.erb", + "spec/public/template/templates/template.html.erb", + "spec/public/template/template_spec.rb", + "spec/public/reloading", + "spec/public/reloading/reload_spec.rb", + "spec/public/reloading/directory", + "spec/public/reloading/directory/app", + "spec/public/reloading/directory/app/controllers", + "spec/public/reloading/directory/app/controllers/reload.rb", + "spec/public/reloading/directory/app/controllers/application.rb", + "spec/public/reloading/directory/config", + "spec/public/reloading/directory/config/init.rb", + "spec/public/reloading/directory/log", + "spec/public/reloading/directory/log/merb_test.log", "spec/public/abstract_controller", + "spec/public/abstract_controller/filter_spec.rb", + "spec/public/abstract_controller/render_spec.rb", + "spec/public/abstract_controller/display_spec.rb", "spec/public/abstract_controller/controllers", + "spec/public/abstract_controller/controllers/render.rb", + "spec/public/abstract_controller/controllers/display.rb", "spec/public/abstract_controller/controllers/alt_views", + "spec/public/abstract_controller/controllers/alt_views/partial", + "spec/public/abstract_controller/controllers/alt_views/partial/basic_partial_with_multiple_roots", + "spec/public/abstract_controller/controllers/alt_views/partial/basic_partial_with_multiple_roots/_partial.erb", + "spec/public/abstract_controller/controllers/alt_views/render_template_multiple_roots_and_custom_location", + "spec/public/abstract_controller/controllers/alt_views/render_template_multiple_roots_and_custom_location/index.erb", "spec/public/abstract_controller/controllers/alt_views/layout", "spec/public/abstract_controller/controllers/alt_views/layout/application.erb", "spec/public/abstract_controller/controllers/alt_views/layout/merb", @@ -96,119 +73,136 @@ Gem::Specification.new do |s| "spec/public/abstract_controller/controllers/alt_views/layout/merb/test/fixtures/abstract", "spec/public/abstract_controller/controllers/alt_views/layout/merb/test/fixtures/abstract/render_string_controller_layout.erb", "spec/public/abstract_controller/controllers/alt_views/layout/merb/test/fixtures/abstract/render_template_controller_layout.erb", + "spec/public/abstract_controller/controllers/alt_views/render_template_multiple_roots_inherited", + "spec/public/abstract_controller/controllers/alt_views/render_template_multiple_roots_inherited/index.erb", "spec/public/abstract_controller/controllers/alt_views/merb", "spec/public/abstract_controller/controllers/alt_views/merb/test", "spec/public/abstract_controller/controllers/alt_views/merb/test/fixtures", "spec/public/abstract_controller/controllers/alt_views/merb/test/fixtures/abstract", "spec/public/abstract_controller/controllers/alt_views/merb/test/fixtures/abstract/display_object_with_multiple_roots", - "spec/public/abstract_controller/controllers/alt_views/merb/test/fixtures/abstract/display_object_with_multiple_roots/index.erb", "spec/public/abstract_controller/controllers/alt_views/merb/test/fixtures/abstract/display_object_with_multiple_roots/show.erb", + "spec/public/abstract_controller/controllers/alt_views/merb/test/fixtures/abstract/display_object_with_multiple_roots/index.erb", "spec/public/abstract_controller/controllers/alt_views/merb/test/fixtures/abstract/render_template_multiple_roots", "spec/public/abstract_controller/controllers/alt_views/merb/test/fixtures/abstract/render_template_multiple_roots/index.erb", - "spec/public/abstract_controller/controllers/alt_views/partial", - "spec/public/abstract_controller/controllers/alt_views/partial/basic_partial_with_multiple_roots", - "spec/public/abstract_controller/controllers/alt_views/partial/basic_partial_with_multiple_roots/_partial.erb", - "spec/public/abstract_controller/controllers/alt_views/render_template_multiple_roots_and_custom_location", - "spec/public/abstract_controller/controllers/alt_views/render_template_multiple_roots_and_custom_location/index.erb", - "spec/public/abstract_controller/controllers/alt_views/render_template_multiple_roots_inherited", - "spec/public/abstract_controller/controllers/alt_views/render_template_multiple_roots_inherited/index.erb", - "spec/public/abstract_controller/controllers/display.rb", - "spec/public/abstract_controller/controllers/filters.rb", - "spec/public/abstract_controller/controllers/helpers.rb", "spec/public/abstract_controller/controllers/partial.rb", - "spec/public/abstract_controller/controllers/render.rb", "spec/public/abstract_controller/controllers/views", - "spec/public/abstract_controller/controllers/views/helpers", - "spec/public/abstract_controller/controllers/views/helpers/capture", - "spec/public/abstract_controller/controllers/views/helpers/capture/index.erb", - "spec/public/abstract_controller/controllers/views/helpers/concat", - "spec/public/abstract_controller/controllers/views/helpers/concat/index.erb", + "spec/public/abstract_controller/controllers/views/test_display", + "spec/public/abstract_controller/controllers/views/test_display/foo.html.erb", + "spec/public/abstract_controller/controllers/views/partial", + "spec/public/abstract_controller/controllers/views/partial/with_partial", + "spec/public/abstract_controller/controllers/views/partial/with_partial/_with_partial.erb", + "spec/public/abstract_controller/controllers/views/partial/with_partial/index.erb", + "spec/public/abstract_controller/controllers/views/partial/partial_with_locals", + "spec/public/abstract_controller/controllers/views/partial/partial_with_locals/_variables.erb", + "spec/public/abstract_controller/controllers/views/partial/partial_with_locals/index.erb", + "spec/public/abstract_controller/controllers/views/partial/partial_with_with_and_locals", + "spec/public/abstract_controller/controllers/views/partial/partial_with_with_and_locals/_both.erb", + "spec/public/abstract_controller/controllers/views/partial/partial_with_with_and_locals/index.erb", + "spec/public/abstract_controller/controllers/views/partial/with_nil_partial", + "spec/public/abstract_controller/controllers/views/partial/with_nil_partial/_with_partial.erb", + "spec/public/abstract_controller/controllers/views/partial/with_nil_partial/index.erb", + "spec/public/abstract_controller/controllers/views/partial/partial_in_another_directory", + "spec/public/abstract_controller/controllers/views/partial/partial_in_another_directory/index.erb", + "spec/public/abstract_controller/controllers/views/partial/partial_with_collections_and_as", + "spec/public/abstract_controller/controllers/views/partial/partial_with_collections_and_as/_collection.erb", + "spec/public/abstract_controller/controllers/views/partial/partial_with_collections_and_as/index.erb", + "spec/public/abstract_controller/controllers/views/partial/with_as_partial", + "spec/public/abstract_controller/controllers/views/partial/with_as_partial/_with_partial.erb", + "spec/public/abstract_controller/controllers/views/partial/with_as_partial/index.erb", + "spec/public/abstract_controller/controllers/views/partial/partial_with_collections", + "spec/public/abstract_controller/controllers/views/partial/partial_with_collections/_collection.erb", + "spec/public/abstract_controller/controllers/views/partial/partial_with_collections/index.erb", + "spec/public/abstract_controller/controllers/views/partial/nested_partial", + "spec/public/abstract_controller/controllers/views/partial/nested_partial/_first.erb", + "spec/public/abstract_controller/controllers/views/partial/nested_partial/_second.erb", + "spec/public/abstract_controller/controllers/views/partial/nested_partial/index.erb", + "spec/public/abstract_controller/controllers/views/partial/basic_partial", + "spec/public/abstract_controller/controllers/views/partial/basic_partial/_partial.erb", + "spec/public/abstract_controller/controllers/views/partial/basic_partial/index.erb", + "spec/public/abstract_controller/controllers/views/partial/basic_partial_with_multiple_roots", + "spec/public/abstract_controller/controllers/views/partial/basic_partial_with_multiple_roots/index.erb", + "spec/public/abstract_controller/controllers/views/partial/partial_with_both", + "spec/public/abstract_controller/controllers/views/partial/partial_with_both/_collection.erb", + "spec/public/abstract_controller/controllers/views/partial/partial_with_both/index.erb", + "spec/public/abstract_controller/controllers/views/partial/another_directory", + "spec/public/abstract_controller/controllers/views/partial/another_directory/_partial.erb", "spec/public/abstract_controller/controllers/views/layout", "spec/public/abstract_controller/controllers/views/layout/alt.erb", "spec/public/abstract_controller/controllers/views/layout/custom.erb", + "spec/public/abstract_controller/controllers/views/wonderful", + "spec/public/abstract_controller/controllers/views/wonderful/index.erb", + "spec/public/abstract_controller/controllers/views/helpers", + "spec/public/abstract_controller/controllers/views/helpers/concat", + "spec/public/abstract_controller/controllers/views/helpers/concat/index.erb", + "spec/public/abstract_controller/controllers/views/helpers/capture", + "spec/public/abstract_controller/controllers/views/helpers/capture/index.erb", + "spec/public/abstract_controller/controllers/views/test_render", + "spec/public/abstract_controller/controllers/views/test_render/foo.html.erb", "spec/public/abstract_controller/controllers/views/merb", "spec/public/abstract_controller/controllers/views/merb/test", "spec/public/abstract_controller/controllers/views/merb/test/fixtures", "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract", "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/display_object", "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/display_object/index.erb", - "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/display_object_with_action", - "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/display_object_with_action/new.erb", "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template", "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template/index.erb", - "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_app_layout", - "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_app_layout/index.erb", - "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_custom_layout", - "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_custom_layout/index.erb", "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_multiple_roots", - "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_multiple_roots/index.erb", "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_multiple_roots/show.erb", - "spec/public/abstract_controller/controllers/views/partial", - "spec/public/abstract_controller/controllers/views/partial/another_directory", - "spec/public/abstract_controller/controllers/views/partial/another_directory/_partial.erb", - "spec/public/abstract_controller/controllers/views/partial/basic_partial", - "spec/public/abstract_controller/controllers/views/partial/basic_partial/_partial.erb", - "spec/public/abstract_controller/controllers/views/partial/basic_partial/index.erb", - "spec/public/abstract_controller/controllers/views/partial/basic_partial_with_multiple_roots", - "spec/public/abstract_controller/controllers/views/partial/basic_partial_with_multiple_roots/index.erb", - "spec/public/abstract_controller/controllers/views/partial/content_type_controller", - "spec/public/abstract_controller/controllers/views/partial/content_type_controller/_content_type_test.html.erb", - "spec/public/abstract_controller/controllers/views/partial/content_type_controller/_content_type_test.xml.erb", - "spec/public/abstract_controller/controllers/views/partial/content_type_controller/index.html.erb", - "spec/public/abstract_controller/controllers/views/partial/nested_partial", - "spec/public/abstract_controller/controllers/views/partial/nested_partial/_first.erb", - "spec/public/abstract_controller/controllers/views/partial/nested_partial/_second.erb", - "spec/public/abstract_controller/controllers/views/partial/nested_partial/index.erb", - "spec/public/abstract_controller/controllers/views/partial/partial_in_another_directory", - "spec/public/abstract_controller/controllers/views/partial/partial_in_another_directory/index.erb", - "spec/public/abstract_controller/controllers/views/partial/partial_with_both", - "spec/public/abstract_controller/controllers/views/partial/partial_with_both/_collection.erb", - "spec/public/abstract_controller/controllers/views/partial/partial_with_both/index.erb", - "spec/public/abstract_controller/controllers/views/partial/partial_with_collections", - "spec/public/abstract_controller/controllers/views/partial/partial_with_collections/_collection.erb", - "spec/public/abstract_controller/controllers/views/partial/partial_with_collections/index.erb", - "spec/public/abstract_controller/controllers/views/partial/partial_with_collections_and_as", - "spec/public/abstract_controller/controllers/views/partial/partial_with_collections_and_as/_collection.erb", - "spec/public/abstract_controller/controllers/views/partial/partial_with_collections_and_as/index.erb", - "spec/public/abstract_controller/controllers/views/partial/partial_with_locals", - "spec/public/abstract_controller/controllers/views/partial/partial_with_locals/_variables.erb", - "spec/public/abstract_controller/controllers/views/partial/partial_with_locals/index.erb", - "spec/public/abstract_controller/controllers/views/partial/partial_with_with_and_locals", - "spec/public/abstract_controller/controllers/views/partial/partial_with_with_and_locals/_both.erb", - "spec/public/abstract_controller/controllers/views/partial/partial_with_with_and_locals/index.erb", - "spec/public/abstract_controller/controllers/views/partial/with_as_partial", - "spec/public/abstract_controller/controllers/views/partial/with_as_partial/_with_partial.erb", - "spec/public/abstract_controller/controllers/views/partial/with_as_partial/index.erb", - "spec/public/abstract_controller/controllers/views/partial/with_nil_partial", - "spec/public/abstract_controller/controllers/views/partial/with_nil_partial/_with_partial.erb", - "spec/public/abstract_controller/controllers/views/partial/with_nil_partial/index.erb", - "spec/public/abstract_controller/controllers/views/partial/with_partial", - "spec/public/abstract_controller/controllers/views/partial/with_partial/_with_partial.erb", - "spec/public/abstract_controller/controllers/views/partial/with_partial/index.erb", - "spec/public/abstract_controller/controllers/views/test_display", - "spec/public/abstract_controller/controllers/views/test_display/foo.html.erb", - "spec/public/abstract_controller/controllers/views/test_render", - "spec/public/abstract_controller/controllers/views/test_render/foo.html.erb", - "spec/public/abstract_controller/controllers/views/wonderful", - "spec/public/abstract_controller/controllers/views/wonderful/index.erb", - "spec/public/abstract_controller/display_spec.rb", - "spec/public/abstract_controller/filter_spec.rb", - "spec/public/abstract_controller/helper_spec.rb", + "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_multiple_roots/index.erb", + "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_custom_layout", + "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_custom_layout/index.erb", + "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_app_layout", + "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/render_template_app_layout/index.erb", + "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/display_object_with_action", + "spec/public/abstract_controller/controllers/views/merb/test/fixtures/abstract/display_object_with_action/new.erb", + "spec/public/abstract_controller/controllers/helpers.rb", + "spec/public/abstract_controller/controllers/filters.rb", "spec/public/abstract_controller/partial_spec.rb", - "spec/public/abstract_controller/render_spec.rb", "spec/public/abstract_controller/spec_helper.rb", + "spec/public/abstract_controller/helper_spec.rb", + "spec/public/DEFINITIONS", + "spec/public/test", + "spec/public/test/controller_matchers_spec.rb", + "spec/public/test/route_matchers_spec.rb", + "spec/public/test/request_helper_spec.rb", + "spec/public/test/multipart_request_helper_spec.rb", + "spec/public/test/view_matchers_spec.rb", + "spec/public/test/controllers", + "spec/public/test/controllers/controller_assertion_mock.rb", + "spec/public/test/controllers/spec_helper_controller.rb", + "spec/public/test/controllers/dispatch_controller.rb", + "spec/public/test/route_helper_spec.rb", + "spec/public/test/view_helper_spec.rb", + "spec/public/test/multipart_upload_text_file.txt", + "spec/public/request", + "spec/public/request/multipart_spec.rb", + "spec/public/request/request_spec.rb", + "spec/public/core", + "spec/public/core/merb_core_spec.rb", + "spec/public/router", + "spec/public/router/special_spec.rb", + "spec/public/router/default_spec.rb", + "spec/public/router/namespace_spec.rb", + "spec/public/router/deferred_spec.rb", + "spec/public/router/spec_helper.rb", + "spec/public/router/nested_resources_spec.rb", + "spec/public/router/resources_spec.rb", + "spec/public/router/resource_spec.rb", + "spec/public/router/string_spec.rb", + "spec/public/logger", + "spec/public/logger/logger_spec.rb", + "spec/public/logger/spec_helper.rb", "spec/public/boot_loader", "spec/public/boot_loader/boot_loader_spec.rb", "spec/public/boot_loader/spec_helper.rb", "spec/public/controller", "spec/public/controller/authentication_spec.rb", - "spec/public/controller/base_spec.rb", + "spec/public/controller/display_spec.rb", "spec/public/controller/controllers", - "spec/public/controller/controllers/authentication.rb", - "spec/public/controller/controllers/base.rb", "spec/public/controller/controllers/display.rb", - "spec/public/controller/controllers/responder.rb", "spec/public/controller/controllers/url.rb", + "spec/public/controller/controllers/responder.rb", + "spec/public/controller/controllers/authentication.rb", "spec/public/controller/controllers/views", "spec/public/controller/controllers/views/layout", "spec/public/controller/controllers/views/layout/custom.html.erb", @@ -217,196 +211,199 @@ Gem::Specification.new do |s| "spec/public/controller/controllers/views/merb/test", "spec/public/controller/controllers/views/merb/test/fixtures", "spec/public/controller/controllers/views/merb/test/fixtures/controllers", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/class_provides", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/class_provides/index.html.erb", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/class_provides/index.xml.erb", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/display_with_template", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/display_with_template/index.html.erb", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/display_with_template_argument", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/display_with_template_argument/index.html.erb", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/html_default", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/html_default/index.html.erb", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/multi_provides", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/multi_provides/index.html.erb", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/multi_provides/index.js.erb", "spec/public/controller/controllers/views/merb/test/fixtures/controllers/layout", "spec/public/controller/controllers/views/merb/test/fixtures/controllers/layout/custom.html.erb", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/html_default", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/html_default/index.html.erb", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/display_with_template_argument", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/display_with_template_argument/index.html.erb", "spec/public/controller/controllers/views/merb/test/fixtures/controllers/local_provides", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/local_provides/index.html.erb", "spec/public/controller/controllers/views/merb/test/fixtures/controllers/local_provides/index.xml.erb", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/multi_provides", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/multi_provides/index.html.erb", - "spec/public/controller/controllers/views/merb/test/fixtures/controllers/multi_provides/index.js.erb", - "spec/public/controller/display_spec.rb", - "spec/public/controller/responder_spec.rb", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/local_provides/index.html.erb", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/display_with_template", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/display_with_template/index.html.erb", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/class_provides", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/class_provides/index.xml.erb", + "spec/public/controller/controllers/views/merb/test/fixtures/controllers/class_provides/index.html.erb", + "spec/public/controller/controllers/base.rb", "spec/public/controller/spec_helper.rb", + "spec/public/controller/base_spec.rb", "spec/public/controller/url_spec.rb", - "spec/public/core", - "spec/public/core/merb_core_spec.rb", - "spec/public/DEFINITIONS", + "spec/public/controller/responder_spec.rb", "spec/public/directory_structure", "spec/public/directory_structure/directory", "spec/public/directory_structure/directory/app", "spec/public/directory_structure/directory/app/controllers", - "spec/public/directory_structure/directory/app/controllers/application.rb", "spec/public/directory_structure/directory/app/controllers/base.rb", + "spec/public/directory_structure/directory/app/controllers/application.rb", "spec/public/directory_structure/directory/app/controllers/custom.rb", "spec/public/directory_structure/directory/app/views", - "spec/public/directory_structure/directory/app/views/base", - "spec/public/directory_structure/directory/app/views/base/template.html.erb", "spec/public/directory_structure/directory/app/views/wonderful", "spec/public/directory_structure/directory/app/views/wonderful/template.erb", + "spec/public/directory_structure/directory/app/views/base", + "spec/public/directory_structure/directory/app/views/base/template.html.erb", "spec/public/directory_structure/directory/config", "spec/public/directory_structure/directory/config/router.rb", "spec/public/directory_structure/directory/log", - "spec/public/directory_structure/directory/log/merb.4000.pid", "spec/public/directory_structure/directory/log/merb_test.log", - "spec/public/directory_structure/directory/merb.4000.pid", "spec/public/directory_structure/directory_spec.rb", - "spec/public/logger", - "spec/public/logger/logger_spec.rb", - "spec/public/logger/spec_helper.rb", - "spec/public/reloading", - "spec/public/reloading/directory", - "spec/public/reloading/directory/app", - "spec/public/reloading/directory/app/controllers", - "spec/public/reloading/directory/app/controllers/application.rb", - "spec/public/reloading/directory/app/controllers/reload.rb", - "spec/public/reloading/directory/config", - "spec/public/reloading/directory/config/init.rb", - "spec/public/reloading/directory/log", - "spec/public/reloading/directory/log/merb.4000.pid", - "spec/public/reloading/directory/log/merb_test.log", - "spec/public/reloading/directory/merb.4000.pid", - "spec/public/reloading/reload_spec.rb", - "spec/public/request", - "spec/public/request/multipart_spec.rb", - "spec/public/request/request_spec.rb", - "spec/public/router", - "spec/public/router/default_spec.rb", - "spec/public/router/deferred_spec.rb", - "spec/public/router/namespace_spec.rb", - "spec/public/router/nested_resources_spec.rb", - "spec/public/router/resource_spec.rb", - "spec/public/router/resources_spec.rb", - "spec/public/router/spec_helper.rb", - "spec/public/router/special_spec.rb", - "spec/public/router/string_spec.rb", - "spec/public/template", - "spec/public/template/template_spec.rb", - "spec/public/template/templates", - "spec/public/template/templates/error.html.erb", - "spec/public/template/templates/template.html.erb", - "spec/public/template/templates/template.html.myt", - "spec/public/test", - "spec/public/test/controller_matchers_spec.rb", - "spec/public/test/controllers", - "spec/public/test/controllers/controller_assertion_mock.rb", - "spec/public/test/controllers/dispatch_controller.rb", - "spec/public/test/controllers/spec_helper_controller.rb", - "spec/public/test/multipart_request_helper_spec.rb", - "spec/public/test/multipart_upload_text_file.txt", - "spec/public/test/request_helper_spec.rb", - "spec/public/test/route_helper_spec.rb", - "spec/public/test/route_matchers_spec.rb", - "spec/public/test/view_helper_spec.rb", - "spec/public/test/view_matchers_spec.rb", + "spec/private", + "spec/private/rack", + "spec/private/rack/application_spec.rb", + "spec/private/config", + "spec/private/config/config_spec.rb", + "spec/private/config/spec_helper.rb", + "spec/private/config/environment_spec.rb", + "spec/private/config/adapter_spec.rb", + "spec/private/dispatch", + "spec/private/dispatch/dispatch_spec.rb", + "spec/private/dispatch/spec_helper.rb", + "spec/private/dispatch/cookies_spec.rb", + "spec/private/dispatch/fixture", + "spec/private/dispatch/fixture/public", + "spec/private/dispatch/fixture/public/stylesheets", + "spec/private/dispatch/fixture/public/stylesheets/master.css", + "spec/private/dispatch/fixture/public/images", + "spec/private/dispatch/fixture/public/images/merb.jpg", + "spec/private/dispatch/fixture/public/merb.fcgi", + "spec/private/dispatch/fixture/app", + "spec/private/dispatch/fixture/app/controllers", + "spec/private/dispatch/fixture/app/controllers/exceptions.rb", + "spec/private/dispatch/fixture/app/controllers/foo.rb", + "spec/private/dispatch/fixture/app/controllers/application.rb", + "spec/private/dispatch/fixture/app/views", + "spec/private/dispatch/fixture/app/views/foo", + "spec/private/dispatch/fixture/app/views/foo/bar.html.erb", + "spec/private/dispatch/fixture/app/views/layout", + "spec/private/dispatch/fixture/app/views/layout/application.html.erb", + "spec/private/dispatch/fixture/app/views/exeptions", + "spec/private/dispatch/fixture/app/views/exeptions/internal_server_error.html.erb", + "spec/private/dispatch/fixture/app/views/exeptions/not_found.html.erb", + "spec/private/dispatch/fixture/app/views/exeptions/client_error.html.erb", + "spec/private/dispatch/fixture/app/views/exeptions/not_acceptable.html.erb", + "spec/private/dispatch/fixture/app/helpers", + "spec/private/dispatch/fixture/app/helpers/global_helpers.rb", + "spec/private/dispatch/fixture/config", + "spec/private/dispatch/fixture/config/router.rb", + "spec/private/dispatch/fixture/config/black_hole.rb", + "spec/private/dispatch/fixture/config/rack.rb", + "spec/private/dispatch/fixture/config/init.rb", + "spec/private/dispatch/fixture/config/environments", + "spec/private/dispatch/fixture/config/environments/production.rb", + "spec/private/dispatch/fixture/config/environments/development.rb", + "spec/private/dispatch/fixture/config/environments/test.rb", + "spec/private/dispatch/fixture/log", + "spec/private/dispatch/fixture/log/merb_test.log", + "spec/private/dispatch/route_params_spec.rb", + "spec/private/dispatch/bootloader_spec.rb", + "spec/private/plugins", + "spec/private/plugins/plugin_spec.rb", + "spec/private/core_ext", + "spec/private/core_ext/set_spec.rb", + "spec/private/core_ext/kernel_spec.rb", + "spec/private/core_ext/time_spec.rb", + "spec/private/core_ext/hash_spec.rb", + "spec/private/core_ext/string_spec.rb", + "spec/private/core_ext/class_spec.rb", + "spec/private/core_ext/object_spec.rb", "spec/spec_helper.rb", + "lib/merb-core.rb", + "lib/coretasks.rb", "lib/merb-core", - "lib/merb-core/autoload.rb", "lib/merb-core/bootloader.rb", - "lib/merb-core/config.rb", - "lib/merb-core/constants.rb", - "lib/merb-core/controller", - "lib/merb-core/controller/abstract_controller.rb", - "lib/merb-core/controller/exceptions.rb", - "lib/merb-core/controller/merb_controller.rb", - "lib/merb-core/controller/mime.rb", - "lib/merb-core/controller/mixins", - "lib/merb-core/controller/mixins/authentication.rb", - "lib/merb-core/controller/mixins/controller.rb", - "lib/merb-core/controller/mixins/render.rb", - "lib/merb-core/controller/mixins/responder.rb", - "lib/merb-core/controller/template.rb", - "lib/merb-core/core_ext", - "lib/merb-core/core_ext/class.rb", - "lib/merb-core/core_ext/hash.rb", - "lib/merb-core/core_ext/kernel.rb", - "lib/merb-core/core_ext/mash.rb", - "lib/merb-core/core_ext/object.rb", - "lib/merb-core/core_ext/object_space.rb", - "lib/merb-core/core_ext/rubygems.rb", - "lib/merb-core/core_ext/set.rb", - "lib/merb-core/core_ext/string.rb", - "lib/merb-core/core_ext/time.rb", - "lib/merb-core/core_ext.rb", - "lib/merb-core/dispatch", - "lib/merb-core/dispatch/cookies.rb", - "lib/merb-core/dispatch/dispatcher.rb", - "lib/merb-core/dispatch/exceptions.html.erb", - "lib/merb-core/dispatch/request.rb", - "lib/merb-core/dispatch/router", - "lib/merb-core/dispatch/router/behavior.rb", - "lib/merb-core/dispatch/router/cached_proc.rb", - "lib/merb-core/dispatch/router/route.rb", - "lib/merb-core/dispatch/router.rb", - "lib/merb-core/dispatch/session", - "lib/merb-core/dispatch/session/cookie.rb", - "lib/merb-core/dispatch/session/memcached.rb", - "lib/merb-core/dispatch/session/memory.rb", - "lib/merb-core/dispatch/session.rb", - "lib/merb-core/gem_ext", - "lib/merb-core/gem_ext/erubis.rb", - "lib/merb-core/logger.rb", - "lib/merb-core/plugins.rb", "lib/merb-core/rack", + "lib/merb-core/rack/handler", + "lib/merb-core/rack/handler/mongrel.rb", "lib/merb-core/rack/adapter", - "lib/merb-core/rack/adapter/ebb.rb", "lib/merb-core/rack/adapter/evented_mongrel.rb", + "lib/merb-core/rack/adapter/thin.rb", "lib/merb-core/rack/adapter/fcgi.rb", - "lib/merb-core/rack/adapter/irb.rb", "lib/merb-core/rack/adapter/mongrel.rb", - "lib/merb-core/rack/adapter/runner.rb", - "lib/merb-core/rack/adapter/thin.rb", "lib/merb-core/rack/adapter/webrick.rb", - "lib/merb-core/rack/adapter.rb", + "lib/merb-core/rack/adapter/runner.rb", + "lib/merb-core/rack/adapter/irb.rb", + "lib/merb-core/rack/adapter/ebb.rb", "lib/merb-core/rack/application.rb", - "lib/merb-core/rack/handler", - "lib/merb-core/rack/handler/mongrel.rb", + "lib/merb-core/rack/adapter.rb", + "lib/merb-core/gem_ext", + "lib/merb-core/gem_ext/erubis.rb", + "lib/merb-core/config.rb", "lib/merb-core/rack.rb", - "lib/merb-core/server.rb", "lib/merb-core/test", + "lib/merb-core/test/matchers.rb", + "lib/merb-core/test/run_specs.rb", + "lib/merb-core/test/matchers", + "lib/merb-core/test/matchers/controller_matchers.rb", + "lib/merb-core/test/matchers/route_matchers.rb", + "lib/merb-core/test/matchers/view_matchers.rb", + "lib/merb-core/test/test_ext", + "lib/merb-core/test/test_ext/object.rb", + "lib/merb-core/test/test_ext/hpricot.rb", "lib/merb-core/test/helpers", "lib/merb-core/test/helpers/controller_helper.rb", - "lib/merb-core/test/helpers/multipart_request_helper.rb", - "lib/merb-core/test/helpers/request_helper.rb", "lib/merb-core/test/helpers/route_helper.rb", "lib/merb-core/test/helpers/view_helper.rb", + "lib/merb-core/test/helpers/request_helper.rb", + "lib/merb-core/test/helpers/multipart_request_helper.rb", "lib/merb-core/test/helpers.rb", - "lib/merb-core/test/matchers", - "lib/merb-core/test/matchers/controller_matchers.rb", - "lib/merb-core/test/matchers/route_matchers.rb", - "lib/merb-core/test/matchers/view_matchers.rb", - "lib/merb-core/test/matchers.rb", - "lib/merb-core/test/run_specs.rb", "lib/merb-core/test/tasks", "lib/merb-core/test/tasks/spectasks.rb", - "lib/merb-core/test/test_ext", - "lib/merb-core/test/test_ext/hpricot.rb", - "lib/merb-core/test/test_ext/object.rb", + "lib/merb-core/dispatch", + "lib/merb-core/dispatch/request.rb", + "lib/merb-core/dispatch/router.rb", + "lib/merb-core/dispatch/session.rb", + "lib/merb-core/dispatch/router", + "lib/merb-core/dispatch/router/route.rb", + "lib/merb-core/dispatch/router/behavior.rb", + "lib/merb-core/dispatch/router/cached_proc.rb", + "lib/merb-core/dispatch/cookies.rb", + "lib/merb-core/dispatch/dispatcher.rb", + "lib/merb-core/dispatch/exceptions.html.erb", + "lib/merb-core/dispatch/session", + "lib/merb-core/dispatch/session/memory.rb", + "lib/merb-core/dispatch/session/memcached.rb", + "lib/merb-core/dispatch/session/cookie.rb", + "lib/merb-core/core_ext.rb", + "lib/merb-core/plugins.rb", "lib/merb-core/test.rb", + "lib/merb-core/server.rb", + "lib/merb-core/constants.rb", + "lib/merb-core/logger.rb", + "lib/merb-core/autoload.rb", + "lib/merb-core/controller", + "lib/merb-core/controller/template.rb", + "lib/merb-core/controller/exceptions.rb", + "lib/merb-core/controller/mime.rb", + "lib/merb-core/controller/merb_controller.rb", + "lib/merb-core/controller/abstract_controller.rb", + "lib/merb-core/controller/mixins", + "lib/merb-core/controller/mixins/render.rb", + "lib/merb-core/controller/mixins/responder.rb", + "lib/merb-core/controller/mixins/controller.rb", + "lib/merb-core/controller/mixins/authentication.rb", "lib/merb-core/vendor", "lib/merb-core/vendor/facets", - "lib/merb-core/vendor/facets/dictionary.rb", "lib/merb-core/vendor/facets/inflect.rb", + "lib/merb-core/vendor/facets/dictionary.rb", "lib/merb-core/vendor/facets.rb", - "lib/merb-core/version.rb", - "lib/merb-core.rb"] - s.description = "Merb. Pocket rocket web framework." - s.add_dependency "erubis", ">= 0" - s.add_dependency "rake", ">= 0" - s.add_dependency "json_pure", ">= 0" - s.add_dependency "rspec", ">= 0" - s.add_dependency "rack", ">= 0" - s.add_dependency "hpricot", ">= 0" - s.add_dependency "mime-types", ">= 0" - s.version = "0.9.2" - s.date = "Fri Apr 25 00:00:00 +1000 2008" + "lib/merb-core/core_ext", + "lib/merb-core/core_ext/string.rb", + "lib/merb-core/core_ext/rubygems.rb", + "lib/merb-core/core_ext/class.rb", + "lib/merb-core/core_ext/kernel.rb", + "lib/merb-core/core_ext/hash.rb", + "lib/merb-core/core_ext/mash.rb", + "lib/merb-core/core_ext/set.rb", + "lib/merb-core/core_ext/object.rb", + "lib/merb-core/core_ext/object_space.rb", + "lib/merb-core/core_ext/time.rb", + "lib/merb-core/version.rb"] + s.authors = ["Ezra Zygmuntowicz"] + s.require_paths = ["lib"] + s.name = "merb-core" + s.requirements = ["install the json gem to get faster json parsing"] + s.required_rubygems_version = ">= 0" end \ No newline at end of file merb-core.gemspec @@ -444,16 +444,16 @@ hsh = {:x => :y, :z => :a, :b => :c, :d => :e, :f => :g, :h => :i, :j => :k, :l arr = hsh.to_a dic = Dictionary[*arr.flatten] -# Benchmark.bmbm do |x| -# x.report("Hash") do -# TIMES.times { hsh[:b] } -# end -# -# x.report("Array") do -# TIMES.times { arr.assoc(:b) } -# end -# -# x.report("Dicrionary") do -# TIMES.times{ dic[:b] } -# end -# end \ No newline at end of file +Benchmark.bmbm do |x| + x.report("Hash") do + TIMES.times { hsh[:b] } + end + + x.report("Array") do + TIMES.times { arr.assoc(:b) } + end + + x.report("Dictionary") do + TIMES.times{ dic[:b] } + end +end \ No newline at end of file simple_benches/hash_assoc.rb @@ -567,7 +567,7 @@ Inflector.inflections do |inflect| inflect.uncountable(%w(equipment information rice money species series fish sheep)) end -module Inflections #:nodoc: +module Inflections def pluralize Inflector.pluralize(self) simple_benches/inflector.rb @@ -49,7 +49,7 @@ describe Merb::Config do Merb::Config[:group].should == "tester" end - it "should support -f to set the filename to run Merb as" do + it "should support -d to daemonize Merb" do Merb::Config.parse_args(["-d"]) Merb::Config[:daemonize].should == true end @@ -71,7 +71,7 @@ describe Merb::Config do it "should have server return PIDfile setting as is with no cluster nodes" do Merb::Config.parse_args(["-P", "pidfile", "-p", "6000"]) - Merb::Server.pid_file(6000).should == "pidfile" + Merb::Server.pid_file(6000).should == "pidfile" Merb::Server.pid_files.should == ["pidfile"] end @@ -79,7 +79,7 @@ describe Merb::Config do Merb::Config.parse_args(["-P", "/tmp/merb.pidfile", "-c", "2", "-p", "6000"]) Merb::Server.pid_file(6000).should == "/tmp/merb.6000.pidfile" Merb::Server.pid_file(6001).should == "/tmp/merb.6001.pidfile" - + Dir.should_receive(:[]).with("/tmp/merb.*.pidfile") Merb::Server.pid_files end @@ -87,7 +87,7 @@ describe Merb::Config do it "should support default PIDfile setting" do Merb::Config.parse_args(["-p", "6000"]) Merb::Server.pid_file(6000).should == Merb.log_path / "merb.6000.pid" - + Dir.should_receive(:[]).with(Merb.log_path / "merb.*.pid") Merb::Server.pid_files end @@ -164,4 +164,19 @@ describe Merb::Config do $TESTING = true; Merb::Config[:testing] = false # reset end + it "supports -V to turn on verbose mode" do + Merb::Config[:verbose] = false + Merb::Config.parse_args(["-V"]) + Merb::Config[:verbose].should be(true) + end + + it "supports --verbose to turn on verbose mode" do + Merb::Config[:verbose] = false + Merb::Config.parse_args(["--verbose"]) + Merb::Config[:verbose].should be(true) + end + + it "has verbose mode turned off by default" do + Merb::Config[:verbose].should be(false) + end end spec/private/config/config_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 @@ -57,35 +57,77 @@ describe Object, "#full_const_get" do end it "returns constant corresponding to the name" do - self.full_const_get("April").should == April + Object.full_const_get("April").should == April end it "handles nested classes" do - self.full_const_get("April::In::Paris").should == April::In::Paris + Object.full_const_get("April::In::Paris").should == April::In::Paris end it "handles nested modules" do - self.full_const_get("Succubus::In::Rapture").should == Succubus::In::Rapture + Object.full_const_get("Succubus::In::Rapture").should == Succubus::In::Rapture + end + + it "handles top level constant naming" do + Object.full_const_get("::Succubus::In::Rapture").should == Succubus::In::Rapture end it "handles in-scoped constants in modules" do - self.full_const_get("Succubus::In::Rapture::PERFORMER").should == "Dimmu Borgir" + Object.full_const_get("Succubus::In::Rapture::PERFORMER").should == "Dimmu Borgir" end it "handles in-scoped constants in classes" do - self.full_const_get("April::In::Paris::PERFORMER").should == "Ella Fitzgerald" + Object.full_const_get("April::In::Paris::PERFORMER").should == "Ella Fitzgerald" end it "acts as a global function" do - lambda { April::In::Paris.full_const_get("PERFORMER") }.should raise_error(NameError) + lambda { self.full_const_get("April::In::Paris::PERFORMER") }.should raise_error(NameError) end it "raises an exception if constant is undefined" do - lambda { self.full_const_get("We::May::Never::Meet::Again") }.should raise_error(NameError) + lambda { Object.full_const_get("We::May::Never::Meet::Again") }.should raise_error(NameError) end end +describe Object, "#full_const_set" do + class April + class In + class Paris + end + end + end + + module Succubus + module In + module Rapture + end + end + end + + it "should assign top level constants" do + Object.full_const_set('May', 5).should == 5 + Object.full_const_get('May').should == 5 + end + + it "handles top level constant naming" do + Object.full_const_set('::June', 6).should == 6 + Object.full_const_get('::June').should == 6 + end + + it "handles in-scoped constants in classes" do + Object.full_const_set("April::In::Paris::COUNTRY", "USA").should == "USA" + Object.full_const_get("April::In::Paris::COUNTRY").should == "USA" + end + + it "handles in-scoped constants in modules" do + Object.full_const_set("Succubus::In::Rapture::COUNTRY", "Norway").should == "Norway" + Object.full_const_get("Succubus::In::Rapture::COUNTRY").should == "Norway" + end + it "raises an exception if constant is undefined" do + lambda { Object.full_const_set("We::May::Never::Meet", "Again") }.should raise_error(NameError) + end +end describe Object, "#make_module" do it "defines module from a string name" do spec/private/core_ext/object_spec.rb @@ -6,7 +6,7 @@ describe Merb::BootLoader::RackUpApplication do options = {:merb_root => File.dirname(__FILE__) / 'fixture'} Merb::Config.setup(options) app = Merb::BootLoader::RackUpApplication.run - app.class.should == Merb::Rack::Application + app.class.should == Merb::Rack::Static end it "should use rackup config that we specified" do spec/private/dispatch/bootloader_spec.rb @@ -22,5 +22,14 @@ describe Merb::Dispatcher do env['REQUEST_URI'] = '/foo/raise_conflict' Merb::Dispatcher.handle(env).action_name.should == 'client_error' end + + it "should log the start time of the transaction" do + t = Time.now + env = Rack::MockRequest.env_for("/notreal") + Time.stub!(:now).and_return(t) + Merb.logger.should_receive(:info).with("Start: #{t}") + + Merb::Dispatcher.handle(env) + end end \ No newline at end of file spec/private/dispatch/dispatch_spec.rb @@ -1 +1,11 @@ +# use PathPrefix Middleware if :path_prefix is set in Merb::Config +if prefix = ::Merb::Config[:path_prefix] + use Merb::Rack::PathPrefix, prefix +end + +# comment this out if you are running merb behind a load balancer +# that serves static files +use Merb::Rack::Static, Merb.dir_for(:public) + +# this is our main merb application run Merb::Rack::Application.new \ No newline at end of file spec/private/dispatch/fixture/config/rack.rb @@ -2,125 +2,135 @@ require File.join(File.dirname(__FILE__), "..", "..", "spec_helper") Merb.environment = 'test' -describe "Plugins", "default GENERATOR_SCOPE" do - it "should have :merb_default first" do - Merb.generator_scope.first.should == :merb_default +def reset_merb_generator_scope + Merb.orm_generator_scope = :merb_default + Merb.test_framework_generator_scope = :rspec + Kernel.stub!(:dependency) +end + +describe "Plugins", "default generator scope" do + it "has :merb_default" do + Merb.generator_scope.should include(:merb_default) end - it "should have :merb" do + it "MUST include :merb" do Merb.generator_scope.should include(:merb) end - it "should have :rspec last" do - Merb.generator_scope.last.should == :rspec + it "has :rspec" do + Merb.generator_scope.should include(:rspec) end end -describe "Plugins","use_orm" do - before(:each) do - Merb.generator_scope.replace [:merb_default, :merb, :rspec] - Kernel.stub!(:dependency) + + +describe "Plugins", "ORM generator scope" do + before :each do + reset_merb_generator_scope end - it "should raise an error if use_orm is called twice" do - use_orm(:activerecord) - lambda { use_orm(:datamapper) }.should raise_error("Don't call use_orm more than once") + it "has merb_default stub by default" do + Merb.orm_generator_scope.should == :merb_default end +end - it "should not have :merb_default in GENERATOR_SCOPE with use_orm(:activerecord)" do - use_orm(:activerecord) + + +describe "Plugins","use_orm" do + before(:each) do + reset_merb_generator_scope + end + + it "removes defaults from generator scope" do + use_orm(:datamapper) Merb.generator_scope.should_not include(:merb_default) end - it "should have :activerecord in GENERATOR_SCOPE with use_orm(:activerecord)" do + it "adds orm symbol to generator scope" do use_orm(:activerecord) Merb.generator_scope.should include(:activerecord) end - it "should have :activerecord first in GENERATOR_SCOPE with use_orm(:activerecord)" do + it "replaces previously used if use_orm is called more than once" do + use_orm(:sequel) use_orm(:activerecord) - Merb.generator_scope.first.should == :activerecord + use_orm(:datamapper) + + Merb.generator_scope.should_not include(:sequel) + Merb.generator_scope.should_not include(:activerecord) + Merb.generator_scope.should include(:datamapper) end - it "should call dependency :merb_activerecord with use_orm(:activerecord)" do + it "calls dependency :merb_<orm>" do Kernel.should_receive(:dependency).with("merb_activerecord").once. and_return(true) use_orm(:activerecord) end + + it "does not affect presence of :merb in generator scope" do + use_orm(:datamapper) + Merb.generator_scope.should include(:merb) + end end -describe "Plugins","use_test" do - before(:each) do - Merb.generator_scope.replace [:merb_default, :merb, :rspec] - Kernel.stub!(:dependency) +describe "Plugins", "test framework generator scope" do + before :each do + reset_merb_generator_scope end - it "should have :rspec in GENERATOR_SCOPE by default" do - Merb.generator_scope.should include(:rspec) + it "has rspec by default" do + Merb.test_framework_generator_scope.should == :rspec end +end - it "should not have :rspec in GENERATOR_SCOPE with use_test(:test_unit)" do - use_test(:test_unit) - Merb.generator_scope.should_not include(:rspec) + + +describe "Plugins","use_test" do + before(:each) do + reset_merb_generator_scope end - it "should have :test_unit in GENERATOR_SCOPE with use_test(:test_unit)" do + it "removes defaults" do use_test(:test_unit) - Merb.generator_scope.should include(:test_unit) + Merb.generator_scope.should_not include(:rspec) end - it "should have :test_unit last in GENERATOR_SCOPE with use_test(:test_unit)" do + it "adds used test framework to generator scope" do use_test(:test_unit) - Merb.generator_scope.last.should == :test_unit + Merb.generator_scope.should include(:test_unit) end - it "should raise an error if called with an unsupported test framework" do + it "raises an error when unsupported test framework is used" do lambda { use_test(:fiddlefaddle) }.should raise_error end -end - - -describe "Plugins", "register_orm" do - before(:each) do - Merb.generator_scope.replace [:merb_default, :merb, :rspec] - Kernel.stub!(:dependency) - end - it "registers ORM plugin at generator scope" do - register_orm(:sequel) - - Merb.generator_scope.should include(:sequel) + it "does not affect presence of :merb in generator scope" do + use_test(:test_unit) + Merb.generator_scope.should include(:merb) end end -describe "Plugins", "registred_orm?" do +describe "Plugins", "register_orm" do before(:each) do - Merb.generator_scope.replace [:merb_default, :merb, :rspec] - Kernel.stub!(:dependency) - end - - it "returns false unless ORM is registred" do - registred_orm?(:sequel).should be(false) + reset_merb_generator_scope end - it "returns true once ORM is registred" do - use_orm(:sequel) + it "registers ORM plugin at orm generator scope" do + register_orm(:sequel) - registred_orm?(:sequel).should be(false) + Merb.orm_generator_scope.should == :sequel end end - describe "Plugins", "register_test_framework" do before(:each) do - Merb.generator_scope.replace [:merb_default, :merb, :rspec] - Kernel.stub!(:dependency) + reset_merb_generator_scope end it "registers test framework at generator scope" do @@ -146,7 +156,11 @@ describe "Plugins", "supported_test_framework?" do supported_test_framework?(:rspec).should be(true) end - it "DOES NOT yet support MSpec (of Rubinius fame)" do + it "does not (no yet) support MSpec" do supported_test_framework?(:mspec).should be(false) end + + it "does not (no yet) support Bacon" do + supported_test_framework?(:bacon).should be(false) + end end spec/private/plugins/plugin_spec.rb @@ -20,7 +20,13 @@ describe Merb::Rack::Application, "with :path_prefix set" do before do Merb::Config[:path_prefix] = "/quux" - @app = Merb::Rack::Application.new + @app = ::Rack::Builder.new { + if prefix = ::Merb::Config[:path_prefix] + use Merb::Rack::PathPrefix, prefix + end + use Merb::Rack::Static, Merb.dir_for(:public) + run Merb::Rack::Application.new + }.to_app @nullobj = mock('controller', :null_object => true) end spec/private/rack/application_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 @@ -78,6 +78,15 @@ describe Merb::AbstractController, " should support before and after filters" do running { dispatch_should_make_body("TestConditionalFilterWithNoProcOrSymbol", "") }.should raise_error(ArgumentError, /a Symbol or a Proc/) end + it "should throw an error if an unknown option is passed to a filter" do + running { Merb::Test::Fixtures::Abstract.class_eval do + + class TestErrorFilter < Merb::Test::Fixtures::Abstract::Testing + before :foo, :except => :index + end + end }.should raise_error(ArgumentError, /known filter options/) + end + it "should support passing an argument to a before filter method" do dispatch_should_make_body("TestBeforeFilterWithArgument", "index action") end @@ -85,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 @@ -5,7 +5,7 @@ require File.join(File.dirname(__FILE__), "spec_helper") class Merb::BootLoader::AfterTest < Merb::BootLoader - after Merb::BootLoader::BeforeAppRuns + after Merb::BootLoader::BeforeAppLoads def self.run end @@ -21,7 +21,7 @@ end describe "The BootLoader" do it "should support adding a BootLoader after another" do - idx = Merb::BootLoader.subclasses.index("Merb::BootLoader::BeforeAppRuns") + idx = Merb::BootLoader.subclasses.index("Merb::BootLoader::BeforeAppLoads") Merb::BootLoader.subclasses.index("Merb::BootLoader::AfterTest").should == idx + 1 end spec/public/boot_loader/boot_loader_spec.rb @@ -9,6 +9,10 @@ describe Merb::Controller, " callable actions" do end end + it "should not have any callable actions by default" do + Merb::Controller.callable_actions.should be_empty + end + it "should dispatch to callable actions" do controller = dispatch_to(Merb::Test::Fixtures::Controllers::Base, :index) controller.body.should == "index" spec/public/controller/base_spec.rb @@ -1,47 +1,45 @@ module Merb::Test::Fixtures::Controllers - + class Testing < Merb::Controller self._template_root = File.dirname(__FILE__) / "views" end class BasicAuthentication < Testing - before :authenticate, :only => :index def index "authenticated" end - + protected - + def authenticate basic_authentication { |u, p| u == "Fred" && p == "secret" } end - end - + class BasicAuthenticationWithRealm < BasicAuthentication def authenticate basic_authentication("My Super App") { |u, p| u == "Fred" && p == "secret" } end end - + class AuthenticateBasicAuthentication < Testing def index basic_authentication.authenticate { |u, p| "Fred:secret" } end end - + class RequestBasicAuthentication < BasicAuthentication def authenticate basic_authentication.request end end - + class RequestBasicAuthenticationWithRealm < BasicAuthentication def authenticate basic_authentication("My SuperApp").request end end - -end \ No newline at end of file + +end spec/public/controller/controllers/authentication.rb @@ -1,15 +1,10 @@ - - module Merb::Test::Fixtures - module Controllers - class Testing < Merb::Controller self._template_root = File.dirname(__FILE__) / "views" end module Inclusion - def self.included(base) base.show_action(:baz) end @@ -21,12 +16,11 @@ module Merb::Test::Fixtures def bat "bat" end - end class Base < Testing include Inclusion - + def index self.status = :ok "index" @@ -39,4 +33,4 @@ module Merb::Test::Fixtures end end -end \ No newline at end of file +end spec/public/controller/controllers/base.rb @@ -1,7 +1,4 @@ - - module Merb::Test::Fixtures::Controllers - class SomeModel def to_xml; "<XML:Model />" end def to_json(options = {}) @@ -9,18 +6,31 @@ module Merb::Test::Fixtures::Controllers excludes = options[:except].first rescue "" "{ 'include': '#{includes}', 'exclude': '#{excludes}' }" end + def to_param + "1" + end end - + + class Testing < Merb::Controller self._template_root = File.dirname(__FILE__) / "views" end - + + class Display < Testing - 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 @@ -29,17 +39,30 @@ module Merb::Test::Fixtures::Controllers provides :xml end + class DisplayLocalProvides < Display - def index @obj = SomeModel.new provides :xml display @obj end end - + + class DisplayWithTemplate < Display layout :custom + + 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 @@ -47,24 +70,33 @@ module Merb::Test::Fixtures::Controllers @obj = SomeModel.new display @obj, :layout => :custom_arg end - + def index_by_arg @obj = SomeModel.new display @obj, "merb/test/fixtures/controllers/display_with_template_argument/index.html" end end - + + class DisplayWithStringLocation < Display + provides :json + def index + @obj = SomeModel.new + display @obj, :location => "/some_resources/#{@obj.to_param}" + end + end + + class DisplayWithSerializationOptions < Display provides :json - + def index @obj = SomeModel.new display @obj, :include => [:beer, :jazz], :except => [:idiots] end - + def index_that_passes_empty_hash @obj = SomeModel.new display @obj, {} end end -end \ No newline at end of file +end spec/public/controller/controllers/display.rb @@ -1,24 +1,24 @@ - - module Merb::Test::Fixtures::Controllers - class Testing < Merb::Controller self._template_root = File.dirname(__FILE__) / "views" end + class Responder < Testing - def index render end end + class HtmlDefault < Responder; end + class ClassProvides < Responder provides :xml end + class LocalProvides < Responder def index provides :xml @@ -26,37 +26,41 @@ module Merb::Test::Fixtures::Controllers end end + class MultiProvides < Responder def index provides :html, :js render end end - + + class ClassOnlyProvides < Responder only_provides :text, :xml - + def index "nothing" end end - + + class OnlyProvides < Responder def index only_provides :text, :xml "nothing" end end - + class ClassDoesntProvides < Responder provides :xml does_not_provide :html - + def index "nothing" end end - + + class DoesntProvide < Responder def index provides :xml @@ -64,4 +68,19 @@ module Merb::Test::Fixtures::Controllers "nothing" end end -end \ No newline at end of file + + + class FooFormatProvides < Responder + only_provides :foo + + def index + render "nothing" + end + + def show + headers["Content-Language"] = 'nl' + headers["Biz"] = "buzz" + render "nothing" + end + end +end spec/public/controller/controllers/responder.rb @@ -7,23 +7,44 @@ describe Merb::Controller, " displaying objects based on mime type" do r.default_routes end end - + it "should default the mime-type to HTML (and raise since there's no to_html)" do running { dispatch_to(Merb::Test::Fixtures::Controllers::DisplayHtmlDefault, :index) }.should raise_error(Merb::ControllerExceptions::NotAcceptable) end - + + it "should set headers['Location'] to string provided by :location" do + dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithStringLocation, :index, {}, :http_accept => "application/json").headers['Location'].should =~ /some_resources/ + end + it "should use a template if specified" do - dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplate, :index).body.should == "Custom: Template" + dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplate, :index).body.should match(/Custom: Template/) + end + + 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 a layout argument" do - dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithTemplateArgument, :index).body.should == "Custom Arg: Template" + 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 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 />" @@ -36,16 +57,16 @@ describe Merb::Controller, " displaying objects based on mime type" do it "should use mime-types that are provided at the local level" do controller = dispatch_to(Merb::Test::Fixtures::Controllers::DisplayLocalProvides, :index, {}, :http_accept => "application/xml") - controller.body.should == "<XML:Model />" + controller.body.should == "<XML:Model />" end - + it "passes all options to serialization method like :to_json" do controller = dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithSerializationOptions, :index, {}, :http_accept => "application/json") controller.body.should == "{ 'include': 'beer, jazz', 'exclude': 'idiots' }" end - + it "passes single argument to serialization method like :to_json" do controller = dispatch_to(Merb::Test::Fixtures::Controllers::DisplayWithSerializationOptions, :index_that_passes_empty_hash, {}, :http_accept => "application/json") controller.body.should == "{ 'include': '', 'exclude': '' }" end -end \ No newline at end of file +end spec/public/controller/display_spec.rb @@ -92,4 +92,44 @@ describe Merb::Controller, " responds" do controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassOnlyProvides, :index, {}, :http_accept => "application/html") lambda { controller.content_type }.should raise_error(Merb::ControllerExceptions::NotAcceptable) end + + it "should return the correct default HTTP headers for a format" do + controller = dispatch_to(Merb::Test::Fixtures::Controllers::ClassProvides, :index, :format => "xml") + controller.headers.keys.sort.should == ["Content-Type"] + controller.headers["Content-Type"].should == "application/xml; charset=utf-8" + end + + it "should append the correct charset which was set when the format was added" do + Merb.add_mime_type(:foo, nil, %w[application/foo], :charset => "iso-8859-1") + controller = dispatch_to(Merb::Test::Fixtures::Controllers::FooFormatProvides, :index, :format => "foo") + controller.headers["Content-Type"].should == "application/foo; charset=iso-8859-1" + end + + it "should return the correct HTTP headers which were set when the format was added" do + Merb.add_mime_type(:foo, nil, %w[application/foo], "Foo" => 'bar', "Content-Language" => "en", :charset => "utf-8") + controller = dispatch_to(Merb::Test::Fixtures::Controllers::FooFormatProvides, :index, :format => "foo") + controller.headers.keys.should_not include(:charset) + controller.headers["Content-Type"].should == "application/foo; charset=utf-8" + controller.headers["Content-Language"].should == "en" + controller.headers["Foo"] = "bar" + end + + it "should return the correct HTTP headers using the block given when the format was added" do + Merb.add_mime_type(:foo, nil, %w[application/foo], "Foo" => "bar") do |controller| + controller.headers["Action-Name"] = controller.action_name + end + controller = dispatch_to(Merb::Test::Fixtures::Controllers::FooFormatProvides, :index, :format => "foo") + controller.headers["Content-Type"].should == "application/foo" + controller.headers["Action-Name"].should == "index" + controller.headers["Foo"] = "bar" + end + + it "should not overwrite runtime-set headers with default format response headers" do + Merb.add_mime_type(:foo, nil, %w[application/foo], "Foo" => "bar", "Content-Language" => "en") + controller = dispatch_to(Merb::Test::Fixtures::Controllers::FooFormatProvides, :show, :format => "foo") + controller.headers["Content-Language"].should == "nl" + controller.headers["Biz"] = "buzz" + controller.headers["Foo"] = "bar" + end + end spec/public/controller/responder_spec.rb @@ -30,5 +30,16 @@ describe "Merb.env helpers" do end end + it "should allow an environment to merge another environments settings" do + %w(development test production staging demo custom).each do |e| + + Merb.environment = e + Merb.start_environment + Merb.merge_env "some_other_env" + Merb.environment_info.nil?.should be_false + Merb.environment_info[:merged_envs].first.should == "some_other_env" + end + end + end \ No newline at end of file spec/public/core/merb_core_spec.rb @@ -1,18 +1,41 @@ require File.join(File.dirname(__FILE__), "..", "..", "spec_helper") + +class MockTimedExecutor + def self.every(seconds, &block) + @@scheduled_action = block + end + def self.run_task + @@scheduled_action.call + end +end + +RealTimedExecutor = Merb::BootLoader::ReloadClasses::TimedExecutor +Merb::BootLoader::ReloadClasses::TimedExecutor = MockTimedExecutor + Merb.start :environment => 'test', :merb_root => File.dirname(__FILE__) / "directory" -describe "The reloader" do - SLEEP_TIME = 0.5 - - def reload! - Merb::BootLoader::ReloadClasses.reload +describe "TimedExecutor" do + it "should call a block of code repeatedly in the background" do + list_of_things = [] + + RealTimedExecutor.every(0.1) do + list_of_things << "Something" + end + + sleep 0.5 + + list_of_things.should_not be_empty + list_of_things.size.should > 1 end + +end + +describe "The reloader" do before :all do @reload_file = File.dirname(__FILE__) / "directory" / "app" / "controllers" / "reload.rb" - File.open(@reload_file, "w") do |f| - @text = <<-END + @text = <<-END class Reloader < Application end @@ -20,10 +43,16 @@ describe "The reloader" do class Hello < Application end END - f.puts @text - end + update_file @text + MockTimedExecutor.run_task + end - sleep SLEEP_TIME + def update_file(contents) + mtime = File.mtime(@reload_file) + f = File.open(@reload_file, "w") do |f| + f.puts contents + end + FileUtils.touch(@reload_file, :mtime => mtime + 30) end it "should reload files that were changed" do @@ -31,10 +60,7 @@ describe "The reloader" do defined?(Reloader).should_not be_nil defined?(Reloader2).should be_nil - sleep SLEEP_TIME - - File.open(@reload_file, "w") do |f| - f.puts <<-END + update_file <<-END class Reloader < Application end @@ -42,18 +68,17 @@ describe "The reloader" do class Reloader2 end END - end - - sleep SLEEP_TIME - + + MockTimedExecutor.run_task + defined?(Hello).should be_nil defined?(Reloader).should_not be_nil defined?(Reloader2).should_not be_nil end it "should remove classes for _abstract_subclasses" do - File.open(@reload_file, "w") do |f| - f.puts <<-END + + update_file <<-END class Reloader < Application end @@ -61,9 +86,8 @@ describe "The reloader" do class Reloader2 < Application end END - end - - sleep SLEEP_TIME + + MockTimedExecutor.run_task Merb::AbstractController._abstract_subclasses.should include("Reloader") Merb::AbstractController._abstract_subclasses.should include("Reloader2") @@ -73,9 +97,7 @@ describe "The reloader" do end after :each do - sleep SLEEP_TIME - File.open(@reload_file, "w") do |f| - f.puts @text - end + update_file @text + MockTimedExecutor.run_task end end spec/public/reloading/reload_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 @@ -68,7 +68,14 @@ describe Merb::Request, " query and body params" do request.stub!(:route_params).and_return({}) request.params.should == {"foo" => "bar"} end - + + it "should populated the inflated_object parameter if JSON params do not inflate to a hash" do + request = fake_request({:content_type => "application/json"}, :req => %{["foo", "bar"]}) + request.stub!(:route_params).and_return({}) + request.params.should have_key(:inflated_object) + request.params[:inflated_object].should eql(["foo", "bar"]) + end + it "should support XML params" do request = fake_request({:content_type => "application/xml"}, :req => %{<foo bar="baz"><baz/></foo>}) request.stub!(:route_params).and_return({}) @@ -194,7 +201,7 @@ describe Merb::Request, " misc" do :http_keep_alive => ["keep_alive", "300"], :http_accept_charset => ["accept_charset", "UTF-8"], :http_version => ["version", "1.1"], - :gateway_inteface => ["gateway", "CGI/1.2"], + :gateway_interface => ["gateway", "CGI/1.2"], :http_connection => ["connection", "keep-alive"], :path_info => ["path_info", "foo/bar/baz"], }.each do |env, vars| spec/public/request/request_spec.rb @@ -1,36 +1,54 @@ require File.join(File.dirname(__FILE__), "..", "..", "spec_helper") require 'ostruct' + +require 'rack/mock' +require 'stringio' +Merb.start :environment => 'test', + :merb_root => File.dirname(__FILE__) / 'fixture' + + class SimpleRequest < OpenStruct - + def method @table[:method] end - + def params @table end end def prepare_route(from, to) - Merb::Router.prepare {|r| r.match(from).to(to)} + Merb::Router.prepare {|r| r.match(from).to(to)} end def route_to(path, args = {}, protocol = "http://") Merb::Router.match(SimpleRequest.new({:protocol => protocol, :path => path}.merge(args)))[1] end +def match_for(path, args = {}, protocol = "http://") + Merb::Router.match(SimpleRequest.new({:protocol => protocol, :path => path}.merge(args))) +end + +def matched_route_for(*args) + # get route index + idx = match_for(*args)[0] + + Merb::Router.routes[idx] +end + def generate(*args) Merb::Router.generate *args end module Merb - + module Test - + module RspecMatchers class HaveRoute - + def self.build(expected) this = new this.instance_variable_set("@expected", expected) @@ -62,11 +80,11 @@ module Merb def have_route(expected) HaveRoute.build(expected) end - + def have_nil_route have_route({}) end - + end end -end \ No newline at end of file +end spec/public/router/spec_helper.rb @@ -1,9 +1,9 @@ require File.join(File.dirname(__FILE__), "spec_helper") describe "Regex-based routes" do - + it "should process a simple regex" do - prepare_route(%r[^/foos?/(bar|baz)/:id], :controller => "foo", :action => "[1]", :id => ":id") + prepare_route(%r[^/foos?/(bar|baz)/:id], :controller => "foo", :action => "[1]", :id => ":id") route_to("/foo/bar/baz").should have_route(:controller => "foo", :action => "bar", :id => "baz") route_to("/foos/baz/bam").should have_route(:controller => "foo", :action => "baz", :id => "bam") end @@ -11,7 +11,7 @@ describe "Regex-based routes" do it "should support inbound user agents" do Merb::Router.prepare do |r| r.match(%r[^/foo/(.+)], :user_agent => /(MSIE|Gecko)/). - to(:controller => "foo", :title => "[1]", :action => "show", :agent => ":user_agent[1]") + to(:controller => "foo", :title => "[1]", :action => "show", :agent => ":user_agent[1]") end route_to("/foo/bar", :user_agent => /MSIE/).should have_route( :controller => "foo", :action => "show", :title => "bar", :agent => "MSIE" @@ -21,7 +21,7 @@ describe "Regex-based routes" do end describe "Routes that are restricted based on incoming params" do - + it "should allow you to restrict routes to POST requests" do Merb::Router.prepare do |r| r.match("/:controller/create/:id", :method => :post). @@ -30,12 +30,12 @@ describe "Routes that are restricted based on incoming params" do route_to("/foo/create/12", :method => "post").should have_route( :controller => "foo", :action => "create", :id => "12" ) - + route_to("/foo/create/12", :method => "get").should_not have_route( :controller => "foo", :action => "create", :id => "12" ) end - + it "should allow you to restrict routes based on protocol" do Merb::Router.prepare do |r| r.match(:protocol => "http://").to(:controller => "foo", :action => "bar") @@ -44,5 +44,18 @@ describe "Routes that are restricted based on incoming params" do route_to("/foo/bar").should have_route(:controller => "foo", :action => "bar") route_to("/boo/hoo", :protocol => "https://").should have_route(:controller => "boo", :action => "hoo") end - -end \ No newline at end of file + + it "does not require explicit specifying of params" do + Merb::Router.prepare do |r| + r.match!("/fb/:callback_path/:controller/:action") + end + + route_to("/fb/callybacky/products/search").should have_route( + :controller => "products", :action => "search", :callback_path => "callybacky" + ) + route_to("/fb/ping/products/search").should have_route( + :controller => "products", :action => "search", :callback_path => "ping" + ) + end + +end spec/public/router/special_spec.rb @@ -52,6 +52,7 @@ describe Merb::Template do it "should accept template-type registrations via #register_extensions" do Merb::Template.register_extensions(Merb::Test::Fixtures::MyTemplateEngine, %w[myt]) Merb::Template.engine_for("foo.myt").should == Merb::Test::Fixtures::MyTemplateEngine + Merb::Template.template_extensions.should include("myt") end # @semipublic 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 @@ -28,6 +28,23 @@ describe Merb::Test::RouteHelper do it "should work with a parameters hash" do url(:with_id, :id => 123).should == "/123" end + + it "should turn extra hash items into query params" do + generated_url = url(:getter, :id => 123, :color => 'red', :size => 'large') + lambda { + generated_url.match(/\bid=123\b/) && + generated_url.match(/\bsize=large\b/) && + generated_url.match(/\bcolor=red\b/) + }.call.should_not be_nil + end + + it "should remove items with nil values from query params" do + url(:getter, :color => nil, :size => 'large').should == "/?size=large" + end + + it "should remove items with nil values from query params when named route isn't specified" do + url(:controller => 'cont', :action => 'act', :color => nil, :size => 'large').should == "/cont/act?size=large" + end end describe "#request_to" do @@ -51,4 +68,4 @@ describe Merb::Test::RouteHelper do request_to("/123")[:id].should == "123" end end -end \ No newline at end of file +end spec/public/test/route_helper_spec.rb @@ -92,6 +92,22 @@ describe Merb::Test::Rspec::RouteMatchers do matcher.matches?(:controller => "target_controller", :action => "target_action") matcher.failure_message.should include("TargetController#target_action") end + + it "should include the expected parameters" do + expected_parameters = {:id => '123', :page => '2'} + matcher = RouteToMatcher.new(TestController, :any_action) + matcher.with(expected_parameters) + matcher.matches?(:controller => "target_controller", :action => "target_action") + matcher.failure_message.should include(expected_parameters.inspect) + end + + it "should include the actual paramters" do + expected_parameters, actual_parameters = {:id => '123', :page => '2'}, {:id => '2', :page => '321'} + matcher = RouteToMatcher.new(TestController, :any_action) + matcher.with(expected_parameters) + matcher.matches?(actual_parameters.merge(:controller => "test_controller", :action => "any_action")) + matcher.failure_message.should include(actual_parameters.inspect) + end end describe "#negative_failure_message" do spec/public/test/route_matchers_spec.rb @@ -132,7 +132,7 @@ describe Merb::Test::Rspec::ViewMatchers do describe HasContent do before(:each) do @element = stub(:element) - @element.stub!(:inner_content).and_return <<-EOF + @element.stub!(:inner_text).and_return <<-EOF <div id='main'> <div class='inner'>hello, world!</div> </div> @@ -175,9 +175,9 @@ describe Merb::Test::Rspec::ViewMatchers do hc = HasContent.new(/hello,\sworld!/) hc.matches?(@element) - hc.failure_message.should include(@element.inner_content) + hc.failure_message.should include(@element.inner_text) end end end end -end \ No newline at end of file +end spec/public/test/view_matchers_spec.rb @@ -3,11 +3,13 @@ require "rubygems" require "spec" require File.join(File.dirname(__FILE__), "..", "lib", "merb-core") +Merb.start :environment => 'test', :adapter => 'runner' + # -- Global custom matchers -- # A better +be_kind_of+ with more informative error messages. # -# The default +be_kind_of+ just says +# The default +be_kind_of+ just says # # "expected to return true but got false" # @@ -16,13 +18,9 @@ require File.join(File.dirname(__FILE__), "..", "lib", "merb-core") # "expected File but got Tempfile" module Merb - module Test - module RspecMatchers - class BeKindOf - def initialize(expected) # + args @expected = expected end @@ -43,7 +41,6 @@ module Merb def description "be_kind_of #{@target}" end - end def be_kind_of(expected) # + args @@ -52,20 +49,20 @@ module Merb end module Helper - def running(&blk) blk; end - + def executing(&blk) blk; end - + def doing(&blk) blk; end - - def calling(&blk) blk; end + + def calling(&blk) blk; end end end end + Spec::Runner.configure do |config| config.include Merb::Test::Helper config.include Merb::Test::RspecMatchers - config.include Merb::Test::RequestHelper -end \ No newline at end of file + config.include Merb::Test::RequestHelper +end spec/spec_helper.rb @@ -1,6 +1,6 @@ -class CodeStatistics #:nodoc: +class CodeStatistics TEST_TYPES = %w(Units Functionals Unit\ tests Functional\ tests Integration\ tests) tools/code_statistics.rb deps/rack/lib/rack.rbc deps/rack/lib/rack/builder.rbc 3e8a8934b62aaa5453a97b8150b0ab3877580e0c cd7bacb9c7eb105ecf84c01fb56bcc8af29b5c15 David James djwonk@collectiveinsight.net http://github.com/wycats/merb-core/commit/75f71027c5f023eebb91023845f06262cb16a880 75f71027c5f023eebb91023845f06262cb16a880 2008-06-11T10:52:54-07:00 2008-06-11T10:52:54-07:00 Merge branch 'master' of git://github.com/wycats/merb-core * 'master' of git://github.com/wycats/merb-core: (192 commits) siiiiiigh. Revert partial counter and yielding. Remove some duplication For crying out loud. Refactor display. WARNING: This commit might not be stable. I need to add a bunch more specs for display before I feel confident. Make the TemplateNotFound error read better. Slight refactor of _get_layout. Fix _template_for so it's actually readable uhhhhhhhh... Added Merb::Router.reset! and Merb::Router.capture Speedup Route URL generation Start work on fixing contaminated cousins bug. Changed controller inheritance of _template_root Added the ability to use full/absolute template paths for render, display and partial views This cannot be tested this way. It needs to be tested as a public spec (testing it privately here was a cop-out and fails when I fixed up the way dependency works). Allows passage of query string via env["QUERY_STRING"] in tests. [#358 state:resolved] Handles use of dependency after BootLoading. [#360 state:resolved] properly set the session_id_key added 2 specs for multipart formdata: (1) for checking request with IO, (2) for testing GET with content_type not erroring on multipart/form-data absence; fixed error with multipart/form-data absence. Made Class a lot more sane. Fix README for merb-gen app foo ... cc4fa07242559e1e20f49ba4422e51a48626916f David James djwonk@collectiveinsight.net