actionpack 3.2.22.5 → 4.0.0.beta1

data/lib/action_controller/deprecated/performance_test.rb

@@ -1 +0,0 @@
-ActionController::PerformanceTest = ActionDispatch::PerformanceTest

data/lib/action_controller/metal/compatibility.rb

@@ -1,65 +0,0 @@
-require 'active_support/deprecation'
-
-module ActionController
-  module Compatibility
-    extend ActiveSupport::Concern
-
-    # Temporary hax
-    included do
-      ::ActionController::UnknownAction = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('ActionController::UnknownAction', '::AbstractController::ActionNotFound')
-      ::ActionController::DoubleRenderError = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('ActionController::DoubleRenderError', '::AbstractController::DoubleRenderError')
-
-      # ROUTES TODO: This should be handled by a middleware and route generation
-      # should be able to handle SCRIPT_NAME
-      self.config.relative_url_root = ENV['RAILS_RELATIVE_URL_ROOT']
-
-      def self.default_charset=(new_charset)
-        ActiveSupport::Deprecation.warn "Setting default charset at controller level" \
-          " is deprecated, please use `config.action_dispatch.default_charset` instead", caller
-        ActionDispatch::Response.default_charset = new_charset
-      end
-
-      self.protected_instance_variables = %w(
-        @_status @_headers @_params @_env @_response @_request
-        @_view_runtime @_stream @_url_options @_action_has_layout
-      )
-
-      def rescue_action(env)
-        ActiveSupport::Deprecation.warn "Calling `rescue_action` is deprecated and will be removed in Rails 4.0.", caller
-        raise env["action_dispatch.rescue.exception"]
-      end
-    end
-
-    # For old tests
-    def initialize_template_class(*)
-      ActiveSupport::Deprecation.warn "Calling `initialize_template_class` is deprecated and has no effect anymore.", caller
-    end
-
-    def assign_shortcuts(*)
-      ActiveSupport::Deprecation.warn "Calling `assign_shortcuts` is deprecated and has no effect anymore.", caller
-    end
-
-    def _normalize_options(options)
-      options[:text] = nil if options.delete(:nothing) == true
-      options[:text] = " " if options.key?(:text) && options[:text].nil?
-      super
-    end
-
-    def render_to_body(options)
-      options[:template].sub!(/^\//, '') if options.key?(:template)
-      super || " "
-    end
-
-    def _handle_method_missing
-      ActiveSupport::Deprecation.warn "Using `method_missing` to handle non" \
-        " existing actions is deprecated and will be removed in Rails 4.0, " \
-        " please use `action_missing` instead.", caller
-      method_missing(@_action_name.to_sym)
-    end
-
-    def method_for_action(action_name)
-      super || ((self.class.public_method_defined?(:method_missing) ||
-        self.class.protected_method_defined?(:method_missing)) && "_handle_method_missing")
-    end
-  end
-end

data/lib/action_controller/metal/session_management.rb

@@ -1,14 +0,0 @@
-module ActionController #:nodoc:
-  module SessionManagement #:nodoc:
-    extend ActiveSupport::Concern
-
-    included do
-      ActiveSupport::Deprecation.warn "ActionController::SessionManagement " \
-       "is deprecated because it has no contents since Rails 3.1", caller
-    end
-
-    module ClassMethods
-
-    end
-  end
-end

data/lib/action_controller/railties/paths.rb

@@ -1,25 +0,0 @@
-module ActionController
-  module Railties
-    module Paths
-      def self.with(app)
-        Module.new do
-          define_method(:inherited) do |klass|
-            super(klass)
-
-            if namespace = klass.parents.detect { |m| m.respond_to?(:railtie_helpers_paths) }
-              paths = namespace.railtie_helpers_paths
-            else
-              paths = app.helpers_paths
-            end
-
-            klass.helpers_path = paths
-
-            if klass.superclass == ActionController::Base && ActionController::Base.include_all_helpers
-              klass.helper :all
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/action_dispatch/middleware/best_standards_support.rb

@@ -1,30 +0,0 @@
-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)
-
-      if headers["X-UA-Compatible"] && @header
-        unless headers["X-UA-Compatible"][@header]
-          headers["X-UA-Compatible"] << "," << @header.to_s
-        end
-      else
-        headers["X-UA-Compatible"] = @header
-      end
-
-      [status, headers, body]
-    end
-  end
-end

data/lib/action_dispatch/middleware/body_proxy.rb

@@ -1,30 +0,0 @@
-# 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/lib/action_dispatch/middleware/head.rb

@@ -1,18 +0,0 @@
-module ActionDispatch
-  class Head
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      if env["REQUEST_METHOD"] == "HEAD"
-        env["REQUEST_METHOD"] = "GET"
-        env["rack.methodoverride.original_method"] = "HEAD"
-        status, headers, _ = @app.call(env)
-        [status, headers, []]
-      else
-        @app.call(env)
-      end
-    end
-  end
-end

data/lib/action_dispatch/middleware/rescue.rb

@@ -1,26 +0,0 @@
-module ActionDispatch
-  class Rescue
-    def initialize(app, rescuers = {}, &block)
-      @app, @rescuers = app, {}
-      rescuers.each { |exception, rescuer| rescue_from(exception, rescuer) }
-      instance_eval(&block) if block_given?
-    end
-
-    def call(env)
-      @app.call(env)
-    rescue Exception => exception
-      if rescuer = @rescuers[exception.class.name]
-        env['action_dispatch.rescue.exception'] = exception
-        rescuer.call(env)
-      else
-        raise exception
-      end
-    end
-
-    protected
-      def rescue_from(exception, rescuer)
-        exception = exception.class.name if exception.is_a?(Exception)
-        @rescuers[exception.to_s] = rescuer
-      end
-  end
-end

data/lib/action_dispatch/testing/performance_test.rb

@@ -1,10 +0,0 @@
-require 'active_support/testing/performance'
-
-module ActionDispatch
-  # An integration test that runs a code profiler on your test methods.
-  # Profiling output for combinations of each test method, measurement, and
-  # output format are written to your tmp/performance directory.
-  class PerformanceTest < ActionDispatch::IntegrationTest
-    include ActiveSupport::Testing::Performance
-  end
-end

data/lib/action_view/asset_paths.rb

@@ -1,142 +0,0 @@
-require 'zlib'
-require 'active_support/core_ext/file'
-require 'action_controller/metal/exceptions'
-
-module ActionView
-  class AssetPaths #:nodoc:
-    attr_reader :config, :controller
-
-    def initialize(config, controller = nil)
-      @config = config
-      @controller = controller
-    end
-
-    # Add the extension +ext+ if not present. Return full or scheme-relative URLs otherwise untouched.
-    # Prefix with <tt>/dir/</tt> if lacking a leading +/+. Account for relative URL
-    # roots. Rewrite the asset path for cache-busting asset ids. Include
-    # asset host, if configured, with the correct request protocol.
-    #
-    # When :relative (default), the protocol will be determined by the client using current protocol
-    # When :request, the protocol will be the request protocol
-    # Otherwise, the protocol is used (E.g. :http, :https, etc)
-    def compute_public_path(source, dir, options = {})
-      source = source.to_s
-      return source if is_uri?(source)
-
-      source = rewrite_extension(source, dir, options[:ext]) if options[:ext]
-      source = rewrite_asset_path(source, dir, options)
-      source = rewrite_relative_url_root(source, relative_url_root)
-      source = rewrite_host_and_protocol(source, options[:protocol])
-      source
-    end
-
-    # Return the filesystem path for the source
-    def compute_source_path(source, dir, ext)
-      source = rewrite_extension(source, dir, ext) if ext
-
-      sources = []
-      sources << config.assets_dir
-      sources << dir unless source[0] == ?/
-      sources << source
-
-      File.join(sources)
-    end
-
-    def is_uri?(path)
-      path =~ %r{^[-a-z]+://|^(?:cid|data):|^//}i
-    end
-
-  private
-
-    def rewrite_extension(source, dir, ext)
-      raise NotImplementedError
-    end
-
-    def rewrite_asset_path(source, path = nil)
-      raise NotImplementedError
-    end
-
-    def rewrite_relative_url_root(source, relative_url_root)
-      relative_url_root && !source.starts_with?("#{relative_url_root}/") ? "#{relative_url_root}#{source}" : source
-    end
-
-    def has_request?
-      controller.respond_to?(:request)
-    end
-
-    def rewrite_host_and_protocol(source, protocol = nil)
-      host = compute_asset_host(source)
-      if host && !is_uri?(host)
-        if (protocol || default_protocol) == :request && !has_request?
-          host = nil
-        else
-          host = "#{compute_protocol(protocol)}#{host}"
-        end
-      end
-      host ? "#{host}#{source}" : source
-    end
-
-    def compute_protocol(protocol)
-      protocol ||= default_protocol
-      case protocol
-      when :relative
-        "//"
-      when :request
-        unless @controller
-          invalid_asset_host!("The protocol requested was :request. Consider using :relative instead.")
-        end
-        @controller.request.protocol
-      else
-        "#{protocol}://"
-      end
-    end
-
-    def default_protocol
-      @config.default_asset_host_protocol || (has_request? ? :request : :relative)
-    end
-
-    def invalid_asset_host!(help_message)
-      raise ActionController::RoutingError, "This asset host cannot be computed without a request in scope. #{help_message}"
-    end
-
-    # Pick an asset host for this source. Returns +nil+ if no host is set,
-    # the host if no wildcard is set, the host interpolated with the
-    # numbers 0-3 if it contains <tt>%d</tt> (the number is the source hash mod 4),
-    # or the value returned from invoking call on an object responding to call
-    # (proc or otherwise).
-    def compute_asset_host(source)
-      if host = asset_host_config
-        if host.respond_to?(:call)
-          args = [source]
-          arity = arity_of(host)
-          if (arity > 1 || arity < -2) && !has_request?
-            invalid_asset_host!("Remove the second argument to your asset_host Proc if you do not need the request, or make it optional.")
-          end
-          args << current_request if (arity > 1 || arity < 0) && has_request?
-          host.call(*args)
-        else
-          (host =~ /%d/) ? host % (Zlib.crc32(source) % 4) : host
-        end
-      end
-    end
-
-    def relative_url_root
-      config.relative_url_root
-    end
-
-    def asset_host_config
-      config.asset_host
-    end
-
-    # Returns the current request if one exists.
-    def current_request
-      controller.request if has_request?
-    end
-
-    # Returns the arity of a callable
-    def arity_of(callable)
-      callable.respond_to?(:arity) ? callable.arity : callable.method(:call).arity
-    end
-
-  end
-end

data/lib/action_view/helpers/asset_paths.rb

@@ -1,7 +0,0 @@
-ActiveSupport::Deprecation.warn "ActionView::Helpers::AssetPaths is deprecated. Please use ActionView::AssetPaths instead."
-
-module ActionView
-  module Helpers
-    AssetPaths = ::ActionView::AssetPaths
-  end
-end

data/lib/action_view/helpers/asset_tag_helpers/asset_include_tag.rb

@@ -1,146 +0,0 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/file'
-require 'action_view/helpers/tag_helper'
-
-module ActionView
-  module Helpers
-    module AssetTagHelper
-
-      class AssetIncludeTag
-        include TagHelper
-
-        attr_reader :config, :asset_paths
-        class_attribute :expansions
-
-        def self.inherited(base)
-          base.expansions = { }
-        end
-
-        def initialize(config, asset_paths)
-          @config = config
-          @asset_paths = asset_paths
-        end
-
-        def asset_name
-          raise NotImplementedError
-        end
-
-        def extension
-          raise NotImplementedError
-        end
-
-        def custom_dir
-          raise NotImplementedError
-        end
-
-        def asset_tag(source, options)
-          raise NotImplementedError
-        end
-
-        def include_tag(*sources)
-          options = sources.extract_options!.stringify_keys
-          concat  = options.delete("concat")
-          cache   = concat || options.delete("cache")
-          recursive = options.delete("recursive")
-
-          if concat || (config.perform_caching && cache)
-            joined_name = (cache == true ? "all" : cache) + ".#{extension}"
-            joined_path = File.join((joined_name[/^#{File::SEPARATOR}/] ? config.assets_dir : custom_dir), joined_name)
-            unless config.perform_caching && File.exists?(joined_path)
-              write_asset_file_contents(joined_path, compute_paths(sources, recursive))
-            end
-            asset_tag(joined_name, options)
-          else
-            sources = expand_sources(sources, recursive)
-            ensure_sources!(sources) if cache
-            sources.collect { |source| asset_tag(source, options) }.join("\n").html_safe
-          end
-        end
-
-        private
-
-          def path_to_asset(source, options = {})
-            asset_paths.compute_public_path(source, asset_name.to_s.pluralize, options.merge(:ext => extension))
-          end
-
-          def path_to_asset_source(source)
-            asset_paths.compute_source_path(source, asset_name.to_s.pluralize, extension)
-          end
-
-          def compute_paths(*args)
-            expand_sources(*args).collect { |source| path_to_asset_source(source) }
-          end
-
-          def expand_sources(sources, recursive)
-            if sources.first == :all
-              collect_asset_files(custom_dir, ('**' if recursive), "*.#{extension}")
-            else
-              sources.inject([]) do |list, source|
-                determined_source = determine_source(source, expansions)
-                update_source_list(list, determined_source)
-              end
-            end
-          end
-
-          def update_source_list(list, source)
-            case source
-            when String
-              list.delete(source)
-              list << source
-            when Array
-              updated_sources = source - list
-              list.concat(updated_sources)
-            end
-          end
-
-          def ensure_sources!(sources)
-            sources.each do |source|
-              asset_file_path!(path_to_asset_source(source))
-            end
-          end
-
-          def collect_asset_files(*path)
-            dir = path.first
-
-            Dir[File.join(*path.compact)].collect do |file|
-              file[-(file.size - dir.size - 1)..-1].sub(/\.\w+$/, '')
-            end.sort
-          end
-
-          def determine_source(source, collection)
-            case source
-            when Symbol
-              collection[source] || raise(ArgumentError, "No expansion found for #{source.inspect}")
-            else
-              source
-            end
-          end
-
-          def join_asset_file_contents(paths)
-            paths.collect { |path| File.read(asset_file_path!(path, true)) }.join("\n\n")
-          end
-
-          def write_asset_file_contents(joined_asset_path, asset_paths)
-            FileUtils.mkdir_p(File.dirname(joined_asset_path))
-            File.atomic_write(joined_asset_path) { |cache| cache.write(join_asset_file_contents(asset_paths)) }
-
-            # Set mtime to the latest of the combined files to allow for
-            # consistent ETag without a shared filesystem.
-            mt = asset_paths.map { |p| File.mtime(asset_file_path!(p)) }.max
-            File.utime(mt, mt, joined_asset_path)
-          end
-
-          def asset_file_path!(absolute_path, error_if_file_is_uri = false)
-            if asset_paths.is_uri?(absolute_path)
-              raise(Errno::ENOENT, "Asset file #{path} is uri and cannot be merged into single file") if error_if_file_is_uri
-            else
-              raise(Errno::ENOENT, "Asset file not found at '#{absolute_path}'" ) unless File.exist?(absolute_path)
-              return absolute_path
-            end
-          end
-      end
-
-    end
-  end
-end