versioncake 1.3.0 → 2.0.0

data/lib/versioncake/strategies/http_header_strategy.rb

@@ -2,8 +2,8 @@ module VersionCake
   class HttpHeaderStrategy < ExtractionStrategy
 
     def execute(request)
-      if request.headers.key? "HTTP_X_#{@@version_string.upcase}"
-        request.headers["HTTP_X_#{@@version_string.upcase}"]
+      if request.headers.key? "HTTP_X_#{version_key.upcase}"
+        request.headers["HTTP_X_#{version_key.upcase}"]
       end
     end
 

data/lib/versioncake/strategies/path_parameter_strategy.rb

@@ -0,0 +1,11 @@
+module VersionCake
+  class PathParameterStrategy < ExtractionStrategy
+
+    def execute(request)
+      if request.path_parameters.key? version_key.to_sym
+        request.path_parameters[version_key.to_sym]
+      end
+    end
+
+  end
+end

data/lib/versioncake/strategies/query_parameter_strategy.rb

@@ -2,8 +2,8 @@ module VersionCake
   class QueryParameterStrategy < ExtractionStrategy
 
     def execute(request)
-      if request.query_parameters.key? @@version_string.to_sym
-        request.query_parameters[@@version_string.to_sym]
+      if request.query_parameters.key? version_key.to_sym
+        request.query_parameters[version_key.to_sym].to_s
       end
     end
 

data/lib/versioncake/strategies/request_parameter_strategy.rb

@@ -2,8 +2,8 @@ module VersionCake
   class RequestParameterStrategy < ExtractionStrategy
 
     def execute(request)
-      if request.request_parameters.has_key? @@version_string.to_sym
-        request.request_parameters[@@version_string.to_sym].to_i
+      if request.request_parameters.has_key? version_key.to_sym
+        request.request_parameters[version_key.to_sym]
       end
     end
 

data/lib/versioncake/version.rb

@@ -1,3 +1,3 @@
 module VersionCake
-  VERSION = "1.3.0"
+  VERSION = "2.0.0"
 end

data/lib/versioncake/versioned_request.rb

@@ -4,18 +4,22 @@ module VersionCake
 
     def initialize(request, version_override=nil)
       @version = version_override || extract_version(request)
-      @is_latest_version = @version == VersionCake::Configuration.latest_version
+      @is_latest_version = @version == config.latest_version
     end
 
     def supported_versions
-      VersionCake::Configuration.supported_versions(@version)
+      config.supported_versions(@version)
     end
 
     private
 
+    def config
+      VersionCake::Railtie.config.versioncake
+    end
+
     def apply_strategies(request)
       version = nil
-      VersionCake::Configuration.extraction_strategies.each do |strategy|
+      config.extraction_strategies.each do |strategy|
         version = strategy.extract(request)
         break unless version.nil?
       end
@@ -25,10 +29,10 @@ module VersionCake
     def extract_version(request)
       @extracted_version = apply_strategies(request)
       if @extracted_version.nil?
-        @version = VersionCake::Configuration.default_version || VersionCake::Configuration.latest_version
-      elsif VersionCake::Configuration.supports_version? @extracted_version
+        @version = config.default_version || config.latest_version
+      elsif config.supports_version? @extracted_version
         @version = @extracted_version
-      elsif @extracted_version > VersionCake::Configuration.latest_version
+      elsif @extracted_version > config.latest_version
         raise ActionController::RoutingError.new("No route match for version")
       else
         raise ActionController::RoutingError.new("Version is deprecated")

data/lib/versioncake/view_additions.rb

@@ -3,26 +3,83 @@ require 'action_view'
 # register an addition detail for the lookup context to understand,
 # this will allow us to have the versions available upon lookup in
 # the resolver.
-ActionView::LookupContext.register_detail(:versions){ VersionCake::Configuration.supported_versions }
+ActionView::LookupContext.register_detail(:versions){ VersionCake::Railtie.config.versioncake.supported_versions }
 
 ActionView::PathResolver.class_eval do
-
   # not sure why we are doing this yet, but looks like a good idea
-  ActionView::PathResolver::EXTENSIONS.replace [:locale, :versions, :formats, :handlers]
+  if ActionPack::VERSION::MAJOR >= 4 && ActionPack::VERSION::MINOR >= 1
+    ActionView::PathResolver::EXTENSIONS.replace({
+                                                     :locale => ".",
+                                                     :formats => ".",
+                                                     :versions => ".",
+                                                     :variants => "+",
+                                                     :handlers => "."
+                                                 })
+
+    ActionView::PathResolver::DEFAULT_PATTERN.replace ":prefix/:action{.:locale,}{.:formats,}{+:variants,}{.:versions,}{.:handlers,}"
+  else
+    ActionView::PathResolver::EXTENSIONS.replace [:locale, :formats, :versions, :handlers]
+
+    # The query builder has the @details from the lookup_context and will
+    # match the detail name to the string in the pattern, so we must append
+    # it to the default pattern
+    ActionView::PathResolver::DEFAULT_PATTERN.replace ":prefix/:action{.:locale,}{.:formats,}{.:versions,}{.:handlers,}"
+  end
+
+  # The default extract handler expects that the handler is the last extension and
+  # the format is the next one. Since we are replacing the DEFAULT_PATTERN, we need to
+  # make sure that we extract the format from the correct position.
+  #
+  # The version may be stuck inbetween the format and the handler. This is actually pretty tricky
+  # because the version is optional and the locale is optional-which means when there are 3 'pieces'
+  # it may be the locale, format and handler or the format, version and handler. To check this, we will
+  # try one additional time if there are more pieces, which should cover all the cases:
+  #
+  # Cases:
+  #  1: assume version is in the extension, pieces = ['html','erb']
+  #  2: assume version is in the extension, pieces = ['html','v1','erb']
+  #  3: assume version is in the extension, pieces = ['en','html','erb']
+  #  4: assume version is in the extension, pieces = ['en','html','v1','erb']
+  #
+  def extract_handler_and_format(path, default_formats)
+    pieces = File.basename(path).split(".")
+    pieces.shift
+
+    extension = pieces.pop
+    if ActionPack::VERSION::MAJOR == 4
+      unless extension
+        message = "The file #{path} did not specify a template handler. The default is currently ERB, " \
+                    "but will change to RAW in the future."
+        ActiveSupport::Deprecation.warn message
+      end
+    end
+    handler = ActionView::Template.handler_for_extension(extension)
+    format  = get_format_from_pieces(pieces, (ActionPack::VERSION::MAJOR == 4 ? ActionView::Template::Types : Mime))
 
-  # The query builder has the @details from the lookup_context and will
-  # match the detail name to the string in the pattern, so we must append
-  # it to the default pattern
-  ActionView::PathResolver::DEFAULT_PATTERN.replace ":prefix/:action{.:locale,}{.:versions,}{.:formats,}{.:handlers,}"
+    [handler, format]
+  end
+
+  # If there are still pieces and we didn't find a valid format, we may
+  # have a version in the extension, so try one more time to pop the format.
+  def get_format_from_pieces(pieces, format_list)
+    format = nil
+    pieces.reverse.each do |piece|
+      if ActionView::PathResolver::EXTENSIONS.is_a?(Hash) &&
+          ActionView::PathResolver::EXTENSIONS.include?(:variants)
+        piece = piece.split(ActionView::PathResolver::EXTENSIONS[:variants], 2).first # remove variant from format
+      end
 
+      format = format_list[piece]
+      break unless format.nil?
+    end
+    format
+  end
 end
 
 ActionView::Template.class_eval do
-
   # the identifier method name filters out numbers,
   # but we want to preserve them for v1 etc.
   def identifier_method_name #:nodoc:
     inspect.gsub(/[^a-z0-9_]/, '_')
   end
-
-end
+end

data/lib/versioncake.rb

@@ -2,6 +2,7 @@ require 'versioncake/strategies/extraction_strategy'
 require 'versioncake/strategies/http_accept_parameter_strategy'
 require 'versioncake/strategies/http_header_strategy'
 require 'versioncake/strategies/query_parameter_strategy'
+require 'versioncake/strategies/path_parameter_strategy'
 require 'versioncake/strategies/request_parameter_strategy'
 require 'versioncake/strategies/custom_strategy'
 
@@ -10,3 +11,4 @@ require 'versioncake/controller_additions'
 require 'versioncake/view_additions'
 require 'versioncake/versioned_request'
 require 'versioncake/railtie'
+require 'versioncake/cli'

data/test/config/application.rb

@@ -11,7 +11,8 @@ module RendersTest
     config.eager_load = false
 
     config.active_support.deprecation = :stderr
-    config.view_versions = (1..3)
-    config.view_version_extraction_strategy = :http_header
+
+    config.versioncake.supported_version_numbers = (1..3)
+    config.versioncake.extraction_strategy = [:http_header, :http_accept_parameter, :query_parameter, :request_parameter]
   end
 end

data/test/fixtures/templates/v1_extension_scheme.v3.html.erb

@@ -0,0 +1,7 @@
+<dl>
+  <dt>Versioncake v1 Extension</dt>
+  <dd>v3.html.erb</dd>
+
+  <dt>Versioncake v2 Extension</dt>
+  <dd>html.v3.erb</dd>
+</dl>

data/test/fixtures/templates/v1_extension_scheme.v6.json

@@ -0,0 +1,4 @@
+{
+    "Versioncake v1 Extension": "v6.json",
+    "Versioncake v2 Extension": "json.v6"
+}

data/test/fixtures/templates/versioned.html.v1.erb

@@ -0,0 +1 @@
+template v1

data/test/fixtures/templates/versioned.html.v2.erb

@@ -0,0 +1 @@
+template v2

data/test/fixtures/test_cases.yml

@@ -0,0 +1,70 @@
+# http_header_strategy
+- request:
+    headers:
+      HTTP_ACCEPT: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=1"
+  response: "template v1"
+
+- request:
+    headers:
+      HTTP_ACCEPT: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=2"
+  response: "template v2"
+
+- request:
+    headers:
+      HTTP_ACCEPT: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=INVALID"
+  response: "template v2"
+
+# request_parameter_strategy
+- request:
+    method: post
+    params:
+      api_version: "1"
+  response: "template v1"
+
+- request:
+    method: post
+    params:
+      api_version: "2"
+  response: "template v2"
+
+- request:
+    method: post
+    params:
+      api_version: "INVALID"
+  response: "template v2"
+
+# query_parameter_strategy
+- request:
+    params:
+      api_version: "1"
+  response: "template v1"
+
+- request:
+    params:
+      api_version: "2"
+  response: "template v2"
+
+- request:
+    params:
+      api_version: "INVALID"
+  response: "template v2"
+
+# http_header_strategy
+- request:
+    headers:
+      HTTP_X_API_VERSION: "1"
+  response: "template v1"
+
+- request:
+    headers:
+      HTTP_X_API_VERSION: "2"
+  response: "template v2"
+
+- request:
+    headers:
+      HTTP_X_API_VERSION: "INVALID"
+  response: "template v2"
+
+# general
+- request:
+  response: "template v2"

data/test/functional/custom_strategy_controller_test.rb

@@ -0,0 +1,16 @@
+require './test/test_helper'
+require 'action_controller'
+require 'action_controller/test_case'
+
+class CustomStrategyTest < ActionController::TestCase
+  tests RendersController
+
+  setup do
+    VersionCake::Configuration.any_instance.stubs(:extraction_strategy => lambda { |request| 2 })
+  end
+
+  test "renders version 2 of the partial based on the header Accept" do
+    get :index
+    assert_equal "template v2", @response.body
+  end
+end

data/test/functional/multiple_strategy_controller_test.rb

@@ -0,0 +1,24 @@
+require './test/test_helper'
+require 'action_controller'
+require 'action_controller/test_case'
+
+class MultipleStrategyTest < ActionController::TestCase
+  tests RendersController
+
+  test "renders version 1 of the partial based on the header Accept" do
+    @controller.request.stubs(:headers).returns({"HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=1"})
+    get :index
+    assert_equal "template v1", @response.body
+  end
+
+  test "renders the query parameter when accept parameter isn't available" do
+    get :index, "api_version" => "1"
+    assert_equal "template v1", @response.body
+  end
+
+  test "renders the higher priority accept parameter version" do
+    @controller.request.stubs(:headers).returns({"HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=2"})
+    get :index, "api_version" => "1"
+    assert_equal "template v2", @response.body
+  end
+end

data/test/functional/renders_controller_test.rb

@@ -4,32 +4,23 @@ require 'action_controller/test_case'
 
 class RendersControllerTest < ActionController::TestCase
 
-  setup do
-    # change the version string for configuration testing
-    VersionCake::ExtractionStrategy.version_string = "version"
-  end
-
-  teardown do
-    VersionCake::ExtractionStrategy.version_string = "api_version"
-  end
-
   test "render latest version of partial" do
     get :index
-    assert_equal @response.body, "index.v2.html.erb"
+    assert_equal "template v2", @response.body
   end
 
   test "exposes the requested version" do
-    get :index, "version" => "1"
-    assert_equal @controller.requested_version, 1
+    get :index, "api_version" => "1"
+    assert_equal 1, @controller.requested_version
   end
 
   test "exposes latest version when requesting the latest" do
-    get :index, "version" => "3"
+    get :index, "api_version" => "3"
     assert @controller.is_latest_version
   end
 
   test "reports not the latest version" do
-    get :index, "version" => "1"
+    get :index, "api_version" => "1"
     assert !@controller.is_latest_version
   end
 
@@ -39,10 +30,9 @@ class RendersControllerTest < ActionController::TestCase
   end
 
   test "exposes the default version when the version is not set default is set" do
-    VersionCake::Configuration.default_version = 1
+    VersionCake::Configuration.any_instance.stubs(:default_version => 1)
     get :index
     assert_equal 1, @controller.derived_version
-    VersionCake::Configuration.default_version = nil
   end
 
   test "requested version is blank when the version is not set" do
@@ -51,158 +41,9 @@ class RendersControllerTest < ActionController::TestCase
   end
 
   test "set_version can be called to override the requested version" do
-    get :index, "version" => "1", "override_version" => 2
+    get :index, "api_version" => "1", "override_version" => 2
     assert_equal 2, @controller.derived_version
   end
-end
-
-class ParameterStrategyTest < ActionController::TestCase
-  tests RendersController
-
-  setup do
-    VersionCake::Configuration.extraction_strategy = :query_parameter
-  end
-
-  test "render version 1 of the partial based on the parameter _api_version" do
-    get :index, "api_version" => "1"
-    assert_equal @response.body, "index.v1.html.erb"
-  end
-
-  test "render version 2 of the partial based on the parameter _api_version" do
-    get :index, "api_version" => "2"
-    assert_equal @response.body, "index.v2.html.erb"
-  end
-
-  test "render the latest available version (v2) of the partial based on the parameter _api_version" do
-    get :index, "api_version" => "3"
-    assert_equal @response.body, "index.v2.html.erb"
-  end
-end
-
-class CustomHeaderStrategyTest < ActionController::TestCase
-tests RendersController
-
-  setup do
-    VersionCake::Configuration.extraction_strategy = :http_header
-  end
-
-  test "renders version 1 of the partial based on the header API-Version" do
-    @controller.request.stubs(:headers).returns({"HTTP_X_API_VERSION" => "1"})
-    get :index
-    assert_equal @response.body, "index.v1.html.erb"
-  end
-
-  test "renders version 2 of the partial based on the header API-Version" do
-    @controller.request.stubs(:headers).returns({"HTTP_X_API_VERSION" => "2"})
-    get :index
-    assert_equal @response.body, "index.v2.html.erb"
-  end
-
-  test "renders the latest available version (v2) of the partial based on the header API-Version" do
-    @controller.request.stubs(:headers).returns({"HTTP_X_API_VERSION" => "3"})
-    get :index
-    assert_equal @response.body, "index.v2.html.erb"
-  end
-end
-
-class RequestBodyStrategyTest < ActionController::TestCase
- tests RendersController
-
-  setup do
-    VersionCake::Configuration.extraction_strategy = :request_parameter
-  end
-
-  test "requested version is in the body" do
-    post :index, "api_version" => "2"
-    assert_equal 2, @controller.requested_version
-  end
-end
-
-class AcceptHeaderStrategyTest < ActionController::TestCase
-  tests RendersController
-
-  setup do
-    VersionCake::Configuration.extraction_strategy = :http_accept_parameter
-  end
-
-  test "render version 1 of the partial based on the header Accept" do
-    @controller.request.stubs(:headers).returns({"HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=1"})
-    get :index
-    assert_equal @response.body, "index.v1.html.erb"
-  end
-
-  test "render version 2 of the partial based on the header Accept" do
-    @controller.request.stubs(:headers).returns({"HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=2"})
-    get :index
-    assert_equal @response.body, "index.v2.html.erb"
-  end
-
-  test "render the latest available version (v2) of the partial based on the header Accept" do
-    @controller.request.stubs(:headers).returns({"HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=3"})
-    get :index
-    assert_equal @response.body, "index.v2.html.erb"
-  end
-
-  test "render the latest version of the partial" do
-    @controller.request.stubs(:headers).returns({"HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=abc"})
-    get :index
-    assert_equal @response.body, "index.v2.html.erb"
-  end
-
-  test "render the default version version of the partial" do
-    VersionCake::Configuration.default_version = 1
-    @controller.request.stubs(:headers).returns({"HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=abc"})
-    get :index
-    assert_equal @response.body, "index.v1.html.erb"
-    VersionCake::Configuration.default_version = nil
-  end
-
-end
-
-class CustomStrategyTest < ActionController::TestCase
-  tests RendersController
-
-  setup do
-    VersionCake::Configuration.extraction_strategy = lambda { |request| 2 }
-  end
-
-  test "renders version 2 of the partial based on the header Accept" do
-    get :index
-    assert_equal @response.body, "index.v2.html.erb"
-  end
-end
-
-class MultipleStrategyTest < ActionController::TestCase
-  tests RendersController
-
-  setup do
-    VersionCake::Configuration.extraction_strategy = [:http_accept_parameter, :query_parameter]
-  end
-
-  test "renders version 1 of the partial based on the header Accept" do
-    @controller.request.stubs(:headers).returns({"HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=1"})
-    get :index
-    assert_equal @response.body, "index.v1.html.erb"
-  end
-
-  test "renders the query parameter when accept parameter isn't available" do
-    get :index, "api_version" => "1"
-    assert_equal @response.body, "index.v1.html.erb"
-  end
-
-  test "renders the higher priority accept parameter version" do
-    @controller.request.stubs(:headers).returns({"HTTP_ACCEPT" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8;api_version=2"})
-    get :index, "api_version" => "1"
-    assert_equal @response.body, "index.v2.html.erb"
-  end
-end
-
-class UnsupportedVersionTest < ActionController::TestCase
-  tests RendersController
-
-  setup do
-    VersionCake::Configuration.extraction_strategy = :query_parameter
-  end
 
   test "responds with 404 when the version is larger than the supported version" do
     assert_raise ActionController::RoutingError do
@@ -211,9 +52,14 @@ class UnsupportedVersionTest < ActionController::TestCase
   end
 
   test "responds with 404 when the version is lower than the latest version, but not an available version" do
-    VersionCake::Configuration.supported_version_numbers = [2,3]
     assert_raise ActionController::RoutingError do
-      get :index, "api_version" => "1"
+      get :index, "api_version" => "0"
     end
   end
+
+  test "render the default version version of the partial" do
+    VersionCake::Configuration.any_instance.stubs(:default_version => 1)
+    get :index, "api_version" => "abc"
+    assert_equal "template v1", @response.body
+  end
 end

data/test/functional/strategy_controller_test.rb

@@ -0,0 +1,37 @@
+require './test/test_helper'
+require 'action_controller'
+require 'action_controller/test_case'
+require 'yaml'
+
+class StrategyControllerTest < ActionController::TestCase
+  tests RendersController
+
+  setup do
+    @test_cases = YAML.load(File.open(Rails.root.join('fixtures', 'test_cases.yml')))
+  end
+
+  test "test yml test cases" do
+    @test_cases.each do |test_case|
+      request = (test_case['request'] || {})
+      headers  = request['headers']
+      params   = request['params']
+      method   = (request['method'] || "get").to_sym
+      response = test_case['response']
+      @controller.request.stubs(:headers).returns(headers || {})
+      begin
+        send(method, :index, params || {})
+        assert_equal(response, @response.body, custom_message(headers, params, method, response))
+      rescue => e
+        fail(custom_message(headers, params, method, response) + ", but it failed with an exception '#{e.message}'")
+      end
+    end
+  end
+
+  def custom_message(headers, params, method, response)
+    data = []
+    data << "headers:#{headers}" if headers
+    data << "params:#{params}" if params
+    "Expected #{data.join(",")} with method #{method} to yield #{response}"
+  end
+
+end

data/test/unit/cli_test.rb

@@ -0,0 +1,48 @@
+require './test/test_helper'
+require './lib/versioncake/cli'
+
+class CliTest < ActiveSupport::TestCase
+
+  setup do
+    File.stubs :rename
+    capture_stdout(true)
+  end
+
+  teardown do
+    capture_stdout(false)
+  end
+
+  def capture_stdout(flag=true)
+    if flag
+      out     = StringIO.new
+      $stdout = out
+    else
+      $stdout = STDOUT
+    end
+  end
+
+  test 'it can detect old file names' do
+    renamed_files = VersionCake::Cli.new.migrate('./test/fixtures/templates')
+    assert_equal 2, renamed_files.size
+  end
+
+  test 'it renames old filenames to new filenames' do
+    renamed_files = VersionCake::Cli.new.migrate('./test/fixtures/templates')
+    expected_renamed_files = [
+        ['./test/fixtures/templates/v1_extension_scheme.v3.html.erb', './test/fixtures/templates/v1_extension_scheme.html.v3.erb'],
+        ['./test/fixtures/templates/v1_extension_scheme.v6.json', './test/fixtures/templates/v1_extension_scheme.json.v6']
+    ]
+    assert_empty expected_renamed_files - renamed_files
+  end
+
+  test 'it reports no files changed when new filenames exist' do
+    assert_empty VersionCake::Cli.new.migrate('./test/app/views')
+  end
+
+  test 'it raises if it cannot find the path' do
+    assert_raises ArgumentError do
+      VersionCake::Cli.new.migrate('./a/missing/path')
+    end
+  end
+
+end