Please Don't Cringe
# # <%= image_tag attachments['photo.png'].url -%> # # As we are using Action View's +image_tag+ method, you can pass in any other options you want: # #Please Don't Cringe
# # <%= image_tag attachments['photo.png'].url, alt: 'Our Photo', class: 'photo' -%> # # = Observing and Intercepting Mails # # Action Mailer provides hooks into the Mail observer and interceptor methods. These allow you to # register classes that are called during the mail delivery life cycle. # # An observer class must implement the :delivered_email(message) method which will be # called once for every email sent after the email has been sent. # # An interceptor class must implement the :delivering_email(message) method which will be # called before the email is sent, allowing you to make modifications to the email before it hits # the delivery agents. Your class should make any needed modifications directly to the passed # in Mail::Message instance. # # = Default Hash # # Action Mailer provides some intelligent defaults for your emails, these are usually specified in a # default method inside the class definition: # # class Notifier < ApplicationMailer # default sender: 'system@example.com' # end # # You can pass in any header value that a Mail::Message accepts. Out of the box, # ActionMailer::Base sets the following: # # * mime_version: "1.0" # * charset: "UTF-8", # * content_type: "text/plain", # * parts_order: [ "text/plain", "text/enriched", "text/html" ] # # parts_order and charset are not actually valid Mail::Message header fields, # but Action Mailer translates them appropriately and sets the correct values. # # As you can pass in any header, you need to either quote the header as a string, or pass it in as # an underscored symbol, so the following will work: # # class Notifier < ApplicationMailer # default 'Content-Transfer-Encoding' => '7bit', # content_description: 'This is a description' # end # # Finally, Action Mailer also supports passing Proc objects into the default hash, so you # can define methods that evaluate as the message is being generated: # # class Notifier < ApplicationMailer # default 'X-Special-Header' => Proc.new { my_method } # # private # # def my_method # 'some complex call' # end # end # # Note that the proc is evaluated right at the start of the mail message generation, so if you # set something in the defaults using a proc, and then set the same thing inside of your # mailer method, it will get over written by the mailer method. # # It is also possible to set these default options that will be used in all mailers through # the default_options= configuration in config/application.rb: # # config.action_mailer.default_options = { from: "no-reply@example.org" } # # = Callbacks # # You can specify callbacks using before_action and after_action for configuring your messages. # This may be useful, for example, when you want to add default inline attachments for all # messages sent out by a certain mailer class: # # class Notifier < ApplicationMailer # before_action :add_inline_attachment! # # def welcome # mail # end # # private # # def add_inline_attachment! # attachments.inline["footer.jpg"] = File.read('/path/to/filename.jpg') # end # end # # Callbacks in Action Mailer are implemented using # AbstractController::Callbacks, so you can define and configure # callbacks in the same manner that you would use callbacks in classes that # inherit from ActionController::Base. # # Note that unless you have a specific reason to do so, you should prefer using before_action # rather than after_action in your Action Mailer classes so that headers are parsed properly. # # = Previewing emails # # You can preview your email templates visually by adding a mailer preview file to the # ActionMailer::Base.preview_path. Since most emails do something interesting # with database data, you'll need to write some scenarios to load messages with fake data: # # class NotifierPreview < ActionMailer::Preview # def welcome # Notifier.welcome(User.first) # end # end # # Methods must return a Mail::Message object which can be generated by calling the mailer # method without the additional deliver_now / deliver_later. The location of the # mailer previews directory can be configured using the preview_path option which has a default # of test/mailers/previews: # # config.action_mailer.preview_path = "#{Rails.root}/lib/mailer_previews" # # An overview of all previews is accessible at http://localhost:3000/rails/mailers # on a running development server instance. # # Previews can also be intercepted in a similar manner as deliveries can be by registering # a preview interceptor that has a previewing_email method: # # class CssInlineStyler # def self.previewing_email(message) # # inline CSS styles # end # end # # config.action_mailer.preview_interceptors :css_inline_styler # # Note that interceptors need to be registered both with register_interceptor # and register_preview_interceptor if they should operate on both sending and # previewing emails. # # = Configuration options # # These options are specified on the class level, like # ActionMailer::Base.raise_delivery_errors = true # # * default_options - You can pass this in at a class level as well as within the class itself as # per the above section. # # * logger - the logger is used for generating information on the mailing run if available. # Can be set to +nil+ for no logging. Compatible with both Ruby's own +Logger+ and Log4r loggers. # # * smtp_settings - Allows detailed configuration for :smtp delivery method: # * :address - Allows you to use a remote mail server. Just change it from its default # "localhost" setting. # * :port - On the off chance that your mail server doesn't run on port 25, you can change it. # * :domain - If you need to specify a HELO domain, you can do it here. # * :user_name - If your mail server requires authentication, set the username in this setting. # * :password - If your mail server requires authentication, set the password in this setting. # * :authentication - If your mail server requires authentication, you need to specify the # authentication type here. # This is a symbol and one of :plain (will send the password Base64 encoded), :login (will # send the password Base64 encoded) or :cram_md5 (combines a Challenge/Response mechanism to exchange # information and a cryptographic Message Digest 5 algorithm to hash important information) # * :enable_starttls_auto - Detects if STARTTLS is enabled in your SMTP server and starts # to use it. Defaults to true. # * :openssl_verify_mode - When using TLS, you can set how OpenSSL checks the certificate. This is # really useful if you need to validate a self-signed and/or a wildcard certificate. You can use the name # of an OpenSSL verify constant ('none', 'peer', 'client_once', # 'fail_if_no_peer_cert') or directly the constant (OpenSSL::SSL::VERIFY_NONE, # OpenSSL::SSL::VERIFY_PEER, ...). # # * sendmail_settings - Allows you to override options for the :sendmail delivery method. # * :location - The location of the sendmail executable. Defaults to /usr/sbin/sendmail. # * :arguments - The command line arguments. Defaults to -i -t with -f sender@address # added automatically before the message is sent. # # * file_settings - Allows you to override options for the :file delivery method. # * :location - The directory into which emails will be written. Defaults to the application # tmp/mails. # # * raise_delivery_errors - Whether or not errors should be raised if the email fails to be delivered. # # * delivery_method - Defines a delivery method. Possible values are :smtp (default), # :sendmail, :test, and :file. Or you may provide a custom delivery method # object e.g. +MyOwnDeliveryMethodClass+. See the Mail gem documentation on the interface you need to # implement for a custom delivery agent. # # * perform_deliveries - Determines whether emails are actually sent from Action Mailer when you # call .deliver on an email message or on an Action Mailer method. This is on by default but can # be turned off to aid in functional testing. # # * deliveries - Keeps an array of all the emails sent out through the Action Mailer with # delivery_method :test. Most useful for unit and functional testing. class Base < AbstractController::Base include DeliveryMethods include Previews abstract! include AbstractController::Rendering include AbstractController::Logger include AbstractController::Helpers include AbstractController::Translation include AbstractController::AssetPaths include AbstractController::Callbacks include ActionView::Layouts PROTECTED_IVARS = AbstractController::Rendering::DEFAULT_PROTECTED_INSTANCE_VARIABLES + [:@_action_has_layout] def _protected_ivars # :nodoc: PROTECTED_IVARS end helper ActionMailer::MailHelper private_class_method :new #:nodoc: class_attribute :default_params self.default_params = { mime_version: "1.0", charset: "UTF-8", content_type: "text/plain", parts_order: [ "text/plain", "text/enriched", "text/html" ] }.freeze class << self # Register one or more Observers which will be notified when mail is delivered. def register_observers(*observers) observers.flatten.compact.each { |observer| register_observer(observer) } end # Register one or more Interceptors which will be called before mail is sent. def register_interceptors(*interceptors) interceptors.flatten.compact.each { |interceptor| register_interceptor(interceptor) } end # Register an Observer which will be notified when mail is delivered. # Either a class, string or symbol can be passed in as the Observer. # If a string or symbol is passed in it will be camelized and constantized. def register_observer(observer) delivery_observer = case observer when String, Symbol observer.to_s.camelize.constantize else observer end Mail.register_observer(delivery_observer) end # Register an Interceptor which will be called before mail is sent. # Either a class, string or symbol can be passed in as the Interceptor. # If a string or symbol is passed in it will be camelized and constantized. def register_interceptor(interceptor) delivery_interceptor = case interceptor when String, Symbol interceptor.to_s.camelize.constantize else interceptor end Mail.register_interceptor(delivery_interceptor) end # Returns the name of current mailer. This method is also being used as a path for a view lookup. # If this is an anonymous mailer, this method will return +anonymous+ instead. def mailer_name @mailer_name ||= anonymous? ? "anonymous" : name.underscore end # Allows to set the name of current mailer. attr_writer :mailer_name alias :controller_path :mailer_name # Sets the defaults through app configuration: # # config.action_mailer.default(from: "no-reply@example.org") # # Aliased by ::default_options= def default(value = nil) self.default_params = default_params.merge(value).freeze if value default_params end # Allows to set defaults through app configuration: # # config.action_mailer.default_options = { from: "no-reply@example.org" } alias :default_options= :default # Receives a raw email, parses it into an email object, decodes it, # instantiates a new mailer, and passes the email object to the mailer # object's +receive+ method. # # If you want your mailer to be able to process incoming messages, you'll # need to implement a +receive+ method that accepts the raw email string # as a parameter: # # class MyMailer < ActionMailer::Base # def receive(mail) # # ... # end # end def receive(raw_mail) ActiveSupport::Notifications.instrument("receive.action_mailer") do |payload| mail = Mail.new(raw_mail) set_payload_for_mail(payload, mail) new.receive(mail) end end # Wraps an email delivery inside of ActiveSupport::Notifications instrumentation. # # This method is actually called by the Mail::Message object itself # through a callback when you call :deliver on the Mail::Message, # calling +deliver_mail+ directly and passing a Mail::Message will do # nothing except tell the logger you sent the email. def deliver_mail(mail) #:nodoc: ActiveSupport::Notifications.instrument("deliver.action_mailer") do |payload| set_payload_for_mail(payload, mail) yield # Let Mail do the delivery actions end end def respond_to?(method, include_private = false) #:nodoc: super || action_methods.include?(method.to_s) end protected def set_payload_for_mail(payload, mail) #:nodoc: payload[:mailer] = name payload[:message_id] = mail.message_id payload[:subject] = mail.subject payload[:to] = mail.to payload[:from] = mail.from payload[:bcc] = mail.bcc if mail.bcc.present? payload[:cc] = mail.cc if mail.cc.present? payload[:date] = mail.date payload[:mail] = mail.encoded end def method_missing(method_name, *args) # :nodoc: if action_methods.include?(method_name.to_s) MessageDelivery.new(self, method_name, *args) else super end end end attr_internal :message # Instantiate a new mailer object. If +method_name+ is not +nil+, the mailer # will be initialized according to the named method. If not, the mailer will # remain uninitialized (useful when you only need to invoke the "receive" # method, for instance). def initialize(method_name=nil, *args) super() @_mail_was_called = false @_message = Mail.new process(method_name, *args) if method_name end def process(method_name, *args) #:nodoc: payload = { mailer: self.class.name, action: method_name } ActiveSupport::Notifications.instrument("process.action_mailer", payload) do lookup_context.skip_default_locale! super @_message = NullMail.new unless @_mail_was_called end end class NullMail #:nodoc: def body; '' end def header; {} end def respond_to?(string, include_all=false) true end def method_missing(*args) nil end end # Returns the name of the mailer object. def mailer_name self.class.mailer_name end # Allows you to pass random and unusual headers to the new Mail::Message # object which will add them to itself. # # headers['X-Special-Domain-Specific-Header'] = "SecretValue" # # You can also pass a hash into headers of header field names and values, # which will then be set on the Mail::Message object: # # headers 'X-Special-Domain-Specific-Header' => "SecretValue", # 'In-Reply-To' => incoming.message_id # # The resulting Mail::Message will have the following in its header: # # X-Special-Domain-Specific-Header: SecretValue # # Note about replacing already defined headers: # # * +subject+ # * +sender+ # * +from+ # * +to+ # * +cc+ # * +bcc+ # * +reply-to+ # * +orig-date+ # * +message-id+ # * +references+ # # Fields can only appear once in email headers while other fields such as # X-Anything can appear multiple times. # # If you want to replace any header which already exists, first set it to # +nil+ in order to reset the value otherwise another field will be added # for the same header. def headers(args = nil) if args @_message.headers(args) else @_message end end # Allows you to add attachments to an email, like so: # # mail.attachments['filename.jpg'] = File.read('/path/to/filename.jpg') # # If you do this, then Mail will take the file name and work out the mime type # set the Content-Type, Content-Disposition, Content-Transfer-Encoding and # base64 encode the contents of the attachment all for you. # # You can also specify overrides if you want by passing a hash instead of a string: # # mail.attachments['filename.jpg'] = {mime_type: 'application/x-gzip', # content: File.read('/path/to/filename.jpg')} # # If you want to use a different encoding than Base64, you can pass an encoding in, # but then it is up to you to pass in the content pre-encoded, and don't expect # Mail to know how to decode this data: # # file_content = SpecialEncode(File.read('/path/to/filename.jpg')) # mail.attachments['filename.jpg'] = {mime_type: 'application/x-gzip', # encoding: 'SpecialEncoding', # content: file_content } # # You can also search for specific attachments: # # # By Filename # mail.attachments['filename.jpg'] # => Mail::Part object or nil # # # or by index # mail.attachments[0] # => Mail::Part (first attachment) # def attachments if @_mail_was_called LateAttachmentsProxy.new(@_message.attachments) else @_message.attachments end end class LateAttachmentsProxy < SimpleDelegator def inline; _raise_error end def []=(_name, _content); _raise_error end private def _raise_error raise RuntimeError, "Can't add attachments after `mail` was called.\n" \ "Make sure to use `attachments[]=` before calling `mail`." end end # The main method that creates the message and renders the email templates. There are # two ways to call this method, with a block, or without a block. # # It accepts a headers hash. This hash allows you to specify # the most used headers in an email message, these are: # # * +:subject+ - The subject of the message, if this is omitted, Action Mailer will # ask the Rails I18n class for a translated +:subject+ in the scope of # [mailer_scope, action_name] or if this is missing, will translate the # humanized version of the +action_name+ # * +:to+ - Who the message is destined for, can be a string of addresses, or an array # of addresses. # * +:from+ - Who the message is from # * +:cc+ - Who you would like to Carbon-Copy on this email, can be a string of addresses, # or an array of addresses. # * +:bcc+ - Who you would like to Blind-Carbon-Copy on this email, can be a string of # addresses, or an array of addresses. # * +:reply_to+ - Who to set the Reply-To header of the email to. # * +:date+ - The date to say the email was sent on. # # You can set default values for any of the above headers (except +:date+) # by using the ::default class method: # # class Notifier < ActionMailer::Base # default from: 'no-reply@test.lindsaar.net', # bcc: 'email_logger@test.lindsaar.net', # reply_to: 'bounces@test.lindsaar.net' # end # # If you need other headers not listed above, you can either pass them in # as part of the headers hash or use the headers['name'] = value # method. # # When a +:return_path+ is specified as header, that value will be used as # the 'envelope from' address for the Mail message. Setting this is useful # when you want delivery notifications sent to a different address than the # one in +:from+. Mail will actually use the +:return_path+ in preference # to the +:sender+ in preference to the +:from+ field for the 'envelope # from' value. # # If you do not pass a block to the +mail+ method, it will find all # templates in the view paths using by default the mailer name and the # method name that it is being called from, it will then create parts for # each of these templates intelligently, making educated guesses on correct # content type and sequence, and return a fully prepared Mail::Message # ready to call :deliver on to send. # # For example: # # class Notifier < ActionMailer::Base # default from: 'no-reply@test.lindsaar.net' # # def welcome # mail(to: 'mikel@test.lindsaar.net') # end # end # # Will look for all templates at "app/views/notifier" with name "welcome". # If no welcome template exists, it will raise an ActionView::MissingTemplate error. # # However, those can be customized: # # mail(template_path: 'notifications', template_name: 'another') # # And now it will look for all templates at "app/views/notifications" with name "another". # # If you do pass a block, you can render specific templates of your choice: # # mail(to: 'mikel@test.lindsaar.net') do |format| # format.text # format.html # end # # You can even render plain text directly without using a template: # # mail(to: 'mikel@test.lindsaar.net') do |format| # format.text { render plain: "Hello Mikel!" } # format.html { render html: "Hello Mikel!
".html_safe } # end # # Which will render a +multipart/alternative+ email with +text/plain+ and # +text/html+ parts. # # The block syntax also allows you to customize the part headers if desired: # # mail(to: 'mikel@test.lindsaar.net') do |format| # format.text(content_transfer_encoding: "base64") # format.html # end # def mail(headers = {}, &block) return @_message if @_mail_was_called && headers.blank? && !block m = @_message # At the beginning, do not consider class default for content_type content_type = headers[:content_type] # Call all the procs (if any) default_values = {} self.class.default.each do |k,v| default_values[k] = v.is_a?(Proc) ? instance_eval(&v) : v end # Handle defaults headers = headers.reverse_merge(default_values) headers[:subject] ||= default_i18n_subject # Apply charset at the beginning so all fields are properly quoted m.charset = charset = headers[:charset] # Set configure delivery behavior wrap_delivery_behavior!(headers.delete(:delivery_method), headers.delete(:delivery_method_options)) # Assign all headers except parts_order, content_type and body assignable = headers.except(:parts_order, :content_type, :body, :template_name, :template_path) assignable.each { |k, v| m[k] = v } # Render the templates and blocks responses = collect_responses(headers, &block) @_mail_was_called = true create_parts_from_responses(m, responses) # Setup content type, reapply charset and handle parts order m.content_type = set_content_type(m, content_type, headers[:content_type]) m.charset = charset if m.multipart? m.body.set_sort_order(headers[:parts_order]) m.body.sort_parts! end m end protected # Used by #mail to set the content type of the message. # # It will use the given +user_content_type+, or multipart if the mail # message has any attachments. If the attachments are inline, the content # type will be "multipart/related", otherwise "multipart/mixed". # # If there is no content type passed in via headers, and there are no # attachments, or the message is multipart, then the default content type is # used. def set_content_type(m, user_content_type, class_default) params = m.content_type_parameters || {} case when user_content_type.present? user_content_type when m.has_attachments? if m.attachments.detect { |a| a.inline? } ["multipart", "related", params] else ["multipart", "mixed", params] end when m.multipart? ["multipart", "alternative", params] else m.content_type || class_default end end # Translates the +subject+ using Rails I18n class under [mailer_scope, action_name] scope. # If it does not find a translation for the +subject+ under the specified scope it will default to a # humanized version of the action_name. # If the subject has interpolations, you can pass them through the +interpolations+ parameter. def default_i18n_subject(interpolations = {}) mailer_scope = self.class.mailer_name.tr('/', '.') I18n.t(:subject, interpolations.merge(scope: [mailer_scope, action_name], default: action_name.humanize)) end def collect_responses(headers) #:nodoc: responses = [] if block_given? collector = ActionMailer::Collector.new(lookup_context) { render(action_name) } yield(collector) responses = collector.responses elsif headers[:body] responses << { body: headers.delete(:body), content_type: self.class.default[:content_type] || "text/plain" } else templates_path = headers.delete(:template_path) || self.class.mailer_name templates_name = headers.delete(:template_name) || action_name each_template(Array(templates_path), templates_name) do |template| self.formats = template.formats responses << { body: render(template: template), content_type: template.type.to_s } end end responses end def each_template(paths, name, &block) #:nodoc: templates = lookup_context.find_all(name, paths) if templates.empty? raise ActionView::MissingTemplate.new(paths, name, paths, false, 'mailer') else templates.uniq { |t| t.formats }.each(&block) end end def create_parts_from_responses(m, responses) #:nodoc: if responses.size == 1 && !m.has_attachments? responses[0].each { |k,v| m[k] = v } elsif responses.size > 1 && m.has_attachments? container = Mail::Part.new container.content_type = "multipart/alternative" responses.each { |r| insert_part(container, r, m.charset) } m.add_part(container) else responses.each { |r| insert_part(m, r, m.charset) } end end def insert_part(container, response, charset) #:nodoc: response[:charset] ||= charset part = Mail::Part.new(response) container.add_part(part) end # Emails do not support relative path links. def self.supports_path? false end ActiveSupport.run_load_hooks(:action_mailer, self) end end rails-4.2.10/actionmailer/lib/action_mailer/collector.rb 0000664 0000000 0000000 00000001531 13162731520 0023246 0 ustar 00root root 0000000 0000000 require 'abstract_controller/collector' require 'active_support/core_ext/hash/reverse_merge' require 'active_support/core_ext/array/extract_options' module ActionMailer class Collector include AbstractController::Collector attr_reader :responses def initialize(context, &block) @context = context @responses = [] @default_render = block end def any(*args, &block) options = args.extract_options! raise ArgumentError, "You have to supply at least one format" if args.empty? args.each { |type| send(type, options.dup, &block) } end alias :all :any def custom(mime, options = {}) options.reverse_merge!(content_type: mime.to_s) @context.formats = [mime.to_sym] options[:body] = block_given? ? yield : @default_render.call @responses << options end end end rails-4.2.10/actionmailer/lib/action_mailer/delivery_job.rb 0000664 0000000 0000000 00000000632 13162731520 0023736 0 ustar 00root root 0000000 0000000 require 'active_job' module ActionMailer # The ActionMailer::DeliveryJob class is used when you # want to send emails outside of the request-response cycle. class DeliveryJob < ActiveJob::Base # :nodoc: queue_as :mailers def perform(mailer, mail_method, delivery_method, *args) # :nodoc: mailer.constantize.public_send(mail_method, *args).send(delivery_method) end end end rails-4.2.10/actionmailer/lib/action_mailer/delivery_methods.rb 0000664 0000000 0000000 00000005557 13162731520 0024642 0 ustar 00root root 0000000 0000000 require 'tmpdir' module ActionMailer # This module handles everything related to mail delivery, from registering # new delivery methods to configuring the mail object to be sent. module DeliveryMethods extend ActiveSupport::Concern included do class_attribute :delivery_methods, :delivery_method # Do not make this inheritable, because we always want it to propagate cattr_accessor :raise_delivery_errors self.raise_delivery_errors = true cattr_accessor :perform_deliveries self.perform_deliveries = true self.delivery_methods = {}.freeze self.delivery_method = :smtp add_delivery_method :smtp, Mail::SMTP, address: "localhost", port: 25, domain: 'localhost.localdomain', user_name: nil, password: nil, authentication: nil, enable_starttls_auto: true add_delivery_method :file, Mail::FileDelivery, location: defined?(Rails.root) ? "#{Rails.root}/tmp/mails" : "#{Dir.tmpdir}/mails" add_delivery_method :sendmail, Mail::Sendmail, location: '/usr/sbin/sendmail', arguments: '-i' add_delivery_method :test, Mail::TestMailer end # Helpers for creating and wrapping delivery behavior, used by DeliveryMethods. module ClassMethods # Provides a list of emails that have been delivered by Mail::TestMailer delegate :deliveries, :deliveries=, to: Mail::TestMailer # Adds a new delivery method through the given class using the given # symbol as alias and the default options supplied. # # add_delivery_method :sendmail, Mail::Sendmail, # location: '/usr/sbin/sendmail', # arguments: '-i -t' def add_delivery_method(symbol, klass, default_options={}) class_attribute(:"#{symbol}_settings") unless respond_to?(:"#{symbol}_settings") send(:"#{symbol}_settings=", default_options) self.delivery_methods = delivery_methods.merge(symbol.to_sym => klass).freeze end def wrap_delivery_behavior(mail, method=nil, options=nil) # :nodoc: method ||= self.delivery_method mail.delivery_handler = self case method when NilClass raise "Delivery method cannot be nil" when Symbol if klass = delivery_methods[method] mail.delivery_method(klass, (send(:"#{method}_settings") || {}).merge(options || {})) else raise "Invalid delivery method #{method.inspect}" end else mail.delivery_method(method) end mail.perform_deliveries = perform_deliveries mail.raise_delivery_errors = raise_delivery_errors end end def wrap_delivery_behavior!(*args) # :nodoc: self.class.wrap_delivery_behavior(message, *args) end end end rails-4.2.10/actionmailer/lib/action_mailer/gem_version.rb 0000664 0000000 0000000 00000000500 13162731520 0023570 0 ustar 00root root 0000000 0000000 module ActionMailer # Returns the version of the currently loaded Action Mailer as a Gem::Version def self.gem_version Gem::Version.new VERSION::STRING end module VERSION MAJOR = 4 MINOR = 2 TINY = 10 PRE = nil STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".") end end rails-4.2.10/actionmailer/lib/action_mailer/inline_preview_interceptor.rb 0000664 0000000 0000000 00000002636 13162731520 0026724 0 ustar 00root root 0000000 0000000 require 'base64' module ActionMailer # Implements a mailer preview interceptor that converts image tag src attributes # that use inline cid: style urls to data: style urls so that they are visible # when previewing a HTML email in a web browser. # # This interceptor is not enabled by default, to use it just register it like any # other mailer preview interceptor: # # ActionMailer::Base.register_preview_interceptor(ActionMailer::InlinePreviewInterceptor) # class InlinePreviewInterceptor PATTERN = /src=(?:"cid:[^"]+"|'cid:[^']+')/i include Base64 def self.previewing_email(message) #:nodoc: new(message).transform! end def initialize(message) #:nodoc: @message = message end def transform! #:nodoc: return message if html_part.blank? html_source.gsub!(PATTERN) do |match| if part = find_part(match[9..-2]) %[src="#{data_url(part)}"] else match end end message end private def message @message end def html_part @html_part ||= message.html_part end def html_source html_part.body.raw_source end def data_url(part) "data:#{part.mime_type};base64,#{strict_encode64(part.body.raw_source)}" end def find_part(cid) message.all_parts.find{ |p| p.attachment? && p.cid == cid } end end end rails-4.2.10/actionmailer/lib/action_mailer/log_subscriber.rb 0000664 0000000 0000000 00000002062 13162731520 0024264 0 ustar 00root root 0000000 0000000 require 'active_support/log_subscriber' module ActionMailer # Implements the ActiveSupport::LogSubscriber for logging notifications when # email is delivered and received. class LogSubscriber < ActiveSupport::LogSubscriber # An email was delivered. def deliver(event) info do recipients = Array(event.payload[:to]).join(', ') "\nSent mail to #{recipients} (#{event.duration.round(1)}ms)" end debug { event.payload[:mail] } end # An email was received. def receive(event) info { "\nReceived mail (#{event.duration.round(1)}ms)" } debug { event.payload[:mail] } end # An email was generated. def process(event) debug do mailer = event.payload[:mailer] action = event.payload[:action] "\n#{mailer}##{action}: processed outbound mail in #{event.duration.round(1)}ms" end end # Use the logger configured for ActionMailer::Base def logger ActionMailer::Base.logger end end end ActionMailer::LogSubscriber.attach_to :action_mailer rails-4.2.10/actionmailer/lib/action_mailer/mail_helper.rb 0000664 0000000 0000000 00000003164 13162731520 0023545 0 ustar 00root root 0000000 0000000 module ActionMailer # Provides helper methods for ActionMailer::Base that can be used for easily # formatting messages, accessing mailer or message instances, and the # attachments list. module MailHelper # Take the text and format it, indented two spaces for each line, and # wrapped at 72 columns. def block_format(text) formatted = text.split(/\n\r?\n/).collect { |paragraph| format_paragraph(paragraph) }.join("\n\n") # Make list points stand on their own line formatted.gsub!(/[ ]*([*]+) ([^*]*)/) { " #{$1} #{$2.strip}\n" } formatted.gsub!(/[ ]*([#]+) ([^#]*)/) { " #{$1} #{$2.strip}\n" } formatted end # Access the mailer instance. def mailer @_controller end # Access the message instance. def message @_message end # Access the message attachments list. def attachments mailer.attachments end # Returns +text+ wrapped at +len+ columns and indented +indent+ spaces. # # my_text = 'Here is a sample text with more than 40 characters' # # format_paragraph(my_text, 25, 4) # # => " Here is a sample text with\n more than 40 characters" def format_paragraph(text, len = 72, indent = 2) sentences = [[]] text.split.each do |word| if sentences.first.present? && (sentences.last + [word]).join(' ').length > len sentences << [word] else sentences.last << word end end indentation = " " * indent sentences.map! { |sentence| "#{indentation}#{sentence.join(' ')}" }.join "\n" end end end rails-4.2.10/actionmailer/lib/action_mailer/message_delivery.rb 0000664 0000000 0000000 00000007532 13162731520 0024616 0 ustar 00root root 0000000 0000000 require 'delegate' require 'active_support/core_ext/string/filters' module ActionMailer # The ActionMailer::MessageDelivery class is used by # ActionMailer::Base when creating a new mailer. # MessageDelivery is a wrapper (+Delegator+ subclass) around a lazy # created Mail::Message. You can get direct access to the # Mail::Message, deliver the email or schedule the email to be sent # through Active Job. # # Notifier.welcome(User.first) # an ActionMailer::MessageDelivery object # Notifier.welcome(User.first).deliver_now # sends the email # Notifier.welcome(User.first).deliver_later # enqueue email delivery as a job through Active Job # Notifier.welcome(User.first).message # a Mail::Message object class MessageDelivery < Delegator def initialize(mailer, mail_method, *args) #:nodoc: @mailer = mailer @mail_method = mail_method @args = args end def __getobj__ #:nodoc: @obj ||= @mailer.send(:new, @mail_method, *@args).message end def __setobj__(obj) #:nodoc: @obj = obj end # Returns the Mail::Message object def message __getobj__ end # Enqueues the email to be delivered through Active Job. When the # job runs it will send the email using +deliver_now!+. That means # that the message will be sent bypassing checking +perform_deliveries+ # and +raise_delivery_errors+, so use with caution. # # Notifier.welcome(User.first).deliver_later! # Notifier.welcome(User.first).deliver_later!(wait: 1.hour) # Notifier.welcome(User.first).deliver_later!(wait_until: 10.hours.from_now) # # Options: # # * :wait - Enqueue the email to be delivered with a delay # * :wait_until - Enqueue the email to be delivered at (after) a specific date / time # * :queue - Enqueue the email on the specified queue def deliver_later!(options={}) enqueue_delivery :deliver_now!, options end # Enqueues the email to be delivered through Active Job. When the # job runs it will send the email using +deliver_now+. # # Notifier.welcome(User.first).deliver_later # Notifier.welcome(User.first).deliver_later(wait: 1.hour) # Notifier.welcome(User.first).deliver_later(wait_until: 10.hours.from_now) # # Options: # # * :wait - Enqueue the email to be delivered with a delay # * :wait_until - Enqueue the email to be delivered at (after) a specific date / time # * :queue - Enqueue the email on the specified queue def deliver_later(options={}) enqueue_delivery :deliver_now, options end # Delivers an email without checking +perform_deliveries+ and +raise_delivery_errors+, # so use with caution. # # Notifier.welcome(User.first).deliver_now! # def deliver_now! message.deliver! end # Delivers an email: # # Notifier.welcome(User.first).deliver_now # def deliver_now message.deliver end def deliver! #:nodoc: ActiveSupport::Deprecation.warn(<<-MSG.squish) `#deliver!` is deprecated and will be removed in Rails 5. Use `#deliver_now!` to deliver immediately or `#deliver_later!` to deliver through Active Job. MSG deliver_now! end def deliver #:nodoc: ActiveSupport::Deprecation.warn(<<-MSG.squish) `#deliver` is deprecated and will be removed in Rails 5. Use `#deliver_now` to deliver immediately or `#deliver_later` to deliver through Active Job. MSG deliver_now end private def enqueue_delivery(delivery_method, options={}) args = @mailer.name, @mail_method.to_s, delivery_method.to_s, *@args ActionMailer::DeliveryJob.set(options).perform_later(*args) end end end rails-4.2.10/actionmailer/lib/action_mailer/preview.rb 0000664 0000000 0000000 00000006644 13162731520 0022753 0 ustar 00root root 0000000 0000000 require 'active_support/descendants_tracker' module ActionMailer module Previews #:nodoc: extend ActiveSupport::Concern included do # Set the location of mailer previews through app configuration: # # config.action_mailer.preview_path = "#{Rails.root}/lib/mailer_previews" # mattr_accessor :preview_path, instance_writer: false # Enable or disable mailer previews through app configuration: # # config.action_mailer.show_previews = true # # Defaults to true for development environment # mattr_accessor :show_previews, instance_writer: false # :nodoc: mattr_accessor :preview_interceptors, instance_writer: false self.preview_interceptors = [] end module ClassMethods # Register one or more Interceptors which will be called before mail is previewed. def register_preview_interceptors(*interceptors) interceptors.flatten.compact.each { |interceptor| register_preview_interceptor(interceptor) } end # Register an Interceptor which will be called before mail is previewed. # Either a class or a string can be passed in as the Interceptor. If a # string is passed in it will be constantized. def register_preview_interceptor(interceptor) preview_interceptor = case interceptor when String, Symbol interceptor.to_s.camelize.constantize else interceptor end unless preview_interceptors.include?(preview_interceptor) preview_interceptors << preview_interceptor end end end end class Preview extend ActiveSupport::DescendantsTracker class << self # Returns all mailer preview classes def all load_previews if descendants.empty? descendants end # Returns the mail object for the given email name. The registered preview # interceptors will be informed so that they can transform the message # as they would if the mail was actually being delivered. def call(email) preview = self.new message = preview.public_send(email) inform_preview_interceptors(message) message end # Returns all of the available email previews def emails public_instance_methods(false).map(&:to_s).sort end # Returns true if the email exists def email_exists?(email) emails.include?(email) end # Returns true if the preview exists def exists?(preview) all.any?{ |p| p.preview_name == preview } end # Find a mailer preview by its underscored class name def find(preview) all.find{ |p| p.preview_name == preview } end # Returns the underscored name of the mailer preview without the suffix def preview_name name.sub(/Preview$/, '').underscore end protected def load_previews #:nodoc: if preview_path Dir["#{preview_path}/**/*_preview.rb"].each{ |file| require_dependency file } end end def preview_path #:nodoc: Base.preview_path end def show_previews #:nodoc: Base.show_previews end def inform_preview_interceptors(message) #:nodoc: Base.preview_interceptors.each do |interceptor| interceptor.previewing_email(message) end end end end end rails-4.2.10/actionmailer/lib/action_mailer/railtie.rb 0000664 0000000 0000000 00000004274 13162731520 0022720 0 ustar 00root root 0000000 0000000 require 'active_job/railtie' require "action_mailer" require "rails" require "abstract_controller/railties/routes_helpers" module ActionMailer class Railtie < Rails::Railtie # :nodoc: config.action_mailer = ActiveSupport::OrderedOptions.new config.eager_load_namespaces << ActionMailer initializer "action_mailer.logger" do ActiveSupport.on_load(:action_mailer) { self.logger ||= Rails.logger } end initializer "action_mailer.set_configs" do |app| paths = app.config.paths options = app.config.action_mailer options.assets_dir ||= paths["public"].first options.javascripts_dir ||= paths["public/javascripts"].first options.stylesheets_dir ||= paths["public/stylesheets"].first options.show_previews = Rails.env.development? if options.show_previews.nil? if options.show_previews options.preview_path ||= defined?(Rails.root) ? "#{Rails.root}/test/mailers/previews" : nil end # make sure readers methods get compiled options.asset_host ||= app.config.asset_host options.relative_url_root ||= app.config.relative_url_root ActiveSupport.on_load(:action_mailer) do include AbstractController::UrlFor extend ::AbstractController::Railties::RoutesHelpers.with(app.routes, false) include app.routes.mounted_helpers register_interceptors(options.delete(:interceptors)) register_preview_interceptors(options.delete(:preview_interceptors)) register_observers(options.delete(:observers)) options.each { |k,v| send("#{k}=", v) } if options.show_previews app.routes.append do get '/rails/mailers' => "rails/mailers#index" get '/rails/mailers/*path' => "rails/mailers#preview" end end end end initializer "action_mailer.compile_config_methods" do ActiveSupport.on_load(:action_mailer) do config.compile_methods! if config.respond_to?(:compile_methods!) end end config.after_initialize do if ActionMailer::Base.preview_path ActiveSupport::Dependencies.autoload_paths << ActionMailer::Base.preview_path end end end end rails-4.2.10/actionmailer/lib/action_mailer/test_case.rb 0000664 0000000 0000000 00000005637 13162731520 0023245 0 ustar 00root root 0000000 0000000 require 'active_support/test_case' require 'rails-dom-testing' module ActionMailer class NonInferrableMailerError < ::StandardError def initialize(name) super "Unable to determine the mailer to test from #{name}. " + "You'll need to specify it using tests YourMailer in your " + "test case definition" end end class TestCase < ActiveSupport::TestCase module Behavior extend ActiveSupport::Concern include ActiveSupport::Testing::ConstantLookup include TestHelper include Rails::Dom::Testing::Assertions::SelectorAssertions include Rails::Dom::Testing::Assertions::DomAssertions included do class_attribute :_mailer_class setup :initialize_test_deliveries setup :set_expected_mail teardown :restore_test_deliveries end module ClassMethods def tests(mailer) case mailer when String, Symbol self._mailer_class = mailer.to_s.camelize.constantize when Module self._mailer_class = mailer else raise NonInferrableMailerError.new(mailer) end end def mailer_class if mailer = self._mailer_class mailer else tests determine_default_mailer(name) end end def determine_default_mailer(name) mailer = determine_constant_from_test_name(name) do |constant| Class === constant && constant < ActionMailer::Base end raise NonInferrableMailerError.new(name) if mailer.nil? mailer end end protected def initialize_test_deliveries set_delivery_method :test @old_perform_deliveries = ActionMailer::Base.perform_deliveries ActionMailer::Base.perform_deliveries = true ActionMailer::Base.deliveries.clear end def restore_test_deliveries restore_delivery_method ActionMailer::Base.perform_deliveries = @old_perform_deliveries end def set_delivery_method(method) @old_delivery_method = ActionMailer::Base.delivery_method ActionMailer::Base.delivery_method = method end def restore_delivery_method ActionMailer::Base.deliveries.clear ActionMailer::Base.delivery_method = @old_delivery_method end def set_expected_mail @expected = Mail.new @expected.content_type ["text", "plain", { "charset" => charset }] @expected.mime_version = '1.0' end private def charset "UTF-8" end def encode(subject) Mail::Encodings.q_value_encode(subject, charset) end def read_fixture(action) IO.readlines(File.join(Rails.root, 'test', 'fixtures', self.class.mailer_class.name.underscore, action)) end end include Behavior end end rails-4.2.10/actionmailer/lib/action_mailer/test_helper.rb 0000664 0000000 0000000 00000003410 13162731520 0023574 0 ustar 00root root 0000000 0000000 module ActionMailer # Provides helper methods for testing Action Mailer, including #assert_emails # and #assert_no_emails module TestHelper # Asserts that the number of emails sent matches the given number. # # def test_emails # assert_emails 0 # ContactMailer.welcome.deliver_now # assert_emails 1 # ContactMailer.welcome.deliver_now # assert_emails 2 # end # # If a block is passed, that block should cause the specified number of # emails to be sent. # # def test_emails_again # assert_emails 1 do # ContactMailer.welcome.deliver_now # end # # assert_emails 2 do # ContactMailer.welcome.deliver_now # ContactMailer.welcome.deliver_now # end # end def assert_emails(number) if block_given? original_count = ActionMailer::Base.deliveries.size yield new_count = ActionMailer::Base.deliveries.size assert_equal number, new_count - original_count, "#{number} emails expected, but #{new_count - original_count} were sent" else assert_equal number, ActionMailer::Base.deliveries.size end end # Assert that no emails have been sent. # # def test_emails # assert_no_emails # ContactMailer.welcome.deliver_now # assert_emails 1 # end # # If a block is passed, that block should not cause any emails to be sent. # # def test_emails_again # assert_no_emails do # # No emails should be sent from this block # end # end # # Note: This assertion is simply a shortcut for: # # assert_emails 0 def assert_no_emails(&block) assert_emails 0, &block end end end rails-4.2.10/actionmailer/lib/action_mailer/version.rb 0000664 0000000 0000000 00000000277 13162731520 0022753 0 ustar 00root root 0000000 0000000 require_relative 'gem_version' module ActionMailer # Returns the version of the currently loaded Action Mailer as a # Gem::Version. def self.version gem_version end end rails-4.2.10/actionmailer/lib/rails/ 0000775 0000000 0000000 00000000000 13162731520 0017237 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/lib/rails/generators/ 0000775 0000000 0000000 00000000000 13162731520 0021410 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/lib/rails/generators/mailer/ 0000775 0000000 0000000 00000000000 13162731520 0022661 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/lib/rails/generators/mailer/USAGE 0000664 0000000 0000000 00000001147 13162731520 0023453 0 ustar 00root root 0000000 0000000 Description: ============ Stubs out a new mailer and its views. Passes the mailer name, either CamelCased or under_scored, and an optional list of emails as arguments. This generates a mailer class in app/mailers and invokes your template engine and test framework generators. Example: ======== rails generate mailer Notifications signup forgot_password invoice creates a Notifications mailer class, views, and test: Mailer: app/mailers/notifications.rb Views: app/views/notifications/signup.text.erb [...] Test: test/mailers/notifications_test.rb rails-4.2.10/actionmailer/lib/rails/generators/mailer/mailer_generator.rb 0000664 0000000 0000000 00000001057 13162731520 0026530 0 ustar 00root root 0000000 0000000 module Rails module Generators class MailerGenerator < NamedBase source_root File.expand_path("../templates", __FILE__) argument :actions, type: :array, default: [], banner: "method method" check_class_collision def create_mailer_file template "mailer.rb", File.join('app/mailers', class_path, "#{file_name}.rb") if self.behavior == :invoke template "application_mailer.rb", 'app/mailers/application_mailer.rb' end end hook_for :template_engine, :test_framework end end end rails-4.2.10/actionmailer/lib/rails/generators/mailer/templates/ 0000775 0000000 0000000 00000000000 13162731520 0024657 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/lib/rails/generators/mailer/templates/application_mailer.rb 0000664 0000000 0000000 00000000146 13162731520 0031041 0 ustar 00root root 0000000 0000000 class ApplicationMailer < ActionMailer::Base default from: "from@example.com" layout 'mailer' end rails-4.2.10/actionmailer/lib/rails/generators/mailer/templates/mailer.rb 0000664 0000000 0000000 00000000567 13162731520 0026465 0 ustar 00root root 0000000 0000000 <% module_namespacing do -%> class <%= class_name %> < ApplicationMailer <% actions.each do |action| -%> # Subject can be set in your I18n file at config/locales/en.yml # with the following lookup: # # en.<%= file_path.tr("/",".") %>.<%= action %>.subject # def <%= action %> @greeting = "Hi" mail to: "to@example.org" end <% end -%> end <% end -%> rails-4.2.10/actionmailer/test/ 0000775 0000000 0000000 00000000000 13162731520 0016336 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/abstract_unit.rb 0000664 0000000 0000000 00000002741 13162731520 0021531 0 ustar 00root root 0000000 0000000 require File.expand_path('../../../load_paths', __FILE__) require 'active_support/core_ext/kernel/reporting' # These are the normal settings that will be set up by Railties # TODO: Have these tests support other combinations of these values silence_warnings do Encoding.default_internal = "UTF-8" Encoding.default_external = "UTF-8" end require 'active_support/testing/autorun' require 'action_mailer' require 'action_mailer/test_case' require 'mail' # Emulate AV railtie require 'action_view' ActionMailer::Base.send(:include, ActionView::Layouts) # Show backtraces for deprecated behavior for quicker cleanup. ActiveSupport::Deprecation.debug = true # Disable available locale checks to avoid warnings running the test suite. I18n.enforce_available_locales = false FIXTURE_LOAD_PATH = File.expand_path('fixtures', File.dirname(__FILE__)) ActionMailer::Base.view_paths = FIXTURE_LOAD_PATH module Rails def self.root File.expand_path('../', File.dirname(__FILE__)) end end # Skips the current run on Rubinius using Minitest::Assertions#skip def rubinius_skip(message = '') skip message if RUBY_ENGINE == 'rbx' end # Skips the current run on JRuby using Minitest::Assertions#skip def jruby_skip(message = '') skip message if defined?(JRUBY_VERSION) end require 'mocha/setup' # FIXME: stop using mocha # FIXME: we have tests that depend on run order, we should fix that and # remove this method call. require 'active_support/test_case' ActiveSupport::TestCase.test_order = :sorted rails-4.2.10/actionmailer/test/assert_select_email_test.rb 0000664 0000000 0000000 00000002473 13162731520 0023737 0 ustar 00root root 0000000 0000000 require 'abstract_unit' class AssertSelectEmailTest < ActionMailer::TestCase class AssertSelectMailer < ActionMailer::Base def test(html) mail body: html, content_type: "text/html", subject: "Test e-mail", from: "test@test.host", to: "testfoo
bar
foo
bar
}, mail.body.to_s.strip
end
def test_asset_host_as_one_argument_proc
AssetHostMailer.config.asset_host = Proc.new { |source|
if source.starts_with?('/images')
'http://images.example.com'
end
}
mail = AssetHostMailer.email_with_asset
assert_dom_equal %Q{
}, mail.body.to_s.strip
end
end
rails-4.2.10/actionmailer/test/base_test.rb 0000664 0000000 0000000 00000100436 13162731520 0020640 0 ustar 00root root 0000000 0000000 # encoding: utf-8
require 'abstract_unit'
require 'set'
require 'action_dispatch'
require 'active_support/time'
require 'mailers/base_mailer'
require 'mailers/proc_mailer'
require 'mailers/asset_mailer'
class BaseTest < ActiveSupport::TestCase
include Rails::Dom::Testing::Assertions::DomAssertions
setup do
@original_delivery_method = ActionMailer::Base.delivery_method
ActionMailer::Base.delivery_method = :test
@original_asset_host = ActionMailer::Base.asset_host
@original_assets_dir = ActionMailer::Base.assets_dir
end
teardown do
ActionMailer::Base.asset_host = @original_asset_host
ActionMailer::Base.assets_dir = @original_assets_dir
BaseMailer.deliveries.clear
ActionMailer::Base.delivery_method = @original_delivery_method
end
test "method call to mail does not raise error" do
assert_nothing_raised { BaseMailer.welcome }
end
# Basic mail usage without block
test "mail() should set the headers of the mail message" do
email = BaseMailer.welcome
assert_equal(['system@test.lindsaar.net'], email.to)
assert_equal(['jose@test.plataformatec.com'], email.from)
assert_equal('The first email on new API!', email.subject)
end
test "mail() with from overwrites the class level default" do
email = BaseMailer.welcome(from: 'someone@example.com',
to: 'another@example.org')
assert_equal(['someone@example.com'], email.from)
assert_equal(['another@example.org'], email.to)
end
test "mail() with bcc, cc, content_type, charset, mime_version, reply_to and date" do
time = Time.now.beginning_of_day.to_datetime
email = BaseMailer.welcome(bcc: 'bcc@test.lindsaar.net',
cc: 'cc@test.lindsaar.net',
content_type: 'multipart/mixed',
charset: 'iso-8559-1',
mime_version: '2.0',
reply_to: 'reply-to@test.lindsaar.net',
date: time)
assert_equal(['bcc@test.lindsaar.net'], email.bcc)
assert_equal(['cc@test.lindsaar.net'], email.cc)
assert_equal('multipart/mixed; charset=iso-8559-1', email.content_type)
assert_equal('iso-8559-1', email.charset)
assert_equal('2.0', email.mime_version)
assert_equal(['reply-to@test.lindsaar.net'], email.reply_to)
assert_equal(time, email.date)
end
test "mail() renders the template using the method being processed" do
email = BaseMailer.welcome
assert_equal("Welcome", email.body.encoded)
end
test "can pass in :body to the mail method hash" do
email = BaseMailer.welcome(body: "Hello there")
assert_equal("text/plain", email.mime_type)
assert_equal("Hello there", email.body.encoded)
end
test "should set template content type if mail has only one part" do
mail = BaseMailer.html_only
assert_equal('text/html', mail.mime_type)
mail = BaseMailer.plain_text_only
assert_equal('text/plain', mail.mime_type)
end
# Custom headers
test "custom headers" do
email = BaseMailer.welcome
assert_equal("Not SPAM", email['X-SPAM'].decoded)
end
test "can pass random headers in as a hash to mail" do
hash = {'X-Special-Domain-Specific-Header' => "SecretValue",
'In-Reply-To' => '1234@mikel.me.com' }
mail = BaseMailer.welcome(hash)
assert_equal('SecretValue', mail['X-Special-Domain-Specific-Header'].decoded)
assert_equal('1234@mikel.me.com', mail['In-Reply-To'].decoded)
end
test "can pass random headers in as a hash to headers" do
hash = {'X-Special-Domain-Specific-Header' => "SecretValue",
'In-Reply-To' => '1234@mikel.me.com' }
mail = BaseMailer.welcome_with_headers(hash)
assert_equal('SecretValue', mail['X-Special-Domain-Specific-Header'].decoded)
assert_equal('1234@mikel.me.com', mail['In-Reply-To'].decoded)
end
# Attachments
test "attachment with content" do
email = BaseMailer.attachment_with_content
assert_equal(1, email.attachments.length)
assert_equal('invoice.pdf', email.attachments[0].filename)
assert_equal('This is test File content', email.attachments['invoice.pdf'].decoded)
end
test "attachment gets content type from filename" do
email = BaseMailer.attachment_with_content
assert_equal('invoice.pdf', email.attachments[0].filename)
assert_equal('application/pdf', email.attachments[0].mime_type)
end
test "attachment with hash" do
email = BaseMailer.attachment_with_hash
assert_equal(1, email.attachments.length)
assert_equal('invoice.jpg', email.attachments[0].filename)
expected = "\312\213\254\232)b"
expected.force_encoding(Encoding::BINARY)
assert_equal expected, email.attachments['invoice.jpg'].decoded
end
test "attachment with hash using default mail encoding" do
email = BaseMailer.attachment_with_hash_default_encoding
assert_equal(1, email.attachments.length)
assert_equal('invoice.jpg', email.attachments[0].filename)
expected = "\312\213\254\232)b"
expected.force_encoding(Encoding::BINARY)
assert_equal expected, email.attachments['invoice.jpg'].decoded
end
test "sets mime type to multipart/mixed when attachment is included" do
email = BaseMailer.attachment_with_content
assert_equal(1, email.attachments.length)
assert_equal("multipart/mixed", email.mime_type)
end
test "adds the rendered template as part" do
email = BaseMailer.attachment_with_content
assert_equal(2, email.parts.length)
assert_equal("multipart/mixed", email.mime_type)
assert_equal("text/html", email.parts[0].mime_type)
assert_equal("Attachment with content", email.parts[0].body.encoded)
assert_equal("application/pdf", email.parts[1].mime_type)
assert_equal("VGhpcyBpcyB0ZXN0IEZpbGUgY29udGVudA==\r\n", email.parts[1].body.encoded)
end
test "adds the given :body as part" do
email = BaseMailer.attachment_with_content(body: "I'm the eggman")
assert_equal(2, email.parts.length)
assert_equal("multipart/mixed", email.mime_type)
assert_equal("text/plain", email.parts[0].mime_type)
assert_equal("I'm the eggman", email.parts[0].body.encoded)
assert_equal("application/pdf", email.parts[1].mime_type)
assert_equal("VGhpcyBpcyB0ZXN0IEZpbGUgY29udGVudA==\r\n", email.parts[1].body.encoded)
end
test "can embed an inline attachment" do
email = BaseMailer.inline_attachment
# Need to call #encoded to force the JIT sort on parts
email.encoded
assert_equal(2, email.parts.length)
assert_equal("multipart/related", email.mime_type)
assert_equal("multipart/alternative", email.parts[0].mime_type)
assert_equal("text/plain", email.parts[0].parts[0].mime_type)
assert_equal("text/html", email.parts[0].parts[1].mime_type)
assert_equal("logo.png", email.parts[1].filename)
end
# Defaults values
test "uses default charset from class" do
with_default BaseMailer, charset: "US-ASCII" do
email = BaseMailer.welcome
assert_equal("US-ASCII", email.charset)
email = BaseMailer.welcome(charset: "iso-8559-1")
assert_equal("iso-8559-1", email.charset)
end
end
test "uses default content type from class" do
with_default BaseMailer, content_type: "text/html" do
email = BaseMailer.welcome
assert_equal("text/html", email.mime_type)
email = BaseMailer.welcome(content_type: "text/plain")
assert_equal("text/plain", email.mime_type)
end
end
test "uses default mime version from class" do
with_default BaseMailer, mime_version: "2.0" do
email = BaseMailer.welcome
assert_equal("2.0", email.mime_version)
email = BaseMailer.welcome(mime_version: "1.0")
assert_equal("1.0", email.mime_version)
end
end
test "uses random default headers from class" do
with_default BaseMailer, "X-Custom" => "Custom" do
email = BaseMailer.welcome
assert_equal("Custom", email["X-Custom"].decoded)
end
end
test "subject gets default from I18n" do
with_default BaseMailer, subject: nil do
email = BaseMailer.welcome(subject: nil)
assert_equal "Welcome", email.subject
with_translation 'en', base_mailer: {welcome: {subject: "New Subject!"}} do
email = BaseMailer.welcome(subject: nil)
assert_equal "New Subject!", email.subject
end
end
end
test 'default subject can have interpolations' do
with_translation 'en', base_mailer: {with_subject_interpolations: {subject: 'Will the real %{rapper_or_impersonator} please stand up?'}} do
email = BaseMailer.with_subject_interpolations
assert_equal 'Will the real Slim Shady please stand up?', email.subject
end
end
test "translations are scoped properly" do
with_translation 'en', base_mailer: {email_with_translations: {greet_user: "Hello %{name}!"}} do
email = BaseMailer.email_with_translations
assert_equal 'Hello lifo!', email.body.encoded
end
end
test "adding attachments after mail was called raises exception" do
class LateAttachmentMailer < ActionMailer::Base
def welcome
mail body: "yay", from: "welcome@example.com", to: "to@example.com"
attachments['invoice.pdf'] = 'This is test File content'
end
end
e = assert_raises(RuntimeError) { LateAttachmentMailer.welcome.message }
assert_match(/Can't add attachments after `mail` was called./, e.message)
end
test "adding inline attachments after mail was called raises exception" do
class LateInlineAttachmentMailer < ActionMailer::Base
def welcome
mail body: "yay", from: "welcome@example.com", to: "to@example.com"
attachments.inline['invoice.pdf'] = 'This is test File content'
end
end
e = assert_raises(RuntimeError) { LateInlineAttachmentMailer.welcome.message }
assert_match(/Can't add attachments after `mail` was called./, e.message)
end
test "adding inline attachments while rendering mail works" do
class LateInlineAttachmentMailer < ActionMailer::Base
def on_render
mail from: "welcome@example.com", to: "to@example.com"
end
end
mail = LateInlineAttachmentMailer.on_render
assert_nothing_raised { mail.message }
assert_equal ["image/jpeg; filename=controller_attachments.jpg",
"image/jpeg; filename=attachments.jpg"], mail.attachments.inline.map {|a| a['Content-Type'].to_s }
end
test "accessing attachments works after mail was called" do
class LateAttachmentAccessorMailer < ActionMailer::Base
def welcome
attachments['invoice.pdf'] = 'This is test File content'
mail body: "yay", from: "welcome@example.com", to: "to@example.com"
unless attachments.map(&:filename) == ["invoice.pdf"]
raise Minitest::Assertion, "Should allow access to attachments"
end
end
end
assert_nothing_raised { LateAttachmentAccessorMailer.welcome }
end
# Implicit multipart
test "implicit multipart" do
email = BaseMailer.implicit_multipart
assert_equal(2, email.parts.size)
assert_equal("multipart/alternative", email.mime_type)
assert_equal("text/plain", email.parts[0].mime_type)
assert_equal("TEXT Implicit Multipart", email.parts[0].body.encoded)
assert_equal("text/html", email.parts[1].mime_type)
assert_equal("HTML Implicit Multipart", email.parts[1].body.encoded)
end
test "implicit multipart with sort order" do
order = ["text/html", "text/plain"]
with_default BaseMailer, parts_order: order do
email = BaseMailer.implicit_multipart
assert_equal("text/html", email.parts[0].mime_type)
assert_equal("text/plain", email.parts[1].mime_type)
email = BaseMailer.implicit_multipart(parts_order: order.reverse)
assert_equal("text/plain", email.parts[0].mime_type)
assert_equal("text/html", email.parts[1].mime_type)
end
end
test "implicit multipart with attachments creates nested parts" do
email = BaseMailer.implicit_multipart(attachments: true)
assert_equal("application/pdf", email.parts[0].mime_type)
assert_equal("multipart/alternative", email.parts[1].mime_type)
assert_equal("text/plain", email.parts[1].parts[0].mime_type)
assert_equal("TEXT Implicit Multipart", email.parts[1].parts[0].body.encoded)
assert_equal("text/html", email.parts[1].parts[1].mime_type)
assert_equal("HTML Implicit Multipart", email.parts[1].parts[1].body.encoded)
end
test "implicit multipart with attachments and sort order" do
order = ["text/html", "text/plain"]
with_default BaseMailer, parts_order: order do
email = BaseMailer.implicit_multipart(attachments: true)
assert_equal("application/pdf", email.parts[0].mime_type)
assert_equal("multipart/alternative", email.parts[1].mime_type)
assert_equal("text/plain", email.parts[1].parts[1].mime_type)
assert_equal("text/html", email.parts[1].parts[0].mime_type)
end
end
test "implicit multipart with default locale" do
email = BaseMailer.implicit_with_locale
assert_equal(2, email.parts.size)
assert_equal("multipart/alternative", email.mime_type)
assert_equal("text/plain", email.parts[0].mime_type)
assert_equal("Implicit with locale TEXT", email.parts[0].body.encoded)
assert_equal("text/html", email.parts[1].mime_type)
assert_equal("Implicit with locale EN HTML", email.parts[1].body.encoded)
end
test "implicit multipart with other locale" do
swap I18n, locale: :pl do
email = BaseMailer.implicit_with_locale
assert_equal(2, email.parts.size)
assert_equal("multipart/alternative", email.mime_type)
assert_equal("text/plain", email.parts[0].mime_type)
assert_equal("Implicit with locale PL TEXT", email.parts[0].body.encoded)
assert_equal("text/html", email.parts[1].mime_type)
assert_equal("Implicit with locale HTML", email.parts[1].body.encoded)
end
end
test "implicit multipart with several view paths uses the first one with template" do
old = BaseMailer.view_paths
begin
BaseMailer.view_paths = [File.join(FIXTURE_LOAD_PATH, "another.path")] + old.dup
email = BaseMailer.welcome
assert_equal("Welcome from another path", email.body.encoded)
ensure
BaseMailer.view_paths = old
end
end
test "implicit multipart with inexistent templates uses the next view path" do
old = BaseMailer.view_paths
begin
BaseMailer.view_paths = [File.join(FIXTURE_LOAD_PATH, "unknown")] + old.dup
email = BaseMailer.welcome
assert_equal("Welcome", email.body.encoded)
ensure
BaseMailer.view_paths = old
end
end
# Explicit multipart
test "explicit multipart" do
email = BaseMailer.explicit_multipart
assert_equal(2, email.parts.size)
assert_equal("multipart/alternative", email.mime_type)
assert_equal("text/plain", email.parts[0].mime_type)
assert_equal("TEXT Explicit Multipart", email.parts[0].body.encoded)
assert_equal("text/html", email.parts[1].mime_type)
assert_equal("HTML Explicit Multipart", email.parts[1].body.encoded)
end
test "explicit multipart have a boundary" do
mail = BaseMailer.explicit_multipart
assert_not_nil(mail.content_type_parameters[:boundary])
end
test "explicit multipart with attachments creates nested parts" do
email = BaseMailer.explicit_multipart(attachments: true)
assert_equal("application/pdf", email.parts[0].mime_type)
assert_equal("multipart/alternative", email.parts[1].mime_type)
assert_equal("text/plain", email.parts[1].parts[0].mime_type)
assert_equal("TEXT Explicit Multipart", email.parts[1].parts[0].body.encoded)
assert_equal("text/html", email.parts[1].parts[1].mime_type)
assert_equal("HTML Explicit Multipart", email.parts[1].parts[1].body.encoded)
end
test "explicit multipart with templates" do
email = BaseMailer.explicit_multipart_templates
assert_equal(2, email.parts.size)
assert_equal("multipart/alternative", email.mime_type)
assert_equal("text/plain", email.parts[0].mime_type)
assert_equal("TEXT Explicit Multipart Templates", email.parts[0].body.encoded)
assert_equal("text/html", email.parts[1].mime_type)
assert_equal("HTML Explicit Multipart Templates", email.parts[1].body.encoded)
end
test "explicit multipart with format.any" do
email = BaseMailer.explicit_multipart_with_any
assert_equal(2, email.parts.size)
assert_equal("multipart/alternative", email.mime_type)
assert_equal("text/plain", email.parts[0].mime_type)
assert_equal("Format with any!", email.parts[0].body.encoded)
assert_equal("text/html", email.parts[1].mime_type)
assert_equal("Format with any!", email.parts[1].body.encoded)
end
test "explicit multipart with format(Hash)" do
email = BaseMailer.explicit_multipart_with_options(true)
email.ready_to_send!
assert_equal(2, email.parts.size)
assert_equal("multipart/alternative", email.mime_type)
assert_equal("text/plain", email.parts[0].mime_type)
assert_equal("base64", email.parts[0].content_transfer_encoding)
assert_equal("text/html", email.parts[1].mime_type)
assert_equal("7bit", email.parts[1].content_transfer_encoding)
end
test "explicit multipart with one part is rendered as body and options are merged" do
email = BaseMailer.explicit_multipart_with_options
assert_equal(0, email.parts.size)
assert_equal("text/plain", email.mime_type)
assert_equal("base64", email.content_transfer_encoding)
end
test "explicit multipart with one template has the expected format" do
email = BaseMailer.explicit_multipart_with_one_template
assert_equal(2, email.parts.size)
assert_equal("multipart/alternative", email.mime_type)
assert_equal("text/plain", email.parts[0].mime_type)
assert_equal("[:text]", email.parts[0].body.encoded)
assert_equal("text/html", email.parts[1].mime_type)
assert_equal("[:html]", email.parts[1].body.encoded)
end
test "explicit multipart with sort order" do
order = ["text/html", "text/plain"]
with_default BaseMailer, parts_order: order do
email = BaseMailer.explicit_multipart
assert_equal("text/html", email.parts[0].mime_type)
assert_equal("text/plain", email.parts[1].mime_type)
email = BaseMailer.explicit_multipart(parts_order: order.reverse)
assert_equal("text/plain", email.parts[0].mime_type)
assert_equal("text/html", email.parts[1].mime_type)
end
end
# Class level API with method missing
test "should respond to action methods" do
assert_respond_to BaseMailer, :welcome
assert_respond_to BaseMailer, :implicit_multipart
assert !BaseMailer.respond_to?(:mail)
assert !BaseMailer.respond_to?(:headers)
end
test "calling just the action should return the generated mail object" do
email = BaseMailer.welcome
assert_equal(0, BaseMailer.deliveries.length)
assert_equal('The first email on new API!', email.subject)
end
test "calling deliver on the action should deliver the mail object" do
BaseMailer.expects(:deliver_mail).once
mail = BaseMailer.welcome.deliver_now
assert_equal 'The first email on new API!', mail.subject
end
test "calling deliver on the action should increment the deliveries collection if using the test mailer" do
BaseMailer.welcome.deliver_now
assert_equal(1, BaseMailer.deliveries.length)
end
test "calling deliver, ActionMailer should yield back to mail to let it call :do_delivery on itself" do
mail = Mail::Message.new
mail.expects(:do_delivery).once
BaseMailer.expects(:welcome).returns(mail)
BaseMailer.welcome.deliver
end
# Rendering
test "you can specify a different template for implicit render" do
mail = BaseMailer.implicit_different_template('implicit_multipart').deliver_now
assert_equal("HTML Implicit Multipart", mail.html_part.body.decoded)
assert_equal("TEXT Implicit Multipart", mail.text_part.body.decoded)
end
test "should raise if missing template in implicit render" do
assert_raises ActionView::MissingTemplate do
BaseMailer.implicit_different_template('missing_template').deliver_now
end
assert_equal(0, BaseMailer.deliveries.length)
end
test "you can specify a different template for explicit render" do
mail = BaseMailer.explicit_different_template('explicit_multipart_templates').deliver_now
assert_equal("HTML Explicit Multipart Templates", mail.html_part.body.decoded)
assert_equal("TEXT Explicit Multipart Templates", mail.text_part.body.decoded)
end
test "you can specify a different layout" do
mail = BaseMailer.different_layout('different_layout').deliver_now
assert_equal("HTML -- HTML", mail.html_part.body.decoded)
assert_equal("PLAIN -- PLAIN", mail.text_part.body.decoded)
end
test "you can specify the template path for implicit lookup" do
mail = BaseMailer.welcome_from_another_path('another.path/base_mailer').deliver_now
assert_equal("Welcome from another path", mail.body.encoded)
mail = BaseMailer.welcome_from_another_path(['unknown/invalid', 'another.path/base_mailer']).deliver_now
assert_equal("Welcome from another path", mail.body.encoded)
end
test "assets tags should use ActionMailer's asset_host settings" do
ActionMailer::Base.config.asset_host = "http://global.com"
ActionMailer::Base.config.assets_dir = "global/"
mail = AssetMailer.welcome
assert_dom_equal(%{
}, mail.body.to_s.strip)
end
test "assets tags should use a Mailer's asset_host settings when available" do
ActionMailer::Base.config.asset_host = "http://global.com"
ActionMailer::Base.config.assets_dir = "global/"
TempAssetMailer = Class.new(AssetMailer) do
self.mailer_name = "asset_mailer"
self.asset_host = "http://local.com"
end
mail = TempAssetMailer.welcome
assert_dom_equal(%{
}, mail.body.to_s.strip)
end
test 'the view is not rendered when mail was never called' do
mail = BaseMailer.without_mail_call
assert_equal('', mail.body.to_s.strip)
mail.deliver_now
end
test 'the return value of mailer methods is not relevant' do
mail = BaseMailer.with_nil_as_return_value
assert_equal('Welcome', mail.body.to_s.strip)
mail.deliver_now
end
# Before and After hooks
class MyObserver
def self.delivered_email(mail)
end
end
class MySecondObserver
def self.delivered_email(mail)
end
end
test "you can register an observer to the mail object that gets informed on email delivery" do
mail_side_effects do
ActionMailer::Base.register_observer(MyObserver)
mail = BaseMailer.welcome
MyObserver.expects(:delivered_email).with(mail)
mail.deliver_now
end
end
test "you can register an observer using its stringified name to the mail object that gets informed on email delivery" do
mail_side_effects do
ActionMailer::Base.register_observer("BaseTest::MyObserver")
mail = BaseMailer.welcome
MyObserver.expects(:delivered_email).with(mail)
mail.deliver_now
end
end
test "you can register an observer using its symbolized underscored name to the mail object that gets informed on email delivery" do
mail_side_effects do
ActionMailer::Base.register_observer(:"base_test/my_observer")
mail = BaseMailer.welcome
MyObserver.expects(:delivered_email).with(mail)
mail.deliver_now
end
end
test "you can register multiple observers to the mail object that both get informed on email delivery" do
mail_side_effects do
ActionMailer::Base.register_observers("BaseTest::MyObserver", MySecondObserver)
mail = BaseMailer.welcome
MyObserver.expects(:delivered_email).with(mail)
MySecondObserver.expects(:delivered_email).with(mail)
mail.deliver_now
end
end
class MyInterceptor
def self.delivering_email(mail); end
def self.previewing_email(mail); end
end
class MySecondInterceptor
def self.delivering_email(mail); end
def self.previewing_email(mail); end
end
test "you can register an interceptor to the mail object that gets passed the mail object before delivery" do
mail_side_effects do
ActionMailer::Base.register_interceptor(MyInterceptor)
mail = BaseMailer.welcome
MyInterceptor.expects(:delivering_email).with(mail)
mail.deliver_now
end
end
test "you can register an interceptor using its stringified name to the mail object that gets passed the mail object before delivery" do
mail_side_effects do
ActionMailer::Base.register_interceptor("BaseTest::MyInterceptor")
mail = BaseMailer.welcome
MyInterceptor.expects(:delivering_email).with(mail)
mail.deliver_now
end
end
test "you can register an interceptor using its symbolized underscored name to the mail object that gets passed the mail object before delivery" do
mail_side_effects do
ActionMailer::Base.register_interceptor(:"base_test/my_interceptor")
mail = BaseMailer.welcome
MyInterceptor.expects(:delivering_email).with(mail)
mail.deliver_now
end
end
test "you can register multiple interceptors to the mail object that both get passed the mail object before delivery" do
mail_side_effects do
ActionMailer::Base.register_interceptors("BaseTest::MyInterceptor", MySecondInterceptor)
mail = BaseMailer.welcome
MyInterceptor.expects(:delivering_email).with(mail)
MySecondInterceptor.expects(:delivering_email).with(mail)
mail.deliver_now
end
end
test "being able to put proc's into the defaults hash and they get evaluated on mail sending" do
mail1 = ProcMailer.welcome['X-Proc-Method']
yesterday = 1.day.ago
Time.stubs(:now).returns(yesterday)
mail2 = ProcMailer.welcome['X-Proc-Method']
assert(mail1.to_s.to_i > mail2.to_s.to_i)
end
test 'default values which have to_proc (e.g. symbols) should not be considered procs' do
assert(ProcMailer.welcome['x-has-to-proc'].to_s == 'symbol')
end
test "we can call other defined methods on the class as needed" do
mail = ProcMailer.welcome
assert_equal("Thanks for signing up this afternoon", mail.subject)
end
test "modifying the mail message with a before_action" do
class BeforeActionMailer < ActionMailer::Base
before_action :add_special_header!
def welcome ; mail ; end
private
def add_special_header!
headers('X-Special-Header' => 'Wow, so special')
end
end
assert_equal('Wow, so special', BeforeActionMailer.welcome['X-Special-Header'].to_s)
end
test "modifying the mail message with an after_action" do
class AfterActionMailer < ActionMailer::Base
after_action :add_special_header!
def welcome ; mail ; end
private
def add_special_header!
headers('X-Special-Header' => 'Testing')
end
end
assert_equal('Testing', AfterActionMailer.welcome['X-Special-Header'].to_s)
end
test "adding an inline attachment using a before_action" do
class DefaultInlineAttachmentMailer < ActionMailer::Base
before_action :add_inline_attachment!
def welcome ; mail ; end
private
def add_inline_attachment!
attachments.inline["footer.jpg"] = 'hey there'
end
end
mail = DefaultInlineAttachmentMailer.welcome
assert_equal('image/jpeg; filename=footer.jpg', mail.attachments.inline.first['Content-Type'].to_s)
end
test "action methods should be refreshed after defining new method" do
class FooMailer < ActionMailer::Base
# this triggers action_methods
self.respond_to?(:foo)
def notify
end
end
assert_equal Set.new(["notify"]), FooMailer.action_methods
end
test "mailer can be anonymous" do
mailer = Class.new(ActionMailer::Base) do
def welcome
mail
end
end
assert_equal "anonymous", mailer.mailer_name
assert_equal "Welcome", mailer.welcome.subject
assert_equal "Anonymous mailer body", mailer.welcome.body.encoded.strip
end
test "default_from can be set" do
class DefaultFromMailer < ActionMailer::Base
default to: 'system@test.lindsaar.net'
self.default_options = {from: "robert.pankowecki@gmail.com"}
def welcome
mail(subject: "subject", body: "hello world")
end
end
assert_equal ["robert.pankowecki@gmail.com"], DefaultFromMailer.welcome.from
end
test "mail() without arguments serves as getter for the current mail message" do
class MailerWithCallback < ActionMailer::Base
after_action :a_callback
def welcome
headers('X-Special-Header' => 'special indeed!')
mail subject: "subject", body: "hello world", to: ["joe@example.com"]
end
def a_callback
mail.to << "jane@example.com"
end
end
mail = MailerWithCallback.welcome
assert_equal "subject", mail.subject
assert_equal ["joe@example.com", "jane@example.com"], mail.to
assert_equal "hello world", mail.body.encoded.strip
assert_equal "special indeed!", mail["X-Special-Header"].to_s
end
protected
# Execute the block setting the given values and restoring old values after
# the block is executed.
def swap(klass, new_values)
old_values = {}
new_values.each do |key, value|
old_values[key] = klass.send key
klass.send :"#{key}=", value
end
yield
ensure
old_values.each do |key, value|
klass.send :"#{key}=", value
end
end
def with_default(klass, new_values)
old = klass.default_params
klass.default(new_values)
yield
ensure
klass.default_params = old
end
# A simple hack to restore the observers and interceptors for Mail, as it
# does not have an unregister API yet.
def mail_side_effects
old_observers = Mail.class_variable_get(:@@delivery_notification_observers)
old_delivery_interceptors = Mail.class_variable_get(:@@delivery_interceptors)
yield
ensure
Mail.class_variable_set(:@@delivery_notification_observers, old_observers)
Mail.class_variable_set(:@@delivery_interceptors, old_delivery_interceptors)
end
def with_translation(locale, data)
I18n.backend.store_translations(locale, data)
yield
ensure
I18n.backend.reload!
end
end
class BasePreviewInterceptorsTest < ActiveSupport::TestCase
teardown do
ActionMailer::Base.preview_interceptors.clear
end
class BaseMailerPreview < ActionMailer::Preview
def welcome
BaseMailer.welcome
end
end
class MyInterceptor
def self.delivering_email(mail); end
def self.previewing_email(mail); end
end
class MySecondInterceptor
def self.delivering_email(mail); end
def self.previewing_email(mail); end
end
test "you can register a preview interceptor to the mail object that gets passed the mail object before previewing" do
ActionMailer::Base.register_preview_interceptor(MyInterceptor)
mail = BaseMailer.welcome
BaseMailerPreview.any_instance.stubs(:welcome).returns(mail)
MyInterceptor.expects(:previewing_email).with(mail)
BaseMailerPreview.call(:welcome)
end
test "you can register a preview interceptor using its stringified name to the mail object that gets passed the mail object before previewing" do
ActionMailer::Base.register_preview_interceptor("BasePreviewInterceptorsTest::MyInterceptor")
mail = BaseMailer.welcome
BaseMailerPreview.any_instance.stubs(:welcome).returns(mail)
MyInterceptor.expects(:previewing_email).with(mail)
BaseMailerPreview.call(:welcome)
end
test "you can register an interceptor using its symbolized underscored name to the mail object that gets passed the mail object before previewing" do
ActionMailer::Base.register_preview_interceptor(:"base_preview_interceptors_test/my_interceptor")
mail = BaseMailer.welcome
BaseMailerPreview.any_instance.stubs(:welcome).returns(mail)
MyInterceptor.expects(:previewing_email).with(mail)
BaseMailerPreview.call(:welcome)
end
test "you can register multiple preview interceptors to the mail object that both get passed the mail object before previewing" do
ActionMailer::Base.register_preview_interceptors("BasePreviewInterceptorsTest::MyInterceptor", MySecondInterceptor)
mail = BaseMailer.welcome
BaseMailerPreview.any_instance.stubs(:welcome).returns(mail)
MyInterceptor.expects(:previewing_email).with(mail)
MySecondInterceptor.expects(:previewing_email).with(mail)
BaseMailerPreview.call(:welcome)
end
end
rails-4.2.10/actionmailer/test/delivery_methods_test.rb 0000664 0000000 0000000 00000017023 13162731520 0023273 0 ustar 00root root 0000000 0000000 require 'abstract_unit'
require 'mail'
class MyCustomDelivery
end
class MyOptionedDelivery
attr_reader :options
def initialize(options)
@options = options
end
end
class BogusDelivery
def initialize(*)
end
def deliver!(mail)
raise "failed"
end
end
class DefaultsDeliveryMethodsTest < ActiveSupport::TestCase
test "default smtp settings" do
settings = { address: "localhost",
port: 25,
domain: 'localhost.localdomain',
user_name: nil,
password: nil,
authentication: nil,
enable_starttls_auto: true }
assert_equal settings, ActionMailer::Base.smtp_settings
end
test "default file delivery settings" do
settings = {location: "#{Dir.tmpdir}/mails"}
assert_equal settings, ActionMailer::Base.file_settings
end
test "default sendmail settings" do
settings = {
location: '/usr/sbin/sendmail',
arguments: '-i'
}
assert_equal settings, ActionMailer::Base.sendmail_settings
end
end
class CustomDeliveryMethodsTest < ActiveSupport::TestCase
setup do
@old_delivery_method = ActionMailer::Base.delivery_method
ActionMailer::Base.add_delivery_method :custom, MyCustomDelivery
end
teardown do
ActionMailer::Base.delivery_method = @old_delivery_method
new = ActionMailer::Base.delivery_methods.dup
new.delete(:custom)
ActionMailer::Base.delivery_methods = new
end
test "allow to add custom delivery method" do
ActionMailer::Base.delivery_method = :custom
assert_equal :custom, ActionMailer::Base.delivery_method
end
test "allow to customize custom settings" do
ActionMailer::Base.custom_settings = { foo: :bar }
assert_equal Hash[foo: :bar], ActionMailer::Base.custom_settings
end
test "respond to custom settings" do
assert_respond_to ActionMailer::Base, :custom_settings
assert_respond_to ActionMailer::Base, :custom_settings=
end
test "does not respond to unknown settings" do
assert_raise NoMethodError do
ActionMailer::Base.another_settings
end
end
end
class MailDeliveryTest < ActiveSupport::TestCase
class DeliveryMailer < ActionMailer::Base
DEFAULT_HEADERS = {
to: 'mikel@test.lindsaar.net',
from: 'jose@test.plataformatec.com'
}
def welcome(hash={})
mail(DEFAULT_HEADERS.merge(hash))
end
end
setup do
@old_delivery_method = DeliveryMailer.delivery_method
end
teardown do
DeliveryMailer.delivery_method = @old_delivery_method
DeliveryMailer.deliveries.clear
end
test "ActionMailer should be told when Mail gets delivered" do
DeliveryMailer.expects(:deliver_mail).once
DeliveryMailer.welcome.deliver_now
end
test "delivery method can be customized per instance" do
Mail::SMTP.any_instance.expects(:deliver!)
email = DeliveryMailer.welcome.deliver_now
assert_instance_of Mail::SMTP, email.delivery_method
email = DeliveryMailer.welcome(delivery_method: :test).deliver_now
assert_instance_of Mail::TestMailer, email.delivery_method
end
test "delivery method can be customized in subclasses not changing the parent" do
DeliveryMailer.delivery_method = :test
assert_equal :smtp, ActionMailer::Base.delivery_method
email = DeliveryMailer.welcome.deliver_now
assert_instance_of Mail::TestMailer, email.delivery_method
end
test "delivery method options default to class level options" do
default_options = {a: "b"}
ActionMailer::Base.add_delivery_method :optioned, MyOptionedDelivery, default_options
mail_instance = DeliveryMailer.welcome(delivery_method: :optioned)
assert_equal default_options, mail_instance.delivery_method.options
end
test "delivery method options can be overridden per mail instance" do
default_options = {a: "b"}
ActionMailer::Base.add_delivery_method :optioned, MyOptionedDelivery, default_options
overridden_options = {a: "a"}
mail_instance = DeliveryMailer.welcome(delivery_method: :optioned, delivery_method_options: overridden_options)
assert_equal overridden_options, mail_instance.delivery_method.options
end
test "default delivery options can be overridden per mail instance" do
settings = {
address: "localhost",
port: 25,
domain: 'localhost.localdomain',
user_name: nil,
password: nil,
authentication: nil,
enable_starttls_auto: true
}
assert_equal settings, ActionMailer::Base.smtp_settings
overridden_options = {user_name: "overridden", password: "somethingobtuse"}
mail_instance = DeliveryMailer.welcome(delivery_method_options: overridden_options)
delivery_method_instance = mail_instance.delivery_method
assert_equal "overridden", delivery_method_instance.settings[:user_name]
assert_equal "somethingobtuse", delivery_method_instance.settings[:password]
assert_equal delivery_method_instance.settings.merge(overridden_options), delivery_method_instance.settings
# make sure that overriding delivery method options per mail instance doesn't affect the Base setting
assert_equal settings, ActionMailer::Base.smtp_settings
end
test "non registered delivery methods raises errors" do
DeliveryMailer.delivery_method = :unknown
assert_raise RuntimeError do
DeliveryMailer.welcome.deliver_now
end
end
test "undefined delivery methods raises errors" do
DeliveryMailer.delivery_method = nil
assert_raise RuntimeError do
DeliveryMailer.welcome.deliver_now
end
end
test "does not perform deliveries if requested" do
old_perform_deliveries = DeliveryMailer.perform_deliveries
begin
DeliveryMailer.perform_deliveries = false
Mail::Message.any_instance.expects(:deliver!).never
DeliveryMailer.welcome.deliver_now
ensure
DeliveryMailer.perform_deliveries = old_perform_deliveries
end
end
test "does not append the deliveries collection if told not to perform the delivery" do
old_perform_deliveries = DeliveryMailer.perform_deliveries
begin
DeliveryMailer.perform_deliveries = false
DeliveryMailer.welcome.deliver_now
assert_equal [], DeliveryMailer.deliveries
ensure
DeliveryMailer.perform_deliveries = old_perform_deliveries
end
end
test "raise errors on bogus deliveries" do
DeliveryMailer.delivery_method = BogusDelivery
assert_raise RuntimeError do
DeliveryMailer.welcome.deliver_now
end
end
test "does not increment the deliveries collection on error" do
DeliveryMailer.delivery_method = BogusDelivery
assert_raise RuntimeError do
DeliveryMailer.welcome.deliver_now
end
assert_equal [], DeliveryMailer.deliveries
end
test "does not raise errors on bogus deliveries if set" do
old_raise_delivery_errors = DeliveryMailer.raise_delivery_errors
begin
DeliveryMailer.delivery_method = BogusDelivery
DeliveryMailer.raise_delivery_errors = false
assert_nothing_raised do
DeliveryMailer.welcome.deliver_now
end
ensure
DeliveryMailer.raise_delivery_errors = old_raise_delivery_errors
end
end
test "does not increment the deliveries collection on bogus deliveries" do
old_raise_delivery_errors = DeliveryMailer.raise_delivery_errors
begin
DeliveryMailer.delivery_method = BogusDelivery
DeliveryMailer.raise_delivery_errors = false
DeliveryMailer.welcome.deliver_now
assert_equal [], DeliveryMailer.deliveries
ensure
DeliveryMailer.raise_delivery_errors = old_raise_delivery_errors
end
end
end
rails-4.2.10/actionmailer/test/fixtures/ 0000775 0000000 0000000 00000000000 13162731520 0020207 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/anonymous/ 0000775 0000000 0000000 00000000000 13162731520 0022237 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/anonymous/welcome.erb 0000664 0000000 0000000 00000000026 13162731520 0024362 0 ustar 00root root 0000000 0000000 Anonymous mailer body
rails-4.2.10/actionmailer/test/fixtures/another.path/ 0000775 0000000 0000000 00000000000 13162731520 0022602 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/another.path/base_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0025045 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/another.path/base_mailer/welcome.erb 0000664 0000000 0000000 00000000031 13162731520 0027164 0 ustar 00root root 0000000 0000000 Welcome from another path rails-4.2.10/actionmailer/test/fixtures/asset_host_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0023714 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/asset_host_mailer/email_with_asset.html.erb 0000664 0000000 0000000 00000000037 13162731520 0030672 0 ustar 00root root 0000000 0000000 <%= image_tag "somelogo.png" %> rails-4.2.10/actionmailer/test/fixtures/asset_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0022657 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/asset_mailer/welcome.html.erb 0000664 0000000 0000000 00000000034 13162731520 0025744 0 ustar 00root root 0000000 0000000 <%= image_tag "dummy.png" %> rails-4.2.10/actionmailer/test/fixtures/async_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0022655 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/async_mailer/welcome.erb 0000664 0000000 0000000 00000000007 13162731520 0024777 0 ustar 00root root 0000000 0000000 Welcome rails-4.2.10/actionmailer/test/fixtures/attachments/ 0000775 0000000 0000000 00000000000 13162731520 0022522 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/attachments/foo.jpg 0000664 0000000 0000000 00000003755 13162731520 0024021 0 ustar 00root root 0000000 0000000 ÿØÿà JFIF d d ÿì Ducky < ÿî &Adobe dÀ
w Y è ëÿÛ „
ÿÂ 2 d ÿÄ Å ! 01#@A2$456
! 1AQq‘±Ñ"23“40@Áá’¢Â#st5 ` 1!AQa 0ðq‘¡ÑÁñÿÚ 3Ëöy¿I,éÙ601 ’ÐÔñ˜«Ì•ùº]y«HØ¢u±ûD® $‚~<« WPó/›©÷šŽR±ïeR™¢¾J—±L/JÎ2l^9înÇÞL¼òU”[rd®-åfw(䦡å³xåy»^y*è3¥a:%q¶ø•¢Eðv SË)ÍØóÎû¤{QÄ I HcÁƒew™3 ÝŽRVÙaØüK€Å [8ɾ¤+ÿÚ P…Š<‘I‘G¨¤IžHB‡~Þ7=´[ë.Û÷-¼‘éG\@õ–â
ºxp·n}¿×‰P}µÁ
…’ýìvÖöûSö͸Þևdz.`ƒM¼Q¬Z³>ß‚!AˆAþ§í_Ö¿cÚ¸k^Û˜¾îÇmüv&vLÏGŠ!A£vý¦ícómŸe¹Vò=>"ë—6ÆÍ …3°Œ¦P´‰ =I‘IvÍÎÅ”B< HHHH8N¶½m?ÿÚ ôÔä!Q0¨«Çì…p냹uÁ}wÿÚ ç©\+Jñ)\^î4áÐQâT(PÓ‚& Í^ÿÚ ?7ÿÚ ?7ÿÚ ?óã¬)¾käG•xº=äyÖ'äSÃ¯ß úxš^üS½šÓF¤du‘q¡ÂëÇ*8ô£RïVð|ëx hÃ4D„Çè«´iŠq5A"6h+ÃÓâ[¼%fíê¶
3§Yle9\˜—Q& Ÿn^óúãäCîZì>)ó£‹Ñ9ÁP©@‘ I¥OBžÂ£ÃËä57üNÒž lµø
ü>“³æâ_Ð=ØçPjò„àðÓ´!:ÕMS ®€ˆÖ„ ÛÓ¿ÿÚ ?!ØVR.°oMC“âì+÷ Ò.$¦$Ai•²:;Y WÎòUÚÏHîFžñ'úBL!ö“CŸä Éæ++XZåÜdÖ2Ý.öȆ„ Ü¡zýR<ÆÂ¥ƒŽ"GàîU–6b›‘ÞÄËkÈMÁ2c¬¬Ô|gaþ˜TUÐØBÖ&}ËOSô|«ƒåyË„¬¤M²œwwø‘T¼
z‰ì'n¾b)wÿ cã³H}‘wq§ìïÁº·$ènLá*ÃA½5rJ„+ǧ Å¥YÿÚ ?!½´!"gWؾ˜ìHR!¹Fškä“àn>°EÂñ
¡ô“æ³ôÆìþ2 Oœ“¿«‹pm"JeL¹¥Bb>|›Ú?,ˆ50~ nÒR_e{’H ü0u’Ðu3S//7³{ Å —¨«
g;9ÙfY”
¢º®1ÿÚ ?B/C QÁ:Q.Æ˃ÄÏÂ#X åCh±cÈrì¤Ù1)tž ‡O¼^B`€Ó*-„ ‡Q:q¸4ÂP'M …Â`²Çé' YcõŸÿÚ ?>HB°ÄìaÄ«cìDnEØ„5LŽÚK÷‡'c"ÂY(àRÐ]F‘<¶k´‘¸ØˆÚXrv8ø+}b]$†OT7EŸE?9Äìq†"@æâ 3t¶„‰¢0øq‡„!Xq½Â…‡èÿ ÿÙ rails-4.2.10/actionmailer/test/fixtures/attachments/test.jpg 0000664 0000000 0000000 00000003755 13162731520 0024215 0 ustar 00root root 0000000 0000000 ÿØÿà JFIF d d ÿì Ducky < ÿî &Adobe dÀ
w Y è ëÿÛ „
ÿÂ 2 d ÿÄ Å ! 01#@A2$456
! 1AQq‘±Ñ"23“40@Áá’¢Â#st5 ` 1!AQa 0ðq‘¡ÑÁñÿÚ 3Ëöy¿I,éÙ601 ’ÐÔñ˜«Ì•ùº]y«HØ¢u±ûD® $‚~<« WPó/›©÷šŽR±ïeR™¢¾J—±L/JÎ2l^9înÇÞL¼òU”[rd®-åfw(䦡å³xåy»^y*è3¥a:%q¶ø•¢Eðv SË)ÍØóÎû¤{QÄ I HcÁƒew™3 ÝŽRVÙaØüK€Å [8ɾ¤+ÿÚ P…Š<‘I‘G¨¤IžHB‡~Þ7=´[ë.Û÷-¼‘éG\@õ–â
ºxp·n}¿×‰P}µÁ
…’ýìvÖöûSö͸Þևdz.`ƒM¼Q¬Z³>ß‚!AˆAþ§í_Ö¿cÚ¸k^Û˜¾îÇmüv&vLÏGŠ!A£vý¦ícómŸe¹Vò=>"ë—6ÆÍ …3°Œ¦P´‰ =I‘IvÍÎÅ”B< HHHH8N¶½m?ÿÚ ôÔä!Q0¨«Çì…p냹uÁ}wÿÚ ç©\+Jñ)\^î4áÐQâT(PÓ‚& Í^ÿÚ ?7ÿÚ ?7ÿÚ ?óã¬)¾käG•xº=äyÖ'äSÃ¯ß úxš^üS½šÓF¤du‘q¡ÂëÇ*8ô£RïVð|ëx hÃ4D„Çè«´iŠq5A"6h+ÃÓâ[¼%fíê¶
3§Yle9\˜—Q& Ÿn^óúãäCîZì>)ó£‹Ñ9ÁP©@‘ I¥OBžÂ£ÃËä57üNÒž lµø
ü>“³æâ_Ð=ØçPjò„àðÓ´!:ÕMS ®€ˆÖ„ ÛÓ¿ÿÚ ?!ØVR.°oMC“âì+÷ Ò.$¦$Ai•²:;Y WÎòUÚÏHîFžñ'úBL!ö“CŸä Éæ++XZåÜdÖ2Ý.öȆ„ Ü¡zýR<ÆÂ¥ƒŽ"GàîU–6b›‘ÞÄËkÈMÁ2c¬¬Ô|gaþ˜TUÐØBÖ&}ËOSô|«ƒåyË„¬¤M²œwwø‘T¼
z‰ì'n¾b)wÿ cã³H}‘wq§ìïÁº·$ènLá*ÃA½5rJ„+ǧ Å¥YÿÚ ?!½´!"gWؾ˜ìHR!¹Fškä“àn>°EÂñ
¡ô“æ³ôÆìþ2 Oœ“¿«‹pm"JeL¹¥Bb>|›Ú?,ˆ50~ nÒR_e{’H ü0u’Ðu3S//7³{ Å —¨«
g;9ÙfY”
¢º®1ÿÚ ?B/C QÁ:Q.Æ˃ÄÏÂ#X åCh±cÈrì¤Ù1)tž ‡O¼^B`€Ó*-„ ‡Q:q¸4ÂP'M …Â`²Çé' YcõŸÿÚ ?>HB°ÄìaÄ«cìDnEØ„5LŽÚK÷‡'c"ÂY(àRÐ]F‘<¶k´‘¸ØˆÚXrv8ø+}b]$†OT7EŸE?9Äìq†"@æâ 3t¶„‰¢0øq‡„!Xq½Â…‡èÿ ÿÙ rails-4.2.10/actionmailer/test/fixtures/auto_layout_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0024105 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/auto_layout_mailer/hello.html.erb 0000664 0000000 0000000 00000000006 13162731520 0026641 0 ustar 00root root 0000000 0000000 Inside rails-4.2.10/actionmailer/test/fixtures/auto_layout_mailer/multipart.html.erb 0000664 0000000 0000000 00000000023 13162731520 0027556 0 ustar 00root root 0000000 0000000 text/html multipart rails-4.2.10/actionmailer/test/fixtures/auto_layout_mailer/multipart.text.erb 0000664 0000000 0000000 00000000024 13162731520 0027577 0 ustar 00root root 0000000 0000000 text/plain multipart rails-4.2.10/actionmailer/test/fixtures/base_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0022452 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_mailer/attachment_with_content.erb 0000664 0000000 0000000 00000000027 13162731520 0030060 0 ustar 00root root 0000000 0000000 Attachment with content rails-4.2.10/actionmailer/test/fixtures/base_mailer/attachment_with_hash.html.erb 0000664 0000000 0000000 00000000000 13162731520 0030263 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_mailer/attachment_with_hash_default_encoding.html.erb 0000664 0000000 0000000 00000000000 13162731520 0033635 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_mailer/different_layout.html.erb 0000664 0000000 0000000 00000000004 13162731520 0027444 0 ustar 00root root 0000000 0000000 HTML rails-4.2.10/actionmailer/test/fixtures/base_mailer/different_layout.text.erb 0000664 0000000 0000000 00000000005 13162731520 0027465 0 ustar 00root root 0000000 0000000 PLAIN rails-4.2.10/actionmailer/test/fixtures/base_mailer/email_custom_layout.text.html.erb 0000664 0000000 0000000 00000000011 13162731520 0031140 0 ustar 00root root 0000000 0000000 body_text rails-4.2.10/actionmailer/test/fixtures/base_mailer/email_with_translations.html.erb 0000664 0000000 0000000 00000000045 13162731520 0031031 0 ustar 00root root 0000000 0000000 <%= t('.greet_user', name: 'lifo') %> rails-4.2.10/actionmailer/test/fixtures/base_mailer/explicit_multipart_templates.html.erb 0000664 0000000 0000000 00000000041 13162731520 0032102 0 ustar 00root root 0000000 0000000 HTML Explicit Multipart Templates rails-4.2.10/actionmailer/test/fixtures/base_mailer/explicit_multipart_templates.text.erb 0000664 0000000 0000000 00000000041 13162731520 0032122 0 ustar 00root root 0000000 0000000 TEXT Explicit Multipart Templates rails-4.2.10/actionmailer/test/fixtures/base_mailer/explicit_multipart_with_one_template.erb 0000664 0000000 0000000 00000000033 13162731520 0032651 0 ustar 00root root 0000000 0000000 <%= self.formats.inspect %> rails-4.2.10/actionmailer/test/fixtures/base_mailer/html_only.html.erb 0000664 0000000 0000000 00000000020 13162731520 0026104 0 ustar 00root root 0000000 0000000 Testing
rails-4.2.10/actionmailer/test/fixtures/base_mailer/implicit_multipart.html.erb 0000664 0000000 0000000 00000000027 13162731520 0030021 0 ustar 00root root 0000000 0000000 HTML Implicit Multipart rails-4.2.10/actionmailer/test/fixtures/base_mailer/implicit_multipart.text.erb 0000664 0000000 0000000 00000000027 13162731520 0030041 0 ustar 00root root 0000000 0000000 TEXT Implicit Multipart rails-4.2.10/actionmailer/test/fixtures/base_mailer/implicit_with_locale.en.html.erb 0000664 0000000 0000000 00000000034 13162731520 0030671 0 ustar 00root root 0000000 0000000 Implicit with locale EN HTML rails-4.2.10/actionmailer/test/fixtures/base_mailer/implicit_with_locale.html.erb 0000664 0000000 0000000 00000000031 13162731520 0030265 0 ustar 00root root 0000000 0000000 Implicit with locale HTML rails-4.2.10/actionmailer/test/fixtures/base_mailer/implicit_with_locale.pl.text.erb 0000664 0000000 0000000 00000000034 13162731520 0030722 0 ustar 00root root 0000000 0000000 Implicit with locale PL TEXT rails-4.2.10/actionmailer/test/fixtures/base_mailer/implicit_with_locale.text.erb 0000664 0000000 0000000 00000000031 13162731520 0030305 0 ustar 00root root 0000000 0000000 Implicit with locale TEXT rails-4.2.10/actionmailer/test/fixtures/base_mailer/inline_attachment.html.erb 0000664 0000000 0000000 00000000153 13162731520 0027574 0 ustar 00root root 0000000 0000000Inline Image
<%= image_tag attachments['logo.png'].url %>This is an image that is inline
rails-4.2.10/actionmailer/test/fixtures/base_mailer/inline_attachment.text.erb 0000664 0000000 0000000 00000000040 13162731520 0027607 0 ustar 00root root 0000000 0000000 Inline Image No image for you rails-4.2.10/actionmailer/test/fixtures/base_mailer/plain_text_only.text.erb 0000664 0000000 0000000 00000000007 13162731520 0027334 0 ustar 00root root 0000000 0000000 Testing rails-4.2.10/actionmailer/test/fixtures/base_mailer/welcome.erb 0000664 0000000 0000000 00000000007 13162731520 0024574 0 ustar 00root root 0000000 0000000 Welcome rails-4.2.10/actionmailer/test/fixtures/base_mailer/welcome_with_headers.html.erb 0000664 0000000 0000000 00000000000 13162731520 0030256 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_mailer/without_mail_call.erb 0000664 0000000 0000000 00000000061 13162731520 0026641 0 ustar 00root root 0000000 0000000 <% raise 'the template should not be rendered' %> rails-4.2.10/actionmailer/test/fixtures/base_test/ 0000775 0000000 0000000 00000000000 13162731520 0022160 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_test/after_action_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0026147 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_test/after_action_mailer/welcome.html.erb 0000664 0000000 0000000 00000000000 13162731520 0031225 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_test/before_action_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0026310 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_test/before_action_mailer/welcome.html.erb 0000664 0000000 0000000 00000000000 13162731520 0031366 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_test/default_inline_attachment_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0030703 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_test/default_inline_attachment_mailer/welcome.html.erb 0000664 0000000 0000000 00000000000 13162731520 0033761 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_test/late_inline_attachment_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0030204 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/base_test/late_inline_attachment_mailer/on_render.erb 0000664 0000000 0000000 00000000524 13162731520 0032652 0 ustar 00root root 0000000 0000000Adding an inline image while rendering
<% controller.attachments.inline["controller_attachments.jpg"] = 'via controller.attachments.inline' %> <%= image_tag attachments['controller_attachments.jpg'].url %> <% attachments.inline["attachments.jpg"] = 'via attachments.inline' %> <%= image_tag attachments['attachments.jpg'].url %> rails-4.2.10/actionmailer/test/fixtures/explicit_layout_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0024756 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/explicit_layout_mailer/logout.html.erb 0000664 0000000 0000000 00000000016 13162731520 0027721 0 ustar 00root root 0000000 0000000 You logged out rails-4.2.10/actionmailer/test/fixtures/explicit_layout_mailer/signup.html.erb 0000664 0000000 0000000 00000000016 13162731520 0027715 0 ustar 00root root 0000000 0000000 We do not spam rails-4.2.10/actionmailer/test/fixtures/first_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0022667 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/first_mailer/share.erb 0000664 0000000 0000000 00000000013 13162731520 0024455 0 ustar 00root root 0000000 0000000 first mail rails-4.2.10/actionmailer/test/fixtures/i18n_test_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0023356 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/i18n_test_mailer/mail_with_i18n_subject.erb 0000664 0000000 0000000 00000000077 13162731520 0030407 0 ustar 00root root 0000000 0000000 Hello there, Mr. <%= @recipient %>. Be greeted, new member! rails-4.2.10/actionmailer/test/fixtures/layouts/ 0000775 0000000 0000000 00000000000 13162731520 0021707 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/layouts/auto_layout_mailer.html.erb 0000664 0000000 0000000 00000000036 13162731520 0027241 0 ustar 00root root 0000000 0000000 Hello from layout <%= yield %> rails-4.2.10/actionmailer/test/fixtures/layouts/auto_layout_mailer.text.erb 0000664 0000000 0000000 00000000040 13162731520 0027254 0 ustar 00root root 0000000 0000000 text/plain layout - <%= yield %> rails-4.2.10/actionmailer/test/fixtures/layouts/different_layout.html.erb 0000664 0000000 0000000 00000000024 13162731520 0026703 0 ustar 00root root 0000000 0000000 HTML -- <%= yield %> rails-4.2.10/actionmailer/test/fixtures/layouts/different_layout.text.erb 0000664 0000000 0000000 00000000025 13162731520 0026724 0 ustar 00root root 0000000 0000000 PLAIN -- <%= yield %> rails-4.2.10/actionmailer/test/fixtures/layouts/spam.html.erb 0000664 0000000 0000000 00000000033 13162731520 0024300 0 ustar 00root root 0000000 0000000 Spammer layout <%= yield %> rails-4.2.10/actionmailer/test/fixtures/mail_delivery_test/ 0000775 0000000 0000000 00000000000 13162731520 0024073 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/mail_delivery_test/delivery_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0027247 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/mail_delivery_test/delivery_mailer/welcome.html.erb 0000664 0000000 0000000 00000000000 13162731520 0032325 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/nested_layout_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0024417 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/nested_layout_mailer/signup.html.erb 0000664 0000000 0000000 00000000016 13162731520 0027356 0 ustar 00root root 0000000 0000000 We do not spam rails-4.2.10/actionmailer/test/fixtures/path.with.dots/ 0000775 0000000 0000000 00000000000 13162731520 0023065 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/path.with.dots/funky_path_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0026566 5 ustar 00root root 0000000 0000000 multipart_with_template_path_with_dots.erb 0000664 0000000 0000000 00000000026 13162731520 0037246 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/path.with.dots/funky_path_mailer Have some dots. Enjoy! rails-4.2.10/actionmailer/test/fixtures/proc_mailer/ 0000775 0000000 0000000 00000000000 13162731520 0022503 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/proc_mailer/welcome.html.erb 0000664 0000000 0000000 00000000000 13162731520 0025561 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionmailer/test/fixtures/raw_email 0000664 0000000 0000000 00000001040 13162731520 0022065 0 ustar 00root root 0000000 0000000 From jamis_buck@byu.edu Mon May 2 16:07:05 2005 Mime-Version: 1.0 (Apple Message framework v622) Content-Transfer-Encoding: base64 Message-Id:![\"Somelogo\"](\"/images/somelogo.png\")
"
expected.from = "system@loudthinking.com"
expected.date = Time.local(2004, 12, 12)
expected.content_type = "text/html"
created = nil
assert_nothing_raised { created = UrlTestMailer.signed_up_with_url(@recipient) }
assert_not_nil created
expected.message_id = '<123@456>'
created.message_id = '<123@456>'
assert_dom_equal expected.encoded, created.encoded
assert_nothing_raised { UrlTestMailer.signed_up_with_url(@recipient).deliver_now }
assert_not_nil ActionMailer::Base.deliveries.first
delivered = ActionMailer::Base.deliveries.first
delivered.message_id = '<123@456>'
assert_dom_equal expected.encoded, delivered.encoded
end
end
rails-4.2.10/actionpack/ 0000775 0000000 0000000 00000000000 13162731520 0015024 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/CHANGELOG.md 0000664 0000000 0000000 00000046465 13162731520 0016654 0 ustar 00root root 0000000 0000000 ## Rails 4.2.10 (September 27, 2017) ##
* Fix regression in behavior of `normalize_path`.
In Rails 5 there was a change to ensure the encoding of the original string
in a path was maintained. This was incorrectly backported to Rails 4.2 which
caused a regression.
*Eileen M. Uchitelle*
## Rails 4.2.9 (June 26, 2017) ##
* Use more specific check for :format in route path
The current check for whether to add an optional format to the path is very lax
and will match things like `:format_id` where there are nested resources, e.g:
``` ruby
resources :formats do
resources :items
end
```
Fix this by using a more restrictive regex pattern that looks for the patterns
`(.:format)`, `.:format` or `/` at the end of the path. Note that we need to
allow for multiple closing parenthesis since the route may be of this form:
``` ruby
get "/books(/:action(.:format))", controller: "books"
```
This probably isn't what's intended since it means that the default index action
route doesn't support a format but we have a test for it so we need to allow it.
Fixes #28517.
*Andrew White*
## Rails 4.2.8 (February 21, 2017) ##
* No changes.
## Rails 4.2.7 (July 12, 2016) ##
* No changes.
## Rails 4.2.6 (March 07, 2016) ##
* No changes.
## Rails 4.2.5.2 (February 26, 2016) ##
* Do not allow render with unpermitted parameter.
Fixes CVE-2016-2098.
*Arthur Neves*
## Rails 4.2.5.1 (January 25, 2015) ##
* No changes.
## Rails 4.2.5 (November 12, 2015) ##
* `ActionController::TestCase` can teardown gracefully if an error is raised
early in the `setup` chain.
*Yves Senn*
* Parse RSS/ATOM responses as XML, not HTML.
*Alexander Kaupanin*
* Fix regression in mounted engine named routes generation for app deployed to
a subdirectory. `relative_url_root` was prepended to the path twice (e.g.
"/subdir/subdir/engine_path" instead of "/subdir/engine_path")
Fixes #20920. Fixes #21459.
*Matthew Erhard*
* `url_for` does not modify its arguments when generating polymorphic URLs.
*Bernerd Schaefer*
* Update `ActionController::TestSession#fetch` to behave more like
`ActionDispatch::Request::Session#fetch` when using non-string keys.
*Jeremy Friesen*
## Rails 4.2.4 (August 24, 2015) ##
* ActionController::TestSession now accepts a default value as well as
a block for generating a default value based off the key provided.
This fixes calls to session#fetch in ApplicationController instances that
take more two arguments or a block from raising `ArgumentError: wrong
number of arguments (2 for 1)` when performing controller tests.
*Matthew Gerrior*
* Fix to keep original header instance in `ActionDispatch::SSL`
`ActionDispatch::SSL` changes headers to `Hash`.
So some headers will be broken if there are some middlewares
on `ActionDispatch::SSL` and if it uses `Rack::Utils::HeaderHash`.
*Fumiaki Matsushima*
## Rails 4.2.3 (June 25, 2015) ##
* Fix rake routes not showing the right format when
nesting multiple routes.
See #18373.
*Ravil Bayramgalin*
* Fix regression where a gzip file response would have a Content-type,
even when it was a 304 status code.
See #19271.
*Kohei Suzuki*
* Fix handling of empty X_FORWARDED_HOST header in raw_host_with_port
Previously, an empty X_FORWARDED_HOST header would cause
Actiondispatch::Http:URL.raw_host_with_port to return nil, causing
Actiondispatch::Http:URL.host to raise a NoMethodError.
*Adam Forsyth*
* Fallback to `ENV['RAILS_RELATIVE_URL_ROOT']` in `url_for`.
Fixed an issue where the `RAILS_RELATIVE_URL_ROOT` environment variable is not
prepended to the path when `url_for` is called. If `SCRIPT_NAME` (used by Rack)
is set, it takes precedence.
Fixes #5122.
*Yasyf Mohamedali*
* Fix regression in functional tests. Responses should have default headers
assigned.
See #18423.
*Jeremy Kemper*, *Yves Senn*
## Rails 4.2.2 (June 16, 2015) ##
* No Changes *
## Rails 4.2.1 (March 19, 2015) ##
* Non-string authenticity tokens do not raise NoMethodError when decoding
the masked token.
*Ville Lautanala*
* Explicitly ignored wildcard verbs when searching for HEAD routes before fallback
Fixes an issue where a mounted rack app at root would intercept the HEAD
request causing an incorrect behavior during the fall back to GET requests.
Example:
```ruby
draw do
get '/home' => 'test#index'
mount rack_app, at: '/'
end
head '/home'
assert_response :success
```
In this case, a HEAD request runs through the routes the first time and fails
to match anything. Then, it runs through the list with the fallback and matches
`get '/home'`. The original behavior would match the rack app in the first pass.
*Terence Sun*
* Preserve default format when generating URLs
Fixes an issue that would cause the format set in default_url_options to be
lost when generating URLs with fewer positional arguments than parameters in
the route definition.
Backport of #18627
*Tekin Suleyman*, *Dominic Baggott*
* Default headers, removed in controller actions, are no longer reapplied on
the test response.
*Jonas Baumann*
* Ensure `append_info_to_payload` is called even if an exception is raised.
Fixes an issue where when an exception is raised in the request the additonal
payload data is not available.
See:
* #14903
* https://github.com/roidrage/lograge/issues/37
*Dieter Komendera*, *Margus Pärt*
* Correctly rely on the response's status code to handle calls to `head`.
*Robin Dupret*
* Using `head` method returns empty response_body instead
of returning a single space " ".
The old behavior was added as a workaround for a bug in an early
version of Safari, where the HTTP headers are not returned correctly
if the response body has a 0-length. This is been fixed since and
the workaround is no longer necessary.
Fixes #18253.
*Prathamesh Sonpatki*
* Fix how polymorphic routes works with objects that implement `to_model`.
*Travis Grathwell*
* Fixed handling of positional url helper arguments when `format: false`.
Fixes #17819.
*Andrew White*, *Tatiana Soukiassian*
* Fixed usage of optional scopes in URL helpers.
*Alex Robbin*
## Rails 4.2.0 (December 20, 2014) ##
* Add `ActionController::Parameters#to_unsafe_h` to return an unfiltered
`Hash` representation of Parameters object. This is now a preferred way to
retrieve unfiltered parameters as we will stop inheriting `AC::Parameters`
object in Rails 5.0.
*Prem Sichanugrist*
* Restore handling of a bare `Authorization` header, without `token=`
prefix.
Fixes #17108.
*Guo Xiang Tan*
* Deprecate use of string keys in URL helpers.
Use symbols instead.
Fixes #16958.
*Byron Bischoff*, *Melanie Gilman*
* Deprecate the `only_path` option on `*_path` helpers.
In cases where this option is set to `true`, the option is redundant and can
be safely removed; otherwise, the corresponding `*_url` helper should be
used instead.
Fixes #17294.
*Dan Olson*, *Godfrey Chan*
* Improve Journey compliance to RFC 3986.
The scanner in Journey failed to recognize routes that use literals
from the sub-delims section of RFC 3986. It's now able to parse those
authorized delimiters and route as expected.
Fixes #17212.
*Nicolas Cavigneaux*
* Deprecate implicit Array conversion for Response objects. It was added
(using `#to_ary`) so we could conveniently use implicit splatting:
status, headers, body = response
But it also means `response + response` works and `[response].flatten`
cascades down to the Rack body. Nonsense behavior. Instead, rely on
explicit conversion and splatting with `#to_a`:
status, header, body = *response
*Jeremy Kemper*
* Don't rescue `IPAddr::InvalidAddressError`.
`IPAddr::InvalidAddressError` does not exist in Ruby 1.9.3
and fails for JRuby in 1.9 mode.
*Peter Suschlik*
* Fix bug where the router would ignore any constraints added to redirect
routes.
Fixes #16605.
*Agis Anastasopoulos*
* Allow `config.action_dispatch.trusted_proxies` to accept an IPAddr object.
Example:
# config/environments/production.rb
config.action_dispatch.trusted_proxies = IPAddr.new('4.8.15.0/16')
*Sam Aarons*
* Avoid duplicating routes for HEAD requests.
Instead of duplicating the routes, we will first match the HEAD request to
HEAD routes. If no match is found, we will then map the HEAD request to
GET routes.
*Guo Xiang Tan*, *Andrew White*
* Requests that hit `ActionDispatch::Static` can now take advantage
of gzipped assets on disk. By default a gzip asset will be served if
the client supports gzip and a compressed file is on disk.
*Richard Schneeman*
* `ActionController::Parameters` will stop inheriting from `Hash` and
`HashWithIndifferentAccess` in the next major release. If you use any method
that is not available on `ActionController::Parameters` you should consider
calling `#to_h` to convert it to a `Hash` first before calling that method.
*Prem Sichanugrist*
* `ActionController::Parameters#to_h` now returns a `Hash` with unpermitted
keys removed. This change is to reflect on a security concern where some
method performed on an `ActionController::Parameters` may yield a `Hash`
object which does not maintain `permitted?` status. If you would like to
get a `Hash` with all the keys intact, duplicate and mark it as permitted
before calling `#to_h`.
params = ActionController::Parameters.new({
name: 'Senjougahara Hitagi',
oddity: 'Heavy stone crab'
})
params.to_h
# => {}
unsafe_params = params.dup.permit!
unsafe_params.to_h
# => {"name"=>"Senjougahara Hitagi", "oddity"=>"Heavy stone crab"}
safe_params = params.permit(:name)
safe_params.to_h
# => {"name"=>"Senjougahara Hitagi"}
This change is consider a stopgap as we cannot change the code to stop
`ActionController::Parameters` to inherit from `HashWithIndifferentAccess`
in the next minor release.
*Prem Sichanugrist*
* Deprecated `TagAssertions`.
*Kasper Timm Hansen*
* Use the Active Support JSON encoder for cookie jars using the `:json` or
`:hybrid` serializer. This allows you to serialize custom Ruby objects into
cookies by defining the `#as_json` hook on such objects.
Fixes #16520.
*Godfrey Chan*
* Add `config.action_dispatch.cookies_digest` option for setting custom
digest. The default remains the same - 'SHA1'.
*Åukasz StrzaÅ‚kowski*
* Move `respond_with` (and the class-level `respond_to`) to
the `responders` gem.
*José Valim*
* When your templates change, browser caches bust automatically.
New default: the template digest is automatically included in your ETags.
When you call `fresh_when @post`, the digest for `posts/show.html.erb`
is mixed in so future changes to the HTML will blow HTTP caches for you.
This makes it easy to HTTP-cache many more of your actions.
If you render a different template, you can now pass the `:template`
option to include its digest instead:
fresh_when @post, template: 'widgets/show'
Pass `template: false` to skip the lookup. To turn this off entirely, set:
config.action_controller.etag_with_template_digest = false
*Jeremy Kemper*
* Remove deprecated `AbstractController::Helpers::ClassMethods::MissingHelperError`
in favor of `AbstractController::Helpers::MissingHelperError`.
*Yves Senn*
* Fix `assert_template` not being able to assert that no files were rendered.
*Guo Xiang Tan*
* Extract source code for the entire exception stack trace for
better debugging and diagnosis.
*Ryan Dao*
* Allows ActionDispatch::Request::LOCALHOST to match any IPv4 127.0.0.0/8
loopback address.
*Earl St Sauver*, *Sven Riedel*
* Preserve original path in `ShowExceptions` middleware by stashing it as
`env["action_dispatch.original_path"]`
`ActionDispatch::ShowExceptions` overwrites `PATH_INFO` with the status code
for the exception defined in `ExceptionWrapper`, so the path
the user was visiting when an exception occurred was not previously
available to any custom exceptions_app. The original `PATH_INFO` is now
stashed in `env["action_dispatch.original_path"]`.
*Grey Baker*
* Use `String#bytesize` instead of `String#size` when checking for cookie
overflow.
*Agis Anastasopoulos*
* `render nothing: true` or rendering a `nil` body no longer add a single
space to the response body.
The old behavior was added as a workaround for a bug in an early version of
Safari, where the HTTP headers are not returned correctly if the response
body has a 0-length. This is been fixed since and the workaround is no
longer necessary.
Use `render body: ' '` if the old behavior is desired.
See #14883 for details.
*Godfrey Chan*
* Prepend a JS comment to JSONP callbacks. Addresses CVE-2014-4671
("Rosetta Flash").
*Greg Campbell*
* Because URI paths may contain non US-ASCII characters we need to force
the encoding of any unescaped URIs to UTF-8 if they are US-ASCII.
This essentially replicates the functionality of the monkey patch to
URI.parser.unescape in active_support/core_ext/uri.rb.
Fixes #16104.
*Karl Entwistle*
* Generate shallow paths for all children of shallow resources.
Fixes #15783.
*Seb Jacobs*
* JSONP responses are now rendered with the `text/javascript` content type
when rendering through a `respond_to` block.
Fixes #15081.
*Lucas Mazza*
* Add `config.action_controller.always_permitted_parameters` to configure which
parameters are permitted globally. The default value of this configuration is
`['controller', 'action']`.
*Gary S. Weaver*, *Rafael Chacon*
* Fix env['PATH_INFO'] missing leading slash when a rack app mounted at '/'.
Fixes #15511.
*Larry Lv*
* ActionController::Parameters#require now accepts `false` values.
Fixes #15685.
*Sergio Romano*
* With authorization header `Authorization: Token token=`, `authenticate` now
recognize token as nil, instead of "token".
Fixes #14846.
*Larry Lv*
* Ensure the controller is always notified as soon as the client disconnects
during live streaming, even when the controller is blocked on a write.
*Nicholas Jakobsen*, *Matthew Draper*
* Routes specifying 'to:' must be a string that contains a "#" or a rack
application. Use of a symbol should be replaced with `action: symbol`.
Use of a string without a "#" should be replaced with `controller: string`.
*Aaron Patterson*
* Fix URL generation with `:trailing_slash` such that it does not add
a trailing slash after `.:format`
*Dan Langevin*
* Build full URI as string when processing path in integration tests for
performance reasons. One consequence of this is that the leading slash
is now required in integration test `process` helpers, whereas previously
it could be omitted. The fact that this worked was a unintended consequence
of the implementation and was never an intentional feature.
*Guo Xiang Tan*
* Fix `'Stack level too deep'` when rendering `head :ok` in an action method
called 'status' in a controller.
Fixes #13905.
*Christiaan Van den Poel*
* Add MKCALENDAR HTTP method (RFC 4791).
*Sergey Karpesh*
* Instrument fragment cache metrics.
Adds `:controller`: and `:action` keys to the instrumentation payload
for the `*_fragment.action_controller` notifications. This allows tracking
e.g. the fragment cache hit rates for each controller action.
*Daniel Schierbeck*
* Always use the provided port if the protocol is relative.
Fixes #15043.
*Guilherme Cavalcanti*, *Andrew White*
* Moved `params[request_forgery_protection_token]` into its own method
and improved tests.
Fixes #11316.
*Tom Kadwill*
* Added verification of route constraints given as a Proc or an object responding
to `:matches?`. Previously, when given an non-complying object, it would just
silently fail to enforce the constraint. It will now raise an `ArgumentError`
when setting up the routes.
*Xavier Defrang*
* Properly treat the entire IPv6 User Local Address space as private for
purposes of remote IP detection. Also handle uppercase private IPv6
addresses.
Fixes #12638.
*Caleb Spare*
* Fixed an issue with migrating legacy json cookies.
Previously, the `VerifyAndUpgradeLegacySignedMessage` assumes all incoming
cookies are marshal-encoded. This is not the case when `secret_token` is
used in conjunction with the `:json` or `:hybrid` serializer.
In those case, when upgrading to use `secret_key_base`, this would cause a
`TypeError: incompatible marshal file format` and a 500 error for the user.
Fixes #14774.
*Godfrey Chan*
* Make URL escaping more consistent:
1. Escape '%' characters in URLs - only unescaped data should be passed to URL helpers
2. Add an `escape_segment` helper to `Router::Utils` that escapes '/' characters
3. Use `escape_segment` rather than `escape_fragment` in optimized URL generation
4. Use `escape_segment` rather than `escape_path` in URL generation
For point 4 there are two exceptions. Firstly, when a route uses wildcard segments
(e.g. `*foo`) then we use `escape_path` as the value may contain '/' characters. This
means that wildcard routes can't be optimized. Secondly, if a `:controller` segment
is used in the path then this uses `escape_path` as the controller may be namespaced.
Fixes #14629, #14636 and #14070.
*Andrew White*, *Edho Arief*
* Add alias `ActionDispatch::Http::UploadedFile#to_io` to
`ActionDispatch::Http::UploadedFile#tempfile`.
*Tim Linquist*
* Returns null type format when format is not know and controller is using `any`
format block.
Fixes #14462.
*Rafael Mendonça França*
* Improve routing error page with fuzzy matching search.
*Winston*
* Only make deeply nested routes shallow when parent is shallow.
Fixes #14684.
*Andrew White*, *James Coglan*
* Append link to bad code to backtrace when exception is `SyntaxError`.
*Boris Kuznetsov*
* Swapped the parameters of assert_equal in `assert_select` so that the
proper values were printed correctly.
Fixes #14422.
*Vishal Lal*
* The method `shallow?` returns false if the parent resource is a singleton so
we need to check if we're not inside a nested scope before copying the :path
and :as options to their shallow equivalents.
Fixes #14388.
*Andrew White*
* Make logging of CSRF failures optional (but on by default) with the
`log_warning_on_csrf_failure` configuration setting in
`ActionController::RequestForgeryProtection`.
*John Barton*
* Fix URL generation in controller tests with request-dependent
`default_url_options` methods.
*Tony Wooster*
Please check [4-1-stable](https://github.com/rails/rails/blob/4-1-stable/actionpack/CHANGELOG.md) for previous changes.
rails-4.2.10/actionpack/MIT-LICENSE 0000664 0000000 0000000 00000002062 13162731520 0016460 0 ustar 00root root 0000000 0000000 Copyright (c) 2004-2014 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.
rails-4.2.10/actionpack/README.rdoc 0000664 0000000 0000000 00000003641 13162731520 0016636 0 ustar 00root root 0000000 0000000 = Action Pack -- From request to response
Action Pack is a framework for handling and responding to web requests. It
provides mechanisms for *routing* (mapping request URLs to actions), defining
*controllers* that implement actions, and generating responses by rendering
*views*, which are templates of various formats. In short, Action Pack
provides the view and controller layers in the MVC paradigm.
It consists of several modules:
* Action Dispatch, which parses information about the web request, handles
routing as defined by the user, and does advanced processing related to HTTP
such as MIME-type negotiation, decoding parameters in POST, PATCH, or PUT bodies,
handling HTTP caching logic, cookies and sessions.
* Action Controller, which provides a base controller class that can be
subclassed to implement filters and actions to handle requests. The result
of an action is typically content generated from views.
With the Ruby on Rails framework, users only directly interface with the
Action Controller module. Necessary Action Dispatch functionality is activated
by default and Action View rendering is implicitly triggered by Action
Controller. However, these modules are designed to function on their own and
can be used outside of Rails.
== Download and installation
The latest version of Action Pack can be installed with RubyGems:
% [sudo] gem install actionpack
Source code can be downloaded as part of the Rails project on GitHub
* https://github.com/rails/rails/tree/4-2-stable/actionpack
== License
Action Pack is released under the MIT license:
* http://www.opensource.org/licenses/MIT
== Support
API documentation is at
* http://api.rubyonrails.org
Bug reports can be filed for the Ruby on Rails project here:
* https://github.com/rails/rails/issues
Feature requests should be discussed on the rails-core mailing list here:
* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
rails-4.2.10/actionpack/Rakefile 0000664 0000000 0000000 00000002310 13162731520 0016465 0 ustar 00root root 0000000 0000000 require 'rake/testtask'
require 'rubygems/package_task'
test_files = Dir.glob('test/**/*_test.rb')
desc "Default Task"
task :default => :test
# Run the unit tests
Rake::TestTask.new do |t|
t.libs << 'test'
# make sure we include the tests in alphabetical order as on some systems
# this will not happen automatically and the tests (as a whole) will error
t.test_files = test_files.sort
t.warning = true
t.verbose = true
t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
end
namespace :test do
task :isolated do
test_files.all? do |file|
sh(Gem.ruby, '-w', '-Ilib:test', file)
end or raise "Failures"
end
end
spec = eval(File.read('actionpack.gemspec'))
Gem::PackageTask.new(spec) do |p|
p.gem_spec = spec
end
desc "Release to rubygems"
task :release => :package do
require 'rake/gemcutter'
Rake::Gemcutter::Tasks.new(spec).define
Rake::Task['gem:push'].invoke
end
task :lines do
load File.expand_path('..', File.dirname(__FILE__)) + '/tools/line_statistics'
files = FileList["lib/**/*.rb"]
CodeTools::LineStatistics.new(files).print_loc
end
rule '.rb' => '.y' do |t|
sh "racc -l -o #{t.name} #{t.source}"
end
task compile: 'lib/action_dispatch/journey/parser.rb'
rails-4.2.10/actionpack/actionpack.gemspec 0000664 0000000 0000000 00000002153 13162731520 0020506 0 ustar 00root root 0000000 0000000 version = File.read(File.expand_path('../../RAILS_VERSION', __FILE__)).strip
Gem::Specification.new do |s|
s.platform = Gem::Platform::RUBY
s.name = 'actionpack'
s.version = version
s.summary = 'Web-flow and rendering framework putting the VC in MVC (part of Rails).'
s.description = 'Web apps on Rails. Simple, battle-tested conventions for building and testing MVC web applications. Works with any Rack-compatible server.'
s.required_ruby_version = '>= 1.9.3'
s.license = 'MIT'
s.author = 'David Heinemeier Hansson'
s.email = 'david@loudthinking.com'
s.homepage = 'http://www.rubyonrails.org'
s.files = Dir['CHANGELOG.md', 'README.rdoc', 'MIT-LICENSE', 'lib/**/*']
s.require_path = 'lib'
s.requirements << 'none'
s.add_dependency 'activesupport', version
s.add_dependency 'rack', '~> 1.6'
s.add_dependency 'rack-test', '~> 0.6.2'
s.add_dependency 'rails-html-sanitizer', '~> 1.0', '>= 1.0.2'
s.add_dependency 'rails-dom-testing', '~> 1.0', '>= 1.0.5'
s.add_dependency 'actionview', version
s.add_development_dependency 'activemodel', version
end
rails-4.2.10/actionpack/lib/ 0000775 0000000 0000000 00000000000 13162731520 0015572 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/lib/abstract_controller.rb 0000664 0000000 0000000 00000000771 13162731520 0022172 0 ustar 00root root 0000000 0000000 require 'action_pack'
require 'active_support/rails'
require 'active_support/core_ext/module/attr_internal'
require 'active_support/core_ext/module/anonymous'
require 'active_support/i18n'
module AbstractController
extend ActiveSupport::Autoload
autoload :Base
autoload :Callbacks
autoload :Collector
autoload :DoubleRenderError, "abstract_controller/rendering"
autoload :Helpers
autoload :Logger
autoload :Rendering
autoload :Translation
autoload :AssetPaths
autoload :UrlFor
end
rails-4.2.10/actionpack/lib/abstract_controller/ 0000775 0000000 0000000 00000000000 13162731520 0021640 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/lib/abstract_controller/asset_paths.rb 0000664 0000000 0000000 00000000411 13162731520 0024477 0 ustar 00root root 0000000 0000000 module AbstractController
module AssetPaths #:nodoc:
extend ActiveSupport::Concern
included do
config_accessor :asset_host, :assets_dir, :javascripts_dir,
:stylesheets_dir, :default_asset_host_protocol, :relative_url_root
end
end
end
rails-4.2.10/actionpack/lib/abstract_controller/base.rb 0000664 0000000 0000000 00000023201 13162731520 0023075 0 ustar 00root root 0000000 0000000 require 'erubis'
require 'set'
require 'active_support/configurable'
require 'active_support/descendants_tracker'
require 'active_support/core_ext/module/anonymous'
module AbstractController
class Error < StandardError #:nodoc:
end
# Raised when a non-existing controller action is triggered.
class ActionNotFound < StandardError
end
# AbstractController::Base is a low-level API. Nobody should be
# using it directly, and subclasses (like ActionController::Base) are
# expected to provide their own +render+ method, since rendering means
# different things depending on the context.
class Base
attr_internal :response_body
attr_internal :action_name
attr_internal :formats
include ActiveSupport::Configurable
extend ActiveSupport::DescendantsTracker
undef_method :not_implemented
class << self
attr_reader :abstract
alias_method :abstract?, :abstract
# Define a controller as abstract. See internal_methods for more
# details.
def abstract!
@abstract = true
end
def inherited(klass) # :nodoc:
# Define the abstract ivar on subclasses so that we don't get
# uninitialized ivar warnings
unless klass.instance_variable_defined?(:@abstract)
klass.instance_variable_set(:@abstract, false)
end
super
end
# A list of all internal methods for a controller. This finds the first
# abstract superclass of a controller, and gets a list of all public
# instance methods on that abstract class. Public instance methods of
# a controller would normally be considered action methods, so methods
# declared on abstract classes are being removed.
# (ActionController::Metal and ActionController::Base are defined as abstract)
def internal_methods
controller = self
controller = controller.superclass until controller.abstract?
controller.public_instance_methods(true)
end
# The list of hidden actions. Defaults to an empty array.
# This can be modified by other modules or subclasses
# to specify particular actions as hidden.
#
# ==== Returns
# * Array - An array of method names that should not be considered actions.
def hidden_actions
[]
end
# A list of method names that should be considered actions. This
# includes all public instance methods on a controller, less
# any internal methods (see #internal_methods), adding back in
# any methods that are internal, but still exist on the class
# itself. Finally, #hidden_actions are removed.
#
# ==== Returns
# * Set - A set of all methods that should be considered actions.
def action_methods
@action_methods ||= begin
# All public instance methods of this class, including ancestors
methods = (public_instance_methods(true) -
# Except for public instance methods of Base and its ancestors
internal_methods +
# Be sure to include shadowed public instance methods of this class
public_instance_methods(false)).uniq.map { |x| x.to_s } -
# And always exclude explicitly hidden actions
hidden_actions.to_a
# Clear out AS callback method pollution
Set.new(methods.reject { |method| method =~ /_one_time_conditions/ })
end
end
# action_methods are cached and there is sometimes need to refresh
# them. clear_action_methods! allows you to do that, so next time
# you run action_methods, they will be recalculated
def clear_action_methods!
@action_methods = nil
end
# Returns the full controller name, underscored, without the ending Controller.
# For instance, MyApp::MyPostsController would return "my_app/my_posts" for
# controller_path.
#
# ==== Returns
# * String
def controller_path
@controller_path ||= name.sub(/Controller$/, '').underscore unless anonymous?
end
# Refresh the cached action_methods when a new action_method is added.
def method_added(name)
super
clear_action_methods!
end
end
abstract!
# Calls the action going through the entire action dispatch stack.
#
# The actual method that is called is determined by calling
# #method_for_action. If no method can handle the action, then an
# AbstractController::ActionNotFound error is raised.
#
# ==== Returns
# * self
def process(action, *args)
@_action_name = action.to_s
unless action_name = _find_action_name(@_action_name)
raise ActionNotFound, "The action '#{action}' could not be found for #{self.class.name}"
end
@_response_body = nil
process_action(action_name, *args)
end
# Delegates to the class' #controller_path
def controller_path
self.class.controller_path
end
# Delegates to the class' #action_methods
def action_methods
self.class.action_methods
end
# Returns true if a method for the action is available and
# can be dispatched, false otherwise.
#
# Notice that action_methods.include?("foo") may return
# false and available_action?("foo") returns true because
# this method considers actions that are also available
# through other means, for example, implicit render ones.
#
# ==== Parameters
# * action_name - The name of an action to be tested
#
# ==== Returns
# * TrueClass, FalseClass
def available_action?(action_name)
_find_action_name(action_name).present?
end
# Returns true if the given controller is capable of rendering
# a path. A subclass of +AbstractController::Base+
# may return false. An Email controller for example does not
# support paths, only full URLs.
def self.supports_path?
true
end
private
# Returns true if the name can be considered an action because
# it has a method defined in the controller.
#
# ==== Parameters
# * name - The name of an action to be tested
#
# ==== Returns
# * TrueClass, FalseClass
#
# :api: private
def action_method?(name)
self.class.action_methods.include?(name)
end
# Call the action. Override this in a subclass to modify the
# behavior around processing an action. This, and not #process,
# is the intended way to override action dispatching.
#
# Notice that the first argument is the method to be dispatched
# which is *not* necessarily the same as the action name.
def process_action(method_name, *args)
send_action(method_name, *args)
end
# Actually call the method associated with the action. Override
# this method if you wish to change how action methods are called,
# not to add additional behavior around it. For example, you would
# override #send_action if you want to inject arguments into the
# method.
alias send_action send
# If the action name was not found, but a method called "action_missing"
# was found, #method_for_action will return "_handle_action_missing".
# This method calls #action_missing with the current action name.
def _handle_action_missing(*args)
action_missing(@_action_name, *args)
end
# Takes an action name and returns the name of the method that will
# handle the action.
#
# It checks if the action name is valid and returns false otherwise.
#
# See method_for_action for more information.
#
# ==== Parameters
# * action_name - An action name to find a method name for
#
# ==== Returns
# * string - The name of the method that handles the action
# * false - No valid method name could be found.
# Raise AbstractController::ActionNotFound.
def _find_action_name(action_name)
_valid_action_name?(action_name) && method_for_action(action_name)
end
# Takes an action name and returns the name of the method that will
# handle the action. In normal cases, this method returns the same
# name as it receives. By default, if #method_for_action receives
# a name that is not an action, it will look for an #action_missing
# method and return "_handle_action_missing" if one is found.
#
# Subclasses may override this method to add additional conditions
# that should be considered an action. For instance, an HTTP controller
# with a template matching the action name is considered to exist.
#
# If you override this method to handle additional cases, you may
# also provide a method (like _handle_method_missing) to handle
# the case.
#
# If none of these conditions are true, and method_for_action
# returns nil, an AbstractController::ActionNotFound exception will be raised.
#
# ==== Parameters
# * action_name - An action name to find a method name for
#
# ==== Returns
# * string - The name of the method that handles the action
# * nil - No method name could be found.
def method_for_action(action_name)
if action_method?(action_name)
action_name
elsif respond_to?(:action_missing, true)
"_handle_action_missing"
end
end
# Checks if the action name is valid and returns false otherwise.
def _valid_action_name?(action_name)
!action_name.to_s.include? File::SEPARATOR
end
end
end
rails-4.2.10/actionpack/lib/abstract_controller/callbacks.rb 0000664 0000000 0000000 00000015345 13162731520 0024114 0 ustar 00root root 0000000 0000000 module AbstractController
module Callbacks
extend ActiveSupport::Concern
# Uses ActiveSupport::Callbacks as the base functionality. For
# more details on the whole callback system, read the documentation
# for ActiveSupport::Callbacks.
include ActiveSupport::Callbacks
included do
define_callbacks :process_action,
terminator: ->(controller,_) { controller.response_body },
skip_after_callbacks_if_terminated: true
end
# Override AbstractController::Base's process_action to run the
# process_action callbacks around the normal behavior.
def process_action(*args)
run_callbacks(:process_action) do
super
end
end
module ClassMethods
# If :only or :except are used, convert the options into the
# :unless and :if options of ActiveSupport::Callbacks.
# The basic idea is that :only => :index gets converted to
# :if => proc {|c| c.action_name == "index" }.
#
# ==== Options
# * only - The callback should be run only for this action
# * except - The callback should be run for all actions except this action
def _normalize_callback_options(options)
_normalize_callback_option(options, :only, :if)
_normalize_callback_option(options, :except, :unless)
end
def _normalize_callback_option(options, from, to) # :nodoc:
if from = options[from]
from = Array(from).map {|o| "action_name == '#{o}'"}.join(" || ")
options[to] = Array(options[to]).unshift(from)
end
end
# Skip before, after, and around action callbacks matching any of the names.
#
# ==== Parameters
# * names - A list of valid names that could be used for
# callbacks. Note that skipping uses Ruby equality, so it's
# impossible to skip a callback defined using an anonymous proc
# using #skip_action_callback
def skip_action_callback(*names)
skip_before_action(*names)
skip_after_action(*names)
skip_around_action(*names)
end
alias_method :skip_filter, :skip_action_callback
# Take callback names and an optional callback proc, normalize them,
# then call the block with each callback. This allows us to abstract
# the normalization across several methods that use it.
#
# ==== Parameters
# * callbacks - An array of callbacks, with an optional
# options hash as the last parameter.
# * block - A proc that should be added to the callbacks.
#
# ==== Block Parameters
# * name - The callback to be added
# * options - A hash of options to be used when adding the callback
def _insert_callbacks(callbacks, block = nil)
options = callbacks.extract_options!
_normalize_callback_options(options)
callbacks.push(block) if block
callbacks.each do |callback|
yield callback, options
end
end
##
# :method: before_action
#
# :call-seq: before_action(names, block)
#
# Append a callback before actions. See _insert_callbacks for parameter details.
##
# :method: prepend_before_action
#
# :call-seq: prepend_before_action(names, block)
#
# Prepend a callback before actions. See _insert_callbacks for parameter details.
##
# :method: skip_before_action
#
# :call-seq: skip_before_action(names)
#
# Skip a callback before actions. See _insert_callbacks for parameter details.
##
# :method: append_before_action
#
# :call-seq: append_before_action(names, block)
#
# Append a callback before actions. See _insert_callbacks for parameter details.
##
# :method: after_action
#
# :call-seq: after_action(names, block)
#
# Append a callback after actions. See _insert_callbacks for parameter details.
##
# :method: prepend_after_action
#
# :call-seq: prepend_after_action(names, block)
#
# Prepend a callback after actions. See _insert_callbacks for parameter details.
##
# :method: skip_after_action
#
# :call-seq: skip_after_action(names)
#
# Skip a callback after actions. See _insert_callbacks for parameter details.
##
# :method: append_after_action
#
# :call-seq: append_after_action(names, block)
#
# Append a callback after actions. See _insert_callbacks for parameter details.
##
# :method: around_action
#
# :call-seq: around_action(names, block)
#
# Append a callback around actions. See _insert_callbacks for parameter details.
##
# :method: prepend_around_action
#
# :call-seq: prepend_around_action(names, block)
#
# Prepend a callback around actions. See _insert_callbacks for parameter details.
##
# :method: skip_around_action
#
# :call-seq: skip_around_action(names)
#
# Skip a callback around actions. See _insert_callbacks for parameter details.
##
# :method: append_around_action
#
# :call-seq: append_around_action(names, block)
#
# Append a callback around actions. See _insert_callbacks for parameter details.
# set up before_action, prepend_before_action, skip_before_action, etc.
# for each of before, after, and around.
[:before, :after, :around].each do |callback|
define_method "#{callback}_action" do |*names, &blk|
_insert_callbacks(names, blk) do |name, options|
set_callback(:process_action, callback, name, options)
end
end
alias_method :"#{callback}_filter", :"#{callback}_action"
define_method "prepend_#{callback}_action" do |*names, &blk|
_insert_callbacks(names, blk) do |name, options|
set_callback(:process_action, callback, name, options.merge(:prepend => true))
end
end
alias_method :"prepend_#{callback}_filter", :"prepend_#{callback}_action"
# Skip a before, after or around callback. See _insert_callbacks
# for details on the allowed parameters.
define_method "skip_#{callback}_action" do |*names|
_insert_callbacks(names) do |name, options|
skip_callback(:process_action, callback, name, options)
end
end
alias_method :"skip_#{callback}_filter", :"skip_#{callback}_action"
# *_action is the same as append_*_action
alias_method :"append_#{callback}_action", :"#{callback}_action"
alias_method :"append_#{callback}_filter", :"#{callback}_action"
end
end
end
end
rails-4.2.10/actionpack/lib/abstract_controller/collector.rb 0000664 0000000 0000000 00000002772 13162731520 0024163 0 ustar 00root root 0000000 0000000 require "action_dispatch/http/mime_type"
module AbstractController
module Collector
def self.generate_method_for_mime(mime)
sym = mime.is_a?(Symbol) ? mime : mime.to_sym
const = sym.upcase
class_eval <<-RUBY, __FILE__, __LINE__ + 1
def #{sym}(*args, &block) # def html(*args, &block)
custom(Mime::#{const}, *args, &block) # custom(Mime::HTML, *args, &block)
end # end
RUBY
end
Mime::SET.each do |mime|
generate_method_for_mime(mime)
end
Mime::Type.register_callback do |mime|
generate_method_for_mime(mime) unless self.instance_methods.include?(mime.to_sym)
end
protected
def method_missing(symbol, &block)
const_name = symbol.upcase
unless Mime.const_defined?(const_name)
raise NoMethodError, "To respond to a custom format, register it as a MIME type first: " \
"http://guides.rubyonrails.org/action_controller_overview.html#restful-downloads. " \
"If you meant to respond to a variant like :tablet or :phone, not a custom format, " \
"be sure to nest your variant response within a format response: " \
"format.html { |html| html.tablet { ... } }"
end
mime_constant = Mime.const_get(const_name)
if Mime::SET.include?(mime_constant)
AbstractController::Collector.generate_method_for_mime(mime_constant)
send(symbol, &block)
else
super
end
end
end
end
rails-4.2.10/actionpack/lib/abstract_controller/helpers.rb 0000664 0000000 0000000 00000015505 13162731520 0023635 0 ustar 00root root 0000000 0000000 require 'active_support/dependencies'
module AbstractController
module Helpers
extend ActiveSupport::Concern
included do
class_attribute :_helpers
self._helpers = Module.new
class_attribute :_helper_methods
self._helper_methods = Array.new
end
class MissingHelperError < LoadError
def initialize(error, path)
@error = error
@path = "helpers/#{path}.rb"
set_backtrace error.backtrace
if error.path =~ /^#{path}(\.rb)?$/
super("Missing helper file helpers/%s.rb" % path)
else
raise error
end
end
end
module ClassMethods
# When a class is inherited, wrap its helper module in a new module.
# This ensures that the parent class's module can be changed
# independently of the child class's.
def inherited(klass)
helpers = _helpers
klass._helpers = Module.new { include helpers }
klass.class_eval { default_helper_module! } unless klass.anonymous?
super
end
# Declare a controller method as a helper. For example, the following
# makes the +current_user+ controller method available to the view:
# class ApplicationController < ActionController::Base
# helper_method :current_user, :logged_in?
#
# def current_user
# @current_user ||= User.find_by(id: session[:user])
# end
#
# def logged_in?
# current_user != nil
# end
# end
#
# In a view:
# <% if logged_in? -%>Welcome, <%= current_user.name %><% end -%>
#
# ==== Parameters
# * method[, method] - A name or names of a method on the controller
# to be made available on the view.
def helper_method(*meths)
meths.flatten!
self._helper_methods += meths
meths.each do |meth|
_helpers.class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
def #{meth}(*args, &blk) # def current_user(*args, &blk)
controller.send(%(#{meth}), *args, &blk) # controller.send(:current_user, *args, &blk)
end # end
ruby_eval
end
end
# The +helper+ class method can take a series of helper module names, a block, or both.
#
# ==== Options
# * *args - Module, Symbol, String
# * block - A block defining helper methods
#
# When the argument is a module it will be included directly in the template class.
# helper FooHelper # => includes FooHelper
#
# When the argument is a string or symbol, the method will provide the "_helper" suffix, require the file
# and include the module in the template class. The second form illustrates how to include custom helpers
# when working with namespaced controllers, or other cases where the file containing the helper definition is not
# in one of Rails' standard load paths:
# helper :foo # => requires 'foo_helper' and includes FooHelper
# helper 'resources/foo' # => requires 'resources/foo_helper' and includes Resources::FooHelper
#
# Additionally, the +helper+ class method can receive and evaluate a block, making the methods defined available
# to the template.
#
# # One line
# helper { def hello() "Hello, world!" end }
#
# # Multi-line
# helper do
# def foo(bar)
# "#{bar} is the very best"
# end
# end
#
# Finally, all the above styles can be mixed together, and the +helper+ method can be invoked with a mix of
# +symbols+, +strings+, +modules+ and blocks.
#
# helper(:three, BlindHelper) { def mice() 'mice' end }
#
def helper(*args, &block)
modules_for_helpers(args).each do |mod|
add_template_helper(mod)
end
_helpers.module_eval(&block) if block_given?
end
# Clears up all existing helpers in this class, only keeping the helper
# with the same name as this class.
def clear_helpers
inherited_helper_methods = _helper_methods
self._helpers = Module.new
self._helper_methods = Array.new
inherited_helper_methods.each { |meth| helper_method meth }
default_helper_module! unless anonymous?
end
# Returns a list of modules, normalized from the acceptable kinds of
# helpers with the following behavior:
#
# String or Symbol:: :FooBar or "FooBar" becomes "foo_bar_helper",
# and "foo_bar_helper.rb" is loaded using require_dependency.
#
# Module:: No further processing
#
# After loading the appropriate files, the corresponding modules
# are returned.
#
# ==== Parameters
# * args - An array of helpers
#
# ==== Returns
# * Array - A normalized list of modules for the list of
# helpers provided.
def modules_for_helpers(args)
args.flatten.map! do |arg|
case arg
when String, Symbol
file_name = "#{arg.to_s.underscore}_helper"
begin
require_dependency(file_name)
rescue LoadError => e
raise AbstractController::Helpers::MissingHelperError.new(e, file_name)
end
mod_name = file_name.camelize
begin
mod_name.constantize
rescue LoadError
# dependencies.rb gives a similar error message but its wording is
# not as clear because it mentions autoloading. To the user all it
# matters is that a helper module couldn't be loaded, autoloading
# is an internal mechanism that should not leak.
raise NameError, "Couldn't find #{mod_name}, expected it to be defined in helpers/#{file_name}.rb"
end
when Module
arg
else
raise ArgumentError, "helper must be a String, Symbol, or Module"
end
end
end
private
# Makes all the (instance) methods in the helper module available to templates
# rendered through this controller.
#
# ==== Parameters
# * module - The module to include into the current helper module
# for the class
def add_template_helper(mod)
_helpers.module_eval { include mod }
end
def default_helper_module!
module_name = name.sub(/Controller$/, '')
module_path = module_name.underscore
helper module_path
rescue MissingSourceFile => e
raise e unless e.is_missing? "helpers/#{module_path}_helper"
rescue NameError => e
raise e unless e.missing_name? "#{module_name}Helper"
end
end
end
end
rails-4.2.10/actionpack/lib/abstract_controller/logger.rb 0000664 0000000 0000000 00000000351 13162731520 0023443 0 ustar 00root root 0000000 0000000 require "active_support/benchmarkable"
module AbstractController
module Logger #:nodoc:
extend ActiveSupport::Concern
included do
config_accessor :logger
include ActiveSupport::Benchmarkable
end
end
end
rails-4.2.10/actionpack/lib/abstract_controller/railties/ 0000775 0000000 0000000 00000000000 13162731520 0023454 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/lib/abstract_controller/railties/routes_helpers.rb 0000664 0000000 0000000 00000001102 13162731520 0027036 0 ustar 00root root 0000000 0000000 module AbstractController
module Railties
module RoutesHelpers
def self.with(routes, include_path_helpers = true)
Module.new do
define_method(:inherited) do |klass|
super(klass)
if namespace = klass.parents.detect { |m| m.respond_to?(:railtie_routes_url_helpers) }
klass.send(:include, namespace.railtie_routes_url_helpers(include_path_helpers))
else
klass.send(:include, routes.url_helpers(include_path_helpers))
end
end
end
end
end
end
end
rails-4.2.10/actionpack/lib/abstract_controller/rendering.rb 0000664 0000000 0000000 00000007436 13162731520 0024154 0 ustar 00root root 0000000 0000000 require 'active_support/concern'
require 'active_support/core_ext/class/attribute'
require 'action_view'
require 'action_view/view_paths'
require 'set'
module AbstractController
class DoubleRenderError < Error
DEFAULT_MESSAGE = "Render and/or redirect were called multiple times in this action. Please note that you may only call render OR redirect, and at most once per action. Also note that neither redirect nor render terminate execution of the action, so if you want to exit an action after redirecting, you need to do something like \"redirect_to(...) and return\"."
def initialize(message = nil)
super(message || DEFAULT_MESSAGE)
end
end
module Rendering
extend ActiveSupport::Concern
include ActionView::ViewPaths
# Normalize arguments, options and then delegates render_to_body and
# sticks the result in self.response_body.
# :api: public
def render(*args, &block)
options = _normalize_render(*args, &block)
self.response_body = render_to_body(options)
_process_format(rendered_format, options) if rendered_format
self.response_body
end
# Raw rendering of a template to a string.
#
# It is similar to render, except that it does not
# set the response_body and it should be guaranteed
# to always return a string.
#
# If a component extends the semantics of response_body
# (as Action Controller extends it to be anything that
# responds to the method each), this method needs to be
# overridden in order to still return a string.
# :api: plugin
def render_to_string(*args, &block)
options = _normalize_render(*args, &block)
render_to_body(options)
end
# Performs the actual template rendering.
# :api: public
def render_to_body(options = {})
end
# Returns Content-Type of rendered content
# :api: public
def rendered_format
Mime::TEXT
end
DEFAULT_PROTECTED_INSTANCE_VARIABLES = Set.new %w(
@_action_name @_response_body @_formats @_prefixes @_config
@_view_context_class @_view_renderer @_lookup_context
@_routes @_db_runtime
).map(&:to_sym)
# This method should return a hash with assigns.
# You can overwrite this configuration per controller.
# :api: public
def view_assigns
protected_vars = _protected_ivars
variables = instance_variables
variables.reject! { |s| protected_vars.include? s }
variables.each_with_object({}) { |name, hash|
hash[name.slice(1, name.length)] = instance_variable_get(name)
}
end
# Normalize args by converting render "foo" to render :action => "foo" and
# render "foo/bar" to render :file => "foo/bar".
# :api: plugin
def _normalize_args(action=nil, options={})
if action.respond_to?(:permitted?)
if action.permitted?
action
else
raise ArgumentError, "render parameters are not permitted"
end
elsif action.is_a?(Hash)
action
else
options
end
end
# Normalize options.
# :api: plugin
def _normalize_options(options)
options
end
# Process extra options.
# :api: plugin
def _process_options(options)
options
end
# Process the rendered format.
# :api: private
def _process_format(format, options = {})
end
# Normalize args and options.
# :api: private
def _normalize_render(*args, &block)
options = _normalize_args(*args, &block)
#TODO: remove defined? when we restore AP <=> AV dependency
if defined?(request) && request && request.variant.present?
options[:variant] = request.variant
end
_normalize_options(options)
options
end
def _protected_ivars # :nodoc:
DEFAULT_PROTECTED_INSTANCE_VARIABLES
end
end
end
rails-4.2.10/actionpack/lib/abstract_controller/translation.rb 0000664 0000000 0000000 00000001736 13162731520 0024532 0 ustar 00root root 0000000 0000000 module AbstractController
module Translation
# Delegates to I18n.translate. Also aliased as t.
#
# When the given key starts with a period, it will be scoped by the current
# controller and action. So if you call translate(".foo") from
# PeopleController#index, it will convert the call to
# I18n.translate("people.index.foo"). This makes it less repetitive
# to translate many keys within the same controller / action and gives you a
# simple framework for scoping them consistently.
def translate(*args)
key = args.first
if key.is_a?(String) && (key[0] == '.')
key = "#{ controller_path.tr('/', '.') }.#{ action_name }#{ key }"
args[0] = key
end
I18n.translate(*args)
end
alias :t :translate
# Delegates to I18n.localize. Also aliased as l.
def localize(*args)
I18n.localize(*args)
end
alias :l :localize
end
end
rails-4.2.10/actionpack/lib/abstract_controller/url_for.rb 0000664 0000000 0000000 00000001663 13162731520 0023643 0 ustar 00root root 0000000 0000000 module AbstractController
# Includes +url_for+ into the host class (e.g. an abstract controller or mailer). The class
# has to provide a +RouteSet+ by implementing the _routes methods. Otherwise, an
# exception will be raised.
#
# Note that this module is completely decoupled from HTTP - the only requirement is a valid
# _routes implementation.
module UrlFor
extend ActiveSupport::Concern
include ActionDispatch::Routing::UrlFor
def _routes
raise "In order to use #url_for, you must include routing helpers explicitly. " \
"For instance, `include Rails.application.routes.url_helpers`."
end
module ClassMethods
def _routes
nil
end
def action_methods
@action_methods ||= begin
if _routes
super - _routes.named_routes.helper_names
else
super
end
end
end
end
end
end
rails-4.2.10/actionpack/lib/action_controller.rb 0000664 0000000 0000000 00000003022 13162731520 0021634 0 ustar 00root root 0000000 0000000 require 'active_support/rails'
require 'abstract_controller'
require 'action_dispatch'
require 'action_controller/metal/live'
require 'action_controller/metal/strong_parameters'
module ActionController
extend ActiveSupport::Autoload
autoload :Base
autoload :Caching
autoload :Metal
autoload :Middleware
autoload_under "metal" do
autoload :Compatibility
autoload :ConditionalGet
autoload :Cookies
autoload :DataStreaming
autoload :EtagWithTemplateDigest
autoload :Flash
autoload :ForceSSL
autoload :Head
autoload :Helpers
autoload :HideActions
autoload :HttpAuthentication
autoload :ImplicitRender
autoload :Instrumentation
autoload :MimeResponds
autoload :ParamsWrapper
autoload :RackDelegation
autoload :Redirecting
autoload :Renderers
autoload :Rendering
autoload :RequestForgeryProtection
autoload :Rescue
autoload :Streaming
autoload :StrongParameters
autoload :Testing
autoload :UrlFor
end
autoload :TestCase, 'action_controller/test_case'
autoload :TemplateAssertions, 'action_controller/test_case'
def self.eager_load!
super
ActionController::Caching.eager_load!
end
end
# Common Active Support usage in Action Controller
require 'active_support/core_ext/module/attribute_accessors'
require 'active_support/core_ext/load_error'
require 'active_support/core_ext/module/attr_internal'
require 'active_support/core_ext/name_error'
require 'active_support/core_ext/uri'
require 'active_support/inflector'
rails-4.2.10/actionpack/lib/action_controller/ 0000775 0000000 0000000 00000000000 13162731520 0021312 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/lib/action_controller/base.rb 0000664 0000000 0000000 00000025353 13162731520 0022561 0 ustar 00root root 0000000 0000000 require 'action_view'
require "action_controller/log_subscriber"
require "action_controller/metal/params_wrapper"
module ActionController
# Action Controllers are the core of a web request in \Rails. They are made up of one or more actions that are executed
# on request and then either it renders a template or redirects to another action. An action is defined as a public method
# on the controller, which will automatically be made accessible to the web-server through \Rails Routes.
#
# By default, only the ApplicationController in a \Rails application inherits from ActionController::Base. All other
# controllers in turn inherit from ApplicationController. This gives you one class to configure things such as
# request forgery protection and filtering of sensitive request parameters.
#
# A sample controller could look like this:
#
# class PostsController < ApplicationController
# def index
# @posts = Post.all
# end
#
# def create
# @post = Post.create params[:post]
# redirect_to posts_path
# end
# end
#
# Actions, by default, render a template in the app/views directory corresponding to the name of the controller and action
# after executing code in the action. For example, the +index+ action of the PostsController would render the
# template app/views/posts/index.html.erb by default after populating the @posts instance variable.
#
# Unlike index, the create action will not render a template. After performing its main purpose (creating a
# new post), it initiates a redirect instead. This redirect works by returning an external
# "302 Moved" HTTP response that takes the user to the index action.
#
# These two methods represent the two basic action archetypes used in Action Controllers. Get-and-show and do-and-redirect.
# Most actions are variations on these themes.
#
# == Requests
#
# For every request, the router determines the value of the +controller+ and +action+ keys. These determine which controller
# and action are called. The remaining request parameters, the session (if one is available), and the full request with
# all the HTTP headers are made available to the action through accessor methods. Then the action is performed.
#
# The full request object is available via the request accessor and is primarily used to query for HTTP headers:
#
# def server_ip
# location = request.env["REMOTE_ADDR"]
# render plain: "This server hosted at #{location}"
# end
#
# == Parameters
#
# All request parameters, whether they come from a GET or POST request, or from the URL, are available through the params method
# which returns a hash. For example, an action that was performed through /posts?category=All&limit=5 will include
# { "category" => "All", "limit" => "5" } in params.
#
# It's also possible to construct multi-dimensional parameter hashes by specifying keys using brackets, such as:
#
#
#
#
# A request stemming from a form holding these inputs will include { "post" => { "name" => "david", "address" => "hyacintvej" } }.
# If the address input had been named post[address][street], the params would have included
# { "post" => { "address" => { "street" => "hyacintvej" } } }. There's no limit to the depth of the nesting.
#
# == Sessions
#
# Sessions allow you to store objects in between requests. This is useful for objects that are not yet ready to be persisted,
# such as a Signup object constructed in a multi-paged process, or objects that don't change much and are needed all the time, such
# as a User object for a system that requires login. The session should not be used, however, as a cache for objects where it's likely
# they could be changed unknowingly. It's usually too much work to keep it all synchronized -- something databases already excel at.
#
# You can place objects in the session by using the session method, which accesses a hash:
#
# session[:person] = Person.authenticate(user_name, password)
#
# And retrieved again through the same hash:
#
# Hello #{session[:person]}
#
# For removing objects from the session, you can either assign a single key to +nil+:
#
# # removes :person from session
# session[:person] = nil
#
# or you can remove the entire session with +reset_session+.
#
# Sessions are stored by default in a browser cookie that's cryptographically signed, but unencrypted.
# This prevents the user from tampering with the session but also allows them to see its contents.
#
# Do not put secret information in cookie-based sessions!
#
# == Responses
#
# Each action results in a response, which holds the headers and document to be sent to the user's browser. The actual response
# object is generated automatically through the use of renders and redirects and requires no user intervention.
#
# == Renders
#
# Action Controller sends content to the user by using one of five rendering methods. The most versatile and common is the rendering
# of a template. Included in the Action Pack is the Action View, which enables rendering of ERB templates. It's automatically configured.
# The controller passes objects to the view by assigning instance variables:
#
# def show
# @post = Post.find(params[:id])
# end
#
# Which are then automatically available to the view:
#
# Title: <%= @post.title %>
#
# You don't have to rely on the automated rendering. For example, actions that could result in the rendering of different templates
# will use the manual rendering methods:
#
# def search
# @results = Search.find(params[:query])
# case @results.count
# when 0 then render action: "no_results"
# when 1 then render action: "show"
# when 2..10 then render action: "show_many"
# end
# end
#
# Read more about writing ERB and Builder templates in ActionView::Base.
#
# == Redirects
#
# Redirects are used to move from one action to another. For example, after a create action, which stores a blog entry to the
# database, we might like to show the user the new entry. Because we're following good DRY principles (Don't Repeat Yourself), we're
# going to reuse (and redirect to) a show action that we'll assume has already been created. The code might look like this:
#
# def create
# @entry = Entry.new(params[:entry])
# if @entry.save
# # The entry was saved correctly, redirect to show
# redirect_to action: 'show', id: @entry.id
# else
# # things didn't go so well, do something else
# end
# end
#
# In this case, after saving our new entry to the database, the user is redirected to the show method, which is then executed.
# Note that this is an external HTTP-level redirection which will cause the browser to make a second request (a GET to the show action),
# and not some internal re-routing which calls both "create" and then "show" within one request.
#
# Learn more about redirect_to and what options you have in ActionController::Redirecting.
#
# == Calling multiple redirects or renders
#
# An action may contain only a single render or a single redirect. Attempting to try to do either again will result in a DoubleRenderError:
#
# def do_something
# redirect_to action: "elsewhere"
# render action: "overthere" # raises DoubleRenderError
# end
#
# If you need to redirect on the condition of something, then be sure to add "and return" to halt execution.
#
# def do_something
# redirect_to(action: "elsewhere") and return if monkeys.nil?
# render action: "overthere" # won't be called if monkeys is nil
# end
#
class Base < Metal
abstract!
# We document the request and response methods here because albeit they are
# implemented in ActionController::Metal, the type of the returned objects
# is unknown at that level.
##
# :method: request
#
# Returns an ActionDispatch::Request instance that represents the
# current request.
##
# :method: response
#
# Returns an ActionDispatch::Response that represents the current
# response.
# Shortcut helper that returns all the modules included in
# ActionController::Base except the ones passed as arguments:
#
# class MyBaseController < ActionController::Metal
# ActionController::Base.without_modules(:ParamsWrapper, :Streaming).each do |left|
# include left
# end
# end
#
# This gives better control over what you want to exclude and makes it
# easier to create a bare controller class, instead of listing the modules
# required manually.
def self.without_modules(*modules)
modules = modules.map do |m|
m.is_a?(Symbol) ? ActionController.const_get(m) : m
end
MODULES - modules
end
MODULES = [
AbstractController::Rendering,
AbstractController::Translation,
AbstractController::AssetPaths,
Helpers,
HideActions,
UrlFor,
Redirecting,
ActionView::Layouts,
Rendering,
Renderers::All,
ConditionalGet,
EtagWithTemplateDigest,
RackDelegation,
Caching,
MimeResponds,
ImplicitRender,
StrongParameters,
Cookies,
Flash,
RequestForgeryProtection,
ForceSSL,
Streaming,
DataStreaming,
HttpAuthentication::Basic::ControllerMethods,
HttpAuthentication::Digest::ControllerMethods,
HttpAuthentication::Token::ControllerMethods,
# Before callbacks should also be executed the earliest as possible, so
# also include them at the bottom.
AbstractController::Callbacks,
# Append rescue at the bottom to wrap as much as possible.
Rescue,
# Add instrumentations hooks at the bottom, to ensure they instrument
# all the methods properly.
Instrumentation,
# Params wrapper should come before instrumentation so they are
# properly showed in logs
ParamsWrapper
]
MODULES.each do |mod|
include mod
end
# Define some internal variables that should not be propagated to the view.
PROTECTED_IVARS = AbstractController::Rendering::DEFAULT_PROTECTED_INSTANCE_VARIABLES + [
:@_status, :@_headers, :@_params, :@_env, :@_response, :@_request,
:@_view_runtime, :@_stream, :@_url_options, :@_action_has_layout ]
def _protected_ivars # :nodoc:
PROTECTED_IVARS
end
def self.protected_instance_variables
PROTECTED_IVARS
end
ActiveSupport.run_load_hooks(:action_controller, self)
end
end
rails-4.2.10/actionpack/lib/action_controller/caching.rb 0000664 0000000 0000000 00000004771 13162731520 0023244 0 ustar 00root root 0000000 0000000 require 'fileutils'
require 'uri'
require 'set'
module ActionController
# \Caching is a cheap way of speeding up slow applications by keeping the result of
# calculations, renderings, and database calls around for subsequent requests.
#
# You can read more about each approach by clicking the modules below.
#
# Note: To turn off all caching, set
# config.action_controller.perform_caching = false
#
# == \Caching stores
#
# All the caching stores from ActiveSupport::Cache are available to be used as backends
# for Action Controller caching.
#
# Configuration examples (FileStore is the default):
#
# config.action_controller.cache_store = :memory_store
# config.action_controller.cache_store = :file_store, '/path/to/cache/directory'
# config.action_controller.cache_store = :mem_cache_store, 'localhost'
# config.action_controller.cache_store = :mem_cache_store, Memcached::Rails.new('localhost:11211')
# config.action_controller.cache_store = MyOwnStore.new('parameter')
module Caching
extend ActiveSupport::Concern
extend ActiveSupport::Autoload
eager_autoload do
autoload :Fragments
end
module ConfigMethods
def cache_store
config.cache_store
end
def cache_store=(store)
config.cache_store = ActiveSupport::Cache.lookup_store(store)
end
private
def cache_configured?
perform_caching && cache_store
end
end
include RackDelegation
include AbstractController::Callbacks
include ConfigMethods
include Fragments
included do
extend ConfigMethods
config_accessor :default_static_extension
self.default_static_extension ||= '.html'
config_accessor :perform_caching
self.perform_caching = true if perform_caching.nil?
class_attribute :_view_cache_dependencies
self._view_cache_dependencies = []
helper_method :view_cache_dependencies if respond_to?(:helper_method)
end
module ClassMethods
def view_cache_dependency(&dependency)
self._view_cache_dependencies += [dependency]
end
end
def view_cache_dependencies
self.class._view_cache_dependencies.map { |dep| instance_exec(&dep) }.compact
end
protected
# Convenience accessor.
def cache(key, options = {}, &block)
if cache_configured?
cache_store.fetch(ActiveSupport::Cache.expand_cache_key(key, :controller), options, &block)
else
yield
end
end
end
end
rails-4.2.10/actionpack/lib/action_controller/caching/ 0000775 0000000 0000000 00000000000 13162731520 0022706 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/lib/action_controller/caching/fragments.rb 0000664 0000000 0000000 00000007750 13162731520 0025232 0 ustar 00root root 0000000 0000000 module ActionController
module Caching
# Fragment caching is used for caching various blocks within
# views without caching the entire action as a whole. This is
# useful when certain elements of an action change frequently or
# depend on complicated state while other parts rarely change or
# can be shared amongst multiple parties. The caching is done using
# the +cache+ helper available in the Action View. See
# ActionView::Helpers::CacheHelper for more information.
#
# While it's strongly recommended that you use key-based cache
# expiration (see links in CacheHelper for more information),
# it is also possible to manually expire caches. For example:
#
# expire_fragment('name_of_cache')
module Fragments
# Given a key (as described in +expire_fragment+), returns
# a key suitable for use in reading, writing, or expiring a
# cached fragment. All keys are prefixed with views/ and uses
# ActiveSupport::Cache.expand_cache_key for the expansion.
def fragment_cache_key(key)
ActiveSupport::Cache.expand_cache_key(key.is_a?(Hash) ? url_for(key).split("://").last : key, :views)
end
# Writes +content+ to the location signified by
# +key+ (see +expire_fragment+ for acceptable formats).
def write_fragment(key, content, options = nil)
return content unless cache_configured?
key = fragment_cache_key(key)
instrument_fragment_cache :write_fragment, key do
content = content.to_str
cache_store.write(key, content, options)
end
content
end
# Reads a cached fragment from the location signified by +key+
# (see +expire_fragment+ for acceptable formats).
def read_fragment(key, options = nil)
return unless cache_configured?
key = fragment_cache_key(key)
instrument_fragment_cache :read_fragment, key do
result = cache_store.read(key, options)
result.respond_to?(:html_safe) ? result.html_safe : result
end
end
# Check if a cached fragment from the location signified by
# +key+ exists (see +expire_fragment+ for acceptable formats).
def fragment_exist?(key, options = nil)
return unless cache_configured?
key = fragment_cache_key(key)
instrument_fragment_cache :exist_fragment?, key do
cache_store.exist?(key, options)
end
end
# Removes fragments from the cache.
#
# +key+ can take one of three forms:
#
# * String - This would normally take the form of a path, like
# pages/45/notes.
# * Hash - Treated as an implicit call to +url_for+, like
# { controller: 'pages', action: 'notes', id: 45}
# * Regexp - Will remove any fragment that matches, so
# %r{pages/\d*/notes} might remove all notes. Make sure you
# don't use anchors in the regex (^ or $) because
# the actual filename matched looks like
# ./cache/filename/path.cache. Note: Regexp expiration is
# only supported on caches that can iterate over all keys (unlike
# memcached).
#
# +options+ is passed through to the cache store's +delete+
# method (or delete_matched, for Regexp keys).
def expire_fragment(key, options = nil)
return unless cache_configured?
key = fragment_cache_key(key) unless key.is_a?(Regexp)
instrument_fragment_cache :expire_fragment, key do
if key.is_a?(Regexp)
cache_store.delete_matched(key, options)
else
cache_store.delete(key, options)
end
end
end
def instrument_fragment_cache(name, key) # :nodoc:
payload = {
controller: controller_name,
action: action_name,
key: key
}
ActiveSupport::Notifications.instrument("#{name}.action_controller", payload) { yield }
end
end
end
end
rails-4.2.10/actionpack/lib/action_controller/log_subscriber.rb 0000664 0000000 0000000 00000005361 13162731520 0024650 0 ustar 00root root 0000000 0000000 module ActionController
class LogSubscriber < ActiveSupport::LogSubscriber
INTERNAL_PARAMS = %w(controller action format _method only_path)
def start_processing(event)
return unless logger.info?
payload = event.payload
params = payload[:params].except(*INTERNAL_PARAMS)
format = payload[:format]
format = format.to_s.upcase if format.is_a?(Symbol)
info "Processing by #{payload[:controller]}##{payload[:action]} as #{format}"
info " Parameters: #{params.inspect}" unless params.empty?
end
def process_action(event)
info do
payload = event.payload
additions = ActionController::Base.log_process_action(payload)
status = payload[:status]
if status.nil? && payload[:exception].present?
exception_class_name = payload[:exception].first
status = ActionDispatch::ExceptionWrapper.status_code_for_exception(exception_class_name)
end
message = "Completed #{status} #{Rack::Utils::HTTP_STATUS_CODES[status]} in #{event.duration.round}ms"
message << " (#{additions.join(" | ")})" unless additions.blank?
message
end
end
def halted_callback(event)
info { "Filter chain halted as #{event.payload[:filter].inspect} rendered or redirected" }
end
def send_file(event)
info { "Sent file #{event.payload[:path]} (#{event.duration.round(1)}ms)" }
end
def redirect_to(event)
info { "Redirected to #{event.payload[:location]}" }
end
def send_data(event)
info { "Sent data #{event.payload[:filename]} (#{event.duration.round(1)}ms)" }
end
def unpermitted_parameters(event)
debug do
unpermitted_keys = event.payload[:keys]
"Unpermitted parameter#{'s' if unpermitted_keys.size > 1}: #{unpermitted_keys.join(", ")}"
end
end
def deep_munge(event)
debug do
"Value for params[:#{event.payload[:keys].join('][:')}] was set "\
"to nil, because it was one of [], [null] or [null, null, ...]. "\
"Go to http://guides.rubyonrails.org/security.html#unsafe-query-generation "\
"for more information."\
end
end
%w(write_fragment read_fragment exist_fragment?
expire_fragment expire_page write_page).each do |method|
class_eval <<-METHOD, __FILE__, __LINE__ + 1
def #{method}(event)
return unless logger.info?
key_or_path = event.payload[:key] || event.payload[:path]
human_name = #{method.to_s.humanize.inspect}
info("\#{human_name} \#{key_or_path} (\#{event.duration.round(1)}ms)")
end
METHOD
end
def logger
ActionController::Base.logger
end
end
end
ActionController::LogSubscriber.attach_to :action_controller
rails-4.2.10/actionpack/lib/action_controller/metal.rb 0000664 0000000 0000000 00000015212 13162731520 0022742 0 ustar 00root root 0000000 0000000 require 'active_support/core_ext/array/extract_options'
require 'action_dispatch/middleware/stack'
module ActionController
# Extend ActionDispatch middleware stack to make it aware of options
# allowing the following syntax in controllers:
#
# class PostsController < ApplicationController
# use AuthenticationMiddleware, except: [:index, :show]
# end
#
class MiddlewareStack < ActionDispatch::MiddlewareStack #:nodoc:
class Middleware < ActionDispatch::MiddlewareStack::Middleware #:nodoc:
def initialize(klass, *args, &block)
options = args.extract_options!
@only = Array(options.delete(:only)).map(&:to_s)
@except = Array(options.delete(:except)).map(&:to_s)
args << options unless options.empty?
super
end
def valid?(action)
if @only.present?
@only.include?(action)
elsif @except.present?
!@except.include?(action)
else
true
end
end
end
def build(action, app = Proc.new)
action = action.to_s
middlewares.reverse.inject(app) do |a, middleware|
middleware.valid?(action) ? middleware.build(a) : a
end
end
end
# ActionController::Metal is the simplest possible controller, providing a
# valid Rack interface without the additional niceties provided by
# ActionController::Base.
#
# A sample metal controller might look like this:
#
# class HelloController < ActionController::Metal
# def index
# self.response_body = "Hello World!"
# end
# end
#
# And then to route requests to your metal controller, you would add
# something like this to config/routes.rb:
#
# get 'hello', to: HelloController.action(:index)
#
# The +action+ method returns a valid Rack application for the \Rails
# router to dispatch to.
#
# == Rendering Helpers
#
# ActionController::Metal by default provides no utilities for rendering
# views, partials, or other responses aside from explicitly calling of
# response_body=, content_type=, and status=. To
# add the render helpers you're used to having in a normal controller, you
# can do the following:
#
# class HelloController < ActionController::Metal
# include AbstractController::Rendering
# include ActionView::Layouts
# append_view_path "#{Rails.root}/app/views"
#
# def index
# render "hello/index"
# end
# end
#
# == Redirection Helpers
#
# To add redirection helpers to your metal controller, do the following:
#
# class HelloController < ActionController::Metal
# include ActionController::Redirecting
# include Rails.application.routes.url_helpers
#
# def index
# redirect_to root_url
# end
# end
#
# == Other Helpers
#
# You can refer to the modules included in ActionController::Base to see
# other features you can bring into your metal controller.
#
class Metal < AbstractController::Base
abstract!
attr_internal_writer :env
def env
@_env ||= {}
end
# Returns the last part of the controller's name, underscored, without the ending
# Controller. For instance, PostsController returns posts.
# Namespaces are left out, so Admin::PostsController returns posts as well.
#
# ==== Returns
# * string
def self.controller_name
@controller_name ||= name.demodulize.sub(/Controller$/, '').underscore
end
# Delegates to the class' controller_name
def controller_name
self.class.controller_name
end
# The details below can be overridden to support a specific
# Request and Response object. The default ActionController::Base
# implementation includes RackDelegation, which makes a request
# and response object available. You might wish to control the
# environment and response manually for performance reasons.
attr_internal :headers, :response, :request
delegate :session, :to => "@_request"
def initialize
@_headers = {"Content-Type" => "text/html"}
@_status = 200
@_request = nil
@_response = nil
@_routes = nil
super
end
def params
@_params ||= request.parameters
end
def params=(val)
@_params = val
end
# Basic implementations for content_type=, location=, and headers are
# provided to reduce the dependency on the RackDelegation module
# in Renderer and Redirector.
def content_type=(type)
headers["Content-Type"] = type.to_s
end
def content_type
headers["Content-Type"]
end
def location
headers["Location"]
end
def location=(url)
headers["Location"] = url
end
# Basic url_for that can be overridden for more robust functionality
def url_for(string)
string
end
def status
@_status
end
alias :response_code :status # :nodoc:
def status=(status)
@_status = Rack::Utils.status_code(status)
end
def response_body=(body)
body = [body] unless body.nil? || body.respond_to?(:each)
super
end
# Tests if render or redirect has already happened.
def performed?
response_body || (response && response.committed?)
end
def dispatch(name, request) #:nodoc:
@_request = request
@_env = request.env
@_env['action_controller.instance'] = self
process(name)
to_a
end
def to_a #:nodoc:
response ? response.to_a : [status, headers, response_body]
end
class_attribute :middleware_stack
self.middleware_stack = ActionController::MiddlewareStack.new
def self.inherited(base) # :nodoc:
base.middleware_stack = middleware_stack.dup
super
end
# Pushes the given Rack middleware and its arguments to the bottom of the
# middleware stack.
def self.use(*args, &block)
middleware_stack.use(*args, &block)
end
# Alias for +middleware_stack+.
def self.middleware
middleware_stack
end
# Makes the controller a Rack endpoint that runs the action in the given
# +env+'s +action_dispatch.request.path_parameters+ key.
def self.call(env)
req = ActionDispatch::Request.new env
action(req.path_parameters[:action]).call(env)
end
# Returns a Rack endpoint for the given action name.
def self.action(name, klass = ActionDispatch::Request)
if middleware_stack.any?
middleware_stack.build(name) do |env|
new.dispatch(name, klass.new(env))
end
else
lambda { |env| new.dispatch(name, klass.new(env)) }
end
end
end
end
rails-4.2.10/actionpack/lib/action_controller/metal/ 0000775 0000000 0000000 00000000000 13162731520 0022414 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/lib/action_controller/metal/conditional_get.rb 0000664 0000000 0000000 00000016561 13162731520 0026114 0 ustar 00root root 0000000 0000000 require 'active_support/core_ext/hash/keys'
module ActionController
module ConditionalGet
extend ActiveSupport::Concern
include RackDelegation
include Head
included do
class_attribute :etaggers
self.etaggers = []
end
module ClassMethods
# Allows you to consider additional controller-wide information when generating an ETag.
# For example, if you serve pages tailored depending on who's logged in at the moment, you
# may want to add the current user id to be part of the ETag to prevent authorized displaying
# of cached pages.
#
# class InvoicesController < ApplicationController
# etag { current_user.try :id }
#
# def show
# # Etag will differ even for the same invoice when it's viewed by a different current_user
# @invoice = Invoice.find(params[:id])
# fresh_when(@invoice)
# end
# end
def etag(&etagger)
self.etaggers += [etagger]
end
end
# Sets the +etag+, +last_modified+, or both on the response and renders a
# 304 Not Modified response if the request is already fresh.
#
# === Parameters:
#
# * :etag.
# * :last_modified.
# * :public By default the Cache-Control header is private, set this to
# +true+ if you want your application to be cachable by other devices (proxy caches).
# * :template By default, the template digest for the current
# controller/action is included in ETags. If the action renders a
# different template, you can include its digest instead. If the action
# doesn't render a template at all, you can pass template: false
# to skip any attempt to check for a template digest.
#
# === Example:
#
# def show
# @article = Article.find(params[:id])
# fresh_when(etag: @article, last_modified: @article.created_at, public: true)
# end
#
# This will render the show template if the request isn't sending a matching ETag or
# If-Modified-Since header and just a 304 Not Modified response if there's a match.
#
# You can also just pass a record where +last_modified+ will be set by calling
# +updated_at+ and the +etag+ by passing the object itself.
#
# def show
# @article = Article.find(params[:id])
# fresh_when(@article)
# end
#
# When passing a record, you can still set whether the public header:
#
# def show
# @article = Article.find(params[:id])
# fresh_when(@article, public: true)
# end
#
# When rendering a different template than the default controller/action
# style, you can indicate which digest to include in the ETag:
#
# before_action { fresh_when @article, template: 'widgets/show' }
#
def fresh_when(record_or_options, additional_options = {})
if record_or_options.is_a? Hash
options = record_or_options
options.assert_valid_keys(:etag, :last_modified, :public, :template)
else
record = record_or_options
options = { etag: record, last_modified: record.try(:updated_at) }.merge!(additional_options)
end
response.etag = combine_etags(options) if options[:etag] || options[:template]
response.last_modified = options[:last_modified] if options[:last_modified]
response.cache_control[:public] = true if options[:public]
head :not_modified if request.fresh?(response)
end
# Sets the +etag+ and/or +last_modified+ on the response and checks it against
# the client request. If the request doesn't match the options provided, the
# request is considered stale and should be generated from scratch. Otherwise,
# it's fresh and we don't need to generate anything and a reply of 304 Not Modified is sent.
#
# === Parameters:
#
# * :etag.
# * :last_modified.
# * :public By default the Cache-Control header is private, set this to
# +true+ if you want your application to be cachable by other devices (proxy caches).
# * :template By default, the template digest for the current
# controller/action is included in ETags. If the action renders a
# different template, you can include its digest instead. If the action
# doesn't render a template at all, you can pass template: false
# to skip any attempt to check for a template digest.
#
# === Example:
#
# def show
# @article = Article.find(params[:id])
#
# if stale?(etag: @article, last_modified: @article.created_at)
# @statistics = @article.really_expensive_call
# respond_to do |format|
# # all the supported formats
# end
# end
# end
#
# You can also just pass a record where +last_modified+ will be set by calling
# +updated_at+ and the +etag+ by passing the object itself.
#
# def show
# @article = Article.find(params[:id])
#
# if stale?(@article)
# @statistics = @article.really_expensive_call
# respond_to do |format|
# # all the supported formats
# end
# end
# end
#
# When passing a record, you can still set whether the public header:
#
# def show
# @article = Article.find(params[:id])
#
# if stale?(@article, public: true)
# @statistics = @article.really_expensive_call
# respond_to do |format|
# # all the supported formats
# end
# end
# end
#
# When rendering a different template than the default controller/action
# style, you can indicate which digest to include in the ETag:
#
# def show
# super if stale? @article, template: 'widgets/show'
# end
#
def stale?(record_or_options, additional_options = {})
fresh_when(record_or_options, additional_options)
!request.fresh?(response)
end
# Sets a HTTP 1.1 Cache-Control header. Defaults to issuing a +private+
# instruction, so that intermediate caches must not cache the response.
#
# expires_in 20.minutes
# expires_in 3.hours, public: true
# expires_in 3.hours, public: true, must_revalidate: true
#
# This method will overwrite an existing Cache-Control header.
# See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html for more possibilities.
#
# The method will also ensure a HTTP Date header for client compatibility.
def expires_in(seconds, options = {})
response.cache_control.merge!(
:max_age => seconds,
:public => options.delete(:public),
:must_revalidate => options.delete(:must_revalidate)
)
options.delete(:private)
response.cache_control[:extras] = options.map {|k,v| "#{k}=#{v}"}
response.date = Time.now unless response.date?
end
# Sets a HTTP 1.1 Cache-Control header of no-cache so no caching should
# occur by the browser or intermediate caches (like caching proxy servers).
def expires_now
response.cache_control.replace(:no_cache => true)
end
private
def combine_etags(options)
etags = etaggers.map { |etagger| instance_exec(options, &etagger) }.compact
etags.unshift options[:etag]
end
end
end
rails-4.2.10/actionpack/lib/action_controller/metal/cookies.rb 0000664 0000000 0000000 00000000364 13162731520 0024400 0 ustar 00root root 0000000 0000000 module ActionController #:nodoc:
module Cookies
extend ActiveSupport::Concern
include RackDelegation
included do
helper_method :cookies
end
private
def cookies
request.cookie_jar
end
end
end
rails-4.2.10/actionpack/lib/action_controller/metal/data_streaming.rb 0000664 0000000 0000000 00000017347 13162731520 0025737 0 ustar 00root root 0000000 0000000 require 'action_controller/metal/exceptions'
module ActionController #:nodoc:
# Methods for sending arbitrary data and for streaming files to the browser,
# instead of rendering.
module DataStreaming
extend ActiveSupport::Concern
include ActionController::Rendering
DEFAULT_SEND_FILE_TYPE = 'application/octet-stream'.freeze #:nodoc:
DEFAULT_SEND_FILE_DISPOSITION = 'attachment'.freeze #:nodoc:
protected
# Sends the file. This uses a server-appropriate method (such as X-Sendfile)
# via the Rack::Sendfile middleware. The header to use is set via
# +config.action_dispatch.x_sendfile_header+.
# Your server can also configure this for you by setting the X-Sendfile-Type header.
#
# Be careful to sanitize the path parameter if it is coming from a web
# page. send_file(params[:path]) allows a malicious user to
# download any file on your server.
#
# Options:
# * :filename - suggests a filename for the browser to use.
# Defaults to File.basename(path).
# * :type - specifies an HTTP content type.
# You can specify either a string or a symbol for a registered type register with
# Mime::Type.register, for example :json
# If omitted, type will be guessed from the file extension specified in :filename.
# If no content type is registered for the extension, default type 'application/octet-stream' will be used.
# * :disposition - specifies whether the file will be shown inline or downloaded.
# Valid values are 'inline' and 'attachment' (default).
# * :status - specifies the status code to send with the response. Defaults to 200.
# * :url_based_filename - set to +true+ if you want the browser guess the filename from
# the URL, which is necessary for i18n filenames on certain browsers
# (setting :filename overrides this option).
#
# The default Content-Type and Content-Disposition headers are
# set to download arbitrary binary files in as many browsers as
# possible. IE versions 4, 5, 5.5, and 6 are all known to have
# a variety of quirks (especially when downloading over SSL).
#
# Simple download:
#
# send_file '/path/to.zip'
#
# Show a JPEG in the browser:
#
# send_file '/path/to.jpeg', type: 'image/jpeg', disposition: 'inline'
#
# Show a 404 page in the browser:
#
# send_file '/path/to/404.html', type: 'text/html; charset=utf-8', status: 404
#
# Read about the other Content-* HTTP headers if you'd like to
# provide the user with more information (such as Content-Description) in
# http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.11.
#
# Also be aware that the document may be cached by proxies and browsers.
# The Pragma and Cache-Control headers declare how the file may be cached
# by intermediaries. They default to require clients to validate with
# the server before releasing cached responses. See
# http://www.mnot.net/cache_docs/ for an overview of web caching and
# http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
# for the Cache-Control header spec.
def send_file(path, options = {}) #:doc:
raise MissingFile, "Cannot read file #{path}" unless File.file?(path) and File.readable?(path)
options[:filename] ||= File.basename(path) unless options[:url_based_filename]
send_file_headers! options
self.status = options[:status] || 200
self.content_type = options[:content_type] if options.key?(:content_type)
self.response_body = FileBody.new(path)
end
# Avoid having to pass an open file handle as the response body.
# Rack::Sendfile will usually intercept the response and uses
# the path directly, so there is no reason to open the file.
class FileBody #:nodoc:
attr_reader :to_path
def initialize(path)
@to_path = path
end
# Stream the file's contents if Rack::Sendfile isn't present.
def each
File.open(to_path, 'rb') do |file|
while chunk = file.read(16384)
yield chunk
end
end
end
end
# Sends the given binary data to the browser. This method is similar to
# render plain: data, but also allows you to specify whether
# the browser should display the response as a file attachment (i.e. in a
# download dialog) or as inline data. You may also set the content type,
# the apparent file name, and other things.
#
# Options:
# * :filename - suggests a filename for the browser to use.
# * :type - specifies an HTTP content type. Defaults to 'application/octet-stream'. You can specify
# either a string or a symbol for a registered type register with Mime::Type.register, for example :json
# If omitted, type will be guessed from the file extension specified in :filename.
# If no content type is registered for the extension, default type 'application/octet-stream' will be used.
# * :disposition - specifies whether the file will be shown inline or downloaded.
# Valid values are 'inline' and 'attachment' (default).
# * :status - specifies the status code to send with the response. Defaults to 200.
#
# Generic data download:
#
# send_data buffer
#
# Download a dynamically-generated tarball:
#
# send_data generate_tgz('dir'), filename: 'dir.tgz'
#
# Display an image Active Record in the browser:
#
# send_data image.data, type: image.content_type, disposition: 'inline'
#
# See +send_file+ for more information on HTTP Content-* headers and caching.
def send_data(data, options = {}) #:doc:
send_file_headers! options
render options.slice(:status, :content_type).merge(:text => data)
end
private
def send_file_headers!(options)
type_provided = options.has_key?(:type)
content_type = options.fetch(:type, DEFAULT_SEND_FILE_TYPE)
raise ArgumentError, ":type option required" if content_type.nil?
if content_type.is_a?(Symbol)
extension = Mime[content_type]
raise ArgumentError, "Unknown MIME type #{options[:type]}" unless extension
self.content_type = extension
else
if !type_provided && options[:filename]
# If type wasn't provided, try guessing from file extension.
content_type = Mime::Type.lookup_by_extension(File.extname(options[:filename]).downcase.delete('.')) || content_type
end
self.content_type = content_type
end
disposition = options.fetch(:disposition, DEFAULT_SEND_FILE_DISPOSITION)
unless disposition.nil?
disposition = disposition.to_s
disposition += %(; filename="#{options[:filename]}") if options[:filename]
headers['Content-Disposition'] = disposition
end
headers['Content-Transfer-Encoding'] = 'binary'
response.sending_file = true
# Fix a problem with IE 6.0 on opening downloaded files:
# If Cache-Control: no-cache is set (which Rails does by default),
# IE removes the file it just downloaded from its cache immediately
# after it displays the "open/save" dialog, which means that if you
# hit "open" the file isn't there anymore when the application that
# is called for handling the download is run, so let's workaround that
response.cache_control[:public] ||= false
end
end
end
rails-4.2.10/actionpack/lib/action_controller/metal/etag_with_template_digest.rb 0000664 0000000 0000000 00000003034 13162731520 0030146 0 ustar 00root root 0000000 0000000 module ActionController
# When our views change, they should bubble up into HTTP cache freshness
# and bust browser caches. So the template digest for the current action
# is automatically included in the ETag.
#
# Enabled by default for apps that use Action View. Disable by setting
#
# config.action_controller.etag_with_template_digest = false
#
# Override the template to digest by passing +:template+ to +fresh_when+
# and +stale?+ calls. For example:
#
# # We're going to render widgets/show, not posts/show
# fresh_when @post, template: 'widgets/show'
#
# # We're not going to render a template, so omit it from the ETag.
# fresh_when @post, template: false
#
module EtagWithTemplateDigest
extend ActiveSupport::Concern
include ActionController::ConditionalGet
included do
class_attribute :etag_with_template_digest
self.etag_with_template_digest = true
ActiveSupport.on_load :action_view, yield: true do |action_view_base|
etag do |options|
determine_template_etag(options) if etag_with_template_digest
end
end
end
private
def determine_template_etag(options)
if template = pick_template_for_etag(options)
lookup_and_digest_template(template)
end
end
def pick_template_for_etag(options)
options.fetch(:template) { "#{controller_name}/#{action_name}" }
end
def lookup_and_digest_template(template)
ActionView::Digestor.digest name: template, finder: lookup_context
end
end
end
rails-4.2.10/actionpack/lib/action_controller/metal/exceptions.rb 0000664 0000000 0000000 00000003036 13162731520 0025124 0 ustar 00root root 0000000 0000000 module ActionController
class ActionControllerError < StandardError #:nodoc:
end
class BadRequest < ActionControllerError #:nodoc:
attr_reader :original_exception
def initialize(type = nil, e = nil)
return super() unless type && e
super("Invalid #{type} parameters: #{e.message}")
@original_exception = e
set_backtrace e.backtrace
end
end
class RenderError < ActionControllerError #:nodoc:
end
class RoutingError < ActionControllerError #:nodoc:
attr_reader :failures
def initialize(message, failures=[])
super(message)
@failures = failures
end
end
class ActionController::UrlGenerationError < ActionControllerError #:nodoc:
end
class MethodNotAllowed < ActionControllerError #:nodoc:
def initialize(*allowed_methods)
super("Only #{allowed_methods.to_sentence(:locale => :en)} requests are allowed.")
end
end
class NotImplemented < MethodNotAllowed #:nodoc:
end
class UnknownController < ActionControllerError #:nodoc:
end
class MissingFile < ActionControllerError #:nodoc:
end
class SessionOverflowError < ActionControllerError #:nodoc:
DEFAULT_MESSAGE = 'Your session data is larger than the data column in which it is to be stored. You must increase the size of your data column if you intend to store large data.'
def initialize(message = nil)
super(message || DEFAULT_MESSAGE)
end
end
class UnknownHttpMethod < ActionControllerError #:nodoc:
end
class UnknownFormat < ActionControllerError #:nodoc:
end
end
rails-4.2.10/actionpack/lib/action_controller/metal/flash.rb 0000664 0000000 0000000 00000003306 13162731520 0024040 0 ustar 00root root 0000000 0000000 module ActionController #:nodoc:
module Flash
extend ActiveSupport::Concern
included do
class_attribute :_flash_types, instance_accessor: false
self._flash_types = []
delegate :flash, to: :request
add_flash_types(:alert, :notice)
end
module ClassMethods
# Creates new flash types. You can pass as many types as you want to create
# flash types other than the default alert and notice in
# your controllers and views. For instance:
#
# # in application_controller.rb
# class ApplicationController < ActionController::Base
# add_flash_types :warning
# end
#
# # in your controller
# redirect_to user_path(@user), warning: "Incomplete profile"
#
# # in your view
# <%= warning %>
#
# This method will automatically define a new method for each of the given
# names, and it will be available in your views.
def add_flash_types(*types)
types.each do |type|
next if _flash_types.include?(type)
define_method(type) do
request.flash[type]
end
helper_method type
self._flash_types += [type]
end
end
end
protected
def redirect_to(options = {}, response_status_and_flash = {}) #:doc:
self.class._flash_types.each do |flash_type|
if type = response_status_and_flash.delete(flash_type)
flash[flash_type] = type
end
end
if other_flashes = response_status_and_flash.delete(:flash)
flash.update(other_flashes)
end
super(options, response_status_and_flash)
end
end
end
rails-4.2.10/actionpack/lib/action_controller/metal/force_ssl.rb 0000664 0000000 0000000 00000010276 13162731520 0024726 0 ustar 00root root 0000000 0000000 require 'active_support/core_ext/hash/except'
require 'active_support/core_ext/hash/slice'
module ActionController
# This module provides a method which will redirect browser to use HTTPS
# protocol. This will ensure that user's sensitive information will be
# transferred safely over the internet. You _should_ always force browser
# to use HTTPS when you're transferring sensitive information such as
# user authentication, account information, or credit card information.
#
# Note that if you are really concerned about your application security,
# you might consider using +config.force_ssl+ in your config file instead.
# That will ensure all the data transferred via HTTPS protocol and prevent
# user from getting session hijacked when accessing the site under unsecured
# HTTP protocol.
module ForceSSL
extend ActiveSupport::Concern
include AbstractController::Callbacks
ACTION_OPTIONS = [:only, :except, :if, :unless]
URL_OPTIONS = [:protocol, :host, :domain, :subdomain, :port, :path]
REDIRECT_OPTIONS = [:status, :flash, :alert, :notice]
module ClassMethods
# Force the request to this particular controller or specified actions to be
# under HTTPS protocol.
#
# If you need to disable this for any reason (e.g. development) then you can use
# an +:if+ or +:unless+ condition.
#
# class AccountsController < ApplicationController
# force_ssl if: :ssl_configured?
#
# def ssl_configured?
# !Rails.env.development?
# end
# end
#
# ==== URL Options
# You can pass any of the following options to affect the redirect url
# * host - Redirect to a different host name
# * subdomain - Redirect to a different subdomain
# * domain - Redirect to a different domain
# * port - Redirect to a non-standard port
# * path - Redirect to a different path
#
# ==== Redirect Options
# You can pass any of the following options to affect the redirect status and response
# * status - Redirect with a custom status (default is 301 Moved Permanently)
# * flash - Set a flash message when redirecting
# * alert - Set an alert message when redirecting
# * notice - Set a notice message when redirecting
#
# ==== Action Options
# You can pass any of the following options to affect the before_action callback
# * only - The callback should be run only for this action
# * except - The callback should be run for all actions except this action
# * if - A symbol naming an instance method or a proc; the callback
# will be called only when it returns a true value.
# * unless - A symbol naming an instance method or a proc; the callback
# will be called only when it returns a false value.
def force_ssl(options = {})
action_options = options.slice(*ACTION_OPTIONS)
redirect_options = options.except(*ACTION_OPTIONS)
before_action(action_options) do
force_ssl_redirect(redirect_options)
end
end
end
# Redirect the existing request to use the HTTPS protocol.
#
# ==== Parameters
# * host_or_options - Either a host name or any of the url & redirect options
# available to the force_ssl method.
def force_ssl_redirect(host_or_options = nil)
unless request.ssl?
options = {
:protocol => 'https://',
:host => request.host,
:path => request.fullpath,
:status => :moved_permanently
}
if host_or_options.is_a?(Hash)
options.merge!(host_or_options)
elsif host_or_options
options[:host] = host_or_options
end
secure_url = ActionDispatch::Http::URL.url_for(options.slice(*URL_OPTIONS))
flash.keep if respond_to?(:flash)
redirect_to secure_url, options.slice(*REDIRECT_OPTIONS)
end
end
end
end
rails-4.2.10/actionpack/lib/action_controller/metal/head.rb 0000664 0000000 0000000 00000003240 13162731520 0023641 0 ustar 00root root 0000000 0000000 module ActionController
module Head
# Returns a response that has no content (merely headers). The options
# argument is interpreted to be a hash of header names and values.
# This allows you to easily return a response that consists only of
# significant headers:
#
# head :created, location: person_path(@person)
#
# head :created, location: @person
#
# It can also be used to return exceptional conditions:
#
# return head(:method_not_allowed) unless request.post?
# return head(:bad_request) unless valid_request?
# render
#
# See Rack::Utils::SYMBOL_TO_STATUS_CODE for a full list of valid +status+ symbols.
def head(status, options = {})
options, status = status, nil if status.is_a?(Hash)
status ||= options.delete(:status) || :ok
location = options.delete(:location)
content_type = options.delete(:content_type)
options.each do |key, value|
headers[key.to_s.dasherize.split('-').each { |v| v[0] = v[0].chr.upcase }.join('-')] = value.to_s
end
self.status = status
self.location = url_for(location) if location
self.response_body = ""
if include_content?(self.response_code)
self.content_type = content_type || (Mime[formats.first] if formats)
self.response.charset = false if self.response
else
headers.delete('Content-Type')
headers.delete('Content-Length')
end
true
end
private
# :nodoc:
def include_content?(status)
case status
when 100..199
false
when 204, 205, 304
false
else
true
end
end
end
end
rails-4.2.10/actionpack/lib/action_controller/metal/helpers.rb 0000664 0000000 0000000 00000010033 13162731520 0024400 0 ustar 00root root 0000000 0000000 module ActionController
# The \Rails framework provides a large number of helpers for working with assets, dates, forms,
# numbers and model objects, to name a few. These helpers are available to all templates
# by default.
#
# In addition to using the standard template helpers provided, creating custom helpers to
# extract complicated logic or reusable functionality is strongly encouraged. By default, each controller
# will include all helpers. These helpers are only accessible on the controller through .helpers
#
# In previous versions of \Rails the controller will include a helper whose
# name matches that of the controller, e.g., MyController will automatically
# include MyHelper. To return old behavior set +config.action_controller.include_all_helpers+ to +false+.
#
# Additional helpers can be specified using the +helper+ class method in ActionController::Base or any
# controller which inherits from it.
#
# The +to_s+ method from the \Time class can be wrapped in a helper method to display a custom message if
# a \Time object is blank:
#
# module FormattedTimeHelper
# def format_time(time, format=:long, blank_message=" ")
# time.blank? ? blank_message : time.to_s(format)
# end
# end
#
# FormattedTimeHelper can now be included in a controller, using the +helper+ class method:
#
# class EventsController < ActionController::Base
# helper FormattedTimeHelper
# def index
# @events = Event.all
# end
# end
#
# Then, in any view rendered by EventController, the format_time method can be called:
#
# <% @events.each do |event| -%>
# # <%= format_time(event.time, :short, "N/A") %> | <%= event.name %> #
# <% end -%> # # Finally, assuming we have two event instances, one which has a time and one which does not, # the output might look like this: # # 23 Aug 11:30 | Carolina Railhawks Soccer Match # N/A | Carolina Railhaws Training Workshop # module Helpers extend ActiveSupport::Concern class << self; attr_accessor :helpers_path; end include AbstractController::Helpers included do class_attribute :helpers_path, :include_all_helpers self.helpers_path ||= [] self.include_all_helpers = true end module ClassMethods # Declares helper accessors for controller attributes. For example, the # following adds new +name+ and name= instance methods to a # controller and makes them available to the view: # attr_accessor :name # helper_attr :name # # ==== Parameters # * attrs - Names of attributes to be converted into helpers. def helper_attr(*attrs) attrs.flatten.each { |attr| helper_method(attr, "#{attr}=") } end # Provides a proxy to access helpers methods from outside the view. def helpers @helper_proxy ||= begin proxy = ActionView::Base.new proxy.config = config.inheritable_copy proxy.extend(_helpers) end end # Overwrite modules_for_helpers to accept :all as argument, which loads # all helpers in helpers_path. # # ==== Parameters # * args - A list of helpers # # ==== Returns # * array - A normalized list of modules for the list of helpers provided. def modules_for_helpers(args) args += all_application_helpers if args.delete(:all) super(args) end def all_helpers_from_path(path) helpers = Array(path).flat_map do |_path| extract = /^#{Regexp.quote(_path.to_s)}\/?(.*)_helper.rb$/ names = Dir["#{_path}/**/*_helper.rb"].map { |file| file.sub(extract, '\1') } names.sort! end helpers.uniq! helpers end private # Extract helper names from files in app/helpers/**/*_helper.rb def all_application_helpers all_helpers_from_path(helpers_path) end end end end rails-4.2.10/actionpack/lib/action_controller/metal/hide_actions.rb 0000664 0000000 0000000 00000002226 13162731520 0025374 0 ustar 00root root 0000000 0000000 module ActionController # Adds the ability to prevent public methods on a controller to be called as actions. module HideActions extend ActiveSupport::Concern included do class_attribute :hidden_actions self.hidden_actions = Set.new.freeze end private # Overrides AbstractController::Base#action_method? to return false if the # action name is in the list of hidden actions. def method_for_action(action_name) self.class.visible_action?(action_name) && super end module ClassMethods # Sets all of the actions passed in as hidden actions. # # ==== Parameters # * args - A list of actions def hide_action(*args) self.hidden_actions = hidden_actions.dup.merge(args.map(&:to_s)).freeze end def visible_action?(action_name) not hidden_actions.include?(action_name) end # Overrides AbstractController::Base#action_methods to remove any methods # that are listed as hidden methods. def action_methods @action_methods ||= Set.new(super.reject { |name| hidden_actions.include?(name) }).freeze end end end end rails-4.2.10/actionpack/lib/action_controller/metal/http_authentication.rb 0000664 0000000 0000000 00000050312 13162731520 0027020 0 ustar 00root root 0000000 0000000 require 'base64' require 'active_support/security_utils' module ActionController # Makes it dead easy to do HTTP Basic, Digest and Token authentication. module HttpAuthentication # Makes it dead easy to do HTTP \Basic authentication. # # === Simple \Basic example # # class PostsController < ApplicationController # http_basic_authenticate_with name: "dhh", password: "secret", except: :index # # def index # render plain: "Everyone can see me!" # end # # def edit # render plain: "I'm only accessible if you know the password" # end # end # # === Advanced \Basic example # # Here is a more advanced \Basic example where only Atom feeds and the XML API is protected by HTTP authentication, # the regular HTML interface is protected by a session approach: # # class ApplicationController < ActionController::Base # before_action :set_account, :authenticate # # protected # def set_account # @account = Account.find_by(url_name: request.subdomains.first) # end # # def authenticate # case request.format # when Mime::XML, Mime::ATOM # if user = authenticate_with_http_basic { |u, p| @account.users.authenticate(u, p) } # @current_user = user # else # request_http_basic_authentication # end # else # if session_authenticated? # @current_user = @account.users.find(session[:authenticated][:user_id]) # else # redirect_to(login_url) and return false # end # end # end # end # # In your integration tests, you can do something like this: # # def test_access_granted_from_xml # @request.env['HTTP_AUTHORIZATION'] = ActionController::HttpAuthentication::Basic.encode_credentials(users(:dhh).name, users(:dhh).password) # get "/notes/1.xml" # # assert_equal 200, status # end module Basic extend self module ControllerMethods extend ActiveSupport::Concern module ClassMethods def http_basic_authenticate_with(options = {}) before_action(options.except(:name, :password, :realm)) do authenticate_or_request_with_http_basic(options[:realm] || "Application") do |name, password| # This comparison uses & so that it doesn't short circuit and # uses `variable_size_secure_compare` so that length information # isn't leaked. ActiveSupport::SecurityUtils.variable_size_secure_compare(name, options[:name]) & ActiveSupport::SecurityUtils.variable_size_secure_compare(password, options[:password]) end end end end def authenticate_or_request_with_http_basic(realm = "Application", &login_procedure) authenticate_with_http_basic(&login_procedure) || request_http_basic_authentication(realm) end def authenticate_with_http_basic(&login_procedure) HttpAuthentication::Basic.authenticate(request, &login_procedure) end def request_http_basic_authentication(realm = "Application") HttpAuthentication::Basic.authentication_request(self, realm) end end def authenticate(request, &login_procedure) if has_basic_credentials?(request) login_procedure.call(*user_name_and_password(request)) end end def has_basic_credentials?(request) request.authorization.present? && (auth_scheme(request) == 'Basic') end def user_name_and_password(request) decode_credentials(request).split(':', 2) end def decode_credentials(request) ::Base64.decode64(auth_param(request) || '') end def auth_scheme(request) request.authorization.split(' ', 2).first end def auth_param(request) request.authorization.split(' ', 2).second end def encode_credentials(user_name, password) "Basic #{::Base64.strict_encode64("#{user_name}:#{password}")}" end def authentication_request(controller, realm) controller.headers["WWW-Authenticate"] = %(Basic realm="#{realm.gsub(/"/, "")}") controller.status = 401 controller.response_body = "HTTP Basic: Access denied.\n" end end # Makes it dead easy to do HTTP \Digest authentication. # # === Simple \Digest example # # require 'digest/md5' # class PostsController < ApplicationController # REALM = "SuperSecret" # USERS = {"dhh" => "secret", #plain text password # "dap" => Digest::MD5.hexdigest(["dap",REALM,"secret"].join(":"))} #ha1 digest password # # before_action :authenticate, except: [:index] # # def index # render plain: "Everyone can see me!" # end # # def edit # render plain: "I'm only accessible if you know the password" # end # # private # def authenticate # authenticate_or_request_with_http_digest(REALM) do |username| # USERS[username] # end # end # end # # === Notes # # The +authenticate_or_request_with_http_digest+ block must return the user's password # or the ha1 digest hash so the framework can appropriately hash to check the user's # credentials. Returning +nil+ will cause authentication to fail. # # Storing the ha1 hash: MD5(username:realm:password), is better than storing a plain password. If # the password file or database is compromised, the attacker would be able to use the ha1 hash to # authenticate as the user at this +realm+, but would not have the user's password to try using at # other sites. # # In rare instances, web servers or front proxies strip authorization headers before # they reach your application. You can debug this situation by logging all environment # variables, and check for HTTP_AUTHORIZATION, amongst others. module Digest extend self module ControllerMethods def authenticate_or_request_with_http_digest(realm = "Application", &password_procedure) authenticate_with_http_digest(realm, &password_procedure) || request_http_digest_authentication(realm) end # Authenticate with HTTP Digest, returns true or false def authenticate_with_http_digest(realm = "Application", &password_procedure) HttpAuthentication::Digest.authenticate(request, realm, &password_procedure) end # Render output including the HTTP Digest authentication header def request_http_digest_authentication(realm = "Application", message = nil) HttpAuthentication::Digest.authentication_request(self, realm, message) end end # Returns false on a valid response, true otherwise def authenticate(request, realm, &password_procedure) request.authorization && validate_digest_response(request, realm, &password_procedure) end # Returns false unless the request credentials response value matches the expected value. # First try the password as a ha1 digest password. If this fails, then try it as a plain # text password. def validate_digest_response(request, realm, &password_procedure) secret_key = secret_token(request) credentials = decode_credentials_header(request) valid_nonce = validate_nonce(secret_key, request, credentials[:nonce]) if valid_nonce && realm == credentials[:realm] && opaque(secret_key) == credentials[:opaque] password = password_procedure.call(credentials[:username]) return false unless password method = request.env['rack.methodoverride.original_method'] || request.env['REQUEST_METHOD'] uri = credentials[:uri] [true, false].any? do |trailing_question_mark| [true, false].any? do |password_is_ha1| _uri = trailing_question_mark ? uri + "?" : uri expected = expected_response(method, _uri, credentials, password, password_is_ha1) expected == credentials[:response] end end end end # Returns the expected response for a request of +http_method+ to +uri+ with the decoded +credentials+ and the expected +password+ # Optional parameter +password_is_ha1+ is set to +true+ by default, since best practice is to store ha1 digest instead # of a plain-text password. def expected_response(http_method, uri, credentials, password, password_is_ha1=true) ha1 = password_is_ha1 ? password : ha1(credentials, password) ha2 = ::Digest::MD5.hexdigest([http_method.to_s.upcase, uri].join(':')) ::Digest::MD5.hexdigest([ha1, credentials[:nonce], credentials[:nc], credentials[:cnonce], credentials[:qop], ha2].join(':')) end def ha1(credentials, password) ::Digest::MD5.hexdigest([credentials[:username], credentials[:realm], password].join(':')) end def encode_credentials(http_method, credentials, password, password_is_ha1) credentials[:response] = expected_response(http_method, credentials[:uri], credentials, password, password_is_ha1) "Digest " + credentials.sort_by {|x| x[0].to_s }.map {|v| "#{v[0]}='#{v[1]}'" }.join(', ') end def decode_credentials_header(request) decode_credentials(request.authorization) end def decode_credentials(header) ActiveSupport::HashWithIndifferentAccess[header.to_s.gsub(/^Digest\s+/, '').split(',').map do |pair| key, value = pair.split('=', 2) [key.strip, value.to_s.gsub(/^"|"$/,'').delete('\'')] end] end def authentication_header(controller, realm) secret_key = secret_token(controller.request) nonce = self.nonce(secret_key) opaque = opaque(secret_key) controller.headers["WWW-Authenticate"] = %(Digest realm="#{realm}", qop="auth", algorithm=MD5, nonce="#{nonce}", opaque="#{opaque}") end def authentication_request(controller, realm, message = nil) message ||= "HTTP Digest: Access denied.\n" authentication_header(controller, realm) controller.status = 401 controller.response_body = message end def secret_token(request) key_generator = request.env["action_dispatch.key_generator"] http_auth_salt = request.env["action_dispatch.http_auth_salt"] key_generator.generate_key(http_auth_salt) end # Uses an MD5 digest based on time to generate a value to be used only once. # # A server-specified data string which should be uniquely generated each time a 401 response is made. # It is recommended that this string be base64 or hexadecimal data. # Specifically, since the string is passed in the header lines as a quoted string, the double-quote character is not allowed. # # The contents of the nonce are implementation dependent. # The quality of the implementation depends on a good choice. # A nonce might, for example, be constructed as the base 64 encoding of # # time-stamp H(time-stamp ":" ETag ":" private-key) # # where time-stamp is a server-generated time or other non-repeating value, # ETag is the value of the HTTP ETag header associated with the requested entity, # and private-key is data known only to the server. # With a nonce of this form a server would recalculate the hash portion after receiving the client authentication header and # reject the request if it did not match the nonce from that header or # if the time-stamp value is not recent enough. In this way the server can limit the time of the nonce's validity. # The inclusion of the ETag prevents a replay request for an updated version of the resource. # (Note: including the IP address of the client in the nonce would appear to offer the server the ability # to limit the reuse of the nonce to the same client that originally got it. # However, that would break proxy farms, where requests from a single user often go through different proxies in the farm. # Also, IP address spoofing is not that hard.) # # An implementation might choose not to accept a previously used nonce or a previously used digest, in order to # protect against a replay attack. Or, an implementation might choose to use one-time nonces or digests for # POST, PUT, or PATCH requests and a time-stamp for GET requests. For more details on the issues involved see Section 4 # of this document. # # The nonce is opaque to the client. Composed of Time, and hash of Time with secret # key from the Rails session secret generated upon creation of project. Ensures # the time cannot be modified by client. def nonce(secret_key, time = Time.now) t = time.to_i hashed = [t, secret_key] digest = ::Digest::MD5.hexdigest(hashed.join(":")) ::Base64.strict_encode64("#{t}:#{digest}") end # Might want a shorter timeout depending on whether the request # is a PATCH, PUT, or POST, and if client is browser or web service. # Can be much shorter if the Stale directive is implemented. This would # allow a user to use new nonce without prompting user again for their # username and password. def validate_nonce(secret_key, request, value, seconds_to_timeout=5*60) return false if value.nil? t = ::Base64.decode64(value).split(":").first.to_i nonce(secret_key, t) == value && (t - Time.now.to_i).abs <= seconds_to_timeout end # Opaque based on random generation - but changing each request? def opaque(secret_key) ::Digest::MD5.hexdigest(secret_key) end end # Makes it dead easy to do HTTP Token authentication. # # Simple Token example: # # class PostsController < ApplicationController # TOKEN = "secret" # # before_action :authenticate, except: [ :index ] # # def index # render plain: "Everyone can see me!" # end # # def edit # render plain: "I'm only accessible if you know the password" # end # # private # def authenticate # authenticate_or_request_with_http_token do |token, options| # token == TOKEN # end # end # end # # # Here is a more advanced Token example where only Atom feeds and the XML API is protected by HTTP token authentication, # the regular HTML interface is protected by a session approach: # # class ApplicationController < ActionController::Base # before_action :set_account, :authenticate # # protected # def set_account # @account = Account.find_by(url_name: request.subdomains.first) # end # # def authenticate # case request.format # when Mime::XML, Mime::ATOM # if user = authenticate_with_http_token { |t, o| @account.users.authenticate(t, o) } # @current_user = user # else # request_http_token_authentication # end # else # if session_authenticated? # @current_user = @account.users.find(session[:authenticated][:user_id]) # else # redirect_to(login_url) and return false # end # end # end # end # # # In your integration tests, you can do something like this: # # def test_access_granted_from_xml # get( # "/notes/1.xml", nil, # 'HTTP_AUTHORIZATION' => ActionController::HttpAuthentication::Token.encode_credentials(users(:dhh).token) # ) # # assert_equal 200, status # end # # # On shared hosts, Apache sometimes doesn't pass authentication headers to # FCGI instances. If your environment matches this description and you cannot # authenticate, try this rule in your Apache setup: # # RewriteRule ^(.*)$ dispatch.fcgi [E=X-HTTP_AUTHORIZATION:%{HTTP:Authorization},QSA,L] module Token TOKEN_KEY = 'token=' TOKEN_REGEX = /^Token / AUTHN_PAIR_DELIMITERS = /(?:,|;|\t+)/ extend self module ControllerMethods def authenticate_or_request_with_http_token(realm = "Application", &login_procedure) authenticate_with_http_token(&login_procedure) || request_http_token_authentication(realm) end def authenticate_with_http_token(&login_procedure) Token.authenticate(self, &login_procedure) end def request_http_token_authentication(realm = "Application") Token.authentication_request(self, realm) end end # If token Authorization header is present, call the login # procedure with the present token and options. # # [controller] # ActionController::Base instance for the current request. # # [login_procedure] # Proc to call if a token is present. The Proc should take two arguments: # # authenticate(controller) { |token, options| ... } # # Returns the return value of login_procedure if a # token is found. Returns nil if no token is found. def authenticate(controller, &login_procedure) token, options = token_and_options(controller.request) unless token.blank? login_procedure.call(token, options) end end # Parses the token and options out of the token authorization header. If # the header looks like this: # Authorization: Token token="abc", nonce="def" # Then the returned token is "abc", and the options is {nonce: "def"} # # request - ActionDispatch::Request instance with the current headers. # # Returns an Array of [String, Hash] if a token is present. # Returns nil if no token is found. def token_and_options(request) authorization_request = request.authorization.to_s if authorization_request[TOKEN_REGEX] params = token_params_from authorization_request [params.shift[1], Hash[params].with_indifferent_access] end end def token_params_from(auth) rewrite_param_values params_array_from raw_params auth end # Takes raw_params and turns it into an array of parameters def params_array_from(raw_params) raw_params.map { |param| param.split %r/=(.+)?/ } end # This removes the " characters wrapping the value. def rewrite_param_values(array_params) array_params.each { |param| (param[1] || "").gsub! %r/^"|"$/, '' } end # This method takes an authorization body and splits up the key-value # pairs by the standardized :, ;, or \t # delimiters defined in +AUTHN_PAIR_DELIMITERS+. def raw_params(auth) _raw_params = auth.sub(TOKEN_REGEX, '').split(/\s*#{AUTHN_PAIR_DELIMITERS}\s*/) if !(_raw_params.first =~ %r{\A#{TOKEN_KEY}}) _raw_params[0] = "#{TOKEN_KEY}#{_raw_params.first}" end _raw_params end # Encodes the given token and options into an Authorization header value. # # token - String token. # options - optional Hash of the options. # # Returns String. def encode_credentials(token, options = {}) values = ["#{TOKEN_KEY}#{token.to_s.inspect}"] + options.map do |key, value| "#{key}=#{value.to_s.inspect}" end "Token #{values * ", "}" end # Sets a WWW-Authenticate to let the client know a token is desired. # # controller - ActionController::Base instance for the outgoing response. # realm - String realm to use in the header. # # Returns nothing. def authentication_request(controller, realm) controller.headers["WWW-Authenticate"] = %(Token realm="#{realm.gsub(/"/, "")}") controller.__send__ :render, :text => "HTTP Token: Access denied.\n", :status => :unauthorized end end end end rails-4.2.10/actionpack/lib/action_controller/metal/implicit_render.rb 0000664 0000000 0000000 00000000566 13162731520 0026121 0 ustar 00root root 0000000 0000000 module ActionController module ImplicitRender def send_action(method, *args) ret = super default_render unless performed? ret end def default_render(*args) render(*args) end def method_for_action(action_name) super || if template_exists?(action_name.to_s, _prefixes) "default_render" end end end end rails-4.2.10/actionpack/lib/action_controller/metal/instrumentation.rb 0000664 0000000 0000000 00000006446 13162731520 0026216 0 ustar 00root root 0000000 0000000 require 'benchmark' require 'abstract_controller/logger' module ActionController # Adds instrumentation to several ends in ActionController::Base. It also provides # some hooks related with process_action, this allows an ORM like Active Record # and/or DataMapper to plug in ActionController and show related information. # # Check ActiveRecord::Railties::ControllerRuntime for an example. module Instrumentation extend ActiveSupport::Concern include AbstractController::Logger include ActionController::RackDelegation attr_internal :view_runtime def process_action(*args) raw_payload = { :controller => self.class.name, :action => self.action_name, :params => request.filtered_parameters, :format => request.format.try(:ref), :method => request.request_method, :path => (request.fullpath rescue "unknown") } ActiveSupport::Notifications.instrument("start_processing.action_controller", raw_payload.dup) ActiveSupport::Notifications.instrument("process_action.action_controller", raw_payload) do |payload| begin result = super payload[:status] = response.status result ensure append_info_to_payload(payload) end end end def render(*args) render_output = nil self.view_runtime = cleanup_view_runtime do Benchmark.ms { render_output = super } end render_output end def send_file(path, options={}) ActiveSupport::Notifications.instrument("send_file.action_controller", options.merge(:path => path)) do super end end def send_data(data, options = {}) ActiveSupport::Notifications.instrument("send_data.action_controller", options) do super end end def redirect_to(*args) ActiveSupport::Notifications.instrument("redirect_to.action_controller") do |payload| result = super payload[:status] = response.status payload[:location] = response.filtered_location result end end private # A hook invoked every time a before callback is halted. def halted_callback_hook(filter) ActiveSupport::Notifications.instrument("halted_callback.action_controller", :filter => filter) end # A hook which allows you to clean up any time taken into account in # views wrongly, like database querying time. # # def cleanup_view_runtime # super - time_taken_in_something_expensive # end # # :api: plugin def cleanup_view_runtime #:nodoc: yield end # Every time after an action is processed, this method is invoked # with the payload, so you can add more information. # :api: plugin def append_info_to_payload(payload) #:nodoc: payload[:view_runtime] = view_runtime end module ClassMethods # A hook which allows other frameworks to log what happened during # controller process action. This method should return an array # with the messages to be added. # :api: plugin def log_process_action(payload) #:nodoc: messages, view_runtime = [], payload[:view_runtime] messages << ("Views: %.1fms" % view_runtime.to_f) if view_runtime messages end end end end rails-4.2.10/actionpack/lib/action_controller/metal/live.rb 0000664 0000000 0000000 00000022361 13162731520 0023704 0 ustar 00root root 0000000 0000000 require 'action_dispatch/http/response' require 'delegate' require 'active_support/json' module ActionController # Mix this module in to your controller, and all actions in that controller # will be able to stream data to the client as it's written. # # class MyController < ActionController::Base # include ActionController::Live # # def stream # response.headers['Content-Type'] = 'text/event-stream' # 100.times { # response.stream.write "hello world\n" # sleep 1 # } # ensure # response.stream.close # end # end # # There are a few caveats with this use. You *cannot* write headers after the # response has been committed (Response#committed? will return truthy). # Calling +write+ or +close+ on the response stream will cause the response # object to be committed. Make sure all headers are set before calling write # or close on your stream. # # You *must* call close on your stream when you're finished, otherwise the # socket may be left open forever. # # The final caveat is that your actions are executed in a separate thread than # the main thread. Make sure your actions are thread safe, and this shouldn't # be a problem (don't share state across threads, etc). module Live # This class provides the ability to write an SSE (Server Sent Event) # to an IO stream. The class is initialized with a stream and can be used # to either write a JSON string or an object which can be converted to JSON. # # Writing an object will convert it into standard SSE format with whatever # options you have configured. You may choose to set the following options: # # 1) Event. If specified, an event with this name will be dispatched on # the browser. # 2) Retry. The reconnection time in milliseconds used when attempting # to send the event. # 3) Id. If the connection dies while sending an SSE to the browser, then # the server will receive a +Last-Event-ID+ header with value equal to +id+. # # After setting an option in the constructor of the SSE object, all future # SSEs sent across the stream will use those options unless overridden. # # Example Usage: # # class MyController < ActionController::Base # include ActionController::Live # # def index # response.headers['Content-Type'] = 'text/event-stream' # sse = SSE.new(response.stream, retry: 300, event: "event-name") # sse.write({ name: 'John'}) # sse.write({ name: 'John'}, id: 10) # sse.write({ name: 'John'}, id: 10, event: "other-event") # sse.write({ name: 'John'}, id: 10, event: "other-event", retry: 500) # ensure # sse.close # end # end # # Note: SSEs are not currently supported by IE. However, they are supported # by Chrome, Firefox, Opera, and Safari. class SSE WHITELISTED_OPTIONS = %w( retry event id ) def initialize(stream, options = {}) @stream = stream @options = options end def close @stream.close end def write(object, options = {}) case object when String perform_write(object, options) else perform_write(ActiveSupport::JSON.encode(object), options) end end private def perform_write(json, options) current_options = @options.merge(options).stringify_keys WHITELISTED_OPTIONS.each do |option_name| if (option_value = current_options[option_name]) @stream.write "#{option_name}: #{option_value}\n" end end message = json.gsub(/\n/, "\ndata: ") @stream.write "data: #{message}\n\n" end end class ClientDisconnected < RuntimeError end class Buffer < ActionDispatch::Response::Buffer #:nodoc: include MonitorMixin # Ignore that the client has disconnected. # # If this value is `true`, calling `write` after the client # disconnects will result in the written content being silently # discarded. If this value is `false` (the default), a # ClientDisconnected exception will be raised. attr_accessor :ignore_disconnect def initialize(response) @error_callback = lambda { true } @cv = new_cond @aborted = false @ignore_disconnect = false super(response, SizedQueue.new(10)) end def write(string) unless @response.committed? @response.headers["Cache-Control"] = "no-cache" @response.headers.delete "Content-Length" end super unless connected? @buf.clear unless @ignore_disconnect # Raise ClientDisconnected, which is a RuntimeError (not an # IOError), because that's more appropriate for something beyond # the developer's control. raise ClientDisconnected, "client disconnected" end end end def each @response.sending! while str = @buf.pop yield str end @response.sent! end # Write a 'close' event to the buffer; the producer/writing thread # uses this to notify us that it's finished supplying content. # # See also #abort. def close synchronize do super @buf.push nil @cv.broadcast end end # Inform the producer/writing thread that the client has # disconnected; the reading thread is no longer interested in # anything that's being written. # # See also #close. def abort synchronize do @aborted = true @buf.clear end end # Is the client still connected and waiting for content? # # The result of calling `write` when this is `false` is determined # by `ignore_disconnect`. def connected? !@aborted end def await_close synchronize do @cv.wait_until { @closed } end end def on_error(&block) @error_callback = block end def call_on_error @error_callback.call end end class Response < ActionDispatch::Response #:nodoc: all class Header < DelegateClass(Hash) # :nodoc: def initialize(response, header) @response = response super(header) end def []=(k,v) if @response.committed? raise ActionDispatch::IllegalStateError, 'header already sent' end super end def merge(other) self.class.new @response, __getobj__.merge(other) end def to_hash __getobj__.dup end end private def before_committed super jar = request.cookie_jar # The response can be committed multiple times jar.write self unless committed? end def before_sending super request.cookie_jar.commit! headers.freeze end def build_buffer(response, body) buf = Live::Buffer.new response body.each { |part| buf.write part } buf end def merge_default_headers(original, default) Header.new self, super end def handle_conditional_get! super unless committed? end end def process(name) t1 = Thread.current locals = t1.keys.map { |key| [key, t1[key]] } error = nil # This processes the action in a child thread. It lets us return the # response code and headers back up the rack stack, and still process # the body in parallel with sending data to the client Thread.new { t2 = Thread.current t2.abort_on_exception = true # Since we're processing the view in a different thread, copy the # thread locals from the main thread to the child thread. :'( locals.each { |k,v| t2[k] = v } begin super(name) rescue => e if @_response.committed? begin @_response.stream.write(ActionView::Base.streaming_completion_on_exception) if request.format == :html @_response.stream.call_on_error rescue => exception log_error(exception) ensure log_error(e) @_response.stream.close end else error = e end ensure @_response.commit! end } @_response.await_commit raise error if error end def log_error(exception) logger = ActionController::Base.logger return unless logger logger.fatal do message = "\n#{exception.class} (#{exception.message}):\n" message << exception.annoted_source_code.to_s if exception.respond_to?(:annoted_source_code) message << " " << exception.backtrace.join("\n ") "#{message}\n\n" end end def response_body=(body) super response.close if response end def set_response!(request) if request.env["HTTP_VERSION"] == "HTTP/1.0" super else @_response = Live::Response.new @_response.request = request end end end end rails-4.2.10/actionpack/lib/action_controller/metal/mime_responds.rb 0000664 0000000 0000000 00000026254 13162731520 0025616 0 ustar 00root root 0000000 0000000 require 'abstract_controller/collector' module ActionController #:nodoc: module MimeResponds extend ActiveSupport::Concern # :stopdoc: module ClassMethods def respond_to(*) raise NoMethodError, "The controller-level `respond_to' feature has " \ "been extracted to the `responders` gem. Add it to your Gemfile to " \ "continue using this feature:\n" \ " gem 'responders', '~> 2.0'\n" \ "Consult the Rails upgrade guide for details." end end def respond_with(*) raise NoMethodError, "The `respond_with' feature has been extracted " \ "to the `responders` gem. Add it to your Gemfile to continue using " \ "this feature:\n" \ " gem 'responders', '~> 2.0'\n" \ "Consult the Rails upgrade guide for details." end # :startdoc: # Without web-service support, an action which collects the data for displaying a list of people # might look something like this: # # def index # @people = Person.all # end # # Here's the same action, with web-service support baked in: # # def index # @people = Person.all # # respond_to do |format| # format.html # format.xml { render xml: @people } # end # end # # What that says is, "if the client wants HTML in response to this action, just respond as we # would have before, but if the client wants XML, return them the list of people in XML format." # (Rails determines the desired response format from the HTTP Accept header submitted by the client.) # # Supposing you have an action that adds a new person, optionally creating their company # (by name) if it does not already exist, without web-services, it might look like this: # # def create # @company = Company.find_or_create_by(name: params[:company][:name]) # @person = @company.people.create(params[:person]) # # redirect_to(person_list_url) # end # # Here's the same action, with web-service support baked in: # # def create # company = params[:person].delete(:company) # @company = Company.find_or_create_by(name: company[:name]) # @person = @company.people.create(params[:person]) # # respond_to do |format| # format.html { redirect_to(person_list_url) } # format.js # format.xml { render xml: @person.to_xml(include: @company) } # end # end # # If the client wants HTML, we just redirect them back to the person list. If they want JavaScript, # then it is an Ajax request and we render the JavaScript template associated with this action. # Lastly, if the client wants XML, we render the created person as XML, but with a twist: we also # include the person's company in the rendered XML, so you get something like this: # #Routes FSM with NFA simulation
Type a route in to the box and click "simulate".
Some fun routes to try: <% fun_routes.each do |path| %> <%= path %> <% end %>
<%= svg %>
This is a FSM for a system that has the following routes:
-
<% paths.each do |route| %>
- <%= route %> <% end %>
<%= flash[:notice] %>
# <% end %>
#
# Since the +notice+ and +alert+ keys are a common idiom, convenience accessors are available:
#
# flash.alert = "You must be logged in"
# flash.notice = "Post successfully created"
#
# This example places a string in the flash. And of course, you can put as many as you like at a time too. If you want to pass
# non-primitive types, you will have to handle that in your application. Example: To show messages with links, you will have to
# use sanitize helper.
#
# Just remember: They'll be gone by the time the next action has been performed.
#
# See docs on the FlashHash class for more details about the flash.
class Flash
KEY = 'action_dispatch.request.flash_hash'.freeze
class FlashNow #:nodoc:
attr_accessor :flash
def initialize(flash)
@flash = flash
end
def []=(k, v)
k = k.to_s
@flash[k] = v
@flash.discard(k)
v
end
def [](k)
@flash[k.to_s]
end
# Convenience accessor for flash.now[:alert]=.
def alert=(message)
self[:alert] = message
end
# Convenience accessor for flash.now[:notice]=.
def notice=(message)
self[:notice] = message
end
end
class FlashHash
include Enumerable
def self.from_session_value(value) #:nodoc:
flash = case value
when FlashHash # Rails 3.1, 3.2
new(value.instance_variable_get(:@flashes), value.instance_variable_get(:@used))
when Hash # Rails 4.0
new(value['flashes'], value['discard'])
else
new
end
flash.tap(&:sweep)
end
# Builds a hash containing the discarded values and the hashes
# representing the flashes.
# If there are no values in @flashes, returns nil.
def to_session_value #:nodoc:
return nil if empty?
{'discard' => @discard.to_a, 'flashes' => @flashes}
end
def initialize(flashes = {}, discard = []) #:nodoc:
@discard = Set.new(stringify_array(discard))
@flashes = flashes.stringify_keys
@now = nil
end
def initialize_copy(other)
if other.now_is_loaded?
@now = other.now.dup
@now.flash = self
end
super
end
def []=(k, v)
k = k.to_s
@discard.delete k
@flashes[k] = v
end
def [](k)
@flashes[k.to_s]
end
def update(h) #:nodoc:
@discard.subtract stringify_array(h.keys)
@flashes.update h.stringify_keys
self
end
def keys
@flashes.keys
end
def key?(name)
@flashes.key? name.to_s
end
def delete(key)
key = key.to_s
@discard.delete key
@flashes.delete key
self
end
def to_hash
@flashes.dup
end
def empty?
@flashes.empty?
end
def clear
@discard.clear
@flashes.clear
end
def each(&block)
@flashes.each(&block)
end
alias :merge! :update
def replace(h) #:nodoc:
@discard.clear
@flashes.replace h.stringify_keys
self
end
# Sets a flash that will not be available to the next action, only to the current.
#
# flash.now[:message] = "Hello current action"
#
# This method enables you to use the flash as a central messaging system in your app.
# When you need to pass an object to the next action, you use the standard flash assign ([]=).
# When you need to pass an object to the current action, you use now, and your object will
# vanish when the current action is done.
#
# Entries set via now are accessed the same way as standard entries: flash['my-key'].
#
# Also, brings two convenience accessors:
#
# flash.now.alert = "Beware now!"
# # Equivalent to flash.now[:alert] = "Beware now!"
#
# flash.now.notice = "Good luck now!"
# # Equivalent to flash.now[:notice] = "Good luck now!"
def now
@now ||= FlashNow.new(self)
end
# Keeps either the entire current flash or a specific flash entry available for the next action:
#
# flash.keep # keeps the entire flash
# flash.keep(:notice) # keeps only the "notice" entry, the rest of the flash is discarded
def keep(k = nil)
k = k.to_s if k
@discard.subtract Array(k || keys)
k ? self[k] : self
end
# Marks the entire flash or a single flash entry to be discarded by the end of the current action:
#
# flash.discard # discard the entire flash at the end of the current action
# flash.discard(:warning) # discard only the "warning" entry at the end of the current action
def discard(k = nil)
k = k.to_s if k
@discard.merge Array(k || keys)
k ? self[k] : self
end
# Mark for removal entries that were kept, and delete unkept ones.
#
# This method is called automatically by filters, so you generally don't need to care about it.
def sweep #:nodoc:
@discard.each { |k| @flashes.delete k }
@discard.replace @flashes.keys
end
# Convenience accessor for flash[:alert].
def alert
self[:alert]
end
# Convenience accessor for flash[:alert]=.
def alert=(message)
self[:alert] = message
end
# Convenience accessor for flash[:notice].
def notice
self[:notice]
end
# Convenience accessor for flash[:notice]=.
def notice=(message)
self[:notice] = message
end
protected
def now_is_loaded?
@now
end
def stringify_array(array)
array.map do |item|
item.kind_of?(Symbol) ? item.to_s : item
end
end
end
def initialize(app)
@app = app
end
def call(env)
@app.call(env)
ensure
session = Request::Session.find(env) || {}
flash_hash = env[KEY]
if flash_hash && (flash_hash.present? || session.key?('flash'))
session["flash"] = flash_hash.to_session_value
env[KEY] = flash_hash.dup
end
if (!session.respond_to?(:loaded?) || session.loaded?) && # (reset_session uses {}, which doesn't implement #loaded?)
session.key?('flash') && session['flash'].nil?
session.delete('flash')
end
end
end
end
rails-4.2.10/actionpack/lib/action_dispatch/middleware/params_parser.rb 0000664 0000000 0000000 00000003147 13162731520 0026234 0 ustar 00root root 0000000 0000000 require 'active_support/core_ext/hash/conversions'
require 'action_dispatch/http/request'
require 'active_support/core_ext/hash/indifferent_access'
module ActionDispatch
class ParamsParser
class ParseError < StandardError
attr_reader :original_exception
def initialize(message, original_exception)
super(message)
@original_exception = original_exception
end
end
DEFAULT_PARSERS = { Mime::JSON => :json }
def initialize(app, parsers = {})
@app, @parsers = app, DEFAULT_PARSERS.merge(parsers)
end
def call(env)
if params = parse_formatted_parameters(env)
env["action_dispatch.request.request_parameters"] = params
end
@app.call(env)
end
private
def parse_formatted_parameters(env)
request = Request.new(env)
return false if request.content_length.zero?
strategy = @parsers[request.content_mime_type]
return false unless strategy
case strategy
when Proc
strategy.call(request.raw_post)
when :json
data = ActiveSupport::JSON.decode(request.raw_post)
data = {:_json => data} unless data.is_a?(Hash)
Request::Utils.deep_munge(data).with_indifferent_access
else
false
end
rescue => e # JSON or Ruby code block errors
logger(env).debug "Error occurred while parsing request parameters.\nContents:\n\n#{request.raw_post}"
raise ParseError.new(e.message, e)
end
def logger(env)
env['action_dispatch.logger'] || ActiveSupport::Logger.new($stderr)
end
end
end
rails-4.2.10/actionpack/lib/action_dispatch/middleware/public_exceptions.rb 0000664 0000000 0000000 00000004000 13162731520 0027101 0 ustar 00root root 0000000 0000000 module ActionDispatch
# When called, this middleware renders an error page. By default if an HTML
# response is expected it will render static error pages from the `/public`
# directory. For example when this middleware receives a 500 response it will
# render the template found in `/public/500.html`.
# If an internationalized locale is set, this middleware will attempt to render
# the template in `/public/500.><%= @exception.describe_blame %>
<% end %>
<%
clean_params = @request.filtered_parameters.clone
clean_params.delete("action")
clean_params.delete("controller")
request_dump = clean_params.empty? ? 'None' : clean_params.inspect.gsub(',', ",\n")
def debug_hash(object)
object.to_hash.sort_by { |k, _| k.to_s }.map { |k, v| "#{k}: #{v.inspect rescue $!.message}" }.join("\n")
end unless self.class.method_defined?(:debug_hash)
%>
Request
Parameters:
<%= request_dump %>
Response
Headers:
<%= defined?(@response) ? @response.headers.inspect.gsub(',', ",\n") : 'None' %>
_request_and_response.text.erb 0000664 0000000 0000000 00000001233 13162731520 0034476 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/lib/action_dispatch/middleware/templates/rescues <%
clean_params = @request.filtered_parameters.clone
clean_params.delete("action")
clean_params.delete("controller")
request_dump = clean_params.empty? ? 'None' : clean_params.inspect.gsub(',', ",\n")
def debug_hash(object)
object.to_hash.sort_by { |k, _| k.to_s }.map { |k, v| "#{k}: #{v.inspect rescue $!.message}" }.join("\n")
end unless self.class.method_defined?(:debug_hash)
%>
Request parameters
<%= request_dump %>
Session dump
<%= debug_hash @request.session %>
Env dump
<%= debug_hash @request.env.slice(*@request.class::ENV_METHODS) %>
Response headers
<%= defined?(@response) ? @response.headers.inspect.gsub(',', ",\n") : 'None' %>
rails-4.2.10/actionpack/lib/action_dispatch/middleware/templates/rescues/_source.erb 0000664 0000000 0000000 00000001641 13162731520 0030645 0 ustar 00root root 0000000 0000000 <% @source_extracts.each_with_index do |source_extract, index| %>
<% if source_extract[:code] %>
" id="frame-source-<%=index%>">
<% end %>
<% end %>
rails-4.2.10/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.html.erb 0000664 0000000 0000000 00000003542 13162731520 0031410 0 ustar 00root root 0000000 0000000 <% names = @traces.keys %>
Extracted source (around line #<%= source_extract[:line_number] %>):
<% source_extract[:code].each_key do |line_number| %>
<%= line_number -%>
<% end %>
|
<% source_extract[:code].each do |line, source| -%> |
Rails.root: <%= defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : "unset" %>
<% names.each do |name| %>
<%
show = "show('#{name.gsub(/\s/, '-')}');"
hide = (names - [name]).collect {|hide_name| "hide('#{hide_name.gsub(/\s/, '-')}');"}
%>
<%= name %> <%= '|' unless names.last == name %>
<% end %>
<% @traces.each do |name, trace| %>
<% end %>
rails-4.2.10/actionpack/lib/action_dispatch/middleware/templates/rescues/_trace.text.erb 0000664 0000000 0000000 00000000336 13162731520 0031426 0 ustar 00root root 0000000 0000000 Rails.root: <%= defined?(Rails) && Rails.respond_to?(:root) ? Rails.root : "unset" %>
<% @traces.each do |name, trace| %>
<% if trace.any? %>
<%= name %>
<%= trace.map { |t| t[:trace] }.join("\n") %>
<% end %>
<% end %>
rails-4.2.10/actionpack/lib/action_dispatch/middleware/templates/rescues/diagnostics.html.erb 0000664 0000000 0000000 00000000757 13162731520 0032467 0 ustar 00root root 0000000 0000000 <% trace.each do |frame| %><%= frame[:trace] %>
<% end %><%= @exception.class.to_s %> <% if @request.parameters['controller'] %> in <%= @request.parameters['controller'].camelize %>Controller<% if @request.parameters['action'] %>#<%= @request.parameters['action'] %><% end %> <% end %>
<%= h @exception.message %>
<%= render template: "rescues/_source" %> <%= render template: "rescues/_trace" %> <%= render template: "rescues/_request_and_response" %>Template is missing
<%= h @exception.message %>
<%= render template: "rescues/_source" %> <%= render template: "rescues/_trace" %> <%= render template: "rescues/_request_and_response" %>Routing Error
<%= h @exception.message %>
<% unless @exception.failures.empty? %>
Failure reasons:
-
<% @exception.failures.each do |route, reason| %>
<%= route.inspect.delete('\\') %>failed because <%= reason.downcase %>
<% end %>
Routes
Routes match in priority from top to bottom
<%= @routes_inspector.format(ActionDispatch::Routing::HtmlTableFormatter.new(self)) %> <% end %> <%= render template: "rescues/_request_and_response" %><%= @exception.original_exception.class.to_s %> in <%= @request.parameters["controller"].camelize if @request.parameters["controller"] %>#<%= @request.parameters["action"] %>
Showing <%= @exception.file_name %> where line #<%= @exception.line_number %> raised:
<%= h @exception.message %><%= @exception.sub_template_message %>
<%= render template: "rescues/_trace" %> <%= render template: "rescues/_request_and_response" %>Unknown action
<%= h @exception.message %>
| Helper | HTTP Verb | Path | Controller#Action |
|---|---|---|---|
| <%# Helper %> <%= link_to "Path", "#", 'data-route-helper' => '_path', title: "Returns a relative path (without the http or domain)" %> / <%= link_to "Url", "#", 'data-route-helper' => '_url', title: "Returns an absolute url (with the http and domain)" %> | <%# HTTP Verb %> | <%# Path %> <%= search_field(:path, nil, id: 'search', placeholder: "Path Match") %> | <%# Controller#action %> |
You don't have any routes defined!
- Please add some routes in config/routes.rb.
- For more information about routes, please see the Rails guide Rails Routing from the Outside In.
#{url_for(:action => 'flash_me', :only_path => true)}
"
end
def render_text_with_custom_content_type
render :text => "Hello!", :content_type => Mime::RSS
end
def render_with_layout
@variable_for_layout = nil
render "test/hello_world", :layout => "layouts/standard"
end
def render_with_layout_and_partial
@variable_for_layout = nil
render "test/hello_world_with_partial", :layout => "layouts/standard"
end
def session_stuffing
session['xmas'] = 'turkey'
render :text => "ho ho ho"
end
def raise_exception_on_get
raise "get" if request.get?
render :text => "request method: #{request.env['REQUEST_METHOD']}"
end
def raise_exception_on_post
raise "post" if request.post?
render :text => "request method: #{request.env['REQUEST_METHOD']}"
end
def render_file_absolute_path
render :file => File.expand_path('../../../README.rdoc', __FILE__)
end
def render_file_relative_path
render :file => 'README.rdoc'
end
end
# Used to test that assert_response includes the exception message
# in the failure message when an action raises and assert_response
# is expecting something other than an error.
class AssertResponseWithUnexpectedErrorController < ActionController::Base
def index
raise 'FAIL'
end
def show
render :text => "Boom", :status => 500
end
end
module Admin
class InnerModuleController < ActionController::Base
def index
render :nothing => true
end
def redirect_to_index
redirect_to admin_inner_module_path
end
def redirect_to_absolute_controller
redirect_to :controller => '/content'
end
def redirect_to_fellow_controller
redirect_to :controller => 'user'
end
def redirect_to_top_level_named_route
redirect_to top_level_url(:id => "foo")
end
end
end
class ActionPackAssertionsControllerTest < ActionController::TestCase
def test_render_file_absolute_path
get :render_file_absolute_path
assert_match(/\A= Action Pack/, @response.body)
end
def test_render_file_relative_path
get :render_file_relative_path
assert_match(/\A= Action Pack/, @response.body)
end
def test_get_request
assert_raise(RuntimeError) { get :raise_exception_on_get }
get :raise_exception_on_post
assert_equal 'request method: GET', @response.body
end
def test_post_request
assert_raise(RuntimeError) { post :raise_exception_on_post }
post :raise_exception_on_get
assert_equal 'request method: POST', @response.body
end
def test_get_post_request_switch
post :raise_exception_on_get
assert_equal 'request method: POST', @response.body
get :raise_exception_on_post
assert_equal 'request method: GET', @response.body
post :raise_exception_on_get
assert_equal 'request method: POST', @response.body
get :raise_exception_on_post
assert_equal 'request method: GET', @response.body
end
def test_string_constraint
with_routing do |set|
set.draw do
get "photos", :to => 'action_pack_assertions#nothing', :constraints => {:subdomain => "admin"}
end
end
end
def test_assert_redirect_to_named_route_failure
with_routing do |set|
set.draw do
get 'route_one', :to => 'action_pack_assertions#nothing', :as => :route_one
get 'route_two', :to => 'action_pack_assertions#nothing', :id => 'two', :as => :route_two
get ':controller/:action'
end
process :redirect_to_named_route
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_redirected_to 'http://test.host/route_two'
end
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_redirected_to %r(^http://test.host/route_two)
end
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_redirected_to :controller => 'action_pack_assertions', :action => 'nothing', :id => 'two'
end
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_redirected_to route_two_url
end
end
end
def test_assert_redirect_to_nested_named_route
@controller = Admin::InnerModuleController.new
with_routing do |set|
set.draw do
get 'admin/inner_module', :to => 'admin/inner_module#index', :as => :admin_inner_module
get ':controller/:action'
end
process :redirect_to_index
# redirection is <{"action"=>"index", "controller"=>"admin/admin/inner_module"}>
assert_redirected_to admin_inner_module_path
end
end
def test_assert_redirected_to_top_level_named_route_from_nested_controller
@controller = Admin::InnerModuleController.new
with_routing do |set|
set.draw do
get '/action_pack_assertions/:id', :to => 'action_pack_assertions#index', :as => :top_level
get ':controller/:action'
end
process :redirect_to_top_level_named_route
# assert_redirected_to "http://test.host/action_pack_assertions/foo" would pass because of exact match early return
assert_redirected_to "/action_pack_assertions/foo"
assert_redirected_to %r(/action_pack_assertions/foo)
end
end
def test_assert_redirected_to_top_level_named_route_with_same_controller_name_in_both_namespaces
@controller = Admin::InnerModuleController.new
with_routing do |set|
set.draw do
# this controller exists in the admin namespace as well which is the only difference from previous test
get '/user/:id', :to => 'user#index', :as => :top_level
get ':controller/:action'
end
process :redirect_to_top_level_named_route
# assert_redirected_to top_level_url('foo') would pass because of exact match early return
assert_redirected_to top_level_path('foo')
end
end
def test_assert_redirect_failure_message_with_protocol_relative_url
begin
process :redirect_external_protocol_relative
assert_redirected_to "/foo"
rescue ActiveSupport::TestCase::Assertion => ex
assert_no_match(
/#{request.protocol}#{request.host}\/\/www.rubyonrails.org/,
ex.message,
'protocol relative url was incorrectly normalized'
)
end
end
def test_template_objects_exist
process :assign_this
assert !@controller.instance_variable_defined?(:"@hi")
assert @controller.instance_variable_get(:"@howdy")
end
def test_template_objects_missing
process :nothing
assert !@controller.instance_variable_defined?(:@howdy)
end
def test_empty_flash
process :flash_me_naked
assert flash.empty?
end
def test_flash_exist
process :flash_me
assert flash.any?
assert flash['hello'].present?
end
def test_flash_does_not_exist
process :nothing
assert flash.empty?
end
def test_session_exist
process :session_stuffing
assert_equal 'turkey', session['xmas']
end
def session_does_not_exist
process :nothing
assert session.empty?
end
def test_render_template_action
process :nothing
assert_template nil
process :hello_world
assert_template 'hello_world'
end
def test_redirection_location
process :redirect_internal
assert_equal 'http://test.host/nothing', @response.redirect_url
process :redirect_external
assert_equal 'http://www.rubyonrails.org', @response.redirect_url
process :redirect_external_protocol_relative
assert_equal '//www.rubyonrails.org', @response.redirect_url
end
def test_no_redirect_url
process :nothing
assert_nil @response.redirect_url
end
def test_server_error_response_code
process :response500
assert @response.server_error?
process :response599
assert @response.server_error?
process :response404
assert !@response.server_error?
end
def test_missing_response_code
process :response404
assert @response.missing?
end
def test_client_error_response_code
process :response404
assert @response.client_error?
end
def test_redirect_url_match
process :redirect_external
assert @response.redirect?
assert_match(/rubyonrails/, @response.redirect_url)
assert !/perloffrails/.match(@response.redirect_url)
end
def test_redirection
process :redirect_internal
assert @response.redirect?
process :redirect_external
assert @response.redirect?
process :nothing
assert !@response.redirect?
end
def test_successful_response_code
process :nothing
assert @response.success?
end
def test_response_object
process :nothing
assert_kind_of ActionController::TestResponse, @response
end
def test_render_based_on_parameters
process :render_based_on_parameters, "GET", "name" => "David"
assert_equal "Mr. David", @response.body
end
def test_assert_redirection_fails_with_incorrect_controller
process :redirect_to_controller
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_redirected_to :controller => "action_pack_assertions", :action => "flash_me"
end
end
def test_assert_redirection_with_extra_controller_option
get :redirect_to_action
assert_redirected_to :controller => 'action_pack_assertions', :action => "flash_me", :id => 1, :params => { :panda => 'fun' }
end
def test_redirected_to_url_leading_slash
process :redirect_to_path
assert_redirected_to '/some/path'
end
def test_redirected_to_url_no_leading_slash_fails
process :redirect_to_path
assert_raise ActiveSupport::TestCase::Assertion do
assert_redirected_to 'some/path'
end
end
def test_redirect_invalid_external_route
process :redirect_invalid_external_route
assert_redirected_to "http://test.hostht_tp://www.rubyonrails.org"
end
def test_redirected_to_url_full_url
process :redirect_to_path
assert_redirected_to 'http://test.host/some/path'
end
def test_assert_redirection_with_symbol
process :redirect_to_controller_with_symbol
assert_nothing_raised {
assert_redirected_to :controller => "elsewhere", :action => "flash_me"
}
process :redirect_to_controller_with_symbol
assert_nothing_raised {
assert_redirected_to :controller => :elsewhere, :action => :flash_me
}
end
def test_redirected_to_with_nested_controller
@controller = Admin::InnerModuleController.new
get :redirect_to_absolute_controller
assert_redirected_to :controller => '/content'
get :redirect_to_fellow_controller
assert_redirected_to :controller => 'admin/user'
end
def test_assert_response_uses_exception_message
@controller = AssertResponseWithUnexpectedErrorController.new
e = assert_raise RuntimeError, 'Expected non-success response' do
get :index
end
assert_response :success
assert_includes 'FAIL', e.message
end
def test_assert_response_failure_response_with_no_exception
@controller = AssertResponseWithUnexpectedErrorController.new
get :show
assert_response 500
assert_equal 'Boom', response.body
end
end
class AssertTemplateTest < ActionController::TestCase
tests ActionPackAssertionsController
def test_with_invalid_hash_keys_raises_argument_error
assert_raise(ArgumentError) do
assert_template foo: "bar"
end
end
def test_with_partial
get :partial
assert_template :partial => '_partial'
end
def test_file_with_absolute_path_success
get :render_file_absolute_path
assert_template :file => File.expand_path('../../../README.rdoc', __FILE__)
end
def test_file_with_relative_path_success
get :render_file_relative_path
assert_template :file => 'README.rdoc'
end
def test_with_file_failure
get :render_file_absolute_path
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template :file => 'test/hello_world'
end
get :render_file_absolute_path
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template file: nil
end
end
def test_with_nil_passes_when_no_template_rendered
get :nothing
assert_template nil
end
def test_with_nil_fails_when_template_rendered
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template nil
end
end
def test_with_empty_string_fails_when_template_rendered
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template ""
end
end
def test_with_empty_string_fails_when_no_template_rendered
get :nothing
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template ""
end
end
def test_passes_with_correct_string
get :hello_world
assert_template 'hello_world'
assert_template 'test/hello_world'
end
def test_passes_with_correct_symbol
get :hello_world
assert_template :hello_world
end
def test_fails_with_incorrect_string
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template 'hello_planet'
end
end
def test_fails_with_incorrect_string_that_matches
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template 'est/he'
end
end
def test_fails_with_repeated_name_in_path
get :hello_repeating_in_path
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template 'test/hello'
end
end
def test_fails_with_incorrect_symbol
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template :hello_planet
end
end
def test_fails_with_incorrect_symbol_that_matches
get :hello_world
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template :"est/he"
end
end
def test_fails_with_wrong_layout
get :render_with_layout
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template :layout => "application"
end
end
def test_fails_expecting_no_layout
get :render_with_layout
assert_raise(ActiveSupport::TestCase::Assertion) do
assert_template :layout => nil
end
end
def test_passes_with_correct_layout
get :render_with_layout
assert_template :layout => "layouts/standard"
end
def test_passes_with_layout_and_partial
get :render_with_layout_and_partial
assert_template :layout => "layouts/standard"
end
def test_passed_with_no_layout
get :hello_world
assert_template :layout => nil
end
def test_passed_with_no_layout_false
get :hello_world
assert_template :layout => false
end
def test_passes_with_correct_layout_without_layouts_prefix
get :render_with_layout
assert_template :layout => "standard"
end
def test_passes_with_correct_layout_symbol
get :render_with_layout
assert_template :layout => :standard
end
def test_assert_template_reset_between_requests
get :hello_world
assert_template 'test/hello_world'
get :nothing
assert_template nil
get :partial
assert_template partial: 'test/_partial'
get :nothing
assert_template partial: nil
get :render_with_layout
assert_template layout: 'layouts/standard'
get :nothing
assert_template layout: nil
get :render_file_relative_path
assert_template file: 'README.rdoc'
get :nothing
assert_template file: nil
end
end
class ActionPackHeaderTest < ActionController::TestCase
tests ActionPackAssertionsController
def test_rendering_xml_sets_content_type
process :hello_xml_world
assert_equal('application/xml; charset=utf-8', @response.headers['Content-Type'])
end
def test_rendering_xml_respects_content_type
process :hello_xml_world_pdf
assert_equal('application/pdf; charset=utf-8', @response.headers['Content-Type'])
end
def test_rendering_xml_respects_content_type_when_set_in_the_header
process :hello_xml_world_pdf_header
assert_equal('application/pdf; charset=utf-8', @response.headers['Content-Type'])
end
def test_render_text_with_custom_content_type
get :render_text_with_custom_content_type
assert_equal 'application/rss+xml; charset=utf-8', @response.headers['Content-Type']
end
end
rails-4.2.10/actionpack/test/controller/base_test.rb 0000664 0000000 0000000 00000023623 13162731520 0022472 0 ustar 00root root 0000000 0000000 require 'abstract_unit'
require 'active_support/logger'
require 'controller/fake_models'
require 'pp' # require 'pp' early to prevent hidden_methods from not picking up the pretty-print methods until too late
# Provide some controller to run the tests on.
module Submodule
class ContainedEmptyController < ActionController::Base
end
class ContainedNonEmptyController < ActionController::Base
def public_action
render :nothing => true
end
hide_action :hidden_action
def hidden_action
raise "Noooo!"
end
def another_hidden_action
end
hide_action :another_hidden_action
end
class SubclassedController < ContainedNonEmptyController
hide_action :public_action # Hiding it here should not affect the superclass.
end
end
class EmptyController < ActionController::Base
end
class NonEmptyController < ActionController::Base
def public_action
render :nothing => true
end
hide_action :hidden_action
def hidden_action
end
end
class DefaultUrlOptionsController < ActionController::Base
def from_view
render :inline => "<%= #{params[:route]} %>"
end
def default_url_options
{ :host => 'www.override.com', :action => 'new', :locale => 'en' }
end
end
class OptionalDefaultUrlOptionsController < ActionController::Base
def default_url_options
{ thing: 'default_thing' }
end
end
class DefaultFormatController < ActionController::Base
def show
render nothing: true
end
def default_url_options
{ format: 'atom' }
end
end
class UrlOptionsController < ActionController::Base
def from_view
render :inline => "<%= #{params[:route]} %>"
end
def url_options
super.merge(:host => 'www.override.com')
end
end
class RecordIdentifierIncludedController < ActionController::Base
include ActionView::RecordIdentifier
end
class ActionMissingController < ActionController::Base
def action_missing(action)
render :text => "Response for #{action}"
end
end
class ControllerClassTests < ActiveSupport::TestCase
def test_controller_path
assert_equal 'empty', EmptyController.controller_path
assert_equal EmptyController.controller_path, EmptyController.new.controller_path
assert_equal 'submodule/contained_empty', Submodule::ContainedEmptyController.controller_path
assert_equal Submodule::ContainedEmptyController.controller_path, Submodule::ContainedEmptyController.new.controller_path
end
def test_controller_name
assert_equal 'empty', EmptyController.controller_name
assert_equal 'contained_empty', Submodule::ContainedEmptyController.controller_name
end
def test_no_deprecation_when_action_view_record_identifier_is_included
record = Comment.new
record.save
dom_id = nil
assert_not_deprecated do
dom_id = RecordIdentifierIncludedController.new.dom_id(record)
end
assert_equal 'comment_1', dom_id
dom_class = nil
assert_not_deprecated do
dom_class = RecordIdentifierIncludedController.new.dom_class(record)
end
assert_equal 'comment', dom_class
end
end
class ControllerInstanceTests < ActiveSupport::TestCase
def setup
@empty = EmptyController.new
@contained = Submodule::ContainedEmptyController.new
@empty_controllers = [@empty, @contained, Submodule::SubclassedController.new]
@non_empty_controllers = [NonEmptyController.new,
Submodule::ContainedNonEmptyController.new]
end
def test_performed?
assert !@empty.performed?
@empty.response_body = ["sweet"]
assert @empty.performed?
end
def test_action_methods
@empty_controllers.each do |c|
assert_equal Set.new, c.class.action_methods, "#{c.controller_path} should be empty!"
end
@non_empty_controllers.each do |c|
assert_equal Set.new(%w(public_action)), c.class.action_methods, "#{c.controller_path} should not be empty!"
end
end
def test_temporary_anonymous_controllers
name = 'ExamplesController'
klass = Class.new(ActionController::Base)
Object.const_set(name, klass)
controller = klass.new
assert_equal "examples", controller.controller_path
end
end
class PerformActionTest < ActionController::TestCase
def use_controller(controller_class)
@controller = controller_class.new
# enable a logger so that (e.g.) the benchmarking stuff runs, so we can get
# a more accurate simulation of what happens in "real life".
@controller.logger = ActiveSupport::Logger.new(nil)
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
@request.host = "www.nextangle.com"
end
def test_process_should_be_precise
use_controller EmptyController
exception = assert_raise AbstractController::ActionNotFound do
get :non_existent
end
assert_equal "The action 'non_existent' could not be found for EmptyController", exception.message
end
def test_get_on_hidden_should_fail
use_controller NonEmptyController
assert_raise(AbstractController::ActionNotFound) { get :hidden_action }
assert_raise(AbstractController::ActionNotFound) { get :another_hidden_action }
end
def test_action_missing_should_work
use_controller ActionMissingController
get :arbitrary_action
assert_equal "Response for arbitrary_action", @response.body
end
end
class UrlOptionsTest < ActionController::TestCase
tests UrlOptionsController
def setup
super
@request.host = 'www.example.com'
end
def test_url_for_query_params_included
rs = ActionDispatch::Routing::RouteSet.new
rs.draw do
get 'home' => 'pages#home'
end
options = {
:action => "home",
:controller => "pages",
:only_path => true,
:params => { "token" => "secret" }
}
assert_equal '/home?token=secret', rs.url_for(options)
end
def test_url_options_override
with_routing do |set|
set.draw do
get 'from_view', :to => 'url_options#from_view', :as => :from_view
get ':controller/:action'
end
get :from_view, :route => "from_view_url"
assert_equal 'http://www.override.com/from_view', @response.body
assert_equal 'http://www.override.com/from_view', @controller.send(:from_view_url)
assert_equal 'http://www.override.com/default_url_options/index', @controller.url_for(:controller => 'default_url_options')
end
end
def test_url_helpers_does_not_become_actions
with_routing do |set|
set.draw do
get "account/overview"
end
assert !@controller.class.action_methods.include?("account_overview_path")
end
end
end
class DefaultUrlOptionsTest < ActionController::TestCase
tests DefaultUrlOptionsController
def setup
super
@request.host = 'www.example.com'
end
def test_default_url_options_override
with_routing do |set|
set.draw do
get 'from_view', :to => 'default_url_options#from_view', :as => :from_view
get ':controller/:action'
end
get :from_view, :route => "from_view_url"
assert_equal 'http://www.override.com/from_view?locale=en', @response.body
assert_equal 'http://www.override.com/from_view?locale=en', @controller.send(:from_view_url)
assert_equal 'http://www.override.com/default_url_options/new?locale=en', @controller.url_for(:controller => 'default_url_options')
end
end
def test_default_url_options_are_used_in_non_positional_parameters
with_routing do |set|
set.draw do
scope("/:locale") do
resources :descriptions
end
get ':controller/:action'
end
get :from_view, :route => "description_path(1)"
assert_equal '/en/descriptions/1', @response.body
assert_equal '/en/descriptions', @controller.send(:descriptions_path)
assert_equal '/pl/descriptions', @controller.send(:descriptions_path, "pl")
assert_equal '/pl/descriptions', @controller.send(:descriptions_path, :locale => "pl")
assert_equal '/pl/descriptions.xml', @controller.send(:descriptions_path, "pl", "xml")
assert_equal '/en/descriptions.xml', @controller.send(:descriptions_path, :format => "xml")
assert_equal '/en/descriptions/1', @controller.send(:description_path, 1)
assert_equal '/pl/descriptions/1', @controller.send(:description_path, "pl", 1)
assert_equal '/pl/descriptions/1', @controller.send(:description_path, 1, :locale => "pl")
assert_equal '/pl/descriptions/1.xml', @controller.send(:description_path, "pl", 1, "xml")
assert_equal '/en/descriptions/1.xml', @controller.send(:description_path, 1, :format => "xml")
end
end
end
class DefaultFormatControllerTest < ActionController::TestCase
def test_default_format_preserved_when_missing_from_positional_arguments
with_routing do |set|
set.draw do
get "/things/:id(.:format)" => 'default_format#show', :as => :thing
end
assert_equal '/things/1.atom', thing_path("1")
end
end
end
class OptionalDefaultUrlOptionsControllerTest < ActionController::TestCase
def test_optional_default_url_options_are_overridden_by_missing_positional_args
with_routing do |set|
set.draw do
get "/:category(/:thing)" => "optional_default_url_options#show", :as => :thing
end
assert_equal "/things/a_thing", thing_path('things', 'a_thing')
assert_equal "/things/default_thing", thing_path('things')
end
end
end
class EmptyUrlOptionsTest < ActionController::TestCase
tests NonEmptyController
def setup
super
@request.host = 'www.example.com'
end
def test_ensure_url_for_works_as_expected_when_called_with_no_options_if_default_url_options_is_not_set
get :public_action
assert_equal "http://www.example.com/non_empty/public_action", @controller.url_for
end
def test_named_routes_with_path_without_doing_a_request_first
@controller = EmptyController.new
@controller.request = @request
with_routing do |set|
set.draw do
resources :things
end
assert_equal '/things', @controller.send(:things_path)
end
end
end
rails-4.2.10/actionpack/test/controller/caching_test.rb 0000664 0000000 0000000 00000025650 13162731520 0023156 0 ustar 00root root 0000000 0000000 require 'fileutils'
require 'abstract_unit'
CACHE_DIR = 'test_cache'
# Don't change '/../temp/' cavalierly or you might hose something you don't want hosed
FILE_STORE_PATH = File.join(File.dirname(__FILE__), '/../temp/', CACHE_DIR)
class FragmentCachingMetalTestController < ActionController::Metal
abstract!
include ActionController::Caching
def some_action; end
end
class FragmentCachingMetalTest < ActionController::TestCase
def setup
super
@store = ActiveSupport::Cache::MemoryStore.new
@controller = FragmentCachingMetalTestController.new
@controller.perform_caching = true
@controller.cache_store = @store
@params = { controller: 'posts', action: 'index' }
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
@controller.params = @params
@controller.request = @request
@controller.response = @response
end
def test_fragment_cache_key
assert_equal 'views/what a key', @controller.fragment_cache_key('what a key')
end
end
class CachingController < ActionController::Base
abstract!
self.cache_store = :file_store, FILE_STORE_PATH
end
class FragmentCachingTestController < CachingController
def some_action; end
end
class FragmentCachingTest < ActionController::TestCase
def setup
super
@store = ActiveSupport::Cache::MemoryStore.new
@controller = FragmentCachingTestController.new
@controller.perform_caching = true
@controller.cache_store = @store
@params = {:controller => 'posts', :action => 'index'}
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
@controller.params = @params
@controller.request = @request
@controller.response = @response
end
def test_fragment_cache_key
assert_equal 'views/what a key', @controller.fragment_cache_key('what a key')
assert_equal "views/test.host/fragment_caching_test/some_action",
@controller.fragment_cache_key(:controller => 'fragment_caching_test',:action => 'some_action')
end
def test_read_fragment_with_caching_enabled
@store.write('views/name', 'value')
assert_equal 'value', @controller.read_fragment('name')
end
def test_read_fragment_with_caching_disabled
@controller.perform_caching = false
@store.write('views/name', 'value')
assert_nil @controller.read_fragment('name')
end
def test_fragment_exist_with_caching_enabled
@store.write('views/name', 'value')
assert @controller.fragment_exist?('name')
assert !@controller.fragment_exist?('other_name')
end
def test_fragment_exist_with_caching_disabled
@controller.perform_caching = false
@store.write('views/name', 'value')
assert !@controller.fragment_exist?('name')
assert !@controller.fragment_exist?('other_name')
end
def test_write_fragment_with_caching_enabled
assert_nil @store.read('views/name')
assert_equal 'value', @controller.write_fragment('name', 'value')
assert_equal 'value', @store.read('views/name')
end
def test_write_fragment_with_caching_disabled
assert_nil @store.read('views/name')
@controller.perform_caching = false
assert_equal 'value', @controller.write_fragment('name', 'value')
assert_nil @store.read('views/name')
end
def test_expire_fragment_with_simple_key
@store.write('views/name', 'value')
@controller.expire_fragment 'name'
assert_nil @store.read('views/name')
end
def test_expire_fragment_with_regexp
@store.write('views/name', 'value')
@store.write('views/another_name', 'another_value')
@store.write('views/primalgrasp', 'will not expire ;-)')
@controller.expire_fragment(/name/)
assert_nil @store.read('views/name')
assert_nil @store.read('views/another_name')
assert_equal 'will not expire ;-)', @store.read('views/primalgrasp')
end
def test_fragment_for
@store.write('views/expensive', 'fragment content')
fragment_computed = false
view_context = @controller.view_context
buffer = 'generated till now -> '.html_safe
buffer << view_context.send(:fragment_for, 'expensive') { fragment_computed = true }
assert !fragment_computed
assert_equal 'generated till now -> fragment content', buffer
end
def test_html_safety
assert_nil @store.read('views/name')
content = 'value'.html_safe
assert_equal content, @controller.write_fragment('name', content)
cached = @store.read('views/name')
assert_equal content, cached
assert_equal String, cached.class
html_safe = @controller.read_fragment('name')
assert_equal content, html_safe
assert html_safe.html_safe?
end
end
class FunctionalCachingController < CachingController
def fragment_cached
end
def html_fragment_cached_with_partial
respond_to do |format|
format.html
end
end
def formatted_fragment_cached
respond_to do |format|
format.html
format.xml
end
end
def formatted_fragment_cached_with_variant
respond_to do |format|
format.html.phone
format.html
end
end
def fragment_cached_without_digest
end
end
class FunctionalFragmentCachingTest < ActionController::TestCase
def setup
super
@store = ActiveSupport::Cache::MemoryStore.new
@controller = FunctionalCachingController.new
@controller.perform_caching = true
@controller.cache_store = @store
@request = ActionController::TestRequest.new
@response = ActionController::TestResponse.new
end
def test_fragment_caching
get :fragment_cached
assert_response :success
expected_body = <<-CACHED
Hello
This bit's fragment cached
Ciao
CACHED
assert_equal expected_body, @response.body
assert_equal "This bit's fragment cached",
@store.read("views/test.host/functional_caching/fragment_cached/#{template_digest("functional_caching/fragment_cached")}")
end
def test_fragment_caching_in_partials
get :html_fragment_cached_with_partial
assert_response :success
assert_match(/Old fragment caching in a partial/, @response.body)
assert_match("Old fragment caching in a partial",
@store.read("views/test.host/functional_caching/html_fragment_cached_with_partial/#{template_digest("functional_caching/_partial")}"))
end
def test_skipping_fragment_cache_digesting
get :fragment_cached_without_digest, :format => "html"
assert_response :success
expected_body = "\nERB
\n\n" assert_equal expected_body, @response.body assert_equal "ERB
", @store.read("views/nodigest") end def test_render_inline_before_fragment_caching get :inline_fragment_cached assert_response :success assert_match(/Some inline content/, @response.body) assert_match(/Some cached content/, @response.body) assert_match("Some cached content", @store.read("views/test.host/functional_caching/inline_fragment_cached/#{template_digest("functional_caching/inline_fragment_cached")}")) end def test_fragment_cache_instrumentation payload = nil subscriber = proc do |*args| event = ActiveSupport::Notifications::Event.new(*args) payload = event.payload end ActiveSupport::Notifications.subscribed(subscriber, "read_fragment.action_controller") do get :inline_fragment_cached end assert_equal "functional_caching", payload[:controller] assert_equal "inline_fragment_cached", payload[:action] end def test_html_formatted_fragment_caching get :formatted_fragment_cached, :format => "html" assert_response :success expected_body = "\nERB
\n\n" assert_equal expected_body, @response.body assert_equal "ERB
", @store.read("views/test.host/functional_caching/formatted_fragment_cached/#{template_digest("functional_caching/formatted_fragment_cached")}") end def test_xml_formatted_fragment_caching get :formatted_fragment_cached, :format => "xml" assert_response :success expected_body = "\nBuilder
\n\n" assert_equal expected_body, @response.body assert_equal "Builder
\n", @store.read("views/test.host/functional_caching/formatted_fragment_cached/#{template_digest("functional_caching/formatted_fragment_cached")}") end def test_fragment_caching_with_variant @request.variant = :phone get :formatted_fragment_cached_with_variant, :format => "html" assert_response :success expected_body = "\nPHONE
\n\n" assert_equal expected_body, @response.body assert_equal "PHONE
", @store.read("views/test.host/functional_caching/formatted_fragment_cached_with_variant/#{template_digest("functional_caching/formatted_fragment_cached_with_variant")}") end private def template_digest(name) ActionView::Digestor.digest(name: name, finder: @controller.lookup_context) end end class CacheHelperOutputBufferTest < ActionController::TestCase class MockController def read_fragment(name, options) return false end def write_fragment(name, fragment, options) fragment end end def setup super end def test_output_buffer output_buffer = ActionView::OutputBuffer.new controller = MockController.new cache_helper = Object.new cache_helper.extend(ActionView::Helpers::CacheHelper) cache_helper.expects(:controller).returns(controller).at_least(0) cache_helper.expects(:output_buffer).returns(output_buffer).at_least(0) # if the output_buffer is changed, the new one should be html_safe and of the same type cache_helper.expects(:output_buffer=).with(responds_with(:html_safe?, true)).with(instance_of(output_buffer.class)).at_least(0) assert_nothing_raised do cache_helper.send :fragment_for, 'Test fragment name', 'Test fragment', &Proc.new{ nil } end end def test_safe_buffer output_buffer = ActiveSupport::SafeBuffer.new controller = MockController.new cache_helper = Object.new cache_helper.extend(ActionView::Helpers::CacheHelper) cache_helper.expects(:controller).returns(controller).at_least(0) cache_helper.expects(:output_buffer).returns(output_buffer).at_least(0) # if the output_buffer is changed, the new one should be html_safe and of the same type cache_helper.expects(:output_buffer=).with(responds_with(:html_safe?, true)).with(instance_of(output_buffer.class)).at_least(0) assert_nothing_raised do cache_helper.send :fragment_for, 'Test fragment name', 'Test fragment', &Proc.new{ nil } end end end class ViewCacheDependencyTest < ActionController::TestCase class NoDependenciesController < ActionController::Base end class HasDependenciesController < ActionController::Base view_cache_dependency { "trombone" } view_cache_dependency { "flute" } end def test_view_cache_dependencies_are_empty_by_default assert NoDependenciesController.new.view_cache_dependencies.empty? end def test_view_cache_dependencies_are_listed_in_declaration_order assert_equal %w(trombone flute), HasDependenciesController.new.view_cache_dependencies end end rails-4.2.10/actionpack/test/controller/content_type_test.rb 0000664 0000000 0000000 00000010736 13162731520 0024274 0 ustar 00root root 0000000 0000000 require 'abstract_unit' class OldContentTypeController < ActionController::Base # :ported: def render_content_type_from_body response.content_type = Mime::RSS render :text => "hello world!" end # :ported: def render_defaults render :text => "hello world!" end # :ported: def render_content_type_from_render render :text => "hello world!", :content_type => Mime::RSS end # :ported: def render_charset_from_body response.charset = "utf-16" render :text => "hello world!" end # :ported: def render_nil_charset_from_body response.charset = nil render :text => "hello world!" end def render_default_for_erb end def render_default_for_builder end def render_change_for_builder response.content_type = Mime::HTML render :action => "render_default_for_builder" end def render_default_content_types_for_respond_to respond_to do |format| format.html { render :text => "hello world!" } format.xml { render :action => "render_default_content_types_for_respond_to" } format.js { render :text => "hello world!" } format.rss { render :text => "hello world!", :content_type => Mime::XML } end end end class ContentTypeTest < ActionController::TestCase tests OldContentTypeController def setup super # enable a logger so that (e.g.) the benchmarking stuff runs, so we can get # a more accurate simulation of what happens in "real life". @controller.logger = ActiveSupport::Logger.new(nil) end # :ported: def test_render_defaults get :render_defaults assert_equal "utf-8", @response.charset assert_equal Mime::HTML, @response.content_type end def test_render_changed_charset_default with_default_charset "utf-16" do get :render_defaults assert_equal "utf-16", @response.charset assert_equal Mime::HTML, @response.content_type end end # :ported: def test_content_type_from_body get :render_content_type_from_body assert_equal Mime::RSS, @response.content_type assert_equal "utf-8", @response.charset end # :ported: def test_content_type_from_render get :render_content_type_from_render assert_equal Mime::RSS, @response.content_type assert_equal "utf-8", @response.charset end # :ported: def test_charset_from_body get :render_charset_from_body assert_equal Mime::HTML, @response.content_type assert_equal "utf-16", @response.charset end # :ported: def test_nil_charset_from_body get :render_nil_charset_from_body assert_equal Mime::HTML, @response.content_type assert_equal "utf-8", @response.charset, @response.headers.inspect end def test_nil_default_for_erb with_default_charset nil do get :render_default_for_erb assert_equal Mime::HTML, @response.content_type assert_nil @response.charset, @response.headers.inspect end end def test_default_for_erb get :render_default_for_erb assert_equal Mime::HTML, @response.content_type assert_equal "utf-8", @response.charset end def test_default_for_builder get :render_default_for_builder assert_equal Mime::XML, @response.content_type assert_equal "utf-8", @response.charset end def test_change_for_builder get :render_change_for_builder assert_equal Mime::HTML, @response.content_type assert_equal "utf-8", @response.charset end private def with_default_charset(charset) old_default_charset = ActionDispatch::Response.default_charset ActionDispatch::Response.default_charset = charset yield ensure ActionDispatch::Response.default_charset = old_default_charset end end class AcceptBasedContentTypeTest < ActionController::TestCase tests OldContentTypeController def test_render_default_content_types_for_respond_to @request.accept = Mime::HTML.to_s get :render_default_content_types_for_respond_to assert_equal Mime::HTML, @response.content_type @request.accept = Mime::JS.to_s get :render_default_content_types_for_respond_to assert_equal Mime::JS, @response.content_type end def test_render_default_content_types_for_respond_to_with_template @request.accept = Mime::XML.to_s get :render_default_content_types_for_respond_to assert_equal Mime::XML, @response.content_type end def test_render_default_content_types_for_respond_to_with_overwrite @request.accept = Mime::RSS.to_s get :render_default_content_types_for_respond_to assert_equal Mime::XML, @response.content_type end end rails-4.2.10/actionpack/test/controller/controller_fixtures/ 0000775 0000000 0000000 00000000000 13162731520 0024302 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/test/controller/controller_fixtures/app/ 0000775 0000000 0000000 00000000000 13162731520 0025062 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/test/controller/controller_fixtures/app/controllers/ 0000775 0000000 0000000 00000000000 13162731520 0027430 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/test/controller/controller_fixtures/app/controllers/admin/ 0000775 0000000 0000000 00000000000 13162731520 0030520 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/test/controller/controller_fixtures/app/controllers/admin/user_controller.rb0000664 0000000 0000000 00000000000 13162731520 0034254 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/test/controller/controller_fixtures/app/controllers/user_controller.rb 0000664 0000000 0000000 00000000000 13162731520 0033164 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/test/controller/controller_fixtures/vendor/ 0000775 0000000 0000000 00000000000 13162731520 0025577 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/test/controller/controller_fixtures/vendor/plugins/ 0000775 0000000 0000000 00000000000 13162731520 0027260 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/test/controller/controller_fixtures/vendor/plugins/bad_plugin/ 0000775 0000000 0000000 00000000000 13162731520 0031364 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/test/controller/controller_fixtures/vendor/plugins/bad_plugin/lib/ 0000775 0000000 0000000 00000000000 13162731520 0032132 5 ustar 00root root 0000000 0000000 plugin_controller.rb 0000664 0000000 0000000 00000000000 13162731520 0036127 0 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/test/controller/controller_fixtures/vendor/plugins/bad_plugin/lib rails-4.2.10/actionpack/test/controller/default_url_options_with_before_action_test.rb 0000664 0000000 0000000 00000001266 13162731520 0031552 0 ustar 00root root 0000000 0000000 require 'abstract_unit' class ControllerWithBeforeActionAndDefaultUrlOptions < ActionController::Base before_action { I18n.locale = params[:locale] } after_action { I18n.locale = "en" } def target render :text => "final response" end def redirect redirect_to :action => "target" end def default_url_options {:locale => "de"} end end class ControllerWithBeforeActionAndDefaultUrlOptionsTest < ActionController::TestCase # This test has its roots in issue #1872 test "should redirect with correct locale :de" do get :redirect, :locale => "de" assert_redirected_to "/controller_with_before_action_and_default_url_options/target?locale=de" end end rails-4.2.10/actionpack/test/controller/filters_test.rb 0000664 0000000 0000000 00000074000 13162731520 0023223 0 ustar 00root root 0000000 0000000 require 'abstract_unit' class ActionController::Base class << self %w(append_around_action prepend_after_action prepend_around_action prepend_before_action skip_after_action skip_before_action skip_action_callback).each do |pending| define_method(pending) do |*args| $stderr.puts "#{pending} unimplemented: #{args.inspect}" end unless method_defined?(pending) end def before_actions filters = _process_action_callbacks.select { |c| c.kind == :before } filters.map! { |c| c.raw_filter } end end def assigns(key = nil) assigns = {} instance_variables.each do |ivar| next if ActionController::Base.protected_instance_variables.include?(ivar) assigns[ivar[1..-1]] = instance_variable_get(ivar) end key.nil? ? assigns : assigns[key.to_s] end end class FilterTest < ActionController::TestCase class TestController < ActionController::Base before_action :ensure_login after_action :clean_up def show render :inline => "ran action" end private def ensure_login @ran_filter ||= [] @ran_filter << "ensure_login" end def clean_up @ran_after_action ||= [] @ran_after_action << "clean_up" end end class ChangingTheRequirementsController < TestController before_action :ensure_login, :except => [:go_wild] def go_wild render :text => "gobble" end end class TestMultipleFiltersController < ActionController::Base before_action :try_1 before_action :try_2 before_action :try_3 (1..3).each do |i| define_method "fail_#{i}" do render :text => i.to_s end end protected (1..3).each do |i| define_method "try_#{i}" do instance_variable_set :@try, i if action_name == "fail_#{i}" head(404) end end end end class RenderingController < ActionController::Base before_action :before_action_rendering after_action :unreached_after_action def show @ran_action = true render :inline => "ran action" end private def before_action_rendering @ran_filter ||= [] @ran_filter << "before_action_rendering" render :inline => "something else" end def unreached_after_action @ran_filter << "unreached_after_action_after_render" end end class RenderingForPrependAfterActionController < RenderingController prepend_after_action :unreached_prepend_after_action private def unreached_prepend_after_action @ran_filter << "unreached_preprend_after_action_after_render" end end class BeforeActionRedirectionController < ActionController::Base before_action :before_action_redirects after_action :unreached_after_action def show @ran_action = true render :inline => "ran show action" end def target_of_redirection @ran_target_of_redirection = true render :inline => "ran target_of_redirection action" end private def before_action_redirects @ran_filter ||= [] @ran_filter << "before_action_redirects" redirect_to(:action => 'target_of_redirection') end def unreached_after_action @ran_filter << "unreached_after_action_after_redirection" end end class BeforeActionRedirectionForPrependAfterActionController < BeforeActionRedirectionController prepend_after_action :unreached_prepend_after_action_after_redirection private def unreached_prepend_after_action_after_redirection @ran_filter << "unreached_prepend_after_action_after_redirection" end end class ConditionalFilterController < ActionController::Base def show render :inline => "ran action" end def another_action render :inline => "ran action" end def show_without_action render :inline => "ran action without action" end private def ensure_login @ran_filter ||= [] @ran_filter << "ensure_login" end def clean_up_tmp @ran_filter ||= [] @ran_filter << "clean_up_tmp" end end class ConditionalCollectionFilterController < ConditionalFilterController before_action :ensure_login, :except => [ :show_without_action, :another_action ] end class OnlyConditionSymController < ConditionalFilterController before_action :ensure_login, :only => :show end class ExceptConditionSymController < ConditionalFilterController before_action :ensure_login, :except => :show_without_action end class BeforeAndAfterConditionController < ConditionalFilterController before_action :ensure_login, :only => :show after_action :clean_up_tmp, :only => :show end class OnlyConditionProcController < ConditionalFilterController before_action(:only => :show) {|c| c.instance_variable_set(:"@ran_proc_action", true) } end class ExceptConditionProcController < ConditionalFilterController before_action(:except => :show_without_action) {|c| c.instance_variable_set(:"@ran_proc_action", true) } end class ConditionalClassFilter def self.before(controller) controller.instance_variable_set(:"@ran_class_action", true) end end class OnlyConditionClassController < ConditionalFilterController before_action ConditionalClassFilter, :only => :show end class ExceptConditionClassController < ConditionalFilterController before_action ConditionalClassFilter, :except => :show_without_action end class AnomolousYetValidConditionController < ConditionalFilterController before_action(ConditionalClassFilter, :ensure_login, Proc.new {|c| c.instance_variable_set(:"@ran_proc_action1", true)}, :except => :show_without_action) { |c| c.instance_variable_set(:"@ran_proc_action2", true)} end class OnlyConditionalOptionsFilter < ConditionalFilterController before_action :ensure_login, :only => :index, :if => Proc.new {|c| c.instance_variable_set(:"@ran_conditional_index_proc", true) } end class ConditionalOptionsFilter < ConditionalFilterController before_action :ensure_login, :if => Proc.new { |c| true } before_action :clean_up_tmp, :if => Proc.new { |c| false } end class ConditionalOptionsSkipFilter < ConditionalFilterController before_action :ensure_login before_action :clean_up_tmp skip_before_action :ensure_login, if: -> { false } skip_before_action :clean_up_tmp, if: -> { true } end class ClassController < ConditionalFilterController before_action ConditionalClassFilter end class PrependingController < TestController prepend_before_action :wonderful_life # skip_before_action :fire_flash private def wonderful_life @ran_filter ||= [] @ran_filter << "wonderful_life" end end class SkippingAndLimitedController < TestController skip_before_action :ensure_login before_action :ensure_login, :only => :index def index render :text => 'ok' end def public render :text => 'ok' end end class SkippingAndReorderingController < TestController skip_before_action :ensure_login before_action :find_record before_action :ensure_login def index render :text => 'ok' end private def find_record @ran_filter ||= [] @ran_filter << "find_record" end end class ConditionalSkippingController < TestController skip_before_action :ensure_login, :only => [ :login ] skip_after_action :clean_up, :only => [ :login ] before_action :find_user, :only => [ :change_password ] def login render :inline => "ran action" end def change_password render :inline => "ran action" end protected def find_user @ran_filter ||= [] @ran_filter << "find_user" end end class ConditionalParentOfConditionalSkippingController < ConditionalFilterController before_action :conditional_in_parent_before, :only => [:show, :another_action] after_action :conditional_in_parent_after, :only => [:show, :another_action] private def conditional_in_parent_before @ran_filter ||= [] @ran_filter << 'conditional_in_parent_before' end def conditional_in_parent_after @ran_filter ||= [] @ran_filter << 'conditional_in_parent_after' end end class ChildOfConditionalParentController < ConditionalParentOfConditionalSkippingController skip_before_action :conditional_in_parent_before, :only => :another_action skip_after_action :conditional_in_parent_after, :only => :another_action end class AnotherChildOfConditionalParentController < ConditionalParentOfConditionalSkippingController skip_before_action :conditional_in_parent_before, :only => :show end class ProcController < PrependingController before_action(proc { |c| c.instance_variable_set(:"@ran_proc_action", true) }) end class ImplicitProcController < PrependingController before_action { |c| c.instance_variable_set(:"@ran_proc_action", true) } end class AuditFilter def self.before(controller) controller.instance_variable_set(:"@was_audited", true) end end class AroundFilter def before(controller) @execution_log = "before" controller.class.execution_log << " before aroundfilter " if controller.respond_to? :execution_log controller.instance_variable_set(:"@before_ran", true) end def after(controller) controller.instance_variable_set(:"@execution_log", @execution_log + " and after") controller.instance_variable_set(:"@after_ran", true) controller.class.execution_log << " after aroundfilter " if controller.respond_to? :execution_log end def around(controller) before(controller) yield after(controller) end end class AppendedAroundFilter def before(controller) controller.class.execution_log << " before appended aroundfilter " end def after(controller) controller.class.execution_log << " after appended aroundfilter " end def around(controller) before(controller) yield after(controller) end end class AuditController < ActionController::Base before_action(AuditFilter) def show render :text => "hello" end end class AroundFilterController < PrependingController around_action AroundFilter.new end class BeforeAfterClassFilterController < PrependingController begin filter = AroundFilter.new before_action filter after_action filter end end class MixedFilterController < PrependingController cattr_accessor :execution_log def initialize @@execution_log = "" super() end before_action { |c| c.class.execution_log << " before procfilter " } prepend_around_action AroundFilter.new after_action { |c| c.class.execution_log << " after procfilter " } append_around_action AppendedAroundFilter.new end class MixedSpecializationController < ActionController::Base class OutOfOrder < StandardError; end before_action :first before_action :second, :only => :foo def foo render :text => 'foo' end def bar render :text => 'bar' end protected def first @first = true end def second raise OutOfOrder unless @first end end class DynamicDispatchController < ActionController::Base before_action :choose %w(foo bar baz).each do |action| define_method(action) { render :text => action } end private def choose self.action_name = params[:choose] end end class PrependingBeforeAndAfterController < ActionController::Base prepend_before_action :before_all prepend_after_action :after_all before_action :between_before_all_and_after_all def before_all @ran_filter ||= [] @ran_filter << 'before_all' end def after_all @ran_filter ||= [] @ran_filter << 'after_all' end def between_before_all_and_after_all @ran_filter ||= [] @ran_filter << 'between_before_all_and_after_all' end def show render :text => 'hello' end end class ErrorToRescue < Exception; end class RescuingAroundFilterWithBlock def around(controller) yield rescue ErrorToRescue => ex controller.__send__ :render, :text => "I rescued this: #{ex.inspect}" end end class RescuedController < ActionController::Base around_action RescuingAroundFilterWithBlock.new def show raise ErrorToRescue.new("Something made the bad noise.") end end class NonYieldingAroundFilterController < ActionController::Base before_action :filter_one around_action :non_yielding_action before_action :action_two after_action :action_three def index render :inline => "index" end private def filter_one @filters ||= [] @filters << "filter_one" end def action_two @filters << "action_two" end def non_yielding_action @filters << "it didn't yield" @filter_return_value end def action_three @filters << "action_three" end end class ImplicitActionsController < ActionController::Base before_action :find_only, :only => :edit before_action :find_except, :except => :edit private def find_only @only = 'Only' end def find_except @except = 'Except' end end def test_non_yielding_around_actions_not_returning_false_do_not_raise controller = NonYieldingAroundFilterController.new controller.instance_variable_set "@filter_return_value", true assert_nothing_raised do test_process(controller, "index") end end def test_non_yielding_around_actions_returning_false_do_not_raise controller = NonYieldingAroundFilterController.new controller.instance_variable_set "@filter_return_value", false assert_nothing_raised do test_process(controller, "index") end end def test_after_actions_are_not_run_if_around_action_returns_false controller = NonYieldingAroundFilterController.new controller.instance_variable_set "@filter_return_value", false test_process(controller, "index") assert_equal ["filter_one", "it didn't yield"], controller.assigns['filters'] end def test_after_actions_are_not_run_if_around_action_does_not_yield controller = NonYieldingAroundFilterController.new controller.instance_variable_set "@filter_return_value", true test_process(controller, "index") assert_equal ["filter_one", "it didn't yield"], controller.assigns['filters'] end def test_added_action_to_inheritance_graph assert_equal [ :ensure_login ], TestController.before_actions end def test_base_class_in_isolation assert_equal [ ], ActionController::Base.before_actions end def test_prepending_action assert_equal [ :wonderful_life, :ensure_login ], PrependingController.before_actions end def test_running_actions test_process(PrependingController) assert_equal %w( wonderful_life ensure_login ), assigns["ran_filter"] end def test_running_actions_with_proc test_process(ProcController) assert assigns["ran_proc_action"] end def test_running_actions_with_implicit_proc test_process(ImplicitProcController) assert assigns["ran_proc_action"] end def test_running_actions_with_class test_process(AuditController) assert assigns["was_audited"] end def test_running_anomolous_yet_valid_condition_actions test_process(AnomolousYetValidConditionController) assert_equal %w( ensure_login ), assigns["ran_filter"] assert assigns["ran_class_action"] assert assigns["ran_proc_action1"] assert assigns["ran_proc_action2"] test_process(AnomolousYetValidConditionController, "show_without_action") assert_nil assigns["ran_filter"] assert !assigns["ran_class_action"] assert !assigns["ran_proc_action1"] assert !assigns["ran_proc_action2"] end def test_running_conditional_options test_process(ConditionalOptionsFilter) assert_equal %w( ensure_login ), assigns["ran_filter"] end def test_running_conditional_skip_options test_process(ConditionalOptionsSkipFilter) assert_equal %w( ensure_login ), assigns["ran_filter"] end def test_skipping_class_actions test_process(ClassController) assert_equal true, assigns["ran_class_action"] skipping_class_controller = Class.new(ClassController) do skip_before_action ConditionalClassFilter end test_process(skipping_class_controller) assert_nil assigns['ran_class_action'] end def test_running_collection_condition_actions test_process(ConditionalCollectionFilterController) assert_equal %w( ensure_login ), assigns["ran_filter"] test_process(ConditionalCollectionFilterController, "show_without_action") assert_nil assigns["ran_filter"] test_process(ConditionalCollectionFilterController, "another_action") assert_nil assigns["ran_filter"] end def test_running_only_condition_actions test_process(OnlyConditionSymController) assert_equal %w( ensure_login ), assigns["ran_filter"] test_process(OnlyConditionSymController, "show_without_action") assert_nil assigns["ran_filter"] test_process(OnlyConditionProcController) assert assigns["ran_proc_action"] test_process(OnlyConditionProcController, "show_without_action") assert !assigns["ran_proc_action"] test_process(OnlyConditionClassController) assert assigns["ran_class_action"] test_process(OnlyConditionClassController, "show_without_action") assert !assigns["ran_class_action"] end def test_running_except_condition_actions test_process(ExceptConditionSymController) assert_equal %w( ensure_login ), assigns["ran_filter"] test_process(ExceptConditionSymController, "show_without_action") assert_nil assigns["ran_filter"] test_process(ExceptConditionProcController) assert assigns["ran_proc_action"] test_process(ExceptConditionProcController, "show_without_action") assert !assigns["ran_proc_action"] test_process(ExceptConditionClassController) assert assigns["ran_class_action"] test_process(ExceptConditionClassController, "show_without_action") assert !assigns["ran_class_action"] end def test_running_only_condition_and_conditional_options test_process(OnlyConditionalOptionsFilter, "show") assert_not assigns["ran_conditional_index_proc"] end def test_running_before_and_after_condition_actions test_process(BeforeAndAfterConditionController) assert_equal %w( ensure_login clean_up_tmp), assigns["ran_filter"] test_process(BeforeAndAfterConditionController, "show_without_action") assert_nil assigns["ran_filter"] end def test_around_action test_process(AroundFilterController) assert assigns["before_ran"] assert assigns["after_ran"] end def test_before_after_class_action test_process(BeforeAfterClassFilterController) assert assigns["before_ran"] assert assigns["after_ran"] end def test_having_properties_in_around_action test_process(AroundFilterController) assert_equal "before and after", assigns["execution_log"] end def test_prepending_and_appending_around_action test_process(MixedFilterController) assert_equal " before aroundfilter before procfilter before appended aroundfilter " + " after appended aroundfilter after procfilter after aroundfilter ", MixedFilterController.execution_log end def test_rendering_breaks_actioning_chain response = test_process(RenderingController) assert_equal "something else", response.body assert !assigns["ran_action"] end def test_before_action_rendering_breaks_actioning_chain_for_after_action test_process(RenderingController) assert_equal %w( before_action_rendering ), assigns["ran_filter"] assert !assigns["ran_action"] end def test_before_action_redirects_breaks_actioning_chain_for_after_action test_process(BeforeActionRedirectionController) assert_response :redirect assert_equal "http://test.host/filter_test/before_action_redirection/target_of_redirection", redirect_to_url assert_equal %w( before_action_redirects ), assigns["ran_filter"] end def test_before_action_rendering_breaks_actioning_chain_for_preprend_after_action test_process(RenderingForPrependAfterActionController) assert_equal %w( before_action_rendering ), assigns["ran_filter"] assert !assigns["ran_action"] end def test_before_action_redirects_breaks_actioning_chain_for_preprend_after_action test_process(BeforeActionRedirectionForPrependAfterActionController) assert_response :redirect assert_equal "http://test.host/filter_test/before_action_redirection_for_prepend_after_action/target_of_redirection", redirect_to_url assert_equal %w( before_action_redirects ), assigns["ran_filter"] end def test_actions_with_mixed_specialization_run_in_order assert_nothing_raised do response = test_process(MixedSpecializationController, 'bar') assert_equal 'bar', response.body end assert_nothing_raised do response = test_process(MixedSpecializationController, 'foo') assert_equal 'foo', response.body end end def test_dynamic_dispatch %w(foo bar baz).each do |action| request = ActionController::TestRequest.new request.query_parameters[:choose] = action response = DynamicDispatchController.action(action).call(request.env).last assert_equal action, response.body end end def test_running_prepended_before_and_after_action test_process(PrependingBeforeAndAfterController) assert_equal %w( before_all between_before_all_and_after_all after_all ), assigns["ran_filter"] end def test_skipping_and_limiting_controller test_process(SkippingAndLimitedController, "index") assert_equal %w( ensure_login ), assigns["ran_filter"] test_process(SkippingAndLimitedController, "public") assert_nil assigns["ran_filter"] end def test_skipping_and_reordering_controller test_process(SkippingAndReorderingController, "index") assert_equal %w( find_record ensure_login ), assigns["ran_filter"] end def test_conditional_skipping_of_actions test_process(ConditionalSkippingController, "login") assert_nil assigns["ran_filter"] test_process(ConditionalSkippingController, "change_password") assert_equal %w( ensure_login find_user ), assigns["ran_filter"] test_process(ConditionalSkippingController, "login") assert !@controller.instance_variable_defined?("@ran_after_action") test_process(ConditionalSkippingController, "change_password") assert_equal %w( clean_up ), @controller.instance_variable_get("@ran_after_action") end def test_conditional_skipping_of_actions_when_parent_action_is_also_conditional test_process(ChildOfConditionalParentController) assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), assigns['ran_filter'] test_process(ChildOfConditionalParentController, 'another_action') assert_nil assigns['ran_filter'] end def test_condition_skipping_of_actions_when_siblings_also_have_conditions test_process(ChildOfConditionalParentController) assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), assigns['ran_filter'] test_process(AnotherChildOfConditionalParentController) assert_equal %w( conditional_in_parent_after ), assigns['ran_filter'] test_process(ChildOfConditionalParentController) assert_equal %w( conditional_in_parent_before conditional_in_parent_after ), assigns['ran_filter'] end def test_changing_the_requirements test_process(ChangingTheRequirementsController, "go_wild") assert_nil assigns['ran_filter'] end def test_a_rescuing_around_action response = nil assert_nothing_raised do response = test_process(RescuedController) end assert response.success? assert_equal("I rescued this: #<%= notice %>
" end def lib render :inline => '<%= useful_function %>' end end class MeTooController < JustMeController end class HelpersPathsController < ActionController::Base paths = ["helpers2_pack", "helpers1_pack"].map do |path| File.join(File.expand_path('../../fixtures', __FILE__), path) end $:.unshift(*paths) self.helpers_path = paths helper :all def index render :inline => "<%= conflicting_helper %>" end end class HelpersTypoController < ActionController::Base path = File.expand_path('../../fixtures/helpers_typo', __FILE__) $:.unshift(path) self.helpers_path = path end module LocalAbcHelper def a() end def b() end def c() end end class HelperPathsTest < ActiveSupport::TestCase def setup @request = ActionController::TestRequest.new @response = ActionController::TestResponse.new end def test_helpers_paths_priority request = ActionController::TestRequest.new responses = HelpersPathsController.action(:index).call(request.env) # helpers1_pack was given as a second path, so pack1_helper should be # included as the second one assert_equal "pack1", responses.last.body end end class HelpersTypoControllerTest < ActiveSupport::TestCase def setup @autoload_paths = ActiveSupport::Dependencies.autoload_paths ActiveSupport::Dependencies.autoload_paths = Array(HelpersTypoController.helpers_path) end def test_helper_typo_error_message e = assert_raise(NameError) { HelpersTypoController.helper 'admin/users' } assert_equal "Couldn't find Admin::UsersHelper, expected it to be defined in helpers/admin/users_helper.rb", e.message end def teardown ActiveSupport::Dependencies.autoload_paths = @autoload_paths end end class HelperTest < ActiveSupport::TestCase class TestController < ActionController::Base attr_accessor :delegate_attr def delegate_method() end end def setup # Increment symbol counter. @symbol = (@@counter ||= 'A0').succ!.dup # Generate new controller class. controller_class_name = "Helper#{@symbol}Controller" eval("class #{controller_class_name} < TestController; end") @controller_class = self.class.const_get(controller_class_name) # Set default test helper. self.test_helper = LocalAbcHelper end def test_helper assert_equal expected_helper_methods, missing_methods assert_nothing_raised { @controller_class.helper TestHelper } assert_equal [], missing_methods end def test_helper_method assert_nothing_raised { @controller_class.helper_method :delegate_method } assert master_helper_methods.include?(:delegate_method) end def test_helper_attr assert_nothing_raised { @controller_class.helper_attr :delegate_attr } assert master_helper_methods.include?(:delegate_attr) assert master_helper_methods.include?(:delegate_attr=) end def call_controller(klass, action) request = ActionController::TestRequest.new klass.action(action).call(request.env) end def test_helper_for_nested_controller assert_equal 'hello: Iz guuut!', call_controller(Fun::GamesController, "render_hello_world").last.body # request = ActionController::TestRequest.new # # resp = Fun::GamesController.action(:render_hello_world).call(request.env) # assert_equal 'hello: Iz guuut!', resp.last.body end def test_helper_for_acronym_controller assert_equal "test: baz", call_controller(Fun::PdfController, "test").last.body # # request = ActionController::TestRequest.new # response = ActionController::TestResponse.new # request.action = 'test' # # assert_equal 'test: baz', Fun::PdfController.process(request, response).body end def test_default_helpers_only assert_equal [JustMeHelper], JustMeController._helpers.ancestors.reject(&:anonymous?) assert_equal [MeTooHelper, JustMeHelper], MeTooController._helpers.ancestors.reject(&:anonymous?) end def test_base_helper_methods_after_clear_helpers assert_nothing_raised do call_controller(JustMeController, "flash") end end def test_lib_helper_methods_after_clear_helpers assert_nothing_raised do call_controller(JustMeController, "lib") end end def test_all_helpers methods = AllHelpersController._helpers.instance_methods # abc_helper.rb assert methods.include?(:bare_a) # fun/games_helper.rb assert methods.include?(:stratego) # fun/pdf_helper.rb assert methods.include?(:foobar) end def test_all_helpers_with_alternate_helper_dir @controller_class.helpers_path = File.expand_path('../../fixtures/alternate_helpers', __FILE__) # Reload helpers @controller_class._helpers = Module.new @controller_class.helper :all # helpers/abc_helper.rb should not be included assert !master_helper_methods.include?(:bare_a) # alternate_helpers/foo_helper.rb assert master_helper_methods.include?(:baz) end def test_helper_proxy methods = AllHelpersController.helpers.methods # Action View assert methods.include?(:pluralize) # abc_helper.rb assert methods.include?(:bare_a) # fun/games_helper.rb assert methods.include?(:stratego) # fun/pdf_helper.rb assert methods.include?(:foobar) end def test_helper_proxy_config AllHelpersController.config.my_var = 'smth' assert_equal 'smth', AllHelpersController.helpers.config.my_var end private def expected_helper_methods TestHelper.instance_methods end def master_helper_methods @controller_class._helpers.instance_methods end def missing_methods expected_helper_methods - master_helper_methods end def test_helper=(helper_module) silence_warnings { self.class.const_set('TestHelper', helper_module) } end end class IsolatedHelpersTest < ActiveSupport::TestCase class A < ActionController::Base def index render :inline => '<%= shout %>' end end class B < A helper { def shout; 'B' end } def index render :inline => '<%= shout %>' end end class C < A helper { def shout; 'C' end } def index render :inline => '<%= shout %>' end end def call_controller(klass, action) request = ActionController::TestRequest.new klass.action(action).call(request.env) end def setup @request = ActionController::TestRequest.new @response = ActionController::TestResponse.new @request.action = 'index' end def test_helper_in_a assert_raise(ActionView::Template::Error) { call_controller(A, "index") } end def test_helper_in_b assert_equal 'B', call_controller(B, "index").last.body end def test_helper_in_c assert_equal 'C', call_controller(C, "index").last.body end end rails-4.2.10/actionpack/test/controller/http_basic_authentication_test.rb 0000664 0000000 0000000 00000011452 13162731520 0026774 0 ustar 00root root 0000000 0000000 require 'abstract_unit' class HttpBasicAuthenticationTest < ActionController::TestCase class DummyController < ActionController::Base before_action :authenticate, only: :index before_action :authenticate_with_request, only: :display before_action :authenticate_long_credentials, only: :show http_basic_authenticate_with :name => "David", :password => "Goliath", :only => :search def index render :text => "Hello Secret" end def display render :text => 'Definitely Maybe' end def show render :text => 'Only for loooooong credentials' end def search render :text => 'All inline' end private def authenticate authenticate_or_request_with_http_basic do |username, password| username == 'lifo' && password == 'world' end end def authenticate_with_request if authenticate_with_http_basic { |username, password| username == 'pretty' && password == 'please' } @logged_in = true else request_http_basic_authentication("SuperSecret") end end def authenticate_long_credentials authenticate_or_request_with_http_basic do |username, password| username == '1234567890123456789012345678901234567890' && password == '1234567890123456789012345678901234567890' end end end AUTH_HEADERS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION', 'REDIRECT_X_HTTP_AUTHORIZATION'] tests DummyController AUTH_HEADERS.each do |header| test "successful authentication with #{header.downcase}" do @request.env[header] = encode_credentials('lifo', 'world') get :index assert_response :success assert_equal 'Hello Secret', @response.body, "Authentication failed for request header #{header}" end test "successful authentication with #{header.downcase} and long credentials" do @request.env[header] = encode_credentials('1234567890123456789012345678901234567890', '1234567890123456789012345678901234567890') get :show assert_response :success assert_equal 'Only for loooooong credentials', @response.body, "Authentication failed for request header #{header} and long credentials" end end AUTH_HEADERS.each do |header| test "unsuccessful authentication with #{header.downcase}" do @request.env[header] = encode_credentials('h4x0r', 'world') get :index assert_response :unauthorized assert_equal "HTTP Basic: Access denied.\n", @response.body, "Authentication didn't fail for request header #{header}" end test "unsuccessful authentication with #{header.downcase} and long credentials" do @request.env[header] = encode_credentials('h4x0rh4x0rh4x0rh4x0rh4x0rh4x0rh4x0rh4x0r', 'worldworldworldworldworldworldworldworld') get :show assert_response :unauthorized assert_equal "HTTP Basic: Access denied.\n", @response.body, "Authentication didn't fail for request header #{header} and long credentials" end end def test_encode_credentials_has_no_newline username = 'laskjdfhalksdjfhalkjdsfhalksdjfhklsdjhalksdjfhalksdjfhlakdsjfh' password = 'kjfhueyt9485osdfasdkljfh4lkjhakldjfhalkdsjf' result = ActionController::HttpAuthentication::Basic.encode_credentials( username, password) assert_no_match(/\n/, result) end test "authentication request without credential" do get :display assert_response :unauthorized assert_equal "HTTP Basic: Access denied.\n", @response.body assert_equal 'Basic realm="SuperSecret"', @response.headers['WWW-Authenticate'] end test "authentication request with invalid credential" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials('pretty', 'foo') get :display assert_response :unauthorized assert_equal "HTTP Basic: Access denied.\n", @response.body assert_equal 'Basic realm="SuperSecret"', @response.headers['WWW-Authenticate'] end test "authentication request with valid credential" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials('pretty', 'please') get :display assert_response :success assert assigns(:logged_in) assert_equal 'Definitely Maybe', @response.body end test "authenticate with class method" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials('David', 'Goliath') get :search assert_response :success @request.env['HTTP_AUTHORIZATION'] = encode_credentials('David', 'WRONG!') get :search assert_response :unauthorized end test "authentication request with wrong scheme" do header = 'Bearer ' + encode_credentials('David', 'Goliath').split(' ', 2)[1] @request.env['HTTP_AUTHORIZATION'] = header get :search assert_response :unauthorized end private def encode_credentials(username, password) "Basic #{::Base64.encode64("#{username}:#{password}")}" end end rails-4.2.10/actionpack/test/controller/http_digest_authentication_test.rb 0000664 0000000 0000000 00000024541 13162731520 0027175 0 ustar 00root root 0000000 0000000 require 'abstract_unit' require 'active_support/key_generator' class HttpDigestAuthenticationTest < ActionController::TestCase class DummyDigestController < ActionController::Base before_action :authenticate, only: :index before_action :authenticate_with_request, only: :display USERS = { 'lifo' => 'world', 'pretty' => 'please', 'dhh' => ::Digest::MD5::hexdigest(["dhh","SuperSecret","secret"].join(":"))} def index render :text => "Hello Secret" end def display render :text => 'Definitely Maybe' end private def authenticate authenticate_or_request_with_http_digest("SuperSecret") do |username| # Returns the password USERS[username] end end def authenticate_with_request if authenticate_with_http_digest("SuperSecret") { |username| USERS[username] } @logged_in = true else request_http_digest_authentication("SuperSecret", "Authentication Failed") end end end AUTH_HEADERS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION', 'REDIRECT_X_HTTP_AUTHORIZATION'] tests DummyDigestController setup do # Used as secret in generating nonce to prevent tampering of timestamp @secret = "4fb45da9e4ab4ddeb7580d6a35503d99" @request.env["action_dispatch.key_generator"] = ActiveSupport::LegacyKeyGenerator.new(@secret) end teardown do # ActionController::Base.session_options[:secret] = @old_secret end AUTH_HEADERS.each do |header| test "successful authentication with #{header.downcase}" do @request.env[header] = encode_credentials(:username => 'lifo', :password => 'world') get :index assert_response :success assert_equal 'Hello Secret', @response.body, "Authentication failed for request header #{header}" end end AUTH_HEADERS.each do |header| test "unsuccessful authentication with #{header.downcase}" do @request.env[header] = encode_credentials(:username => 'h4x0r', :password => 'world') get :index assert_response :unauthorized assert_equal "HTTP Digest: Access denied.\n", @response.body, "Authentication didn't fail for request header #{header}" end end test "authentication request without credential" do get :display assert_response :unauthorized assert_equal "Authentication Failed", @response.body credentials = decode_credentials(@response.headers['WWW-Authenticate']) assert_equal 'SuperSecret', credentials[:realm] end test "authentication request with nil credentials" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => nil, :password => nil) get :index assert_response :unauthorized assert_equal "HTTP Digest: Access denied.\n", @response.body, "Authentication didn't fail for request" assert_not_equal 'Hello Secret', @response.body, "Authentication didn't fail for request" end test "authentication request with invalid password" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'foo') get :display assert_response :unauthorized assert_equal "Authentication Failed", @response.body end test "authentication request with invalid nonce" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please', :nonce => "xxyyzz") get :display assert_response :unauthorized assert_equal "Authentication Failed", @response.body end test "authentication request with invalid opaque" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'foo', :opaque => "xxyyzz") get :display assert_response :unauthorized assert_equal "Authentication Failed", @response.body end test "authentication request with invalid realm" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'foo', :realm => "NotSecret") get :display assert_response :unauthorized assert_equal "Authentication Failed", @response.body end test "authentication request with valid credential" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please') get :display assert_response :success assert assigns(:logged_in) assert_equal 'Definitely Maybe', @response.body end test "authentication request with valid credential and nil session" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please') get :display assert_response :success assert assigns(:logged_in) assert_equal 'Definitely Maybe', @response.body end test "authentication request with request-uri that doesn't match credentials digest-uri" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please') @request.env['PATH_INFO'] = "/proxied/uri" get :display assert_response :success assert assigns(:logged_in) assert_equal 'Definitely Maybe', @response.body end test "authentication request with absolute request uri (as in webrick)" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please') @request.env["SERVER_NAME"] = "test.host" @request.env['PATH_INFO'] = "/http_digest_authentication_test/dummy_digest" get :display assert_response :success assert assigns(:logged_in) assert_equal 'Definitely Maybe', @response.body end test "authentication request with absolute uri in credentials (as in IE)" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:url => "http://test.host/http_digest_authentication_test/dummy_digest", :username => 'pretty', :password => 'please') get :display assert_response :success assert assigns(:logged_in) assert_equal 'Definitely Maybe', @response.body end test "authentication request with absolute uri in both request and credentials (as in Webrick with IE)" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:url => "http://test.host/http_digest_authentication_test/dummy_digest", :username => 'pretty', :password => 'please') @request.env['SERVER_NAME'] = "test.host" @request.env['PATH_INFO'] = "/http_digest_authentication_test/dummy_digest" get :display assert_response :success assert assigns(:logged_in) assert_equal 'Definitely Maybe', @response.body end test "authentication request with password stored as ha1 digest hash" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'dhh', :password => ::Digest::MD5::hexdigest(["dhh","SuperSecret","secret"].join(":")), :password_is_ha1 => true) get :display assert_response :success assert assigns(:logged_in) assert_equal 'Definitely Maybe', @response.body end test "authentication request with _method" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please', :method => :post) @request.env['rack.methodoverride.original_method'] = 'POST' put :display assert_response :success assert assigns(:logged_in) assert_equal 'Definitely Maybe', @response.body end test "validate_digest_response should fail with nil returning password_procedure" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => nil, :password => nil) assert !ActionController::HttpAuthentication::Digest.validate_digest_response(@request, "SuperSecret"){nil} end test "authentication request with request-uri ending in '/'" do @request.env['PATH_INFO'] = "/http_digest_authentication_test/dummy_digest/" @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please') # simulate normalizing PATH_INFO @request.env['PATH_INFO'] = "/http_digest_authentication_test/dummy_digest" get :display assert_response :success assert_equal 'Definitely Maybe', @response.body end test "authentication request with request-uri ending in '?'" do @request.env['PATH_INFO'] = "/http_digest_authentication_test/dummy_digest/?" @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:username => 'pretty', :password => 'please') # simulate normalizing PATH_INFO @request.env['PATH_INFO'] = "/http_digest_authentication_test/dummy_digest" get :display assert_response :success assert_equal 'Definitely Maybe', @response.body end test "authentication request with absolute uri in credentials (as in IE) ending with /" do @request.env['PATH_INFO'] = "/http_digest_authentication_test/dummy_digest/" @request.env['HTTP_AUTHORIZATION'] = encode_credentials(:uri => "http://test.host/http_digest_authentication_test/dummy_digest/", :username => 'pretty', :password => 'please') # simulate normalizing PATH_INFO @request.env['PATH_INFO'] = "/http_digest_authentication_test/dummy_digest" get :display assert_response :success assert assigns(:logged_in) assert_equal 'Definitely Maybe', @response.body end test "when sent a basic auth header, returns Unauthorized" do @request.env['HTTP_AUTHORIZATION'] = 'Basic Gwf2aXq8ZLF3Hxq=' get :display assert_response :unauthorized end private def encode_credentials(options) options.reverse_merge!(:nc => "00000001", :cnonce => "0a4f113b", :password_is_ha1 => false) password = options.delete(:password) # Perform unauthenticated request to retrieve digest parameters to use on subsequent request method = options.delete(:method) || 'GET' case method.to_s.upcase when 'GET' get :index when 'POST' post :index end assert_response :unauthorized credentials = decode_credentials(@response.headers['WWW-Authenticate']) credentials.merge!(options) path_info = @request.env['PATH_INFO'].to_s uri = options[:uri] || path_info credentials.merge!(:uri => uri) @request.env["ORIGINAL_FULLPATH"] = path_info ActionController::HttpAuthentication::Digest.encode_credentials(method, credentials, password, options[:password_is_ha1]) end def decode_credentials(header) ActionController::HttpAuthentication::Digest.decode_credentials(header) end end rails-4.2.10/actionpack/test/controller/http_token_authentication_test.rb 0000664 0000000 0000000 00000015516 13162731520 0027040 0 ustar 00root root 0000000 0000000 require 'abstract_unit' class HttpTokenAuthenticationTest < ActionController::TestCase class DummyController < ActionController::Base before_action :authenticate, only: :index before_action :authenticate_with_request, only: :display before_action :authenticate_long_credentials, only: :show def index render :text => "Hello Secret" end def display render :text => 'Definitely Maybe' end def show render :text => 'Only for loooooong credentials' end private def authenticate authenticate_or_request_with_http_token do |token, _| token == 'lifo' end end def authenticate_with_request if authenticate_with_http_token { |token, options| token == '"quote" pretty' && options[:algorithm] == 'test' } @logged_in = true else request_http_token_authentication("SuperSecret") end end def authenticate_long_credentials authenticate_or_request_with_http_token do |token, options| token == '1234567890123456789012345678901234567890' && options[:algorithm] == 'test' end end end AUTH_HEADERS = ['HTTP_AUTHORIZATION', 'X-HTTP_AUTHORIZATION', 'X_HTTP_AUTHORIZATION', 'REDIRECT_X_HTTP_AUTHORIZATION'] tests DummyController AUTH_HEADERS.each do |header| test "successful authentication with #{header.downcase}" do @request.env[header] = encode_credentials('lifo') get :index assert_response :success assert_equal 'Hello Secret', @response.body, "Authentication failed for request header #{header}" end test "successful authentication with #{header.downcase} and long credentials" do @request.env[header] = encode_credentials('1234567890123456789012345678901234567890', :algorithm => 'test') get :show assert_response :success assert_equal 'Only for loooooong credentials', @response.body, "Authentication failed for request header #{header} and long credentials" end end AUTH_HEADERS.each do |header| test "unsuccessful authentication with #{header.downcase}" do @request.env[header] = encode_credentials('h4x0r') get :index assert_response :unauthorized assert_equal "HTTP Token: Access denied.\n", @response.body, "Authentication didn't fail for request header #{header}" end test "unsuccessful authentication with #{header.downcase} and long credentials" do @request.env[header] = encode_credentials('h4x0rh4x0rh4x0rh4x0rh4x0rh4x0rh4x0rh4x0r') get :show assert_response :unauthorized assert_equal "HTTP Token: Access denied.\n", @response.body, "Authentication didn't fail for request header #{header} and long credentials" end end test "authentication request with badly formatted header" do @request.env['HTTP_AUTHORIZATION'] = "Token foobar" get :index assert_response :unauthorized assert_equal "HTTP Token: Access denied.\n", @response.body, "Authentication header was not properly parsed" end test "authentication request without credential" do get :display assert_response :unauthorized assert_equal "HTTP Token: Access denied.\n", @response.body assert_equal 'Token realm="SuperSecret"', @response.headers['WWW-Authenticate'] end test "authentication request with invalid credential" do @request.env['HTTP_AUTHORIZATION'] = encode_credentials('"quote" pretty') get :display assert_response :unauthorized assert_equal "HTTP Token: Access denied.\n", @response.body assert_equal 'Token realm="SuperSecret"', @response.headers['WWW-Authenticate'] end test "token_and_options returns correct token" do token = "rcHu+HzSFw89Ypyhn/896A==" actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token)).first expected = token assert_equal(expected, actual) end test "token_and_options returns correct token with value after the equal sign" do token = 'rcHu+=HzSFw89Ypyhn/896A==f34' actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token)).first expected = token assert_equal(expected, actual) end test "token_and_options returns correct token with slashes" do token = 'rcHu+\\\\"/896A' actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token)).first expected = token assert_equal(expected, actual) end test "token_and_options returns correct token with quotes" do token = '\"quote\" pretty' actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token)).first expected = token assert_equal(expected, actual) end test "token_and_options returns empty string with empty token" do token = '' actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token)).first expected = token assert_equal(expected, actual) end test "token_and_options returns correct token with nounce option" do token = "rcHu+HzSFw89Ypyhn/896A=" nonce_hash = {nonce: "123abc"} actual = ActionController::HttpAuthentication::Token.token_and_options(sample_request(token, nonce_hash)) expected_token = token expected_nonce = {"nonce" => nonce_hash[:nonce]} assert_equal(expected_token, actual.first) assert_equal(expected_nonce, actual.last) end test "token_and_options returns nil with no value after the equal sign" do actual = ActionController::HttpAuthentication::Token.token_and_options(malformed_request).first expected = nil assert_equal(expected, actual) end test "raw_params returns a tuple of two key value pair strings" do auth = sample_request("rcHu+HzSFw89Ypyhn/896A=").authorization.to_s actual = ActionController::HttpAuthentication::Token.raw_params(auth) expected = ["token=\"rcHu+HzSFw89Ypyhn/896A=\"", "nonce=\"def\""] assert_equal(expected, actual) end test "token_and_options returns right token when token key is not specified in header" do token = "rcHu+HzSFw89Ypyhn/896A=" actual = ActionController::HttpAuthentication::Token.token_and_options( sample_request_without_token_key(token) ).first expected = token assert_equal(expected, actual) end private def sample_request(token, options = {nonce: "def"}) authorization = options.inject([%{Token token="#{token}"}]) do |arr, (k, v)| arr << "#{k}=\"#{v}\"" end.join(", ") mock_authorization_request(authorization) end def malformed_request mock_authorization_request(%{Token token=}) end def sample_request_without_token_key(token) mock_authorization_request(%{Token #{token}}) end def mock_authorization_request(authorization) OpenStruct.new(authorization: authorization) end def encode_credentials(token, options = {}) ActionController::HttpAuthentication::Token.encode_credentials(token, options) end end rails-4.2.10/actionpack/test/controller/integration_test.rb 0000664 0000000 0000000 00000064014 13162731520 0024102 0 ustar 00root root 0000000 0000000 require 'abstract_unit' require 'controller/fake_controllers' require 'rails/engine' class SessionTest < ActiveSupport::TestCase StubApp = lambda { |env| [200, {"Content-Type" => "text/html", "Content-Length" => "13"}, ["Hello, World!"]] } def setup @session = ActionDispatch::Integration::Session.new(StubApp) end def test_https_bang_works_and_sets_truth_by_default assert !@session.https? @session.https! assert @session.https? @session.https! false assert !@session.https? end def test_host! assert_not_equal "glu.ttono.us", @session.host @session.host! "rubyonrails.com" assert_equal "rubyonrails.com", @session.host end def test_follow_redirect_raises_when_no_redirect @session.stubs(:redirect?).returns(false) assert_raise(RuntimeError) { @session.follow_redirect! } end def test_request_via_redirect_uses_given_method path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue"} @session.expects(:process).with(:put, path, args, headers) @session.stubs(:redirect?).returns(false) @session.request_via_redirect(:put, path, args, headers) end def test_request_via_redirect_follows_redirects path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue"} @session.stubs(:redirect?).returns(true, true, false) @session.expects(:follow_redirect!).times(2) @session.request_via_redirect(:get, path, args, headers) end def test_request_via_redirect_returns_status path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue"} @session.stubs(:redirect?).returns(false) @session.stubs(:status).returns(200) assert_equal 200, @session.request_via_redirect(:get, path, args, headers) end def test_get_via_redirect path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue" } @session.expects(:request_via_redirect).with(:get, path, args, headers) @session.get_via_redirect(path, args, headers) end def test_post_via_redirect path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue" } @session.expects(:request_via_redirect).with(:post, path, args, headers) @session.post_via_redirect(path, args, headers) end def test_patch_via_redirect path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue" } @session.expects(:request_via_redirect).with(:patch, path, args, headers) @session.patch_via_redirect(path, args, headers) end def test_put_via_redirect path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue" } @session.expects(:request_via_redirect).with(:put, path, args, headers) @session.put_via_redirect(path, args, headers) end def test_delete_via_redirect path = "/somepath"; args = {:id => '1'}; headers = {"X-Test-Header" => "testvalue" } @session.expects(:request_via_redirect).with(:delete, path, args, headers) @session.delete_via_redirect(path, args, headers) end def test_get path = "/index"; params = "blah"; headers = {:location => 'blah'} @session.expects(:process).with(:get,path,params,headers) @session.get(path,params,headers) end def test_post path = "/index"; params = "blah"; headers = {:location => 'blah'} @session.expects(:process).with(:post,path,params,headers) @session.post(path,params,headers) end def test_patch path = "/index"; params = "blah"; headers = {:location => 'blah'} @session.expects(:process).with(:patch,path,params,headers) @session.patch(path,params,headers) end def test_put path = "/index"; params = "blah"; headers = {:location => 'blah'} @session.expects(:process).with(:put,path,params,headers) @session.put(path,params,headers) end def test_delete path = "/index"; params = "blah"; headers = {:location => 'blah'} @session.expects(:process).with(:delete,path,params,headers) @session.delete(path,params,headers) end def test_head path = "/index"; params = "blah"; headers = {:location => 'blah'} @session.expects(:process).with(:head,path,params,headers) @session.head(path,params,headers) end def test_xml_http_request_get path = "/index"; params = "blah"; headers = {:location => 'blah'} headers_after_xhr = headers.merge( "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest", "HTTP_ACCEPT" => "text/javascript, text/html, application/xml, text/xml, */*" ) @session.expects(:process).with(:get,path,params,headers_after_xhr) @session.xml_http_request(:get,path,params,headers) end def test_xml_http_request_post path = "/index"; params = "blah"; headers = {:location => 'blah'} headers_after_xhr = headers.merge( "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest", "HTTP_ACCEPT" => "text/javascript, text/html, application/xml, text/xml, */*" ) @session.expects(:process).with(:post,path,params,headers_after_xhr) @session.xml_http_request(:post,path,params,headers) end def test_xml_http_request_patch path = "/index"; params = "blah"; headers = {:location => 'blah'} headers_after_xhr = headers.merge( "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest", "HTTP_ACCEPT" => "text/javascript, text/html, application/xml, text/xml, */*" ) @session.expects(:process).with(:patch,path,params,headers_after_xhr) @session.xml_http_request(:patch,path,params,headers) end def test_xml_http_request_put path = "/index"; params = "blah"; headers = {:location => 'blah'} headers_after_xhr = headers.merge( "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest", "HTTP_ACCEPT" => "text/javascript, text/html, application/xml, text/xml, */*" ) @session.expects(:process).with(:put,path,params,headers_after_xhr) @session.xml_http_request(:put,path,params,headers) end def test_xml_http_request_delete path = "/index"; params = "blah"; headers = {:location => 'blah'} headers_after_xhr = headers.merge( "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest", "HTTP_ACCEPT" => "text/javascript, text/html, application/xml, text/xml, */*" ) @session.expects(:process).with(:delete,path,params,headers_after_xhr) @session.xml_http_request(:delete,path,params,headers) end def test_xml_http_request_head path = "/index"; params = "blah"; headers = {:location => 'blah'} headers_after_xhr = headers.merge( "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest", "HTTP_ACCEPT" => "text/javascript, text/html, application/xml, text/xml, */*" ) @session.expects(:process).with(:head,path,params,headers_after_xhr) @session.xml_http_request(:head,path,params,headers) end def test_xml_http_request_override_accept path = "/index"; params = "blah"; headers = {:location => 'blah', "HTTP_ACCEPT" => "application/xml"} headers_after_xhr = headers.merge( "HTTP_X_REQUESTED_WITH" => "XMLHttpRequest" ) @session.expects(:process).with(:post,path,params,headers_after_xhr) @session.xml_http_request(:post,path,params,headers) end end class IntegrationTestTest < ActiveSupport::TestCase def setup @test = ::ActionDispatch::IntegrationTest.new(:app) @test.class.stubs(:fixture_table_names).returns([]) @session = @test.open_session end def test_opens_new_session session1 = @test.open_session { |sess| } session2 = @test.open_session # implicit session assert_respond_to session1, :assert_template, "open_session makes assert_template available" assert_respond_to session2, :assert_template, "open_session makes assert_template available" assert !session1.equal?(session2) end # RSpec mixes Matchers (which has a #method_missing) into # IntegrationTest's superclass. Make sure IntegrationTest does not # try to delegate these methods to the session object. def test_does_not_prevent_method_missing_passing_up_to_ancestors mixin = Module.new do def method_missing(name, *args) name.to_s == 'foo' ? 'pass' : super end end @test.class.superclass.__send__(:include, mixin) begin assert_equal 'pass', @test.foo ensure # leave other tests as unaffected as possible mixin.__send__(:remove_method, :method_missing) end end end # Tests that integration tests don't call Controller test methods for processing. # Integration tests have their own setup and teardown. class IntegrationTestUsesCorrectClass < ActionDispatch::IntegrationTest def self.fixture_table_names [] end def test_integration_methods_called reset! @integration_session.stubs(:generic_url_rewriter) @integration_session.stubs(:process) %w( get post head patch put delete ).each do |verb| assert_nothing_raised("'#{verb}' should use integration test methods") { __send__(verb, '/') } end end end class IntegrationProcessTest < ActionDispatch::IntegrationTest class IntegrationController < ActionController::Base def get respond_to do |format| format.html { render :text => "OK", :status => 200 } format.js { render :text => "JS OK", :status => 200 } format.xml { render :xml => "Hello Firefox
', @response.body
@request.accept = "text/iphone"
get :index
assert_equal 'Hello iPhone', @response.body
end
def test_format_with_inherited_layouts
@controller = SuperPostController.new
get :index
assert_equal 'Super Firefox
', @response.body
@request.accept = "text/iphone"
get :index
assert_equal 'Super iPhone
', @response.body
end
def test_non_navigational_format_with_no_template_fallbacks_to_html_template_with_no_layout
get :index, :format => :js
assert_equal "Hello Firefox", @response.body
end
end
rails-4.2.10/actionpack/test/controller/mime/respond_to_test.rb 0000664 0000000 0000000 00000050412 13162731520 0024657 0 ustar 00root root 0000000 0000000 require 'abstract_unit'
class RespondToController < ActionController::Base
layout :set_layout
def html_xml_or_rss
respond_to do |type|
type.html { render :text => "HTML" }
type.xml { render :text => "XML" }
type.rss { render :text => "RSS" }
type.all { render :text => "Nothing" }
end
end
def js_or_html
respond_to do |type|
type.html { render :text => "HTML" }
type.js { render :text => "JS" }
type.all { render :text => "Nothing" }
end
end
def json_or_yaml
respond_to do |type|
type.json { render :text => "JSON" }
type.yaml { render :text => "YAML" }
end
end
def html_or_xml
respond_to do |type|
type.html { render :text => "HTML" }
type.xml { render :text => "XML" }
type.all { render :text => "Nothing" }
end
end
def json_xml_or_html
respond_to do |type|
type.json { render :text => 'JSON' }
type.xml { render :xml => 'XML' }
type.html { render :text => 'HTML' }
end
end
def forced_xml
request.format = :xml
respond_to do |type|
type.html { render :text => "HTML" }
type.xml { render :text => "XML" }
end
end
def just_xml
respond_to do |type|
type.xml { render :text => "XML" }
end
end
def using_defaults
respond_to do |type|
type.html
type.xml
end
end
def using_defaults_with_type_list
respond_to(:html, :xml)
end
def using_defaults_with_all
respond_to do |type|
type.html
type.all{ render text: "ALL" }
end
end
def made_for_content_type
respond_to do |type|
type.rss { render :text => "RSS" }
type.atom { render :text => "ATOM" }
type.all { render :text => "Nothing" }
end
end
def custom_type_handling
respond_to do |type|
type.html { render :text => "HTML" }
type.custom("application/crazy-xml") { render :text => "Crazy XML" }
type.all { render :text => "Nothing" }
end
end
def custom_constant_handling
respond_to do |type|
type.html { render :text => "HTML" }
type.mobile { render :text => "Mobile" }
end
end
def custom_constant_handling_without_block
respond_to do |type|
type.html { render :text => "HTML" }
type.mobile
end
end
def handle_any
respond_to do |type|
type.html { render :text => "HTML" }
type.any(:js, :xml) { render :text => "Either JS or XML" }
end
end
def handle_any_any
respond_to do |type|
type.html { render :text => 'HTML' }
type.any { render :text => 'Whatever you ask for, I got it' }
end
end
def all_types_with_layout
respond_to do |type|
type.html
end
end
def json_with_callback
respond_to do |type|
type.json { render :json => 'JS', :callback => 'alert' }
end
end
def iphone_with_html_response_type
request.format = :iphone if request.env["HTTP_ACCEPT"] == "text/iphone"
respond_to do |type|
type.html { @type = "Firefox" }
type.iphone { @type = "iPhone" }
end
end
def iphone_with_html_response_type_without_layout
request.format = "iphone" if request.env["HTTP_ACCEPT"] == "text/iphone"
respond_to do |type|
type.html { @type = "Firefox"; render :action => "iphone_with_html_response_type" }
type.iphone { @type = "iPhone" ; render :action => "iphone_with_html_response_type" }
end
end
def variant_with_implicit_rendering
end
def variant_with_format_and_custom_render
request.variant = :mobile
respond_to do |type|
type.html { render text: "mobile" }
end
end
def multiple_variants_for_format
respond_to do |type|
type.html do |html|
html.tablet { render text: "tablet" }
html.phone { render text: "phone" }
end
end
end
def variant_plus_none_for_format
respond_to do |format|
format.html do |variant|
variant.phone { render text: "phone" }
variant.none
end
end
end
def variant_inline_syntax
respond_to do |format|
format.js { render text: "js" }
format.html.none { render text: "none" }
format.html.phone { render text: "phone" }
end
end
def variant_inline_syntax_without_block
respond_to do |format|
format.js
format.html.none
format.html.phone
end
end
def variant_any
respond_to do |format|
format.html do |variant|
variant.any(:tablet, :phablet){ render text: "any" }
variant.phone { render text: "phone" }
end
end
end
def variant_any_any
respond_to do |format|
format.html do |variant|
variant.any { render text: "any" }
variant.phone { render text: "phone" }
end
end
end
def variant_inline_any
respond_to do |format|
format.html.any(:tablet, :phablet){ render text: "any" }
format.html.phone { render text: "phone" }
end
end
def variant_inline_any_any
respond_to do |format|
format.html.phone { render text: "phone" }
format.html.any { render text: "any" }
end
end
def variant_any_implicit_render
respond_to do |format|
format.html.phone
format.html.any(:tablet, :phablet)
end
end
def variant_any_with_none
respond_to do |format|
format.html.any(:none, :phone){ render text: "none or phone" }
end
end
def format_any_variant_any
respond_to do |format|
format.html { render text: "HTML" }
format.any(:js, :xml) do |variant|
variant.phone{ render text: "phone" }
variant.any(:tablet, :phablet){ render text: "tablet" }
end
end
end
protected
def set_layout
case action_name
when "all_types_with_layout", "iphone_with_html_response_type"
"respond_to/layouts/standard"
when "iphone_with_html_response_type_without_layout"
"respond_to/layouts/missing"
end
end
end
class RespondToControllerTest < ActionController::TestCase
def setup
super
@request.host = "www.example.com"
Mime::Type.register_alias("text/html", :iphone)
Mime::Type.register("text/x-mobile", :mobile)
end
def teardown
super
Mime::Type.unregister(:iphone)
Mime::Type.unregister(:mobile)
end
def test_html
@request.accept = "text/html"
get :js_or_html
assert_equal 'HTML', @response.body
get :html_or_xml
assert_equal 'HTML', @response.body
assert_raises(ActionController::UnknownFormat) do
get :just_xml
end
end
def test_all
@request.accept = "*/*"
get :js_or_html
assert_equal 'HTML', @response.body # js is not part of all
get :html_or_xml
assert_equal 'HTML', @response.body
get :just_xml
assert_equal 'XML', @response.body
end
def test_xml
@request.accept = "application/xml"
get :html_xml_or_rss
assert_equal 'XML', @response.body
end
def test_js_or_html
@request.accept = "text/javascript, text/html"
xhr :get, :js_or_html
assert_equal 'JS', @response.body
@request.accept = "text/javascript, text/html"
xhr :get, :html_or_xml
assert_equal 'HTML', @response.body
@request.accept = "text/javascript, text/html"
assert_raises(ActionController::UnknownFormat) do
xhr :get, :just_xml
end
end
def test_json_or_yaml_with_leading_star_star
@request.accept = "*/*, application/json"
get :json_xml_or_html
assert_equal 'HTML', @response.body
@request.accept = "*/* , application/json"
get :json_xml_or_html
assert_equal 'HTML', @response.body
end
def test_json_or_yaml
xhr :get, :json_or_yaml
assert_equal 'JSON', @response.body
get :json_or_yaml, :format => 'json'
assert_equal 'JSON', @response.body
get :json_or_yaml, :format => 'yaml'
assert_equal 'YAML', @response.body
{ 'YAML' => %w(text/yaml),
'JSON' => %w(application/json text/x-json)
}.each do |body, content_types|
content_types.each do |content_type|
@request.accept = content_type
get :json_or_yaml
assert_equal body, @response.body
end
end
end
def test_js_or_anything
@request.accept = "text/javascript, */*"
xhr :get, :js_or_html
assert_equal 'JS', @response.body
xhr :get, :html_or_xml
assert_equal 'HTML', @response.body
xhr :get, :just_xml
assert_equal 'XML', @response.body
end
def test_using_defaults
@request.accept = "*/*"
get :using_defaults
assert_equal "text/html", @response.content_type
assert_equal 'Hello world!', @response.body
@request.accept = "application/xml"
get :using_defaults
assert_equal "application/xml", @response.content_type
assert_equal "Hello world!
\n", @response.body end def test_using_defaults_with_all @request.accept = "*/*" get :using_defaults_with_all assert_equal "HTML!", @response.body.strip @request.accept = "text/html" get :using_defaults_with_all assert_equal "HTML!", @response.body.strip @request.accept = "application/json" get :using_defaults_with_all assert_equal "ALL", @response.body end def test_using_defaults_with_type_list @request.accept = "*/*" get :using_defaults_with_type_list assert_equal "text/html", @response.content_type assert_equal 'Hello world!', @response.body @request.accept = "application/xml" get :using_defaults_with_type_list assert_equal "application/xml", @response.content_type assert_equal "Hello world!
\n", @response.body end def test_with_atom_content_type @request.accept = "" @request.env["CONTENT_TYPE"] = "application/atom+xml" xhr :get, :made_for_content_type assert_equal "ATOM", @response.body end def test_with_rss_content_type @request.accept = "" @request.env["CONTENT_TYPE"] = "application/rss+xml" xhr :get, :made_for_content_type assert_equal "RSS", @response.body end def test_synonyms @request.accept = "application/javascript" get :js_or_html assert_equal 'JS', @response.body @request.accept = "application/x-xml" get :html_xml_or_rss assert_equal "XML", @response.body end def test_custom_types @request.accept = "application/crazy-xml" get :custom_type_handling assert_equal "application/crazy-xml", @response.content_type assert_equal 'Crazy XML', @response.body @request.accept = "text/html" get :custom_type_handling assert_equal "text/html", @response.content_type assert_equal 'HTML', @response.body end def test_xhtml_alias @request.accept = "application/xhtml+xml,application/xml" get :html_or_xml assert_equal 'HTML', @response.body end def test_firefox_simulation @request.accept = "text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.5" get :html_or_xml assert_equal 'HTML', @response.body end def test_handle_any @request.accept = "*/*" get :handle_any assert_equal 'HTML', @response.body @request.accept = "text/javascript" get :handle_any assert_equal 'Either JS or XML', @response.body @request.accept = "text/xml" get :handle_any assert_equal 'Either JS or XML', @response.body end def test_handle_any_any @request.accept = "*/*" get :handle_any_any assert_equal 'HTML', @response.body end def test_handle_any_any_parameter_format get :handle_any_any, {:format=>'html'} assert_equal 'HTML', @response.body end def test_handle_any_any_explicit_html @request.accept = "text/html" get :handle_any_any assert_equal 'HTML', @response.body end def test_handle_any_any_javascript @request.accept = "text/javascript" get :handle_any_any assert_equal 'Whatever you ask for, I got it', @response.body end def test_handle_any_any_xml @request.accept = "text/xml" get :handle_any_any assert_equal 'Whatever you ask for, I got it', @response.body end def test_handle_any_any_unkown_format get :handle_any_any, { format: 'php' } assert_equal 'Whatever you ask for, I got it', @response.body end def test_browser_check_with_any_any @request.accept = "application/json, application/xml" get :json_xml_or_html assert_equal 'JSON', @response.body @request.accept = "application/json, application/xml, */*" get :json_xml_or_html assert_equal 'HTML', @response.body end def test_html_type_with_layout @request.accept = "text/html" get :all_types_with_layout assert_equal 'HTML for all_types_with_layout
', @response.body
end
def test_json_with_callback_sets_javascript_content_type
@request.accept = 'application/json'
get :json_with_callback
assert_equal '/**/alert(JS)', @response.body
assert_equal 'text/javascript', @response.content_type
end
def test_xhr
xhr :get, :js_or_html
assert_equal 'JS', @response.body
end
def test_custom_constant
get :custom_constant_handling, :format => "mobile"
assert_equal "text/x-mobile", @response.content_type
assert_equal "Mobile", @response.body
end
def test_custom_constant_handling_without_block
get :custom_constant_handling_without_block, :format => "mobile"
assert_equal "text/x-mobile", @response.content_type
assert_equal "Mobile", @response.body
end
def test_forced_format
get :html_xml_or_rss
assert_equal "HTML", @response.body
get :html_xml_or_rss, :format => "html"
assert_equal "HTML", @response.body
get :html_xml_or_rss, :format => "xml"
assert_equal "XML", @response.body
get :html_xml_or_rss, :format => "rss"
assert_equal "RSS", @response.body
end
def test_internally_forced_format
get :forced_xml
assert_equal "XML", @response.body
get :forced_xml, :format => "html"
assert_equal "XML", @response.body
end
def test_extension_synonyms
get :html_xml_or_rss, :format => "xhtml"
assert_equal "HTML", @response.body
end
def test_render_action_for_html
@controller.instance_eval do
def render(*args)
@action = args.first[:action] unless args.empty?
@action ||= action_name
response.body = "#{@action} - #{formats}"
end
end
get :using_defaults
assert_equal "using_defaults - #{[:html]}", @response.body
get :using_defaults, :format => "xml"
assert_equal "using_defaults - #{[:xml]}", @response.body
end
def test_format_with_custom_response_type
get :iphone_with_html_response_type
assert_equal 'Hello future from Firefox!
', @response.body
get :iphone_with_html_response_type, :format => "iphone"
assert_equal "text/html", @response.content_type
assert_equal 'Hello iPhone future from iPhone!
', @response.body
end
def test_format_with_custom_response_type_and_request_headers
@request.accept = "text/iphone"
get :iphone_with_html_response_type
assert_equal 'Hello iPhone future from iPhone!
', @response.body
assert_equal "text/html", @response.content_type
end
def test_invalid_format
assert_raises(ActionController::UnknownFormat) do
get :using_defaults, :format => "invalidformat"
end
end
def test_invalid_variant
@request.variant = :invalid
assert_raises(ActionView::MissingTemplate) do
get :variant_with_implicit_rendering
end
end
def test_variant_not_set_regular_template_missing
assert_raises(ActionView::MissingTemplate) do
get :variant_with_implicit_rendering
end
end
def test_variant_with_implicit_rendering
@request.variant = :mobile
get :variant_with_implicit_rendering
assert_equal "text/html", @response.content_type
assert_equal "mobile", @response.body
end
def test_variant_with_format_and_custom_render
@request.variant = :phone
get :variant_with_format_and_custom_render
assert_equal "text/html", @response.content_type
assert_equal "mobile", @response.body
end
def test_multiple_variants_for_format
@request.variant = :tablet
get :multiple_variants_for_format
assert_equal "text/html", @response.content_type
assert_equal "tablet", @response.body
end
def test_no_variant_in_variant_setup
get :variant_plus_none_for_format
assert_equal "text/html", @response.content_type
assert_equal "none", @response.body
end
def test_variant_inline_syntax
get :variant_inline_syntax, format: :js
assert_equal "text/javascript", @response.content_type
assert_equal "js", @response.body
get :variant_inline_syntax
assert_equal "text/html", @response.content_type
assert_equal "none", @response.body
@request.variant = :phone
get :variant_inline_syntax
assert_equal "text/html", @response.content_type
assert_equal "phone", @response.body
end
def test_variant_inline_syntax_without_block
@request.variant = :phone
get :variant_inline_syntax_without_block
assert_equal "text/html", @response.content_type
assert_equal "phone", @response.body
end
def test_variant_any
@request.variant = :phone
get :variant_any
assert_equal "text/html", @response.content_type
assert_equal "phone", @response.body
@request.variant = :tablet
get :variant_any
assert_equal "text/html", @response.content_type
assert_equal "any", @response.body
@request.variant = :phablet
get :variant_any
assert_equal "text/html", @response.content_type
assert_equal "any", @response.body
end
def test_variant_any_any
get :variant_any_any
assert_equal "text/html", @response.content_type
assert_equal "any", @response.body
@request.variant = :phone
get :variant_any_any
assert_equal "text/html", @response.content_type
assert_equal "phone", @response.body
@request.variant = :yolo
get :variant_any_any
assert_equal "text/html", @response.content_type
assert_equal "any", @response.body
end
def test_variant_inline_any
@request.variant = :phone
get :variant_any
assert_equal "text/html", @response.content_type
assert_equal "phone", @response.body
@request.variant = :tablet
get :variant_inline_any
assert_equal "text/html", @response.content_type
assert_equal "any", @response.body
@request.variant = :phablet
get :variant_inline_any
assert_equal "text/html", @response.content_type
assert_equal "any", @response.body
end
def test_variant_inline_any_any
@request.variant = :phone
get :variant_inline_any_any
assert_equal "text/html", @response.content_type
assert_equal "phone", @response.body
@request.variant = :yolo
get :variant_inline_any_any
assert_equal "text/html", @response.content_type
assert_equal "any", @response.body
end
def test_variant_any_implicit_render
@request.variant = :tablet
get :variant_any_implicit_render
assert_equal "text/html", @response.content_type
assert_equal "tablet", @response.body
@request.variant = :phablet
get :variant_any_implicit_render
assert_equal "text/html", @response.content_type
assert_equal "phablet", @response.body
end
def test_variant_any_with_none
get :variant_any_with_none
assert_equal "text/html", @response.content_type
assert_equal "none or phone", @response.body
@request.variant = :phone
get :variant_any_with_none
assert_equal "text/html", @response.content_type
assert_equal "none or phone", @response.body
end
def test_format_any_variant_any
@request.variant = :tablet
get :format_any_variant_any, format: :js
assert_equal "text/javascript", @response.content_type
assert_equal "tablet", @response.body
end
def test_variant_negotiation_inline_syntax
@request.variant = [:tablet, :phone]
get :variant_inline_syntax_without_block
assert_equal "text/html", @response.content_type
assert_equal "phone", @response.body
end
def test_variant_negotiation_block_syntax
@request.variant = [:tablet, :phone]
get :variant_plus_none_for_format
assert_equal "text/html", @response.content_type
assert_equal "phone", @response.body
end
def test_variant_negotiation_without_block
@request.variant = [:tablet, :phone]
get :variant_inline_syntax_without_block
assert_equal "text/html", @response.content_type
assert_equal "phone", @response.body
end
end
rails-4.2.10/actionpack/test/controller/mime/responders_test.rb 0000664 0000000 0000000 00000001313 13162731520 0024663 0 ustar 00root root 0000000 0000000 require 'abstract_unit'
require 'controller/fake_models'
class ResponderTest < ActionController::TestCase
def test_class_level_respond_to
e = assert_raises(NoMethodError) do
Class.new(ActionController::Base) do
respond_to :json
end
end
assert_includes e.message, '`responders` gem'
assert_includes e.message, '~> 2.0'
end
def test_respond_with
klass = Class.new(ActionController::Base) do
def index
respond_with Customer.new("david", 13)
end
end
@controller = klass.new
e = assert_raises(NoMethodError) do
get :index
end
assert_includes e.message, '`responders` gem'
assert_includes e.message, '~> 2.0'
end
end
rails-4.2.10/actionpack/test/controller/new_base/ 0000775 0000000 0000000 00000000000 13162731520 0021751 5 ustar 00root root 0000000 0000000 rails-4.2.10/actionpack/test/controller/new_base/bare_metal_test.rb 0000664 0000000 0000000 00000011343 13162731520 0025432 0 ustar 00root root 0000000 0000000 require "abstract_unit"
module BareMetalTest
class BareController < ActionController::Metal
include ActionController::RackDelegation
def index
self.response_body = "Hello world"
end
end
class BareTest < ActiveSupport::TestCase
test "response body is a Rack-compatible response" do
status, headers, body = BareController.action(:index).call(Rack::MockRequest.env_for("/"))
assert_equal 200, status
string = ""
body.each do |part|
assert part.is_a?(String), "Each part of the body must be a String"
string << part
end
assert_kind_of Hash, headers, "Headers must be a Hash"
assert headers["Content-Type"], "Content-Type must exist"
assert_equal "Hello world", string
end
test "response_body value is wrapped in an array when the value is a String" do
controller = BareController.new
controller.index
assert_equal ["Hello world"], controller.response_body
end
end
class HeadController < ActionController::Metal
include ActionController::Head
def index
head :not_found
end
def continue
self.content_type = "text/html"
head 100
end
def switching_protocols
self.content_type = "text/html"
head 101
end
def processing
self.content_type = "text/html"
head 102
end
def no_content
self.content_type = "text/html"
head 204
end
def reset_content
self.content_type = "text/html"
head 205
end
def not_modified
self.content_type = "text/html"
head 304
end
end
class HeadTest < ActiveSupport::TestCase
test "head works on its own" do
status = HeadController.action(:index).call(Rack::MockRequest.env_for("/")).first
assert_equal 404, status
end
test "head :continue (100) does not return a content-type header" do
headers = HeadController.action(:continue).call(Rack::MockRequest.env_for("/")).second
assert_nil headers['Content-Type']
assert_nil headers['Content-Length']
end
test "head :switching_protocols (101) does not return a content-type header" do
headers = HeadController.action(:switching_protocols).call(Rack::MockRequest.env_for("/")).second
assert_nil headers['Content-Type']
assert_nil headers['Content-Length']
end
test "head :processing (102) does not return a content-type header" do
headers = HeadController.action(:processing).call(Rack::MockRequest.env_for("/")).second
assert_nil headers['Content-Type']
assert_nil headers['Content-Length']
end
test "head :no_content (204) does not return a content-type header" do
headers = HeadController.action(:no_content).call(Rack::MockRequest.env_for("/")).second
assert_nil headers['Content-Type']
assert_nil headers['Content-Length']
end
test "head :reset_content (205) does not return a content-type header" do
headers = HeadController.action(:reset_content).call(Rack::MockRequest.env_for("/")).second
assert_nil headers['Content-Type']
assert_nil headers['Content-Length']
end
test "head :not_modified (304) does not return a content-type header" do
headers = HeadController.action(:not_modified).call(Rack::MockRequest.env_for("/")).second
assert_nil headers['Content-Type']
assert_nil headers['Content-Length']
end
test "head :no_content (204) does not return any content" do
content = HeadController.action(:no_content).call(Rack::MockRequest.env_for("/")).third.first
assert_empty content
end
test "head :reset_content (205) does not return any content" do
content = HeadController.action(:reset_content).call(Rack::MockRequest.env_for("/")).third.first
assert_empty content
end
test "head :not_modified (304) does not return any content" do
content = HeadController.action(:not_modified).call(Rack::MockRequest.env_for("/")).third.first
assert_empty content
end
test "head :continue (100) does not return any content" do
content = HeadController.action(:continue).call(Rack::MockRequest.env_for("/")).third.first
assert_empty content
end
test "head :switching_protocols (101) does not return any content" do
content = HeadController.action(:switching_protocols).call(Rack::MockRequest.env_for("/")).third.first
assert_empty content
end
test "head :processing (102) does not return any content" do
content = HeadController.action(:processing).call(Rack::MockRequest.env_for("/")).third.first
assert_empty content
end
end
class BareControllerTest < ActionController::TestCase
test "GET index" do
get :index
assert_equal "Hello world", @response.body
end
end
end
rails-4.2.10/actionpack/test/controller/new_base/base_test.rb 0000664 0000000 0000000 00000010614 13162731520 0024251 0 ustar 00root root 0000000 0000000 require 'abstract_unit'
# Tests the controller dispatching happy path
module Dispatching
class SimpleController < ActionController::Base
before_action :authenticate
def index
render :text => "success"
end
def modify_response_body
self.response_body = "success"
end
def modify_response_body_twice
ret = (self.response_body = "success")
self.response_body = "#{ret}!"
end
def modify_response_headers
end
def show_actions
render :text => "actions: #{action_methods.to_a.sort.join(', ')}"
end
protected
def authenticate
end
end
class EmptyController < ActionController::Base ; end
class SubEmptyController < EmptyController ; end
class NonDefaultPathController < ActionController::Base
def self.controller_path; "i_am_not_default"; end
end
module Submodule
class ContainedEmptyController < ActionController::Base ; end
class ContainedSubEmptyController < ContainedEmptyController ; end
class ContainedNonDefaultPathController < ActionController::Base
def self.controller_path; "i_am_extremely_not_default"; end
end
end
class BaseTest < Rack::TestCase
# :api: plugin
test "simple dispatching" do
get "/dispatching/simple/index"
assert_body "success"
assert_status 200
assert_content_type "text/html; charset=utf-8"
end
# :api: plugin
test "directly modifying response body" do
get "/dispatching/simple/modify_response_body"
assert_body "success"
end
# :api: plugin
test "directly modifying response body twice" do
get "/dispatching/simple/modify_response_body_twice"
assert_body "success!"
end
test "controller path" do
assert_equal 'dispatching/empty', EmptyController.controller_path
assert_equal EmptyController.controller_path, EmptyController.new.controller_path
end
test "non-default controller path" do
assert_equal 'i_am_not_default', NonDefaultPathController.controller_path
assert_equal NonDefaultPathController.controller_path, NonDefaultPathController.new.controller_path
end
test "sub controller path" do
assert_equal 'dispatching/sub_empty', SubEmptyController.controller_path
assert_equal SubEmptyController.controller_path, SubEmptyController.new.controller_path
end
test "namespaced controller path" do
assert_equal 'dispatching/submodule/contained_empty', Submodule::ContainedEmptyController.controller_path
assert_equal Submodule::ContainedEmptyController.controller_path, Submodule::ContainedEmptyController.new.controller_path
end
test "namespaced non-default controller path" do
assert_equal 'i_am_extremely_not_default', Submodule::ContainedNonDefaultPathController.controller_path
assert_equal Submodule::ContainedNonDefaultPathController.controller_path, Submodule::ContainedNonDefaultPathController.new.controller_path
end
test "namespaced sub controller path" do
assert_equal 'dispatching/submodule/contained_sub_empty', Submodule::ContainedSubEmptyController.controller_path
assert_equal Submodule::ContainedSubEmptyController.controller_path, Submodule::ContainedSubEmptyController.new.controller_path
end
test "controller name" do
assert_equal 'empty', EmptyController.controller_name
assert_equal 'contained_empty', Submodule::ContainedEmptyController.controller_name
end
test "non-default path controller name" do
assert_equal 'non_default_path', NonDefaultPathController.controller_name
assert_equal 'contained_non_default_path', Submodule::ContainedNonDefaultPathController.controller_name
end
test "sub controller name" do
assert_equal 'sub_empty', SubEmptyController.controller_name
assert_equal 'contained_sub_empty', Submodule::ContainedSubEmptyController.controller_name
end
test "action methods" do
assert_equal Set.new(%w(
index
modify_response_headers
modify_response_body_twice
modify_response_body
show_actions
)), SimpleController.action_methods
assert_equal Set.new, EmptyController.action_methods
assert_equal Set.new, Submodule::ContainedEmptyController.action_methods
get "/dispatching/simple/show_actions"
assert_body "actions: index, modify_response_body, modify_response_body_twice, modify_response_headers, show_actions"
end
end
end
rails-4.2.10/actionpack/test/controller/new_base/content_negotiation_test.rb 0000664 0000000 0000000 00000001434 13162731520 0027411 0 ustar 00root root 0000000 0000000 require 'abstract_unit'
module ContentNegotiation
# This has no layout and it works
class BasicController < ActionController::Base
self.view_paths = [ActionView::FixtureResolver.new(
"content_negotiation/basic/hello.html.erb" => "Hello world <%= request.formats.first.to_s %>!"
)]
def all
render :text => self.formats.inspect
end
end
class TestContentNegotiation < Rack::TestCase
test "A */* Accept header will return HTML" do
get "/content_negotiation/basic/hello", {}, "HTTP_ACCEPT" => "*/*"
assert_body "Hello world */*!"
end
test "Not all mimes are converted to symbol" do
get "/content_negotiation/basic/all", {}, "HTTP_ACCEPT" => "text/plain, mime/another"
assert_body '[:text, "mime/another"]'
end
end
end
rails-4.2.10/actionpack/test/controller/new_base/content_type_test.rb 0000664 0000000 0000000 00000006625 13162731520 0026061 0 ustar 00root root 0000000 0000000 require 'abstract_unit'
module ContentType
class BaseController < ActionController::Base
def index
render :text => "Hello world!"
end
def set_on_response_obj
response.content_type = Mime::RSS
render :text => "Hello world!"
end
def set_on_render
render :text => "Hello world!", :content_type => Mime::RSS
end
end
class ImpliedController < ActionController::Base
# Template's mime type is used if no content_type is specified
self.view_paths = [ActionView::FixtureResolver.new(
"content_type/implied/i_am_html_erb.html.erb" => "Hello world!",
"content_type/implied/i_am_xml_erb.xml.erb" => "Hello
\n\n" end end end module RenderActionWithControllerLayout class BasicController < ActionController::Base self.view_paths = [ActionView::FixtureResolver.new( "render_action_with_controller_layout/basic/hello_world.html.erb" => "Hello World!", "layouts/render_action_with_controller_layout/basic.html.erb" => "With Controller Layout! <%= yield %> Bye" )] def hello_world render :action => "hello_world" end def hello_world_with_layout render :action => "hello_world", :layout => true end def hello_world_with_layout_false render :action => "hello_world", :layout => false end def hello_world_with_layout_nil render :action => "hello_world", :layout => nil end def hello_world_with_custom_layout render :action => "hello_world", :layout => "greetings" end end class ControllerLayoutTest < Rack::TestCase test "render hello_world and implicitly usehello world
", layout: nil end def with_safe_html_tag render html: "hello world
".html_safe, layout: nil end end class RenderHtmlTest < Rack::TestCase test "rendering text from a minimal controller" do get "/render_html/minimal/index" assert_body "Hello World!" assert_status 200 end test "rendering text from an action with default options renders the text with the layout" do with_routing do |set| set.draw { get ':controller', action: 'index' } get "/render_html/simple" assert_body "hello david" assert_status 200 end end test "rendering text from an action with default options renders the text without the layout" do with_routing do |set| set.draw { get ':controller', action: 'index' } get "/render_html/with_layout" assert_body "hello david" assert_status 200 end end test "rendering text, while also providing a custom status code" do get "/render_html/with_layout/custom_code" assert_body "hello world" assert_status 404 end test "rendering text with nil returns an empty body" do get "/render_html/with_layout/with_nil" assert_body "" assert_status 200 end test "Rendering text with nil and custom status code returns an empty body and the status" do get "/render_html/with_layout/with_nil_and_status" assert_body "" assert_status 403 end test "rendering text with false returns the string 'false'" do get "/render_html/with_layout/with_false" assert_body "false" assert_status 200 end test "rendering text with layout: true" do get "/render_html/with_layout/with_layout_true" assert_body "hello world, I'm here!" assert_status 200 end test "rendering text with layout: 'greetings'" do get "/render_html/with_layout/with_custom_layout" assert_body "hello world, I wish thee well." assert_status 200 end test "rendering text with layout: false" do get "/render_html/with_layout/with_layout_false" assert_body "hello world" assert_status 200 end test "rendering text with layout: nil" do get "/render_html/with_layout/with_layout_nil" assert_body "hello world" assert_status 200 end test "rendering html should escape the string if it is not html safe" do get "/render_html/with_layout/with_unsafe_html_tag" assert_body "<p>hello world</p>" assert_status 200 end test "rendering html should not escape the string if it is html safe" do get "/render_html/with_layout/with_safe_html_tag" assert_body "hello world
" assert_status 200 end test "rendering from minimal controller returns response with text/html content type" do get "/render_html/minimal/index" assert_content_type "text/html" end test "rendering from normal controller returns response with text/html content type" do get "/render_html/simple/index" assert_content_type "text/html; charset=utf-8" end end end rails-4.2.10/actionpack/test/controller/new_base/render_implicit_action_test.rb 0000664 0000000 0000000 00000004117 13162731520 0030046 0 ustar 00root root 0000000 0000000 require 'abstract_unit' module RenderImplicitAction class SimpleController < ::ApplicationController self.view_paths = [ActionView::FixtureResolver.new( "render_implicit_action/simple/hello_world.html.erb" => "Hello world!", "render_implicit_action/simple/hyphen-ated.html.erb" => "Hello hyphen-ated!", "render_implicit_action/simple/not_implemented.html.erb" => "Not Implemented" ), ActionView::FileSystemResolver.new(File.expand_path('../../../controller', __FILE__))] def hello_world() end end class RenderImplicitActionTest < Rack::TestCase test "render a simple action with new explicit call to render" do get "/render_implicit_action/simple/hello_world" assert_body "Hello world!" assert_status 200 end test "render an action with a missing method and has special characters" do get "/render_implicit_action/simple/hyphen-ated" assert_body "Hello hyphen-ated!" assert_status 200 end test "render an action called not_implemented" do get "/render_implicit_action/simple/not_implemented" assert_body "Not Implemented" assert_status 200 end test "render does not traverse the file system" do assert_raises(AbstractController::ActionNotFound) do action_name = %w(.. .. fixtures shared).join(File::SEPARATOR) SimpleController.action(action_name).call(Rack::MockRequest.env_for("/")) end end test "available_action? returns true for implicit actions" do assert SimpleController.new.available_action?(:hello_world) assert SimpleController.new.available_action?(:"hyphen-ated") assert SimpleController.new.available_action?(:not_implemented) end test "available_action? does not allow File::SEPARATOR on the name" do action_name = %w(evil .. .. path).join(File::SEPARATOR) assert_equal false, SimpleController.new.available_action?(action_name.to_sym) action_name = %w(evil path).join(File::SEPARATOR) assert_equal false, SimpleController.new.available_action?(action_name.to_sym) end end end rails-4.2.10/actionpack/test/controller/new_base/render_layout_test.rb 0000664 0000000 0000000 00000007016 13162731520 0026215 0 ustar 00root root 0000000 0000000 require 'abstract_unit' module ControllerLayouts class ImplicitController < ::ApplicationController self.view_paths = [ActionView::FixtureResolver.new( "layouts/application.html.erb" => "Main <%= yield %> Layout", "layouts/override.html.erb" => "Override! <%= yield %>", "basic.html.erb" => "Hello world!", "controller_layouts/implicit/layout_false.html.erb" => "hi(layout_false.html.erb)" )] def index render :template => "basic" end def override render :template => "basic", :layout => "override" end def layout_false render :layout => false end def builder_override end end class ImplicitNameController < ::ApplicationController self.view_paths = [ActionView::FixtureResolver.new( "layouts/controller_layouts/implicit_name.html.erb" => "Implicit <%= yield %> Layout", "basic.html.erb" => "Hello world!" )] def index render :template => "basic" end end class RenderLayoutTest < Rack::TestCase test "rendering a normal template, but using the implicit layout" do get "/controller_layouts/implicit/index" assert_body "Main Hello world! Layout" assert_status 200 end test "rendering a normal template, but using an implicit NAMED layout" do get "/controller_layouts/implicit_name/index" assert_body "Implicit Hello world! Layout" assert_status 200 end test "overriding an implicit layout with render :layout option" do get "/controller_layouts/implicit/override" assert_body "Override! Hello world!" end end class LayoutOptionsTest < Rack::TestCase testing ControllerLayouts::ImplicitController test "rendering with :layout => false leaves out the implicit layout" do get :layout_false assert_response "hi(layout_false.html.erb)" end end class MismatchFormatController < ::ApplicationController self.view_paths = [ActionView::FixtureResolver.new( "layouts/application.html.erb" => "<%= yield %>", "controller_layouts/mismatch_format/index.xml.builder" => "xml.instruct!", "controller_layouts/mismatch_format/implicit.builder" => "xml.instruct!", "controller_layouts/mismatch_format/explicit.js.erb" => "alert('foo');" )] def explicit render :layout => "application" end end class MismatchFormatTest < Rack::TestCase testing ControllerLayouts::MismatchFormatController XML_INSTRUCT = %Q(\n) test "if XML is selected, an HTML template is not also selected" do get :index, :format => "xml" assert_response XML_INSTRUCT end test "if XML is implicitly selected, an HTML template is not also selected" do get :implicit assert_response XML_INSTRUCT end test "a layout for JS is ignored even if explicitly provided for HTML" do get :explicit, { :format => "js" } assert_response "alert('foo');" end end class FalseLayoutMethodController < ::ApplicationController self.view_paths = [ActionView::FixtureResolver.new( "controller_layouts/false_layout_method/index.js.erb" => "alert('foo');" )] layout :which_layout? def which_layout? false end def index end end class FalseLayoutMethodTest < Rack::TestCase testing ControllerLayouts::FalseLayoutMethodController test "access false layout returned by a method/proc" do get :index, :format => "js" assert_response "alert('foo');" end end end rails-4.2.10/actionpack/test/controller/new_base/render_partial_test.rb 0000664 0000000 0000000 00000004167 13162731520 0026340 0 ustar 00root root 0000000 0000000 require 'abstract_unit' module RenderPartial class BasicController < ActionController::Base self.view_paths = [ActionView::FixtureResolver.new( "render_partial/basic/_basic.html.erb" => "BasicPartial!", "render_partial/basic/basic.html.erb" => "<%= @test_unchanged = 'goodbye' %><%= render :partial => 'basic' %><%= @test_unchanged %>", "render_partial/basic/with_json.html.erb" => "<%= render :partial => 'with_json', :formats => [:json] %>", "render_partial/basic/_with_json.json.erb" => "<%= render :partial => 'final', :formats => [:json] %>", "render_partial/basic/_final.json.erb" => "{ final: json }", "render_partial/basic/overridden.html.erb" => "<%= @test_unchanged = 'goodbye' %><%= render :partial => 'overridden' %><%= @test_unchanged %>", "render_partial/basic/_overridden.html.erb" => "ParentPartial!", "render_partial/child/_overridden.html.erb" => "OverriddenPartial!" )] def html_with_json_inside_json render :action => "with_json" end def changing @test_unchanged = 'hello' render :action => "basic" end def overridden @test_unchanged = 'hello' end end class ChildController < BasicController; end class TestPartial < Rack::TestCase testing BasicController test "rendering a partial in ActionView doesn't pull the ivars again from the controller" do get :changing assert_response("goodbyeBasicPartial!goodbye") end test "rendering a template with renders another partial with other format that renders other partial in the same format" do get :html_with_json_inside_json assert_content_type "text/html; charset=utf-8" assert_response "{ final: json }" end end class TestInheritedPartial < Rack::TestCase testing ChildController test "partial from parent controller gets picked if missing in child one" do get :changing assert_response("goodbyeBasicPartial!goodbye") end test "partial from child controller gets picked" do get :overridden assert_response("goodbyeOverriddenPartial!goodbye") end end end rails-4.2.10/actionpack/test/controller/new_base/render_plain_test.rb 0000664 0000000 0000000 00000010236 13162731520 0026001 0 ustar 00root root 0000000 0000000 require 'abstract_unit' module RenderPlain class MinimalController < ActionController::Metal include AbstractController::Rendering include ActionController::Rendering def index render plain: "Hello World!" end end class SimpleController < ActionController::Base self.view_paths = [ActionView::FixtureResolver.new] def index render plain: "hello david" end end class WithLayoutController < ::ApplicationController self.view_paths = [ActionView::FixtureResolver.new( "layouts/application.text.erb" => "<%= yield %>, I'm here!", "layouts/greetings.text.erb" => "<%= yield %>, I wish thee well.", "layouts/ivar.text.erb" => "<%= yield %>, <%= @ivar %>" )] def index render plain: "hello david" end def custom_code render plain: "hello world", status: 404 end def with_custom_code_as_string render plain: "hello world", status: "404 Not Found" end def with_nil render plain: nil end def with_nil_and_status render plain: nil, status: 403 end def with_false render plain: false end def with_layout_true render plain: "hello world", layout: true end def with_layout_false render plain: "hello world", layout: false end def with_layout_nil render plain: "hello world", layout: nil end def with_custom_layout render plain: "hello world", layout: "greetings" end def with_ivar_in_layout @ivar = "hello world" render plain: "hello world", layout: "ivar" end end class RenderPlainTest < Rack::TestCase test "rendering text from a minimal controller" do get "/render_plain/minimal/index" assert_body "Hello World!" assert_status 200 end test "rendering text from an action with default options renders the text with the layout" do with_routing do |set| set.draw { get ':controller', action: 'index' } get "/render_plain/simple" assert_body "hello david" assert_status 200 end end test "rendering text from an action with default options renders the text without the layout" do with_routing do |set| set.draw { get ':controller', action: 'index' } get "/render_plain/with_layout" assert_body "hello david" assert_status 200 end end test "rendering text, while also providing a custom status code" do get "/render_plain/with_layout/custom_code" assert_body "hello world" assert_status 404 end test "rendering text with nil returns an empty body" do get "/render_plain/with_layout/with_nil" assert_body "" assert_status 200 end test "Rendering text with nil and custom status code returns an empty body and the status" do get "/render_plain/with_layout/with_nil_and_status" assert_body "" assert_status 403 end test "rendering text with false returns the string 'false'" do get "/render_plain/with_layout/with_false" assert_body "false" assert_status 200 end test "rendering text with layout: true" do get "/render_plain/with_layout/with_layout_true" assert_body "hello world, I'm here!" assert_status 200 end test "rendering text with layout: 'greetings'" do get "/render_plain/with_layout/with_custom_layout" assert_body "hello world, I wish thee well." assert_status 200 end test "rendering text with layout: false" do get "/render_plain/with_layout/with_layout_false" assert_body "hello world" assert_status 200 end test "rendering text with layout: nil" do get "/render_plain/with_layout/with_layout_nil" assert_body "hello world" assert_status 200 end test "rendering from minimal controller returns response with text/plain content type" do get "/render_plain/minimal/index" assert_content_type "text/plain" end test "rendering from normal controller returns response with text/plain content type" do get "/render_plain/simple/index" assert_content_type "text/plain; charset=utf-8" end end end rails-4.2.10/actionpack/test/controller/new_base/render_streaming_test.rb 0000664 0000000 0000000 00000007036 13162731520 0026673 0 ustar 00root root 0000000 0000000 require 'abstract_unit' module RenderStreaming class BasicController < ActionController::Base self.view_paths = [ActionView::FixtureResolver.new( "render_streaming/basic/hello_world.html.erb" => "Hello world", "render_streaming/basic/boom.html.erb" => "<%= raise 'Ruby was here!' %>", "layouts/application.html.erb" => "<%= yield %>, I'm here!", "layouts/boom.html.erb" => "\"<%= yield %>" )] layout "application" def hello_world render :stream => true end def layout_exception render :action => "hello_world", :stream => true, :layout => "boom" end def template_exception render :action => "boom", :stream => true end def skip render :action => "hello_world", :stream => false end def explicit render :action => "hello_world", :stream => true end def no_layout render :action => "hello_world", :stream => true, :layout => false end def explicit_cache headers["Cache-Control"] = "private" render :action => "hello_world", :stream => true end end class StreamingTest < Rack::TestCase test "rendering with streaming enabled at the class level" do get "/render_streaming/basic/hello_world" assert_body "b\r\nHello world\r\nb\r\n, I'm here!\r\n0\r\n\r\n" assert_streaming! end test "rendering with streaming given to render" do get "/render_streaming/basic/explicit" assert_body "b\r\nHello world\r\nb\r\n, I'm here!\r\n0\r\n\r\n" assert_streaming! end test "rendering with streaming do not override explicit cache control given to render" do get "/render_streaming/basic/explicit_cache" assert_body "b\r\nHello world\r\nb\r\n, I'm here!\r\n0\r\n\r\n" assert_streaming! "private" end test "rendering with streaming no layout" do get "/render_streaming/basic/no_layout" assert_body "b\r\nHello world\r\n0\r\n\r\n" assert_streaming! end test "skip rendering with streaming at render level" do get "/render_streaming/basic/skip" assert_body "Hello world, I'm here!" end test "rendering with layout exception" do get "/render_streaming/basic/layout_exception" assert_body "d\r\n\r\n0\r\n\r\n" assert_streaming! end test "rendering with template exception" do get "/render_streaming/basic/template_exception" assert_body "37\r\n\">