active_mailer 0.0.3

data/test/fixtures/dummyapp_rails_3.2/vendor/bundle/ruby/1.9.1/gems/actionpack-3.2.12/lib/action_dispatch/http/upload.rb

@@ -0,0 +1,47 @@
+module ActionDispatch
+  module Http
+    class UploadedFile
+      attr_accessor :original_filename, :content_type, :tempfile, :headers
+
+      def initialize(hash)
+        @original_filename = encode_filename(hash[:filename])
+        @content_type      = hash[:type]
+        @headers           = hash[:head]
+        @tempfile          = hash[:tempfile]
+        raise(ArgumentError, ':tempfile is required') unless @tempfile
+      end
+
+      def read(*args)
+        @tempfile.read(*args)
+      end
+
+      # Delegate these methods to the tempfile.
+      [:open, :path, :rewind, :size].each do |method|
+        class_eval "def #{method}; @tempfile.#{method}; end"
+      end
+
+      private
+      def encode_filename(filename)
+        # Encode the filename in the utf8 encoding, unless it is nil or we're in 1.8
+        if "ruby".encoding_aware? && filename
+          filename.force_encoding("UTF-8").encode!
+        else
+          filename
+        end
+      end
+    end
+
+    module Upload
+      # Convert nested Hash to HashWithIndifferentAccess and replace
+      # file upload hash with UploadedFile objects
+      def normalize_parameters(value)
+        if Hash === value && value.has_key?(:tempfile)
+          UploadedFile.new(value)
+        else
+          super
+        end
+      end
+      private :normalize_parameters
+    end
+  end
+end

data/test/fixtures/dummyapp_rails_3.2/vendor/bundle/ruby/1.9.1/gems/actionpack-3.2.12/lib/action_dispatch/http/url.rb

@@ -0,0 +1,174 @@
+module ActionDispatch
+  module Http
+    module URL
+      mattr_accessor :tld_length
+      self.tld_length = 1
+
+      class << self
+        def extract_domain(host, tld_length = @@tld_length)
+          return nil unless named_host?(host)
+          host.split('.').last(1 + tld_length).join('.')
+        end
+
+        def extract_subdomains(host, tld_length = @@tld_length)
+          return [] unless named_host?(host)
+          parts = host.split('.')
+          parts[0..-(tld_length+2)]
+        end
+
+        def extract_subdomain(host, tld_length = @@tld_length)
+          extract_subdomains(host, tld_length).join('.')
+        end
+
+        def url_for(options = {})
+          unless options[:host].present? || options[:only_path].present?
+            raise ArgumentError, 'Missing host to link to! Please provide the :host parameter, set default_url_options[:host], or set :only_path to true'
+          end
+
+          rewritten_url = ""
+
+          unless options[:only_path]
+            unless options[:protocol] == false
+              rewritten_url << (options[:protocol] || "http")
+              rewritten_url << ":" unless rewritten_url.match(%r{:|//})
+            end
+            rewritten_url << "//" unless rewritten_url.match("//")
+            rewritten_url << rewrite_authentication(options)
+            rewritten_url << host_or_subdomain_and_domain(options)
+            rewritten_url << ":#{options.delete(:port)}" if options[:port]
+          end
+
+          path = options.delete(:path) || ''
+
+          params = options[:params] || {}
+          params.reject! {|k,v| v.to_param.nil? }
+
+          rewritten_url << (options[:trailing_slash] ? path.sub(/\?|\z/) { "/" + $& } : path)
+          rewritten_url << "?#{params.to_query}" unless params.empty?
+          rewritten_url << "##{Journey::Router::Utils.escape_fragment(options[:anchor].to_param.to_s)}" if options[:anchor]
+          rewritten_url
+        end
+
+        private
+
+        def named_host?(host)
+          !(host.nil? || /\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.match(host))
+        end
+
+        def rewrite_authentication(options)
+          if options[:user] && options[:password]
+            "#{Rack::Utils.escape(options[:user])}:#{Rack::Utils.escape(options[:password])}@"
+          else
+            ""
+          end
+        end
+
+        def host_or_subdomain_and_domain(options)
+          return options[:host] if !named_host?(options[:host]) || (options[:subdomain].nil? && options[:domain].nil?)
+
+          tld_length = options[:tld_length] || @@tld_length
+
+          host = ""
+          unless options[:subdomain] == false
+            host << (options[:subdomain] || extract_subdomain(options[:host], tld_length)).to_param
+            host << "."
+          end
+          host << (options[:domain] || extract_domain(options[:host], tld_length))
+          host
+        end
+      end
+
+      # Returns the complete URL used for this request.
+      def url
+        protocol + host_with_port + fullpath
+      end
+
+      # Returns 'https://' if this is an SSL request and 'http://' otherwise.
+      def protocol
+        @protocol ||= ssl? ? 'https://' : 'http://'
+      end
+
+      # Returns the \host for this request, such as "example.com".
+      def raw_host_with_port
+        if forwarded = env["HTTP_X_FORWARDED_HOST"]
+          forwarded.split(/,\s?/).last
+        else
+          env['HTTP_HOST'] || "#{env['SERVER_NAME'] || env['SERVER_ADDR']}:#{env['SERVER_PORT']}"
+        end
+      end
+
+      # Returns the host for this request, such as example.com.
+      def host
+        raw_host_with_port.sub(/:\d+$/, '')
+      end
+
+      # Returns a \host:\port string for this request, such as "example.com" or
+      # "example.com:8080".
+      def host_with_port
+        "#{host}#{port_string}"
+      end
+
+      # Returns the port number of this request as an integer.
+      def port
+        @port ||= begin
+          if raw_host_with_port =~ /:(\d+)$/
+            $1.to_i
+          else
+            standard_port
+          end
+        end
+      end
+
+      # Returns the standard \port number for this request's protocol.
+      def standard_port
+        case protocol
+          when 'https://' then 443
+          else 80
+        end
+      end
+
+      # Returns whether this request is using the standard port
+      def standard_port?
+        port == standard_port
+      end
+
+      # Returns a number \port suffix like 8080 if the \port number of this request
+      # is not the default HTTP \port 80 or HTTPS \port 443.
+      def optional_port
+        standard_port? ? nil : port
+      end
+
+      # Returns a string \port suffix, including colon, like ":8080" if the \port
+      # number of this request is not the default HTTP \port 80 or HTTPS \port 443.
+      def port_string
+        standard_port? ? '' : ":#{port}"
+      end
+
+      def server_port
+        @env['SERVER_PORT'].to_i
+      end
+
+      # Returns the \domain part of a \host, such as "rubyonrails.org" in "www.rubyonrails.org". You can specify
+      # a different <tt>tld_length</tt>, such as 2 to catch rubyonrails.co.uk in "www.rubyonrails.co.uk".
+      def domain(tld_length = @@tld_length)
+        ActionDispatch::Http::URL.extract_domain(host, tld_length)
+      end
+
+      # Returns all the \subdomains as an array, so <tt>["dev", "www"]</tt> would be
+      # returned for "dev.www.rubyonrails.org". You can specify a different <tt>tld_length</tt>,
+      # such as 2 to catch <tt>["www"]</tt> instead of <tt>["www", "rubyonrails"]</tt>
+      # in "www.rubyonrails.co.uk".
+      def subdomains(tld_length = @@tld_length)
+        ActionDispatch::Http::URL.extract_subdomains(host, tld_length)
+      end
+
+      # Returns all the \subdomains as a string, so <tt>"dev.www"</tt> would be
+      # returned for "dev.www.rubyonrails.org". You can specify a different <tt>tld_length</tt>,
+      # such as 2 to catch <tt>"www"</tt> instead of <tt>"www.rubyonrails"</tt>
+      # in "www.rubyonrails.co.uk".
+      def subdomain(tld_length = @@tld_length)
+        subdomains(tld_length).join(".")
+      end
+    end
+  end
+end

data/test/fixtures/dummyapp_rails_3.2/vendor/bundle/ruby/1.9.1/gems/actionpack-3.2.12/lib/action_dispatch/middleware/best_standards_support.rb

@@ -0,0 +1,22 @@
+module ActionDispatch
+  class BestStandardsSupport
+    def initialize(app, type = true)
+      @app = app
+
+      @header = case type
+      when true
+        "IE=Edge,chrome=1"
+      when :builtin
+        "IE=Edge"
+      when false
+        nil
+      end
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers["X-UA-Compatible"] = @header
+      [status, headers, body]
+    end
+  end
+end

data/test/fixtures/dummyapp_rails_3.2/vendor/bundle/ruby/1.9.1/gems/actionpack-3.2.12/lib/action_dispatch/middleware/body_proxy.rb

@@ -0,0 +1,30 @@
+# Keep this file meanwhile https://github.com/rack/rack/pull/313 is not released
+module ActionDispatch
+  class BodyProxy
+    def initialize(body, &block)
+      @body, @block, @closed = body, block, false
+    end
+
+    def respond_to?(*args)
+      super or @body.respond_to?(*args)
+    end
+
+    def close
+      return if @closed
+      @closed = true
+      begin
+        @body.close if @body.respond_to? :close
+      ensure
+        @block.call
+      end
+    end
+
+    def closed?
+      @closed
+    end
+
+    def method_missing(*args, &block)
+      @body.__send__(*args, &block)
+    end
+  end
+end

data/test/fixtures/dummyapp_rails_3.2/vendor/bundle/ruby/1.9.1/gems/actionpack-3.2.12/lib/action_dispatch/middleware/callbacks.rb

@@ -0,0 +1,32 @@
+require 'active_support/core_ext/module/delegation'
+
+module ActionDispatch
+  # Provide callbacks to be executed before and after the request dispatch.
+  class Callbacks
+    include ActiveSupport::Callbacks
+
+    define_callbacks :call, :rescuable => true
+
+    class << self
+      delegate :to_prepare, :to_cleanup, :to => "ActionDispatch::Reloader"
+    end
+
+    def self.before(*args, &block)
+      set_callback(:call, :before, *args, &block)
+    end
+
+    def self.after(*args, &block)
+      set_callback(:call, :after, *args, &block)
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      run_callbacks :call do
+        @app.call(env)
+      end
+    end
+  end
+end

data/test/fixtures/dummyapp_rails_3.2/vendor/bundle/ruby/1.9.1/gems/actionpack-3.2.12/lib/action_dispatch/middleware/cookies.rb

@@ -0,0 +1,353 @@
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/module/attribute_accessors'
+
+module ActionDispatch
+  class Request
+    def cookie_jar
+      env['action_dispatch.cookies'] ||= Cookies::CookieJar.build(self)
+    end
+  end
+
+  # \Cookies are read and written through ActionController#cookies.
+  #
+  # The cookies being read are the ones received along with the request, the cookies
+  # being written will be sent out with the response. Reading a cookie does not get
+  # the cookie object itself back, just the value it holds.
+  #
+  # Examples for writing:
+  #
+  #   # Sets a simple session cookie.
+  #   # This cookie will be deleted when the user's browser is closed.
+  #   cookies[:user_name] = "david"
+  #
+  #   # Assign an array of values to a cookie.
+  #   cookies[:lat_lon] = [47.68, -122.37]
+  #
+  #   # Sets a cookie that expires in 1 hour.
+  #   cookies[:login] = { :value => "XJ-122", :expires => 1.hour.from_now }
+  #
+  #   # Sets a signed cookie, which prevents a user from tampering with its value.
+  #   # The cookie is signed by your app's <tt>config.secret_token</tt> value.
+  #   # Rails generates this value by default when you create a new Rails app.
+  #   cookies.signed[:user_id] = current_user.id
+  #
+  #   # Sets a "permanent" cookie (which expires in 20 years from now).
+  #   cookies.permanent[:login] = "XJ-122"
+  #
+  #   # You can also chain these methods:
+  #   cookies.permanent.signed[:login] = "XJ-122"
+  #
+  # Examples for reading:
+  #
+  #   cookies[:user_name] # => "david"
+  #   cookies.size        # => 2
+  #   cookies[:lat_lon]   # => [47.68, -122.37]
+  #
+  # Example for deleting:
+  #
+  #   cookies.delete :user_name
+  #
+  # Please note that if you specify a :domain when setting a cookie, you must also specify the domain when deleting the cookie:
+  #
+  #  cookies[:key] = {
+  #    :value => 'a yummy cookie',
+  #    :expires => 1.year.from_now,
+  #    :domain => 'domain.com'
+  #  }
+  #
+  #  cookies.delete(:key, :domain => 'domain.com')
+  #
+  # The option symbols for setting cookies are:
+  #
+  # * <tt>:value</tt> - The cookie's value or list of values (as an array).
+  # * <tt>:path</tt> - The path for which this cookie applies. Defaults to the root
+  #   of the application.
+  # * <tt>:domain</tt> - The domain for which this cookie applies so you can
+  #   restrict to the domain level. If you use a schema like www.example.com
+  #   and want to share session with user.example.com set <tt>:domain</tt>
+  #   to <tt>:all</tt>. Make sure to specify the <tt>:domain</tt> option with
+  #   <tt>:all</tt> again when deleting keys.
+  #
+  #     :domain => nil  # Does not sets cookie domain. (default)
+  #     :domain => :all # Allow the cookie for the top most level
+  #                       domain and subdomains.
+  #
+  # * <tt>:expires</tt> - The time at which this cookie expires, as a \Time object.
+  # * <tt>:secure</tt> - Whether this cookie is a only transmitted to HTTPS servers.
+  #   Default is +false+.
+  # * <tt>:httponly</tt> - Whether this cookie is accessible via scripting or
+  #   only HTTP. Defaults to +false+.
+  class Cookies
+    HTTP_HEADER = "Set-Cookie".freeze
+    TOKEN_KEY   = "action_dispatch.secret_token".freeze
+
+    # Raised when storing more than 4K of session data.
+    class CookieOverflow < StandardError; end
+
+    class CookieJar #:nodoc:
+      include Enumerable
+
+      # This regular expression is used to split the levels of a domain.
+      # The top level domain can be any string without a period or
+      # **.**, ***.** style TLDs like co.uk or com.au
+      #
+      # www.example.co.uk gives:
+      # $& => example.co.uk
+      #
+      # example.com gives:
+      # $& => example.com
+      #
+      # lots.of.subdomains.example.local gives:
+      # $& => example.local
+      DOMAIN_REGEXP = /[^.]*\.([^.]*|..\...|...\...)$/
+
+      def self.build(request)
+        secret = request.env[TOKEN_KEY]
+        host = request.host
+        secure = request.ssl?
+
+        new(secret, host, secure).tap do |hash|
+          hash.update(request.cookies)
+        end
+      end
+
+      def initialize(secret = nil, host = nil, secure = false)
+        @secret = secret
+        @set_cookies = {}
+        @delete_cookies = {}
+        @host = host
+        @secure = secure
+        @closed = false
+        @cookies = {}
+      end
+
+      def each(&block)
+        @cookies.each(&block)
+      end
+
+      # Returns the value of the cookie by +name+, or +nil+ if no such cookie exists.
+      def [](name)
+        @cookies[name.to_s]
+      end
+
+      def key?(name)
+        @cookies.key?(name.to_s)
+      end
+      alias :has_key? :key?
+
+      def update(other_hash)
+        @cookies.update other_hash.stringify_keys
+        self
+      end
+
+      def handle_options(options) #:nodoc:
+        options[:path] ||= "/"
+
+        if options[:domain] == :all
+          # if there is a provided tld length then we use it otherwise default domain regexp
+          domain_regexp = options[:tld_length] ? /([^.]+\.?){#{options[:tld_length]}}$/ : DOMAIN_REGEXP
+
+          # if host is not ip and matches domain regexp
+          # (ip confirms to domain regexp so we explicitly check for ip)
+          options[:domain] = if (@host !~ /^[\d.]+$/) && (@host =~ domain_regexp)
+            ".#{$&}"
+          end
+        elsif options[:domain].is_a? Array
+          # if host matches one of the supplied domains without a dot in front of it
+          options[:domain] = options[:domain].find {|domain| @host.include? domain[/^\.?(.*)$/, 1] }
+        end
+      end
+
+      # Sets the cookie named +name+. The second argument may be the very cookie
+      # value, or a hash of options as documented above.
+      def []=(key, options)
+        if options.is_a?(Hash)
+          options.symbolize_keys!
+          value = options[:value]
+        else
+          value = options
+          options = { :value => value }
+        end
+
+        handle_options(options)
+
+        if @cookies[key.to_s] != value or options[:expires]
+          @cookies[key.to_s] = value
+          @set_cookies[key.to_s] = options
+          @delete_cookies.delete(key.to_s)
+        end
+
+        value
+      end
+
+      # Removes the cookie on the client machine by setting the value to an empty string
+      # and setting its expiration date into the past. Like <tt>[]=</tt>, you can pass in
+      # an options hash to delete cookies with extra data such as a <tt>:path</tt>.
+      def delete(key, options = {})
+        options.symbolize_keys!
+
+        handle_options(options)
+
+        value = @cookies.delete(key.to_s)
+        @delete_cookies[key.to_s] = options
+        value
+      end
+
+      # Removes all cookies on the client machine by calling <tt>delete</tt> for each cookie
+      def clear(options = {})
+        @cookies.each_key{ |k| delete(k, options) }
+      end
+
+      # Returns a jar that'll automatically set the assigned cookies to have an expiration date 20 years from now. Example:
+      #
+      #   cookies.permanent[:prefers_open_id] = true
+      #   # => Set-Cookie: prefers_open_id=true; path=/; expires=Sun, 16-Dec-2029 03:24:16 GMT
+      #
+      # This jar is only meant for writing. You'll read permanent cookies through the regular accessor.
+      #
+      # This jar allows chaining with the signed jar as well, so you can set permanent, signed cookies. Examples:
+      #
+      #   cookies.permanent.signed[:remember_me] = current_user.id
+      #   # => Set-Cookie: remember_me=BAhU--848956038e692d7046deab32b7131856ab20e14e; path=/; expires=Sun, 16-Dec-2029 03:24:16 GMT
+      def permanent
+        @permanent ||= PermanentCookieJar.new(self, @secret)
+      end
+
+      # Returns a jar that'll automatically generate a signed representation of cookie value and verify it when reading from
+      # the cookie again. This is useful for creating cookies with values that the user is not supposed to change. If a signed
+      # cookie was tampered with by the user (or a 3rd party), an ActiveSupport::MessageVerifier::InvalidSignature exception will
+      # be raised.
+      #
+      # This jar requires that you set a suitable secret for the verification on your app's config.secret_token.
+      #
+      # Example:
+      #
+      #   cookies.signed[:discount] = 45
+      #   # => Set-Cookie: discount=BAhpMg==--2c1c6906c90a3bc4fd54a51ffb41dffa4bf6b5f7; path=/
+      #
+      #   cookies.signed[:discount] # => 45
+      def signed
+        @signed ||= SignedCookieJar.new(self, @secret)
+      end
+
+      def write(headers)
+        @set_cookies.each { |k, v| ::Rack::Utils.set_cookie_header!(headers, k, v) if write_cookie?(v) }
+        @delete_cookies.each { |k, v| ::Rack::Utils.delete_cookie_header!(headers, k, v) }
+      end
+
+      def recycle! #:nodoc:
+        @set_cookies.clear
+        @delete_cookies.clear
+      end
+
+      mattr_accessor :always_write_cookie
+      self.always_write_cookie = false
+
+      private
+
+        def write_cookie?(cookie)
+          @secure || !cookie[:secure] || always_write_cookie
+        end
+    end
+
+    class PermanentCookieJar < CookieJar #:nodoc:
+      def initialize(parent_jar, secret)
+        @parent_jar, @secret = parent_jar, secret
+      end
+
+      def []=(key, options)
+        if options.is_a?(Hash)
+          options.symbolize_keys!
+        else
+          options = { :value => options }
+        end
+
+        options[:expires] = 20.years.from_now
+        @parent_jar[key] = options
+      end
+
+      def signed
+        @signed ||= SignedCookieJar.new(self, @secret)
+      end
+
+      def method_missing(method, *arguments, &block)
+        @parent_jar.send(method, *arguments, &block)
+      end
+    end
+
+    class SignedCookieJar < CookieJar #:nodoc:
+      MAX_COOKIE_SIZE = 4096 # Cookies can typically store 4096 bytes.
+      SECRET_MIN_LENGTH = 30 # Characters
+
+      def initialize(parent_jar, secret)
+        ensure_secret_secure(secret)
+        @parent_jar = parent_jar
+        @verifier   = ActiveSupport::MessageVerifier.new(secret)
+      end
+
+      def [](name)
+        if signed_message = @parent_jar[name]
+          @verifier.verify(signed_message)
+        end
+      rescue ActiveSupport::MessageVerifier::InvalidSignature
+        nil
+      end
+
+      def []=(key, options)
+        if options.is_a?(Hash)
+          options.symbolize_keys!
+          options[:value] = @verifier.generate(options[:value])
+        else
+          options = { :value => @verifier.generate(options) }
+        end
+
+        raise CookieOverflow if options[:value].size > MAX_COOKIE_SIZE
+        @parent_jar[key] = options
+      end
+
+      def method_missing(method, *arguments, &block)
+        @parent_jar.send(method, *arguments, &block)
+      end
+
+    protected
+
+      # To prevent users from using something insecure like "Password" we make sure that the
+      # secret they've provided is at least 30 characters in length.
+      def ensure_secret_secure(secret)
+        if secret.blank?
+          raise ArgumentError, "A secret is required to generate an " +
+            "integrity hash for cookie session data. Use " +
+            "config.secret_token = \"some secret phrase of at " +
+            "least #{SECRET_MIN_LENGTH} characters\"" +
+            "in config/initializers/secret_token.rb"
+        end
+
+        if secret.length < SECRET_MIN_LENGTH
+          raise ArgumentError, "Secret should be something secure, " +
+            "like \"#{SecureRandom.hex(16)}\". The value you " +
+            "provided, \"#{secret}\", is shorter than the minimum length " +
+            "of #{SECRET_MIN_LENGTH} characters"
+        end
+      end
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      cookie_jar = nil
+      status, headers, body = @app.call(env)
+
+      if cookie_jar = env['action_dispatch.cookies']
+        cookie_jar.write(headers)
+        if headers[HTTP_HEADER].respond_to?(:join)
+          headers[HTTP_HEADER] = headers[HTTP_HEADER].join("\n")
+        end
+      end
+
+      [status, headers, body]
+    end
+  end
+end