open-source-mirrors
/
bazarr
mirror of https://github.com/morpheus65535/bazarr
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '03b181701e'
${ noResults }
bazarr/libs/git/test/fixtures/diff_mode_only

1153 lines
45 KiB
Raw Blame History

diff --git a/bin/merb b/bin/merb
old mode 100644
new mode 100755
diff --git a/lib/merb.rb b/lib/merb.rb
index 76cb3e269e46fdf9b63cda7cb563c6cf40fdcb15..a2ab4ed47f9cb2ab942da5c46a2b561758a0d704 100644
--- a/lib/merb.rb
+++ b/lib/merb.rb
@@ -15,7 +15,7 @@ require 'merb_core/core_ext'
require 'merb_core/gem_ext/erubis'
require 'merb_core/logger'
require 'merb_core/version'
-
+require 'merb_core/controller/mime'
module Merb
class << self
@@ -23,6 +23,7 @@ module Merb
def start(argv=ARGV)
Merb::Config.parse_args(argv)
BootLoader.run
+
case Merb::Config[:adapter]
when "mongrel"
adapter = Merb::Rack::Mongrel
diff --git a/lib/merb_core/boot/bootloader.rb b/lib/merb_core/boot/bootloader.rb
index d873924860bf4da06ac93db5c6a188f63dd1c3cc..57da75f05e28e8a256922bf345ccd3902e0a0b02 100644
--- a/lib/merb_core/boot/bootloader.rb
+++ b/lib/merb_core/boot/bootloader.rb
@@ -20,7 +20,7 @@ module Merb
end
def run
- subclasses.each {|klass| Object.full_const_get(klass).new.run }
+ subclasses.each {|klass| Object.full_const_get(klass).run }
end
def after(klass)
@@ -37,95 +37,128 @@ module Merb
end
-class Merb::BootLoader::BuildFramework < Merb::BootLoader
- def run
- build_framework
+class Merb::BootLoader::LoadInit < Merb::BootLoader
+ def self.run
+ if Merb::Config[:init_file]
+ require Merb.root / Merb::Config[:init_file]
+ elsif File.exists?(Merb.root / "config" / "merb_init.rb")
+ require Merb.root / "config" / "merb_init"
+ elsif File.exists?(Merb.root / "merb_init.rb")
+ require Merb.root / "merb_init"
+ elsif File.exists?(Merb.root / "application.rb")
+ require Merb.root / "application"
+ end
+ end
+end
+
+class Merb::BootLoader::Environment < Merb::BootLoader
+ def self.run
+ Merb.environment = Merb::Config[:environment]
+ end
+end
+
+class Merb::BootLoader::Logger < Merb::BootLoader
+ def self.run
+ Merb.logger = Merb::Logger.new(Merb.dir_for(:log) / "test_log")
+ Merb.logger.level = Merb::Logger.const_get(Merb::Config[:log_level].upcase) rescue Merb::Logger::INFO
end
+end
+
+class Merb::BootLoader::BuildFramework < Merb::BootLoader
+ class << self
+ def run
+ build_framework
+ end
- # This method should be overridden in merb_init.rb before Merb.start to set up a different
- # framework structure
- def build_framework
- %[view model controller helper mailer part].each do |component|
- Merb.push_path(component.to_sym, Merb.root_path("app/#{component}s"))
+ # This method should be overridden in merb_init.rb before Merb.start to set up a different
+ # framework structure
+ def build_framework
+ %w[view model controller helper mailer part].each do |component|
+ Merb.push_path(component.to_sym, Merb.root_path("app/#{component}s"))
+ end
+ Merb.push_path(:application, Merb.root_path("app/controllers/application.rb"))
+ Merb.push_path(:config, Merb.root_path("config/router.rb"))
+ Merb.push_path(:lib, Merb.root_path("lib"))
end
- Merb.push_path(:application, Merb.root_path("app/controllers/application.rb"))
- Merb.push_path(:config, Merb.root_path("config/router.rb"))
- Merb.push_path(:lib, Merb.root_path("lib"))
end
end
class Merb::BootLoader::LoadPaths < Merb::BootLoader
LOADED_CLASSES = {}
- def run
- # Add models, controllers, and lib to the load path
- $LOAD_PATH.unshift Merb.load_paths[:model].first if Merb.load_paths[:model]
- $LOAD_PATH.unshift Merb.load_paths[:controller].first if Merb.load_paths[:controller]
- $LOAD_PATH.unshift Merb.load_paths[:lib].first if Merb.load_paths[:lib]
+ class << self
+ def run
+ # Add models, controllers, and lib to the load path
+ $LOAD_PATH.unshift Merb.load_paths[:model].first if Merb.load_paths[:model]
+ $LOAD_PATH.unshift Merb.load_paths[:controller].first if Merb.load_paths[:controller]
+ $LOAD_PATH.unshift Merb.load_paths[:lib].first if Merb.load_paths[:lib]
- # Require all the files in the registered load paths
- puts Merb.load_paths.inspect
- Merb.load_paths.each do |name, path|
- Dir[path.first / path.last].each do |file|
- klasses = ObjectSpace.classes.dup
- require f
- LOADED_CLASSES[file] = ObjectSpace.classes - klasses
+ # Require all the files in the registered load paths
+ puts Merb.load_paths.inspect
+ Merb.load_paths.each do |name, path|
+ Dir[path.first / path.last].each do |file|
+ klasses = ObjectSpace.classes.dup
+ require file
+ LOADED_CLASSES[file] = ObjectSpace.classes - klasses
+ end
end
end
- end
- def reload(file)
- if klasses = LOADED_CLASSES[file]
- klasses.each do |klass|
- remove_constant(klass)
+ def reload(file)
+ if klasses = LOADED_CLASSES[file]
+ klasses.each do |klass|
+ remove_constant(klass)
+ end
end
+ load file
end
- load file
- end
- 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.
- if klass.superclass.respond_to?(:_subclasses_list)
- klass.superclass.send(:_subclasses_list).delete(klass)
- klass.superclass.send(:_subclasses_list).delete(klass.to_s)
- end
+ 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.
+ if klass.superclass.respond_to?(:_subclasses_list)
+ klass.superclass.send(:_subclasses_list).delete(klass)
+ klass.superclass.send(:_subclasses_list).delete(klass.to_s)
+ end
- parts = const.to_s.split("::")
- base = parts.size == 1 ? Object : Object.full_const_get(parts[0..-2].join("::"))
- object = parts[-1].intern
- Merb.logger.debugger("Removing constant #{object} from #{base}")
- base.send(:remove_const, object) if object
+ parts = const.to_s.split("::")
+ base = parts.size == 1 ? Object : Object.full_const_get(parts[0..-2].join("::"))
+ object = parts[-1].intern
+ Merb.logger.debugger("Removing constant #{object} from #{base}")
+ base.send(:remove_const, object) if object
+ end
end
end
class Merb::BootLoader::Templates < Merb::BootLoader
- def run
- template_paths.each do |path|
- Merb::Template.inline_template(path)
+ class << self
+ def run
+ template_paths.each do |path|
+ Merb::Template.inline_template(path)
+ end
end
- end
- def template_paths
- extension_glob = "{#{Merb::Template::EXTENSIONS.keys.join(',')}}"
+ def template_paths
+ extension_glob = "{#{Merb::Template::EXTENSIONS.keys.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.map {|path| Dir["#{path}/**/*.#{extension_glob}"] }
+ # 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}"] }
- # This gets the templates that might be created outside controllers
- # template roots. eg app/views/shared/*
- template_paths << Dir["#{Merb.dir_for(:view)}/**/*.#{extension_glob}"] if Merb.dir_for(:view)
+ # This gets the templates that might be created outside controllers
+ # template roots. eg app/views/shared/*
+ template_paths << Dir["#{Merb.dir_for(:view)}/**/*.#{extension_glob}"] if Merb.dir_for(:view)
- template_paths.flatten.compact.uniq
- end
+ template_paths.flatten.compact.uniq
+ end
+ end
end
class Merb::BootLoader::Libraries < Merb::BootLoader
@@ -145,18 +178,41 @@ class Merb::BootLoader::Libraries < Merb::BootLoader
def self.add_libraries(hsh)
@@libraries.merge!(hsh)
end
-
- def run
+
+ def self.run
@@libraries.each do |exclude, choices|
require_first_working(*choices) unless Merb::Config[exclude]
end
end
-
- def require_first_working(first, *rest)
+
+ def self.require_first_working(first, *rest)
p first, rest
require first
rescue LoadError
raise LoadError if rest.empty?
require_first_working rest.unshift, *rest
end
+end
+
+class Merb::BootLoader::MimeTypes < Merb::BootLoader
+ def self.run
+ # Sets the default mime-types
+ #
+ # By default, the mime-types include:
+ # :all:: no transform, */*
+ # :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
+ # :js:: to_json, text/javascript ot application/javascript or application/x-javascript
+ # :json:: to_json, application/json or text/x-json
+ Merb.available_mime_types.clear
+ 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])
+ end
end
\ No newline at end of file
diff --git a/lib/merb_core/config.rb b/lib/merb_core/config.rb
index c92f2e6f071c234551ecb16a4716d47fa92f6c7b..ab0864e0174b54833c758f9f22a840d3b53c7653 100644
--- a/lib/merb_core/config.rb
+++ b/lib/merb_core/config.rb
@@ -92,6 +92,10 @@ module Merb
options[:cluster] = nodes
end
+ opts.on("-I", "--init-file FILE", "Name of the file to load first") do |init_file|
+ options[:init_file] = init_file
+ end
+
opts.on("-p", "--port PORTNUM", "Port to run merb on, defaults to 4000.") do |port|
options[:port] = port
end
@@ -261,29 +265,29 @@ module Merb
@configuration = Merb::Config.apply_configuration_from_file options, environment_merb_yml
- case Merb::Config[:environment].to_s
- when 'production'
- Merb::Config[:reloader] = Merb::Config.fetch(:reloader, false)
- Merb::Config[:exception_details] = Merb::Config.fetch(:exception_details, false)
- Merb::Config[:cache_templates] = true
- else
- Merb::Config[:reloader] = Merb::Config.fetch(:reloader, true)
- Merb::Config[:exception_details] = Merb::Config.fetch(:exception_details, true)
- end
-
- Merb::Config[:reloader_time] ||= 0.5 if Merb::Config[:reloader] == true
-
-
- if Merb::Config[:reloader]
- Thread.abort_on_exception = true
- Thread.new do
- loop do
- sleep( Merb::Config[:reloader_time] )
- ::Merb::BootLoader.reload if ::Merb::BootLoader.app_loaded?
- end
- Thread.exit
- end
- end
+ # case Merb::Config[:environment].to_s
+ # when 'production'
+ # Merb::Config[:reloader] = Merb::Config.fetch(:reloader, false)
+ # Merb::Config[:exception_details] = Merb::Config.fetch(:exception_details, false)
+ # Merb::Config[:cache_templates] = true
+ # else
+ # Merb::Config[:reloader] = Merb::Config.fetch(:reloader, true)
+ # Merb::Config[:exception_details] = Merb::Config.fetch(:exception_details, true)
+ # end
+ #
+ # Merb::Config[:reloader_time] ||= 0.5 if Merb::Config[:reloader] == true
+ #
+ #
+ # if Merb::Config[:reloader]
+ # Thread.abort_on_exception = true
+ # Thread.new do
+ # loop do
+ # sleep( Merb::Config[:reloader_time] )
+ # ::Merb::BootLoader.reload if ::Merb::BootLoader.app_loaded?
+ # end
+ # Thread.exit
+ # end
+ # end
@configuration
end
diff --git a/lib/merb_core/controller/abstract_controller.rb b/lib/merb_core/controller/abstract_controller.rb
index fbf83372793da6da4b803b799994f0e341fddf88..f5e9a59057d67a6d56377a516a726cf51aa03d6f 100644
--- a/lib/merb_core/controller/abstract_controller.rb
+++ b/lib/merb_core/controller/abstract_controller.rb
@@ -96,7 +96,7 @@ class Merb::AbstractController
# the superclass.
#---
# @public
- def _template_location(action, controller = controller_name, type = nil)
+ def _template_location(action, type = nil, controller = controller_name)
"#{controller}/#{action}"
end
@@ -106,6 +106,8 @@ class Merb::AbstractController
# own subclasses. We're using a Set so we don't have to worry about
# uniqueness.
self._abstract_subclasses = Set.new
+ self._template_root = Merb.dir_for(:view)
+
def self.subclasses_list() _abstract_subclasses end
class << self
@@ -114,7 +116,6 @@ class Merb::AbstractController
# The controller that is being inherited from Merb::AbstractController
def inherited(klass)
_abstract_subclasses << klass.to_s
- klass._template_root ||= Merb.dir_for(:view)
super
end
diff --git a/lib/merb_core/controller/merb_controller.rb b/lib/merb_core/controller/merb_controller.rb
index 7283f006bb0501b29f825da129600cf045264b62..98af6ef3330a6b3f46d7bb1f8643261e28155ae5 100644
--- a/lib/merb_core/controller/merb_controller.rb
+++ b/lib/merb_core/controller/merb_controller.rb
@@ -71,6 +71,10 @@ class Merb::Controller < Merb::AbstractController
end
end
+ def _template_location(action, type = nil, controller = controller_name)
+ "#{controller}/#{action}.#{type}"
+ end
+
# Sets the variables that came in through the dispatch as available to
# the controller. This is called by .build, so see it for more
# information.
@@ -107,9 +111,7 @@ class Merb::Controller < Merb::AbstractController
request.cookies[_session_id_key] = request.params[_session_id_key]
end
end
- @_request, @_response, @_status, @_headers =
- request, response, status, headers
-
+ @request, @response, @status, @headers = request, response, status, headers
nil
end
@@ -135,7 +137,8 @@ class Merb::Controller < Merb::AbstractController
@_benchmarks[:action_time] = Time.now - start
end
- _attr_reader :request, :response, :status, :headers
+ attr_reader :request, :response, :headers
+ attr_accessor :status
def params() request.params end
def cookies() request.cookies end
def session() request.session end
diff --git a/lib/merb_core/controller/mime.rb b/lib/merb_core/controller/mime.rb
index d17570786ca318cff7201c4b1e947ae229b01de8..ff9abe4d1c452aeabfcf5f7dc7a2c7cdd3f67035 100644
--- a/lib/merb_core/controller/mime.rb
+++ b/lib/merb_core/controller/mime.rb
@@ -8,7 +8,7 @@ module Merb
# Any specific outgoing headers should be included here. These are not
# the content-type header but anything in addition to it.
- # +tranform_method+ should be set to a symbol of the method used to
+ # +transform_method+ should be set to a symbol of the method used to
# transform a resource into this mime type.
# For example for the :xml mime type an object might be transformed by
# calling :to_xml, or for the :js mime type, :to_json.
@@ -71,27 +71,6 @@ module Merb
def mime_by_request_header(header)
available_mime_types.find {|key,info| info[request_headers].include?(header)}.first
end
-
- # Resets the default mime-types
- #
- # By default, the mime-types include:
- # :all:: no transform, */*
- # :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
- # :js:: to_json, text/javascript ot application/javascript or application/x-javascript
- # :json:: to_json, application/json or text/x-json
- def reset_default_mime_types!
- available_mime_types.clear
- 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])
- end
end
end
\ No newline at end of file
diff --git a/lib/merb_core/controller/mixins/render.rb b/lib/merb_core/controller/mixins/render.rb
index 8e096546d4647bb597ab2e00a4b15d09db35e9c9..a298263af7d655d9ce43007554f3827046831287 100644
--- a/lib/merb_core/controller/mixins/render.rb
+++ b/lib/merb_core/controller/mixins/render.rb
@@ -51,21 +51,22 @@ module Merb::RenderMixin
# 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
# Do we have a template to try to render?
if thing.is_a?(Symbol) || opts[:template]
-
+
# Find a template path to look up (_template_location adds flexibility here)
- template_location = _template_root / (opts[:template] || _template_location(thing))
+ template_location = _template_root / (opts[:template] || _template_location(thing, content_type))
+
# Get the method name from the previously inlined list
template_method = Merb::Template.template_for(template_location)
# Raise an error if there's no template
raise TemplateNotFound, "No template found at #{template_location}" unless
- self.respond_to?(template_method)
+ template_method && self.respond_to?(template_method)
# Call the method in question and throw the content for later consumption by the layout
throw_content(:for_layout, self.send(template_method))
diff --git a/lib/merb_core/controller/mixins/responder.rb b/lib/merb_core/controller/mixins/responder.rb
index e910b2b32c844ab51cf2a10d0ad26c314dbb3631..5ac67fb907aaf9f95effc7eb3cbb07b8963ce022 100644
--- a/lib/merb_core/controller/mixins/responder.rb
+++ b/lib/merb_core/controller/mixins/responder.rb
@@ -97,6 +97,8 @@ module Merb
# and none of the provides methods can be used.
module ResponderMixin
+ TYPES = {}
+
class ContentTypeAlreadySet < StandardError; end
# ==== Parameters
@@ -105,6 +107,7 @@ module Merb
base.extend(ClassMethods)
base.class_eval do
class_inheritable_accessor :class_provided_formats
+ self.class_provided_formats = []
end
base.reset_provides
end
@@ -178,171 +181,253 @@ module Merb
def reset_provides
only_provides(:html)
end
-
- # ==== Returns
- # The current list of formats provided for this instance of the controller.
- # It starts with what has been set in the controller (or :html by default)
- # but can be modifed on a per-action basis.
- def _provided_formats
- @_provided_formats ||= class_provided_formats.dup
+ end
+
+ # ==== Returns
+ # The current list of formats provided for this instance of the controller.
+ # It starts with what has been set in the controller (or :html by default)
+ # but can be modifed on a per-action basis.
+ def _provided_formats
+ @_provided_formats ||= class_provided_formats.dup
+ end
+
+ # Sets the provided formats for this action. Usually, you would
+ # use a combination of +provides+, +only_provides+ and +does_not_provide+
+ # to manage this, but you can set it directly.
+ #
+ # ==== Parameters
+ # *formats<Symbol>:: A list of formats to be passed to provides
+ #
+ # ==== Raises
+ # Merb::ResponderMixin::ContentTypeAlreadySet::
+ # Content negotiation already occured, and the content_type is set.
+ #
+ # ==== Returns
+ # Array:: List of formats passed in
+ def _set_provided_formats(*formats)
+ if @_content_type
+ raise ContentTypeAlreadySet, "Cannot modify provided_formats because content_type has already been set"
end
-
- # Sets the provided formats for this action. Usually, you would
- # use a combination of +provides+, +only_provides+ and +does_not_provide+
- # to manage this, but you can set it directly.
- #
- # ==== Parameters
- # *formats<Symbol>:: A list of formats to be passed to provides
- #
- # ==== Raises
- # Merb::ResponderMixin::ContentTypeAlreadySet::
- # Content negotiation already occured, and the content_type is set.
- #
- # ==== Returns
- # Array:: List of formats passed in
- def _set_provided_formats(*formats)
- if @_content_type
- raise ContentTypeAlreadySet, "Cannot modify provided_formats because content_type has already been set"
- end
- @_provided_formats = []
- provides(*formats)
+ @_provided_formats = []
+ provides(*formats)
+ end
+ alias :_provided_formats= :_set_provided_formats
+
+ # Adds formats to the list of provided formats for this particular
+ # request. Usually used to add formats to a single action. See also
+ # the controller-level provides that affects all actions in a controller.
+ #
+ # ==== Parameters
+ # *formats<Symbol>:: A list of formats to add to the per-action list
+ # of provided formats
+ #
+ # ==== Raises
+ # Merb::ResponderMixin::ContentTypeAlreadySet::
+ # Content negotiation already occured, and the content_type is set.
+ #
+ # ==== Returns
+ # Array:: List of formats passed in
+ #
+ #---
+ # @public
+ def provides(*formats)
+ if @_content_type
+ raise ContentTypeAlreadySet, "Cannot modify provided_formats because content_type has already been set"
end
- alias :_provided_formats= :_set_provided_formats
-
- # Adds formats to the list of provided formats for this particular
- # request. Usually used to add formats to a single action. See also
- # the controller-level provides that affects all actions in a controller.
- #
- # ==== Parameters
- # *formats<Symbol>:: A list of formats to add to the per-action list
- # of provided formats
- #
- # ==== Raises
- # Merb::ResponderMixin::ContentTypeAlreadySet::
- # Content negotiation already occured, and the content_type is set.
- #
- # ==== Returns
- # Array:: List of formats passed in
- #
- #---
- # @public
- def provides(*formats)
- if @_content_type
- raise ContentTypeAlreadySet, "Cannot modify provided_formats because content_type has already been set"
- end
- formats.each do |fmt|
- _provided_formats << fmt unless _provided_formats.include?(fmt)
- end
+ formats.each do |fmt|
+ _provided_formats << fmt unless _provided_formats.include?(fmt)
end
+ end
- # Sets list of provided formats for this particular
- # request. Usually used to limit formats to a single action. See also
- # the controller-level only_provides that affects all actions
- # in a controller.
- #
- # ==== Parameters
- # *formats<Symbol>:: A list of formats to use as the per-action list
- # of provided formats
- #
- # ==== Returns
- # Array:: List of formats passed in
- #
- #---
- # @public
- def only_provides(*formats)
- self._provided_formats = *formats
- end
-
- # Removes formats from the list of provided formats for this particular
- # request. Usually used to remove formats from a single action. See
- # also the controller-level does_not_provide that affects all actions in a
- # controller.
- #
- # ==== Parameters
- # *formats<Symbol>:: Registered mime-type
- #
- # ==== Returns
- # Array:: List of formats that remain after removing the ones not to provide
- #
- #---
- # @public
- def does_not_provide(*formats)
- formats.flatten!
- self._provided_formats -= formats
- end
-
- # Do the content negotiation:
- # 1. if params[:format] is there, and provided, use it
- # 2. Parse the Accept header
- # 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:
- raise Merb::ControllerExceptions::NotAcceptable if provided_formats.empty?
- if fmt = params[:format]
- return fmt.to_sym if provided_formats.include?(fmt.to_sym)
- else
- accepts = Responder.parse(request.accept).map {|t| t.to_sym}
- return provided_formats.first if accepts.include?(:all)
- return accepts.each { |type| break type if provided_formats.include?(type) }
- end
- raise Merb::ControllerExceptions::NotAcceptable
+ # Sets list of provided formats for this particular
+ # request. Usually used to limit formats to a single action. See also
+ # the controller-level only_provides that affects all actions
+ # in a controller.
+ #
+ # ==== Parameters
+ # *formats<Symbol>:: A list of formats to use as the per-action list
+ # of provided formats
+ #
+ # ==== Returns
+ # Array:: List of formats passed in
+ #
+ #---
+ # @public
+ def only_provides(*formats)
+ self._provided_formats = *formats
+ end
+
+ # Removes formats from the list of provided formats for this particular
+ # request. Usually used to remove formats from a single action. See
+ # also the controller-level does_not_provide that affects all actions in a
+ # controller.
+ #
+ # ==== Parameters
+ # *formats<Symbol>:: Registered mime-type
+ #
+ # ==== Returns
+ # Array:: List of formats that remain after removing the ones not to provide
+ #
+ #---
+ # @public
+ def does_not_provide(*formats)
+ formats.flatten!
+ self._provided_formats -= formats
+ end
+
+ # Do the content negotiation:
+ # 1. if params[:format] is there, and provided, use it
+ # 2. Parse the Accept header
+ # 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:
+ raise Merb::ControllerExceptions::NotAcceptable if _provided_formats.empty?
+ if fmt = params[:format] && _provided_formats.include?(fmt.to_sym)
+ return fmt.to_sym
end
+ accepts = Responder.parse(request.accept).map {|t| t.to_sym}
+ return _provided_formats.first if accepts.include?(:all)
+ (accepts & _provided_formats).first || (raise Merb::ControllerExceptions::NotAcceptable)
+ end
- # Returns the output format for this request, based on the
- # provided formats, <tt>params[:format]</tt> and the client's HTTP
- # Accept header.
- #
- # The first time this is called, it triggers content negotiation
- # and caches the value. Once you call +content_type+ you can
- # not set or change the list of provided formats.
- #
- # Called automatically by +render+, so you should only call it if
- # you need the value, not to trigger content negotiation.
- #
- # ==== Parameters
- # fmt<String?>::
- # An optional format to use instead of performing content negotiation.
- # This can be used to pass in the values of opts[:format] from the
- # render function to short-circuit content-negotiation when it's not
- # necessary. This optional parameter should not be considered part
- # of the public API.
- #
- # ==== Returns
- # Symbol:: The content-type that will be used for this controller.
- #
- #---
- # @public
- def content_type(fmt = nil)
- self.content_type = (fmt || _perform_content_negotiation) unless @_content_type
- @_content_type
+ # Returns the output format for this request, based on the
+ # provided formats, <tt>params[:format]</tt> and the client's HTTP
+ # Accept header.
+ #
+ # The first time this is called, it triggers content negotiation
+ # and caches the value. Once you call +content_type+ you can
+ # not set or change the list of provided formats.
+ #
+ # Called automatically by +render+, so you should only call it if
+ # you need the value, not to trigger content negotiation.
+ #
+ # ==== Parameters
+ # fmt<String?>::
+ # An optional format to use instead of performing content negotiation.
+ # This can be used to pass in the values of opts[:format] from the
+ # render function to short-circuit content-negotiation when it's not
+ # necessary. This optional parameter should not be considered part
+ # of the public API.
+ #
+ # ==== Returns
+ # Symbol:: The content-type that will be used for this controller.
+ #
+ #---
+ # @public
+ def content_type(fmt = nil)
+ @_content_type = (fmt || _perform_content_negotiation) unless @_content_type
+ @_content_type
+ end
+
+ # Sets the content type of the current response to a value based on
+ # a passed in key. The Content-Type header will be set to the first
+ # registered header for the mime-type.
+ #
+ # ==== Parameters
+ # type<Symbol>:: A type that is in the list of registered mime-types.
+ #
+ # ==== Raises
+ # ArgumentError:: "type" is not in the list of registered mime-types.
+ #
+ # ==== Returns
+ # Symbol:: The content-type that was passed in.
+ #
+ #---
+ # @semipublic
+ 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].first
+ @_content_type = type
+ end
+
+ end
+
+ class Responder
+
+ protected
+ def self.parse(accept_header)
+ # parse the raw accept header into a unique, sorted array of AcceptType objects
+ list = accept_header.to_s.split(/,/).enum_for(:each_with_index).map do |entry,index|
+ AcceptType.new(entry,index += 1)
+ end.sort.uniq
+ # firefox (and possibly other browsers) send broken default accept headers.
+ # fix them up by sorting alternate xml forms (namely application/xhtml+xml)
+ # ahead of pure xml types (application/xml,text/xml).
+ if app_xml = list.detect{|e| e.super_range == 'application/xml'}
+ list.select{|e| e.to_s =~ /\+xml/}.each { |acc_type|
+ list[list.index(acc_type)],list[list.index(app_xml)] =
+ list[list.index(app_xml)],list[list.index(acc_type)] }
end
-
- # Sets the content type of the current response to a value based on
- # a passed in key. The Content-Type header will be set to the first
- # registered header for the mime-type.
- #
- # ==== Parameters
- # type<Symbol>:: A type that is in the list of registered mime-types.
- #
- # ==== Raises
- # ArgumentError:: "type" is not in the list of registered mime-types.
- #
- # ==== Returns
- # Symbol:: The content-type that was passed in.
- #
- #---
- # @semipublic
- 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].first
- @_content_type = type
+ list
+ end
+
+ public
+ def self.params_to_query_string(value, prefix = nil)
+ case value
+ when Array
+ value.map { |v|
+ params_to_query_string(v, "#{prefix}[]")
+ } * "&"
+ when Hash
+ value.map { |k, v|
+ params_to_query_string(v, prefix ? "#{prefix}[#{Merb::Request.escape(k)}]" : Merb::Request.escape(k))
+ } * "&"
+ else
+ "#{prefix}=#{Merb::Request.escape(value)}"
end
+ end
- end
+ end
+
+ class AcceptType
+
+ attr_reader :media_range, :quality, :index, :type, :sub_type
+ def initialize(entry,index)
+ @index = index
+ @media_range, quality = entry.split(/;\s*q=/).map{|a| a.strip }
+ @type, @sub_type = @media_range.split(/\//)
+ quality ||= 0.0 if @media_range == '*/*'
+ @quality = ((quality || 1.0).to_f * 100).to_i
+ end
+
+ def <=>(entry)
+ c = entry.quality <=> quality
+ c = index <=> entry.index if c == 0
+ c
+ end
+
+ def eql?(entry)
+ synonyms.include?(entry.media_range)
+ end
+
+ def ==(entry); eql?(entry); end
+
+ def hash; super_range.hash; end
+
+ def synonyms
+ @syns ||= Merb.available_mime_types.values.map do |e|
+ e[:request_headers] if e[:request_headers].include?(@media_range)
+ end.compact.flatten
+ end
+
+ def super_range
+ synonyms.first || @media_range
+ end
+
+ def to_sym
+ Merb.available_mime_types.select{|k,v|
+ v[:request_headers] == synonyms || v[:request_headers][0] == synonyms[0]}.flatten.first
+ end
+
+ def to_s
+ @media_range
+ end
+
end
+
end
\ No newline at end of file
diff --git a/lib/merb_core/dispatch/dispatcher.rb b/lib/merb_core/dispatch/dispatcher.rb
index c458c9f9ad454d3b0c3055d6b2a8e88b17712b44..f7fed0f539a20f9cce08b72c551725ad0563bf37 100644
--- a/lib/merb_core/dispatch/dispatcher.rb
+++ b/lib/merb_core/dispatch/dispatcher.rb
@@ -33,10 +33,10 @@ class Merb::Dispatcher
# this is the custom dispatch_exception; it allows failures to still be dispatched
# to the error controller
- rescue => exception
- Merb.logger.error(Merb.exception(exception))
- exception = controller_exception(exception)
- dispatch_exception(request, response, exception)
+ # rescue => exception
+ # Merb.logger.error(Merb.exception(exception))
+ # exception = controller_exception(exception)
+ # dispatch_exception(request, response, exception)
end
private
@@ -49,10 +49,10 @@ class Merb::Dispatcher
def dispatch_action(klass, action, request, response, status=200)
# build controller
controller = klass.build(request, response, status)
- if @@use_mutex
- @@mutex.synchronize { controller.dispatch(action) }
+ if use_mutex
+ @@mutex.synchronize { controller._dispatch(action) }
else
- controller.dispatch(action)
+ controller._dispatch(action)
end
[controller, action]
end
diff --git a/lib/merb_core/rack/adapter.rb b/lib/merb_core/rack/adapter.rb
index ffc7117e9733e83b0567bbe4a43fac7663800b7d..217399a5382d0b3878aaea3d3e302173c5b5f119 100644
--- a/lib/merb_core/rack/adapter.rb
+++ b/lib/merb_core/rack/adapter.rb
@@ -40,7 +40,7 @@ module Merb
begin
controller, action = ::Merb::Dispatcher.handle(request, response)
rescue Object => e
- return [500, {"Content-Type"=>"text/html"}, "Internal Server Error"]
+ return [500, {"Content-Type"=>"text/html"}, e.message + "<br/>" + e.backtrace.join("<br/>")]
end
[controller.status, controller.headers, controller.body]
end
diff --git a/lib/merb_core/test/request_helper.rb b/lib/merb_core/test/request_helper.rb
index 10a9fb3ace56eaf1db0fa300df3fb2ab88a7118a..f302a3b71539182ba142cd208fe6d6aae171b1a1 100644
--- a/lib/merb_core/test/request_helper.rb
+++ b/lib/merb_core/test/request_helper.rb
@@ -26,8 +26,10 @@ module Merb::Test::RequestHelper
Merb::Test::FakeRequest.new(env, StringIO.new(req))
end
- def dispatch_to(controller_klass, action, env = {}, opt = {}, &blk)
- request = fake_request(env, opt)
+ def dispatch_to(controller_klass, action, params = {}, env = {}, &blk)
+ request = fake_request(env,
+ :query_string => Merb::Responder.params_to_query_string(params))
+
controller = controller_klass.build(request)
controller.instance_eval(&blk) if block_given?
controller._dispatch(action)
diff --git a/spec/public/abstract_controller/spec_helper.rb b/spec/public/abstract_controller/spec_helper.rb
index df759008d14e7572b5c44de24f77f828f83f1682..694cee2592a210a5c1fa40ca7846beeaa09725fe 100644
--- a/spec/public/abstract_controller/spec_helper.rb
+++ b/spec/public/abstract_controller/spec_helper.rb
@@ -1,12 +1,10 @@
__DIR__ = File.dirname(__FILE__)
require File.join(__DIR__, "..", "..", "spec_helper")
-# The framework structure *must* be set up before loading in framework
-# files.
require File.join(__DIR__, "controllers", "filters")
require File.join(__DIR__, "controllers", "render")
-Merb::BootLoader::Templates.new.run
+Merb::BootLoader::Templates.run
module Merb::Test::Behaviors
def dispatch_should_make_body(klass, body, action = :index)
diff --git a/spec/public/controller/base_spec.rb b/spec/public/controller/base_spec.rb
index 1709e612629ed2c2b6af4579a8b89684aca9aa3c..5bcdb59948cc22592639b1aee9bd233ff2c306fa 100644
--- a/spec/public/controller/base_spec.rb
+++ b/spec/public/controller/base_spec.rb
@@ -10,11 +10,11 @@ describe Merb::Controller, " callable actions" do
end
it "should dispatch to callable actions" do
- dispatch_to(Merb::Test::Fixtures::TestFoo, :index).body.should == "index"
+ dispatch_to(Merb::Test::Fixtures::TestBase, :index).body.should == "index"
end
it "should not dispatch to hidden actions" do
- calling { dispatch_to(Merb::Test::Fixtures::TestFoo, :hidden) }.
+ calling { dispatch_to(Merb::Test::Fixtures::TestBase, :hidden) }.
should raise_error(Merb::ControllerExceptions::ActionNotFound)
end
diff --git a/spec/public/controller/controllers/base.rb b/spec/public/controller/controllers/base.rb
index a1b3beb27899df781d943427d9b23945f02e14de..c4b69a440a9da3c3486208d2cb95ccb8bdb974b9 100644
--- a/spec/public/controller/controllers/base.rb
+++ b/spec/public/controller/controllers/base.rb
@@ -3,7 +3,7 @@ module Merb::Test::Fixtures
self._template_root = File.dirname(__FILE__) / "views"
end
- class TestFoo < ControllerTesting
+ class TestBase < ControllerTesting
def index
"index"
end
diff --git a/spec/public/controller/controllers/responder.rb b/spec/public/controller/controllers/responder.rb
new file mode 100644
index 0000000000000000000000000000000000000000..867192e8f6e995a43fd5cd3daffa0ec11b3d31e5
--- /dev/null
+++ b/spec/public/controller/controllers/responder.rb
@@ -0,0 +1,25 @@
+module Merb::Test::Fixtures
+ class ControllerTesting < Merb::Controller
+ self._template_root = File.dirname(__FILE__) / "views"
+ end
+
+ class TestResponder < ControllerTesting
+ def index
+ render
+ end
+ end
+
+ class TestHtmlDefault < TestResponder; end
+
+ class TestClassProvides < TestResponder;
+ provides :xml
+ end
+
+ class TestLocalProvides < TestResponder;
+ def index
+ provides :xml
+ render
+ end
+ end
+
+end
\ No newline at end of file
diff --git a/spec/public/controller/controllers/views/merb/test/fixtures/test_class_provides/index.html.erb b/spec/public/controller/controllers/views/merb/test/fixtures/test_class_provides/index.html.erb
new file mode 100644
index 0000000000000000000000000000000000000000..1bfb77d4a44c444bba6888ae7740f7df4b074c58
--- /dev/null
+++ b/spec/public/controller/controllers/views/merb/test/fixtures/test_class_provides/index.html.erb
@@ -0,0 +1 @@
+This should not be rendered
\ No newline at end of file
diff --git a/spec/public/controller/controllers/views/merb/test/fixtures/test_class_provides/index.xml.erb b/spec/public/controller/controllers/views/merb/test/fixtures/test_class_provides/index.xml.erb
new file mode 100644
index 0000000000000000000000000000000000000000..7c91f633987348e87e5e34e1d9e87d9dd0e5100c
--- /dev/null
+++ b/spec/public/controller/controllers/views/merb/test/fixtures/test_class_provides/index.xml.erb
@@ -0,0 +1 @@
+<XML:Class provides='true' />
\ No newline at end of file
diff --git a/spec/public/controller/controllers/views/merb/test/fixtures/test_html_default/index.html.erb b/spec/public/controller/controllers/views/merb/test/fixtures/test_html_default/index.html.erb
new file mode 100644
index 0000000000000000000000000000000000000000..eb4b52bf5a7aaba8f1706de419f42789c05684a2
--- /dev/null
+++ b/spec/public/controller/controllers/views/merb/test/fixtures/test_html_default/index.html.erb
@@ -0,0 +1 @@
+HTML: Default
\ No newline at end of file
diff --git a/spec/public/controller/controllers/views/merb/test/fixtures/test_local_provides/index.html.erb b/spec/public/controller/controllers/views/merb/test/fixtures/test_local_provides/index.html.erb
new file mode 100644
index 0000000000000000000000000000000000000000..a3a841a89c62e6174038935a42da9cd24ff54413
--- /dev/null
+++ b/spec/public/controller/controllers/views/merb/test/fixtures/test_local_provides/index.html.erb
@@ -0,0 +1 @@
+This should not render
\ No newline at end of file
diff --git a/spec/public/controller/controllers/views/merb/test/fixtures/test_local_provides/index.xml.erb b/spec/public/controller/controllers/views/merb/test/fixtures/test_local_provides/index.xml.erb
new file mode 100644
index 0000000000000000000000000000000000000000..c1384ec6af0357b585cc367035d1bc3a30347ade
--- /dev/null
+++ b/spec/public/controller/controllers/views/merb/test/fixtures/test_local_provides/index.xml.erb
@@ -0,0 +1 @@
+<XML:Local provides='true' />
\ No newline at end of file
diff --git a/spec/public/controller/responder_spec.rb b/spec/public/controller/responder_spec.rb
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..bcf18532442e5965cf6ca8501770d7b7a1eb2429 100644
--- a/spec/public/controller/responder_spec.rb
+++ b/spec/public/controller/responder_spec.rb
@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Merb::Controller, " responds" do
+
+ before do
+ Merb.push_path(:layout, File.dirname(__FILE__) / "controllers" / "views" / "layouts")
+ Merb::Router.prepare do |r|
+ r.default_routes
+ end
+ end
+
+ it "should default the mime-type to HTML" do
+ dispatch_to(Merb::Test::Fixtures::TestHtmlDefault, :index).body.should == "HTML: Default"
+ end
+
+ it "should use other mime-types if they are provided on the class level" do
+ controller = dispatch_to(Merb::Test::Fixtures::TestClassProvides, :index, {}, :http_accept => "application/xml")
+ controller.body.should == "<XML:Class provides='true' />"
+ end
+
+ it "should fail if none of the acceptable mime-types are available" do
+ calling { dispatch_to(Merb::Test::Fixtures::TestClassProvides, :index, {}, :http_accept => "application/json") }.
+ should raise_error(Merb::ControllerExceptions::NotAcceptable)
+ end
+
+ it "should use mime-types that are provided at the local level" do
+ controller = dispatch_to(Merb::Test::Fixtures::TestLocalProvides, :index, {}, :http_accept => "application/xml")
+ controller.body.should == "<XML:Local provides='true' />"
+ end
+
+end
\ No newline at end of file
diff --git a/spec/public/controller/spec_helper.rb b/spec/public/controller/spec_helper.rb
index f68628a63740f4ce0235a15d71c5889e55ecaf78..e360194c1fbaf72c3298c61543c2d3a19b512b41 100644
--- a/spec/public/controller/spec_helper.rb
+++ b/spec/public/controller/spec_helper.rb
@@ -1,4 +1,10 @@
__DIR__ = File.dirname(__FILE__)
+require 'ruby-debug'
+
require File.join(__DIR__, "..", "..", "spec_helper")
-require File.join(__DIR__, "controllers", "base")
\ No newline at end of file
+require File.join(__DIR__, "controllers", "base")
+require File.join(__DIR__, "controllers", "responder")
+
+Merb::BootLoader::Templates.run
+Merb::BootLoader::MimeTypes.run
\ No newline at end of file
Reference in new issue View Git Blame Copy Permalink