versioncake 4.0.0 → 4.1.0

data/lib/versioncake/view_additions_rails6.rb

@@ -0,0 +1,69 @@
+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){ [] }
+
+ActionView::PathResolver.class_eval do
+  ActionView::PathResolver::EXTENSIONS.replace({
+    locale: ".",
+    formats: ".",
+    versions: ".",
+    variants: "+",
+    handlers: "."
+  })
+  Kernel::silence_warnings {
+    ActionView::PathResolver::DEFAULT_PATTERN = ":prefix/:action{.:locale,}{.:formats,}{.:versions,}{+:variants,}{.:handlers,}"
+  }
+
+  # 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
+    handler = ActionView::Template.handler_for_extension(extension)
+    format  = get_format_from_pieces(pieces, Mime)
+
+    [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

data/lib/versioncake/view_additions_rails7.rb

@@ -0,0 +1,155 @@
+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){ [] }
+
+ActionView::Resolver::PathParser.class_eval do
+    def build_path_regex
+      handlers = ActionView::Template::Handlers.extensions.map { |x| Regexp.escape(x) }.join("|")
+      formats = ActionView::Template::Types.symbols.map { |x| Regexp.escape(x) }.join("|")
+      locales = "[a-z]{2}(?:-[A-Z]{2})?"
+      variants = "[^.]*"
+
+      %r{
+          \A
+          (?:(?<prefix>.*)/)?
+          (?<partial>_)?
+          (?<action>.*?)
+          (?:\.(?<locale>#{locales}))??
+          (?:\.(?<format>#{formats}))??
+          (?:\+(?<variant>#{variants}))??
+          (?:\.(?<versions>v[0-9]+))??
+          (?:\.(?<handler>#{handlers}))?
+          \z
+        }x
+    end
+
+    def parse(path)
+      @regex ||= build_path_regex
+      match = @regex.match(path)
+      path = ActionView::TemplatePath.build(match[:action], match[:prefix] || "", !!match[:partial])
+      details = ActionView::TemplateDetails.new(
+        match[:locale]&.to_sym,
+        match[:handler]&.to_sym,
+        match[:format]&.to_sym,
+        match[:variant]&.to_sym,
+        match[:versions]&.to_sym,
+      )
+
+      ActionView::Resolver::PathParser::ParsedPath.new(path, details)
+    end
+  end
+
+ActionView::TemplateDetails::Requested.class_eval do
+  attr_reader :locale, :handlers, :formats, :variants, :versions
+  attr_reader :locale_idx, :handlers_idx, :formats_idx, :variants_idx, :versions_idx
+
+  def initialize(locale:, handlers:, formats:, variants:, versions:)
+    @locale = locale
+    @handlers = handlers
+    @formats = formats
+    @variants = variants
+    @versions = versions
+
+    @locale_idx   = build_idx_hash(locale)
+    @handlers_idx = build_idx_hash(handlers)
+    @formats_idx  = build_idx_hash(formats)
+    @versions_idx  = build_idx_hash(versions)
+    if variants == :any
+      @variants_idx = ANY_HASH
+    else
+      @variants_idx = build_idx_hash(variants)
+    end
+  end
+end
+
+ActionView::TemplateDetails.class_eval do
+  attr_reader :locale, :handler, :format, :variant, :version
+
+  def initialize(locale, handler, format, variant, version)
+    @locale = locale
+    @handler = handler
+    @format = format
+    @variant = variant
+    @version = version
+  end
+
+  def matches?(requested)
+    requested.formats_idx[@format] &&
+      requested.locale_idx[@locale] &&
+      requested.versions_idx[@version] &&
+      requested.variants_idx[@variant] &&
+      requested.handlers_idx[@handler]
+  end
+
+  def sort_key_for(requested)
+    [
+      requested.formats_idx[@format],
+      requested.locale_idx[@locale],
+      requested.versions_idx[@version],
+      requested.variants_idx[@variant],
+      requested.handlers_idx[@handler]
+    ]
+  end
+end
+
+ActionView::Template.class_eval do
+  def initialize(source, identifier, handler, locals:, format: nil, variant: nil, virtual_path: nil, version: nil)
+    @source            = source
+    @identifier        = identifier
+    @handler           = handler
+    @compiled          = false
+    @locals            = locals
+    @virtual_path      = virtual_path
+
+    @variable = if @virtual_path
+      base = @virtual_path.end_with?("/") ? "" : ::File.basename(@virtual_path)
+      base =~ /\A_?(.*?)(?:\.\w+)*\z/
+      $1.to_sym
+    end
+
+    @format            = format
+    @version           = version
+    @variant           = variant
+    @compile_mutex     = Mutex.new
+  end
+
+  def marshal_dump # :nodoc:
+    [ @source, @identifier, @handler, @compiled, @locals, @virtual_path, @format, @variant, @version ]
+  end
+
+  def marshal_load(array) # :nodoc:
+    @source, @identifier, @handler, @compiled, @locals, @virtual_path, @format, @variant, @version = *array
+    @compile_mutex = Mutex.new
+  end
+
+  # the identifier method name filters out numbers,
+  # but we want to preserve them for v1 etc.
+  # TODO: Consider updating to match current implementation:
+  # short_identifier.tr("^a-z_", "_")
+  def identifier_method_name #:nodoc:
+    short_identifier.gsub(/[^a-z0-9_]/, '_')
+  end
+end
+
+ActionView::UnboundTemplate.class_eval do
+  delegate :version, to: :@details
+
+  def build_template(locals)
+    ActionView::Template.new(
+      @source,
+      @identifier,
+      details.handler_class,
+
+      format: details.format_or_default,
+      variant: variant&.to_s,
+      virtual_path: @virtual_path,
+      version: version&.to_s,
+
+      locals: locals.map(&:to_s)
+    )
+  end
+end
+

data/lib/versioncake.rb

@@ -26,6 +26,7 @@ if defined?(Rails)
   require 'versioncake/controller_additions'
   require 'versioncake/view_additions'
   require 'versioncake/engine'
+  require 'versioncake/railtie'
 end
 
 module VersionCake
@@ -38,4 +39,5 @@ module VersionCake
   def self.setup
     yield self.config
   end
-end
+end
+

data/spec/integration/controller/unversioned_controller_spec.rb

@@ -6,7 +6,7 @@ describe UnversionedController, type: :controller do
   context '#index' do
     render_views
 
-    it { expect(response).to be_success }
+    it { expect(response).to be_successful }
     it { expect(response.body).to eq 'unversioned index' }
   end
 end

data/spec/integration/view/render_spec.rb

@@ -3,7 +3,14 @@ require './spec/rails_helper'
 describe ActionView::Base do
   let(:path) { ActionView::FileSystemResolver.new('./spec/fixtures') }
   let(:view_paths) { ActionView::PathSet.new([path]) }
-  let(:view) { ActionView::Base.new(view_paths) }
+  let(:view) do
+    clazz = if ActionPack::VERSION::MAJOR >= 7
+      ActionView::Base.with_empty_template_cache
+    else
+      ActionView::Base
+    end
+    clazz.new(ActionView::LookupContext.new(view_paths), [], nil)
+  end
   let(:version_override) { nil }
   subject { view.render(template: 'templates/versioned', versions: version_override) }
 

data/spec/integration/view/view_additions_rails5_spec.rb

@@ -0,0 +1,67 @@
+require './spec/rails_helper'
+
+if ActionPack::VERSION::MAJOR == 5
+  describe ActionView::PathResolver do
+    let(:resolver) { ActionView::PathResolver.new }
+
+    context '#extract_handler_and_format_and_variant' do
+      subject do
+        resolver.extract_handler_and_format_and_variant("application.#{extension}")
+      end
+
+      let(:variant) { subject[2].to_s }
+      let(:format) { subject[1].to_s }
+      let(:handler) { subject[0] }
+
+      context 'when only handler and format are present' do
+        let(:extension) { 'html.erb' }
+
+        it do
+          expect(format).to eq 'text/html'
+          expect(variant).to be_empty
+          expect(handler).to be_a ActionView::Template::Handlers::ERB
+        end
+      end
+
+      context 'when handler, format and version are present' do
+        let(:extension) { 'json.v1.jbuilder' }
+
+        it do
+          expect(format).to eq 'application/json'
+          expect(variant).to be_empty
+          expect(handler).to be_a ActionView::Template::Handlers::Raw
+        end
+      end
+
+      context 'when handler, format and locale are present' do
+        let(:extension) { 'en.json.jbuilder' }
+
+        it do
+          expect(format).to eq 'application/json'
+          expect(variant).to be_empty
+          expect(handler).to be_a ActionView::Template::Handlers::Raw
+        end
+      end
+
+      context 'when handler, format, locale and version are present' do
+        let(:extension) { 'en.json.v1.jbuilder' }
+
+        it do
+          expect(format).to eq 'application/json'
+          expect(variant).to be_empty
+          expect(handler).to be_a ActionView::Template::Handlers::Raw
+        end
+      end
+
+      context 'when handler, format, variant and version are present' do
+        let(:extension) { 'json+tablet.v1.jbuilder' }
+
+        it do
+          expect(format).to eq 'application/json'
+          expect(variant).to eq 'tablet'
+          expect(handler).to be_a ActionView::Template::Handlers::Raw
+        end
+      end
+    end
+  end
+end

data/spec/integration/view/view_additions_rails6_spec.rb

@@ -0,0 +1,44 @@
+require './spec/rails_helper'
+
+if ActionPack::VERSION::MAJOR == 6
+  describe ActionView::PathResolver do
+    let(:resolver) { ActionView::PathResolver.new }
+
+    context '#extract_handler_and_format' do
+      subject(:template_format) do
+        _, format = resolver.extract_handler_and_format("application.#{template_extension}", nil)
+        format.to_s
+      end
+
+      context 'when only handler and format are present' do
+        let(:template_extension) { 'html.erb' }
+
+        it { expect(template_format).to eq 'text/html' }
+      end
+
+      context 'when handler, format and version are present' do
+        let(:template_extension) { 'json.v1.jbuilder' }
+
+        it { expect(template_format).to eq 'application/json' }
+      end
+
+      context 'when handler, format and locale are present' do
+        let(:template_extension) { 'en.json.jbuilder' }
+
+        it { expect(template_format).to eq 'application/json' }
+      end
+
+      context 'when handler, format, locale and version are present' do
+        let(:template_extension) { 'en.json.v1.jbuilder' }
+
+        it { expect(template_format).to eq 'application/json' }
+      end
+
+      context 'when handler, format, variant and version are present' do
+        let(:template_extension) { 'application.json+tablet.v1.jbuilder' }
+
+        it { expect(template_format).to eq 'application/json' }
+      end
+    end
+  end
+end

data/spec/integration/view/view_additions_rails7_spec.rb

@@ -0,0 +1,76 @@
+require './spec/rails_helper'
+
+if ActionPack::VERSION::MAJOR == 7
+  describe ActionView::Resolver::PathParser do
+    let(:resolver) { ActionView::Resolver::PathParser.new }
+
+    context '#extract_handler_and_format' do
+      subject(:parsed_path) do
+        resolver.parse("application.#{template_extension}")
+      end
+
+      context 'when only handler and format are present' do
+        let(:template_extension) { 'html.erb' }
+
+        it do
+          expect(parsed_path.details.format).to eq :html
+          expect(parsed_path.details.handler).to eq :erb
+        end
+      end
+
+      context 'when handler, format and version are present' do
+        let(:template_extension) { 'json.v1.builder' }
+
+        it do
+          expect(parsed_path.details.format).to eq :json
+          expect(parsed_path.details.handler).to eq :builder
+          expect(parsed_path.details.version).to eq :v1
+        end
+      end
+
+      context 'when handler, format and locale are present' do
+        let(:template_extension) { 'en.json.builder' }
+
+        it do
+          expect(parsed_path.details.locale).to eq :en
+          expect(parsed_path.details.format).to eq :json
+          expect(parsed_path.details.handler).to eq :builder
+          expect(parsed_path.details.version).to eq nil
+        end
+      end
+
+      context 'when handler, format, locale and version are present' do
+        let(:template_extension) { 'en.json.v1.builder' }
+
+        it do
+          expect(parsed_path.details.format).to eq :json
+          expect(parsed_path.details.handler).to eq :builder
+          expect(parsed_path.details.version).to eq :v1
+        end
+      end
+
+      context 'when handler, format, variant and version are present' do
+        let(:template_extension) { 'json+tablet.v1.builder' }
+
+        it do
+          expect(parsed_path.details.variant).to eq :tablet
+          expect(parsed_path.details.format).to eq :json
+          expect(parsed_path.details.handler).to eq :builder
+          expect(parsed_path.details.version).to eq :v1
+        end
+      end
+
+      context 'when handler, format, variant, locale and version are present' do
+        let(:template_extension) { 'en.json+tablet.v1.builder' }
+
+        it do
+          expect(parsed_path.details.locale).to eq :en
+          expect(parsed_path.details.variant).to eq :tablet
+          expect(parsed_path.details.format).to eq :json
+          expect(parsed_path.details.handler).to eq :builder
+          expect(parsed_path.details.version).to eq :v1
+        end
+      end
+    end
+  end
+end

data/spec/unit/strategies/extraction_strategy_spec.rb

@@ -60,13 +60,13 @@ describe VersionCake::ExtractionStrategy do
   it "it fails to create a custom strategy for a proc with no parameters" do
     expect do
       VersionCake::ExtractionStrategy.lookup(lambda{})
-    end.to raise_error(Exception)
+    end.to raise_error(VersionCake::ExtractionStrategy::InvalidStrategyError)
   end
 
   it "it raises error when no strategy is found" do
     expect do
       VersionCake::ExtractionStrategy.lookup(:fake_extraction)
-    end.to raise_error(Exception)
+    end.to raise_error(VersionCake::ExtractionStrategy::InvalidStrategyError)
   end
 
   describe '.list' do

data/spec/unit/version_checker_spec.rb

@@ -10,7 +10,7 @@ describe VersionCake::VersionChecker do
   end
   let(:version) { }
   subject do
-    checker = VersionCake::VersionChecker.new(resource, version)
+    checker = VersionCake::VersionChecker.new(version, resource)
     checker.execute
   end
 

data/spec/unit/versioned_request_spec.rb

@@ -24,12 +24,5 @@ describe VersionCake::VersionedRequest do
       it { expect(versioned_request.version).to be_nil }
       it { expect(versioned_request.failed).to be_falsey }
     end
-
-    context 'with a strategy failure' do
-      let(:strategies) { [ lambda { raise 'Failed extraction' } ] }
-
-      it { expect(versioned_request.version).to be_nil }
-      it { expect(versioned_request.failed).to be_truthy }
-    end
   end
 end

data/versioncake.gemspec

@@ -19,14 +19,14 @@ Gem::Specification.new do |s|
 
   s.required_ruby_version = '>= 1.9.2'
 
-  s.add_dependency('actionpack',    '~> 5.0')
-  s.add_dependency('activesupport', '~> 5.0')
-  s.add_dependency('railties',      '~> 5.0')
-  s.add_dependency('tzinfo',        '~> 1.2')
+  s.add_dependency('actionpack',    '> 5.0')
+  s.add_dependency('activesupport', '> 5.0')
+  s.add_dependency('railties',      '> 5.0')
+  s.add_dependency('tzinfo',        '> 1.2')
 
   s.add_development_dependency 'appraisal', '~> 2.2'
   s.add_development_dependency 'coveralls', '~> 0.8'
-  s.add_development_dependency 'rake', '~> 13.0'
+  s.add_development_dependency 'rake', '> 12.0'
 
   s.add_development_dependency 'rspec', '~> 3.6'
   s.add_development_dependency 'rspec-rails', '~> 3.6'