versionist 0.3.1 → 1.0.0

data/lib/generators/versionist/copy_api_version/copy_api_version_generator.rb

@@ -151,6 +151,52 @@ module Versionist
       end
     end
 
+    def copy_helpers
+      in_root do
+        if File.exists? "app/helpers/#{module_name_for_path(old_module_name)}"
+          log "Copying all files from app/helpers/#{module_name_for_path(old_module_name)} to app/helpers/#{module_name_for_path(new_module_name)}"
+          FileUtils.cp_r "app/helpers/#{module_name_for_path(old_module_name)}", "app/helpers/#{module_name_for_path(new_module_name)}"
+          Dir.glob("app/helpers/#{module_name_for_path(new_module_name)}/*.rb").each do |f|
+            text = File.read(f)
+            File.open(f, 'w') {|f| f << text.gsub(/#{old_module_name}/, new_module_name)}
+          end
+        else
+          say "No helpers found in app/helpers for #{old_version}"
+        end
+      end
+    end
+
+    def copy_helper_tests
+      in_root do
+        case Versionist.configuration.configured_test_framework
+        when :test_unit
+          if File.exists? "test/helpers/#{module_name_for_path(old_module_name)}"
+            log "Copying all files from test/helpers/#{module_name_for_path(old_module_name)} to test/helpers/#{module_name_for_path(new_module_name)}"
+            FileUtils.cp_r "test/helpers/#{module_name_for_path(old_module_name)}", "test/helpers/#{module_name_for_path(new_module_name)}"
+            Dir.glob("test/helpers/#{module_name_for_path(new_module_name)}/*.rb").each do |f|
+              text = File.read(f)
+              File.open(f, 'w') {|f| f << text.gsub(/#{old_module_name}/, new_module_name)}
+            end
+          else
+            say "No helper tests found in test/helpers for #{old_version}"
+          end
+        when :rspec
+          if File.exists? "spec/helpers/#{module_name_for_path(old_module_name)}"
+            log "Copying all files from spec/helpers/#{module_name_for_path(old_module_name)} to spec/helpers/#{module_name_for_path(new_module_name)}"
+            FileUtils.cp_r "spec/helpers/#{module_name_for_path(old_module_name)}", "spec/helpers/#{module_name_for_path(new_module_name)}"
+            Dir.glob("spec/helpers/#{module_name_for_path(new_module_name)}/*.rb").each do |f|
+              text = File.read(f)
+              File.open(f, 'w') {|f| f << text.gsub(/#{old_module_name}/, new_module_name)}
+            end
+          else
+            say "No helper specs found in spec/helpers for #{old_version}"
+          end
+        else
+          say "Unsupported test_framework: #{Versionist.configuration.configured_test_framework}"
+        end
+      end
+    end
+
     def copy_documentation
       in_root do
         if File.exists? "public/docs/#{old_version}"

data/lib/generators/versionist/new_api_version/new_api_version_generator.rb

@@ -8,15 +8,47 @@ module Versionist
 
     argument :version, :type => :string
     argument :module_name, :type => :string
-    argument :versioning_strategy, :banner => "VERSIONING_STRATEGY_OPTIONS", :type => :hash
+    class_option :default, :type => :boolean
+    class_option :header, :type => :hash, :group => :header
+    class_option :parameter, :type => :hash, :group => :parameter
+    class_option :path, :type => :hash, :group => :path
+    class_option :defaults, :type => :hash, :group => :defaults
+
+
+    def verify_options
+      raise "Must specify at least one versioning strategy option" if !['header', 'parameter', 'path'].any? {|strategy| options.has_key?(strategy)}
+      if options.has_key?("header")
+        raise "Must specify name and value for header versioning strategy" if !options["header"].has_key?("name") || !options["header"].has_key?("value")
+      end
+      if options.has_key?("parameter")
+        raise "Must specify name and value for parameter versioning strategy" if !options["parameter"].has_key?("name") || !options["parameter"].has_key?("value")
+      end
+      if options.has_key?("path")
+        raise "Must specify value for path versioning strategy" if !options["path"].has_key?("value")
+      end
+    end
 
     def add_routes
       in_root do
         api_version_block = /api_version.*:module\s*(=>|:)\s*("|')#{module_name_for_route(module_name)}("|')/
         matching_version_blocks = File.readlines("config/routes.rb").grep(api_version_block)
         raise "API version already exists in config/routes.rb" if !matching_version_blocks.empty?
-        versioning_strategy.symbolize_keys!
-        route "api_version(:module => \"#{module_name_for_route(module_name)}\", #{versioning_strategy.to_s.gsub(/[\{\}]/, '')}) do\n  end"
+        route_string = "api_version(:module => \"#{module_name_for_route(module_name)}\""
+        ['header', 'parameter', 'path'].each do |versioning_strategy|
+          if options.has_key?(versioning_strategy)
+            options[versioning_strategy].symbolize_keys!
+            route_string << ", :#{versioning_strategy} => {#{options[versioning_strategy].to_s.gsub(/[\{\}]/, '').gsub('=>', ' => ')}}"
+          end
+        end
+        if options.has_key?('defaults')
+          options['defaults'].symbolize_keys!
+          route_string << ", :defaults => {#{options['defaults'].to_s.gsub(/[\{\}]/, '').gsub('=>', ' => ')}}"
+        end
+        if options.has_key?('default')
+          route_string << ", :default => true"
+        end
+        route_string << ") do\n  end"
+        route route_string
       end
     end
 
@@ -69,6 +101,25 @@ module Versionist
       end
     end
 
+    def add_helpers_dir
+      in_root do
+        empty_directory "app/helpers/#{module_name_for_path(module_name)}"
+      end
+    end
+
+    def add_helpers_test_dir
+      in_root do
+        case Versionist.configuration.configured_test_framework
+        when :test_unit
+          empty_directory "test/helpers/#{module_name_for_path(module_name)}"
+        when :rspec
+          empty_directory "spec/helpers/#{module_name_for_path(module_name)}"
+        else
+          say "Unsupported test_framework: #{Versionist.configuration.configured_test_framework}"
+        end
+      end
+    end
+
     def add_documentation_base
       in_root do
         empty_directory "public/docs/#{version}"

data/lib/versionist/configuration.rb

@@ -4,12 +4,14 @@ module Versionist
     attr_accessor :default_version
     attr_accessor :header_versions
     attr_accessor :parameter_versions
+    attr_accessor :path_versions
     attr_accessor :configured_test_framework
 
     def initialize
       @versioning_strategies ||= Array.new
       @header_versions ||= Array.new
       @parameter_versions ||= Array.new
+      @path_versions ||= Array.new
     end
 
     def clear!
@@ -17,6 +19,7 @@ module Versionist
       @default_version = nil
       @header_versions.clear
       @parameter_versions.clear
+      @path_versions.clear
     end
   end
 end

data/lib/versionist/middleware.rb

@@ -19,13 +19,16 @@ module Versionist
 
     def _call(env)
       request = ::Rack::Request.new(env)
-      strategy = Versionist.configuration.versioning_strategies.detect {|vs| vs.is_a?(Versionist::VersioningStrategy::Header) && vs.config[:header] == ACCEPT && env[HTTP_ACCEPT].try(:include?, vs.config[:value])}
+      potential_matches = Versionist.configuration.header_versions.select {|hv| hv.config[:header][:name] == ACCEPT && env[HTTP_ACCEPT].try(:include?, hv.config[:header][:value])}
+      if !potential_matches.empty?
+        strategy = potential_matches.max {|a,b| a.config[:header][:value].length <=> b.config[:header][:value].length}
+      end
       if !strategy.nil?
         entries = env[HTTP_ACCEPT].split(',')
         index = -1
         entries.each_with_index do |e, i|
           e.strip!
-          index = i if e == strategy.config[:value]
+          index = i if e == strategy.config[:header][:value]
         end
         if (index != -1)
           version = entries.delete_at(index)

data/lib/versionist/routing.rb

@@ -1,25 +1,37 @@
+require 'active_support/core_ext/hash/keys'
+
 module Versionist
   module Routing
     # Allows you to constrain routes to specific versions of your api using versioning strategies.
     # Supported formats:
-    # api_version(:module => "v1", :header => "Accept", :value => "application/vnd.mycompany.com-v1")
-    # api_version(:module => "v2__3__4", :path => "/v2.3.4")
-    # api_version(:module => "v20120317", :parameter => "version", :value => "v20120317")
+    #
+    # HTTP Header
+    # api_version(:module => "V1", :header => {:name => "Accept", :value => "application/vnd.mycompany.com; version=1"}})
+    #
+    # Path
+    # api_version(:module => "V1", :path => {:value => "v1"}})
+    #
+    # Request Parameter
+    # api_version(:module => "V1", :parameter => {:name => "version", :value => "1"}})
     #
     # Specifying default version:
-    # api_version(:module => "v3__0__0", :header => "API-VERSION", :value => "v3.0.0", :default => true)
+    # api_version(:module => "V1", :default => true, :header => {:name => "Accept", :value => "application/vnd.mycompany.com; version=1"}})
+    #
+    # Multiple Strategies per version
+    # api_version(:module => "V1", :header => {:name => "Accept", :value => "application/vnd.mycompany.com; version=1"}, :path => {:value => "v1"})
     def api_version(config, &block)
       raise ArgumentError, "you must pass a configuration Hash to api_version" if config.nil? || !config.is_a?(Hash)
-      raise ArgumentError, "you must specify :module in configuration Hash passed to api_version" if !config.has_key?(:module)
+      config.symbolize_keys!
       raise ArgumentError, "you must specify :header, :path, or :parameter in configuration Hash passed to api_version" if !config.has_key?(:header) && !config.has_key?(:path) && !config.has_key?(:parameter)
-      raise ArgumentError, ":defaults must be a Hash" if config.has_key?(:defaults) && !config[:defaults].is_a?(Hash)
-      if config.has_key?(:header)
-        return configure_header(config, &block)
-      elsif config.has_key?(:path)
-        return configure_path(config, &block)
-      elsif config.has_key?(:parameter)
-        configure_parameter(config, &block)
+      [:header, :path, :parameter].each do |s|
+        raise ArgumentError, "#{s} key in configuration Hash passed to api_version must point to a Hash" if config.has_key?(s) && !config[s].is_a?(Hash)
       end
+      raise ArgumentError, "you must specify :module in configuration Hash passed to api_version" if !config.has_key?(:module)
+      raise ArgumentError, ":defaults must be a Hash" if config.has_key?(:defaults) && !config[:defaults].is_a?(Hash)
+      configure_header(config, &block) if config.has_key?(:header)
+      configure_path(config, &block) if config.has_key?(:path)
+      configure_parameter(config, &block) if config.has_key?(:parameter)
+      configure_default(config, &block) if config.has_key?(:default) && config[:default]
     end
 
 
@@ -33,16 +45,13 @@ module Versionist
     end
 
     def configure_path(config, &block)
-      config[:path].slice!(0) if config[:path] =~ /^\//
+      config[:path][:value].slice!(0) if config[:path][:value] =~ /^\//
       path = Versionist::VersioningStrategy::Path.new(config)
       # Use the :as option and strip out non-word characters from the path to avoid this:
       # https://github.com/rails/rails/issues/3224
-      route_hash = {:module => config[:module], :as => config[:path].gsub(/\W/, '_')}
+      route_hash = {:module => config[:module], :as => config[:path][:value].gsub(/\W/, '_')}
       route_hash.merge!({:defaults => config[:defaults]}) if config.has_key?(:defaults)
-      namespace(config[:path], route_hash, &block)
-      if path.default?
-        scope(route_hash, &block)
-      end
+      namespace(config[:path][:value], route_hash, &block)
     end
 
     def configure_parameter(config, &block)
@@ -51,5 +60,12 @@ module Versionist
       route_hash.merge!({:defaults => config[:defaults]}) if config.has_key?(:defaults)
       scope(route_hash, &block)
     end
+
+    def configure_default(config, &block)
+      default = Versionist::VersioningStrategy::Default.new(config)
+      route_hash = {:module => config[:module], :constraints => default}
+      route_hash.merge!({:defaults => config[:defaults]}) if config.has_key?(:defaults)
+      scope(route_hash, &block)
+    end
   end
 end

data/lib/versionist/version.rb

@@ -1,3 +1,3 @@
 module Versionist
-  VERSION = '0.3.1'
+  VERSION = '1.0.0'
 end

data/lib/versionist/versioning_strategy/base.rb

@@ -4,31 +4,17 @@ module Versionist
   module VersioningStrategy
     class Base
       attr_reader :config
-      attr_reader :default
 
       def initialize(config={})
         raise ArgumentError, "you must pass a configuration Hash" if config.nil? || !config.is_a?(Hash)
         @config = config
         @config.symbolize_keys!
-        if @config.has_key?(:default)
-          @default = true
-        else
-          @default = false
-        end
-        if !Versionist.configuration.versioning_strategies.include?(self)
-          raise ArgumentError, "[VERSIONIST] attempt to set more than one default api version" if !Versionist.configuration.default_version.nil? && self.default? && Versionist.configuration.default_version != self
-          Versionist.configuration.versioning_strategies << self
-          Versionist.configuration.default_version = self if self.default?
-        end
-      end
-
-      def default?
-        @default
+        Versionist.configuration.versioning_strategies << self if !Versionist.configuration.versioning_strategies.include?(self)
       end
 
       def ==(other)
         return false if other.nil? || !other.is_a?(Versionist::VersioningStrategy::Base)
-        return self.config == other.config && self.default? == other.default?
+        return self.config == other.config
       end
     end
   end

data/lib/versionist/versioning_strategy/default.rb

@@ -0,0 +1,37 @@
+module Versionist
+  module VersioningStrategy
+    # Implements the default version handling strategy.
+    class Default < Base
+      attr_accessor :strategies
+      attr_accessor :module
+
+      def initialize(config)
+        super
+        @module = config[:module]
+        raise ArgumentError, "[VERSIONIST] attempt to set more than one default api version" if !Versionist.configuration.default_version.nil? && Versionist.configuration.default_version != self
+        Versionist.configuration.default_version = self
+      end
+
+      def matches?(request)
+        !header_matches?(request) && !parameter_matches?(request)
+      end
+
+      def ==(other)
+        super
+        return false if !other.is_a?(Versionist::VersioningStrategy::Default)
+        return self.module == other.module
+      end
+
+
+      private
+
+      def header_matches?(request)
+        Versionist.configuration.header_versions && Versionist.configuration.header_versions.any? {|v| v.matches?(request)}
+      end
+
+      def parameter_matches?(request)
+        Versionist.configuration.parameter_versions && Versionist.configuration.parameter_versions.any? {|v| v.matches?(request)}
+      end
+    end
+  end
+end

data/lib/versionist/versioning_strategy/header.rb

@@ -4,25 +4,38 @@ module Versionist
     class Header < Base
 
       # Creates a new Header VersioningStrategy object. config must contain the following keys:
-      # - :header the header to inspect
-      # - :value the value of the header specifying the version
+      # - :header the header hash to inspect
       def initialize(config)
         super
-        raise ArgumentError, "you must specify :header in the configuration Hash" if !config.has_key?(:header)
-        raise ArgumentError, "you must specify :value in the configuration Hash" if !config.has_key?(:value)
-        Versionist.configuration.header_versions << config[:value]
+        raise ArgumentError, "you must specify :name in the :header configuration Hash" if !config[:header].has_key?(:name)
+        raise ArgumentError, "you must specify :value in the :header configuration Hash" if !config[:header].has_key?(:value)
+        Versionist.configuration.header_versions << self if !Versionist.configuration.header_versions.include?(self)
       end
 
       def matches?(request)
-        header_string = request.headers[config[:header]].to_s
-        return ((!header_string.blank? && header_string.include?(config[:value])) ||
-                (self.default? && (Versionist.configuration.header_versions.none? {|v| header_string.include?(v)})))
+        header_string = request.headers[config[:header][:name]].to_s
+        if !header_string.blank?
+          potential_matches = Versionist.configuration.header_versions.select {|hv| header_string.include?(hv.config[:header][:value])}
+          if !potential_matches.empty?
+            if potential_matches.include?(self)
+              if potential_matches.size == 1
+                return true
+              else
+                # when finding multiple potential matches, the match with the longest value wins
+                #  (i.e. v2.1 trumps v2), as one is a subset of the other
+                longest = potential_matches.max {|a,b| a.config[:header][:value].length <=> b.config[:header][:value].length}
+                return longest == self
+              end
+            end
+          end
+        end
+        false
       end
 
       def ==(other)
         super
         return false if !other.is_a?(Versionist::VersioningStrategy::Header)
-        return config[:header] == other.config[:header] && self.config[:value] == other.config[:value]
+        return config[:header][:name] == other.config[:header][:name] && self.config[:header][:value] == other.config[:header][:value]
       end
     end
   end

data/lib/versionist/versioning_strategy/parameter.rb

@@ -4,25 +4,23 @@ module Versionist
     class Parameter < Base
 
       # Creates a new Parameter VersioningStrategy object. config must contain the following keys:
-      # - :parameter the parameter to inspect
-      # - :value the value of the parameter specifying the version
+      # - :parameter the parameter hash to inspect
       def initialize(config)
         super
-        raise ArgumentError, "you must specify :parameter in the configuration Hash" if !config.has_key?(:parameter)
-        raise ArgumentError, "you must specify :value in the configuration Hash" if !config.has_key?(:value)
-        Versionist.configuration.parameter_versions << config[:value]
+        raise ArgumentError, "you must specify :name in the :parameter configuration Hash" if !config[:parameter].has_key?(:name)
+        raise ArgumentError, "you must specify :value in the :parameter configuration Hash" if !config[:parameter].has_key?(:value)
+        Versionist.configuration.parameter_versions << self if !Versionist.configuration.parameter_versions.include?(self)
       end
 
       def matches?(request)
-        parameter_string = request.params[config[:parameter]].to_s
-        return ((!parameter_string.blank? && parameter_string == config[:value]) ||
-                (self.default? && (Versionist.configuration.parameter_versions.none? {|v| parameter_string.include?(v)})))
+        parameter_string = request.params[config[:parameter][:name]].to_s
+        return !parameter_string.blank? && parameter_string == config[:parameter][:value]
       end
 
       def ==(other)
         super
         return false if !other.is_a?(Versionist::VersioningStrategy::Parameter)
-        return config[:parameter] == other.config[:parameter] && self.config[:value] == other.config[:value]
+        return config[:parameter][:name] == other.config[:parameter][:name] && self.config[:parameter][:value] == other.config[:parameter][:value]
       end
     end
   end

data/lib/versionist/versioning_strategy/path.rb

@@ -8,13 +8,14 @@ module Versionist
       # - :path the path prefix containing the version
       def initialize(config)
         super
-        raise ArgumentError, "you must specify :path in the configuration Hash" if !config.has_key?(:path)
+        raise ArgumentError, "you must specify :value in the :path configuration Hash" if !config[:path].has_key?(:value)
+        Versionist.configuration.path_versions << self if !Versionist.configuration.path_versions.include?(self)
       end
 
       def ==(other)
         super
         return false if !other.is_a?(Versionist::VersioningStrategy::Path)
-        return config[:path] == other.config[:path]
+        return config[:path][:value] == other.config[:path][:value]
       end
     end
   end

data/lib/versionist/versioning_strategy.rb

@@ -6,5 +6,6 @@ module Versionist
     autoload :Header, 'versionist/versioning_strategy/header'
     autoload :Path, 'versionist/versioning_strategy/path'
     autoload :Parameter, 'versionist/versioning_strategy/parameter'
+    autoload :Default, 'versionist/versioning_strategy/default'
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: versionist
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.3.1
+  version: 1.0.0
 platform: ruby
 authors: 
 - Brian Ploetz
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-07-27 00:00:00 Z
+date: 2013-01-23 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rails
@@ -34,7 +34,7 @@ dependencies:
         version: "0.7"
   type: :runtime
   version_requirements: *id002
-description: A plugin for versioning Rails 3 based RESTful APIs.
+description: A plugin for versioning Rails based RESTful APIs.
 email: 
 executables: []
 
@@ -74,6 +74,7 @@ files:
 - lib/versionist/routing.rb
 - lib/versionist/version.rb
 - lib/versionist/versioning_strategy/base.rb
+- lib/versionist/versioning_strategy/default.rb
 - lib/versionist/versioning_strategy/header.rb
 - lib/versionist/versioning_strategy/parameter.rb
 - lib/versionist/versioning_strategy/path.rb
@@ -102,10 +103,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.8.17
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: versionist-0.3.1
+summary: versionist-1.0.0
 test_files: []
 
 has_rdoc: