versioncake 2.5.0 → 3.0.0

data/lib/generators/versioncake/install_generator.rb

@@ -0,0 +1,12 @@
+require 'rails/generators'
+
+module Versioncake
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path('../../templates', __FILE__)
+
+    desc 'Creates a Version Cake initializer in your application.'
+    def copy_initializer
+      template 'versioncake.rb', 'config/initializers/versioncake.rb'
+    end
+  end
+end

data/lib/versioncake.rb

@@ -8,8 +8,29 @@ require 'versioncake/strategies/custom_strategy'
 
 require 'versioncake/exceptions'
 require 'versioncake/configuration'
-require 'versioncake/controller_additions'
-require 'versioncake/view_additions'
 require 'versioncake/versioned_request'
-require 'versioncake/railtie'
+require 'versioncake/version_checker'
+require 'versioncake/version_context'
+require 'versioncake/version_context_service'
+require 'versioncake/versioned_resource'
+require 'versioncake/rack/middleware'
 require 'versioncake/cli'
+require 'versioncake/test_helpers'
+
+if defined?(Rails)
+  require 'versioncake/controller_additions'
+  require 'versioncake/view_additions'
+  require 'versioncake/engine'
+end
+
+module VersionCake
+
+  mattr_accessor :config
+
+  self.config = VersionCake::Configuration.new
+
+  # Yield self on setup for nice config blocks
+  def self.setup
+    yield self.config
+  end
+end

data/lib/versioncake/configuration.rb

@@ -7,11 +7,13 @@ module VersionCake
     SUPPORTED_VERSIONS_DEFAULT = (1..10)
     VERSION_KEY_DEFAULT = 'api_version'
 
-    attr_reader :extraction_strategies, :supported_version_numbers
-    attr_accessor :default_version, :version_key
+    attr_reader :extraction_strategies, :supported_version_numbers, :versioned_resources
+    attr_accessor :missing_version, :version_key, :rails_view_versioning
 
     def initialize
+      @versioned_resources           = []
       @version_key                   = VERSION_KEY_DEFAULT
+      @rails_view_versioning         = true
       self.supported_version_numbers = SUPPORTED_VERSIONS_DEFAULT
       self.extraction_strategy       = :query_parameter
     end
@@ -44,5 +46,20 @@ module VersionCake
       @supported_version_numbers.first
     end
 
+    def resources
+      builder = ResourceBuilder.new
+      yield builder
+      @versioned_resources = builder.resources
+    end
+  end
+
+  class ResourceBuilder
+    attr_reader :resources
+    def initialize
+      @resources = []
+    end
+    def resource(regex, obsolete, unsupported, supported)
+      @resources << VersionCake::VersionedResource.new(regex, obsolete, unsupported, supported)
+    end
   end
 end

data/lib/versioncake/controller_additions.rb

@@ -4,52 +4,64 @@ module VersionCake
   module ControllerAdditions
     extend ActiveSupport::Concern
 
-    attr_accessor :versioned_request
-
     # set_version is the prepend filter that will determine the version of the
     # requests.
     included do
-      prepend_before_filter :set_version
+      if respond_to? :prepend_before_action
+        prepend_before_action :check_version!
+      else
+        prepend_before_filter :check_version!
+      end
     end
 
     # The explicit version requested by a client, this may not
     # be the rendered version and may also be nil.
-    def requested_version
-      versioned_request.extracted_version
+    def request_version
+      @request_version ||= version_context.version
     end
 
-    # The requested version by a client or if it's nil the latest or default
-    # version configured.
-    def derived_version
-      versioned_request.version
+    # A boolean check to determine if the latest version is requested.
+    def is_latest_version?
+      version_context.is_latest_version?
     end
 
-    # A boolean check to determine if the latest version is requested.
-    def is_latest_version
-      versioned_request.is_latest_version?
+    # A boolean check to determine if the version requested is deprecated.
+    def is_deprecated_version?
+      version_context.result == :deprecated
     end
 
     protected
 
-    # The current requests version information.
-    def versioned_request
-      set_version
-      @versioned_request
+    def version_context
+      request.env['versioncake.context']
     end
 
-    # Sets the version of the request as well as several accessor variables.
+    # Check the version of the request and raise errors when it's invalid. Additionally,
+    # setup view versioning if configured.
     #
     # @param override_version a version number to use instead of the one extracted
     #     from the request
     #
     # @return No explicit return, but several attributes are exposed
-    def set_version(override_version=nil)
-      return if @versioned_request.present? && override_version.blank?
-      @versioned_request = VersionCake::VersionedRequest.new(request, override_version)
-      if !@versioned_request.is_version_supported?
-        raise UnsupportedVersionError.new('Unsupported version error')
+    def check_version!(override_version=nil)
+      return unless version_context
+      
+      case version_context.result
+        when :version_invalid, :version_too_high, :version_too_low, :unknown
+          raise UnsupportedVersionError.new('Unsupported version error')
+        when :obsolete
+          raise ObsoleteVersionError.new('The version given is obsolete')
+        when :no_version
+          raise MissingVersionError.new('No version was given')
       end
-      @_lookup_context.versions = @versioned_request.supported_versions
+
+      if VersionCake.config.rails_view_versioning
+        @_lookup_context.versions = version_context.supported_versions.map { |n| :"v#{n}" }
+      end
+    end
+
+    def set_version(version)
+      @request_version = version
     end
   end
 end

data/lib/versioncake/engine.rb

@@ -0,0 +1,7 @@
+module VersionCake
+  class Engine < Rails::Engine
+    initializer 'version_cake.add_middleware' do |app|
+      app.middleware.use VersionCake::Rack::Middleware
+    end
+  end
+end

data/lib/versioncake/exceptions.rb

@@ -3,4 +3,8 @@ require 'action_controller/metal/exceptions'
 module VersionCake
   class UnsupportedVersionError < ::ActionController::RoutingError
   end
+  class ObsoleteVersionError < ::ActionController::RoutingError
+  end
+  class MissingVersionError <  ::ActionController::RoutingError
+  end
 end

data/lib/versioncake/rack/middleware.rb

@@ -0,0 +1,20 @@
+module VersionCake
+  module Rack
+    class Middleware
+
+      def initialize(app)
+        @app = app
+        @version_service = VersionCake::VersionContextService.new(VersionCake.config)
+      end
+
+      def call(env)
+        request = ::Rack::Request.new env
+        if context = @version_service.create_context_from_request(request)
+          env['versioncake.context'] = context
+        end
+
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/versioncake/strategies/extraction_strategy.rb

@@ -9,15 +9,20 @@ module VersionCake
         version
       elsif version.is_a?(String) && /[0-9]+/.match(version)
         version.to_i
-      else
+      elsif version.nil? # no version was found
         nil
+      else
+        raise Exception, "Invalid format for version number."
       end
     end
 
     def version_key
-      VersionCake::Railtie.config.versioncake.version_key
+      VersionCake.config.version_key
     end
 
+    # Execute should return a number or a numeric string if it successfully finds a version. 
+    # If no version is found, nil should be returned. Any other results returned will raise
+    # an exception.
     def execute(request)
       raise Exception, "ExtractionStrategy requires execute to be implemented"
     end
@@ -50,4 +55,4 @@ module VersionCake
       end
     end
   end
-end
+end

data/lib/versioncake/strategies/http_accept_parameter_strategy.rb

@@ -2,8 +2,8 @@ module VersionCake
   class HttpAcceptParameterStrategy < ExtractionStrategy
 
     def execute(request)
-      if request.headers.key?("HTTP_ACCEPT") &&
-          match = request.headers["HTTP_ACCEPT"].match(/#{version_key}=([0-9]+)/)
+      if request.env.key?('HTTP_ACCEPT') &&
+          match = request.env['HTTP_ACCEPT'].match(/#{version_key}=([0-9]+)/)
         match[1]
       end
     end

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_key.upcase}"
-        request.headers["HTTP_X_#{version_key.upcase}"]
+      if request.env.key? "HTTP_#{version_key.upcase}"
+        request.env["HTTP_#{version_key.upcase}"]
       end
     end
 

data/lib/versioncake/strategies/path_parameter_strategy.rb

@@ -2,9 +2,13 @@ module VersionCake
   class PathParameterStrategy < ExtractionStrategy
 
     def execute(request)
-      if request.path_parameters.key? version_key.to_sym
-        request.path_parameters[version_key.to_sym]
+      version = nil
+      request.path.split('/').find do |part|
+        next unless match = part.match(%r{v(?<version>\d+)})
+        version = match[:version]
+        break
       end
+      version
     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_key.to_sym
-        request.query_parameters[version_key.to_sym].to_s
+      if request.GET.key? version_key
+        request.GET[version_key].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_key.to_sym
-        request.request_parameters[version_key.to_sym]
+      if request.POST.has_key? version_key
+        request.POST[version_key]
       end
     end
 

data/lib/versioncake/test_helpers.rb

@@ -0,0 +1,14 @@
+module VersionCake
+  module TestHelpers
+    # Test helper the mimics the middleware because we do not
+    # have middleware during tests.
+    def set_request_version(resource, version)
+      service = VersionCake::VersionContextService.new(VersionCake.config)
+      @request.env['versioncake.context'] = service.create_context resource, version
+    end
+
+    def set_version_context(status, resource=nil, version=nil)
+      @request.env['versioncake.context'] = VersionCake::VersionContext.new(version, resource, status)
+    end
+  end
+end

data/lib/versioncake/version.rb

@@ -1,3 +1,3 @@
 module VersionCake
-  VERSION = "2.5.0"
+  VERSION = '3.0.0'
 end

data/lib/versioncake/version_checker.rb

@@ -0,0 +1,28 @@
+module VersionCake
+  class VersionChecker
+    attr_reader :result
+    def initialize(version, resource)
+      @version, @resource = resource, version
+    end
+
+    def execute
+      @result = if @version.nil?
+        :no_version
+      elsif !@version.is_a? Integer
+        :invalid_format
+      elsif @resource.obsolete_versions.include? @version
+        :obsolete
+      elsif @resource.deprecated_versions.include? @version
+        :deprecated
+      elsif @resource.supported_versions.include? @version
+        :supported
+      elsif @version > @resource.supported_versions.last
+        :version_too_high
+      elsif @version < @resource.supported_versions.first
+        :version_too_low
+      else
+        :unknown
+      end
+    end
+  end
+end

data/lib/versioncake/version_context.rb

@@ -0,0 +1,20 @@
+module VersionCake
+  class VersionContext
+    attr_reader :version, :resource, :result
+
+    def initialize(version, resource, result)
+      @version, @resource, @result = version, resource, result
+    end
+
+    # A boolean check to determine if the latest version is requested.
+    def is_latest_version?
+      @version == @resource.latest_version
+    end
+
+    # Ordered versions that are equal to or lower
+    # than the requested version.
+    def supported_versions
+      @resource.supported_versions.sort.reverse.reject { |v| v > @version }
+    end
+  end
+end

data/lib/versioncake/version_context_service.rb

@@ -0,0 +1,47 @@
+module VersionCake
+  class VersionContextService
+
+    def initialize(config)
+      @versioned_resources = config.versioned_resources
+      @default_version = config.missing_version
+      @strategies = config.extraction_strategies
+    end
+
+    def create_context_from_request(raw_request)
+      return unless resource = find_resource(raw_request.path)
+
+      request = VersionCake::VersionedRequest.new(
+                    raw_request,
+                    @strategies,
+                    @default_version
+                )
+      request.execute
+
+      result = if request.failed
+        :invalid_version
+      else
+        check_version(resource, request.version)
+      end
+
+      VersionCake::VersionContext.new(request.version, resource, result)
+    end
+
+    def create_context(uri, version)
+      return unless resource = find_resource(uri)
+
+      result = check_version(resource, version)
+
+      VersionCake::VersionContext.new(version, resource, result)
+    end
+
+    private
+
+    def check_version(resource, version)
+      VersionCake::VersionChecker.new(resource, version).execute
+    end
+
+    def find_resource(uri)
+      @versioned_resources.find { |resource| resource.uri.match uri }
+    end
+  end
+end

data/lib/versioncake/versioned_request.rb

@@ -1,45 +1,34 @@
 module VersionCake
   class VersionedRequest
-    attr_reader :version, :extracted_version
+    attr_reader :failed, :version
 
-    def initialize(request, version_override=nil)
-      derive_version(request, version_override)
+    def initialize(request, strategies, default_version=nil)
+      @request, @strategies, @default_version, @failed = request, strategies, default_version, false
     end
 
-    def supported_versions
-      config.supported_versions(@version)
-    end
-
-    def is_latest_version?
-      @version == config.latest_version
-    end
-
-    def is_version_supported?
-      config.supports_version? @version
+    def execute
+      begin
+        extracted_version = extract_version
+
+        if extracted_version.nil?
+          @version = @default_version
+        else
+          @version = extracted_version
+        end
+      rescue Exception
+        @failed = true
+      end
     end
 
     private
 
-    def config
-      VersionCake::Railtie.config.versioncake
-    end
-
-    def apply_strategies(request)
-      version = nil
-      config.extraction_strategies.each do |strategy|
-        version = strategy.extract(request)
-        break unless version.nil?
-      end
-      version
-    end
-
-    def derive_version(request, version_override)
-      if version_override
-        @version = version_override
-      else
-        @extracted_version = apply_strategies(request)
-        @version = @extracted_version || config.default_version || config.latest_version
+    def extract_version
+      extracted_version = nil
+      @strategies.each do |strategy|
+        extracted_version = strategy.extract(@request)
+        break unless extracted_version.nil?
       end
+      extracted_version
     end
   end
-end
+end