rack-rewrite-dynamic 0.0.3 → 0.0.4

data/lib/rack/rewrite/dynamic/filter_rewrite.rb

@@ -8,36 +8,87 @@ module Rack
 
         def perform(match, rack_env)
           if !(match[1] =~ /assets/)
-            filter_parts = match[1].split(@opts[:separator])
-            if filter_parts.present?
-              slugs = filter_parts.map do |slug_candidate|
-                find_sluggable(slug_candidate)
+            filter_parts = parse_filter_parts(match)
+            build_return_path(filter_parts, rack_env)
+          else
+            original_path(rack_env)
+          end
+        end
+
+        private
+          def build_return_path(filter_parts, rack_env)
+            if filter_parts.length > 0
+              slugs = filter_parts.map do |candidate|
+                find_sluggable(candidate)
               end
+
+              filter_params = {}
               if !slugs.include?(nil)
-                filter_params = {}
                 slugs.each do |s|
-                  filter_params["#{s[:sluggable_type].underscore}_ids"] ||= []
-                  filter_params["#{s[:sluggable_type].underscore}_ids"] << s[:sluggable_id]
+                  add_filter_param(filter_params, s)
                 end
-                return "/#{@opts[:target]}?#{filter_params.to_query}"
               end
+
+              return "/#{@opts[:target]}?#{filter_params.to_query}" if filter_params.length > 0
             end
-          else
-            rack_env['REQUEST_URI'] || rack_env['PATH_INFO']
+            original_path(rack_env)
+          end
+
+          def parse_filter_parts(match)
+            slug_index = 0
+
+            @opts[:url_parts].map do |url_part|
+              if url_part.keys.include?(:static)
+                # :)
+              elsif url_part.keys.include?(:prefix) || url_part.keys.include?(:suffix)
+                slug_index += 1
+                if match[slug_index]
+                  match[slug_index].chomp(url_part[:separator])
+                end
+              elsif url_part.keys.include?(:groups)
+                if match[slug_index+1]
+                  slug_index += 1
+                  match[slug_index..-1].each_with_index.map { |slug_group, i| slug_group.split(url_part[:groups][i][:separator]) if slug_group }.flatten
+                end
+              end
+            end.flatten.compact
+          end
+
+          def add_filter_param(filter_params, slug)
+            filter_params["#{slug[:sluggable_type].underscore}_ids"] ||= []
+            filter_params["#{slug[:sluggable_type].underscore}_ids"] << slug[:sluggable_id]
+          end
+
+          def slug_group_matcher_string(groups)
+            groups.map do |group|
+              "(#{group[:prefix]}#{filter_string}#{group[:suffix]})?-?"
+            end.join
+          end
+
+          def slug_group_matcher(groups)
+            Regexp.new(slug_group_matcher_string(groups))
           end
-        end
 
-        private
           def build_match_string
-            match_string = '^'
-            match_string << "#{@opts[:prefix]}" if @opts[:prefix]
-            match_string << '\/' + "#{filter_string}"
-            match_string << "#{@opts[:separator]}#{@opts[:suffix]}" if @opts[:suffix] && @opts[:separator]
-            match_string << "\/?$"
-            match_string
+            match_string = '^\/'
+            match_string << @opts[:url_parts].map do |url_part|
+              if url_part.keys.include?(:static)
+                "(#{url_part[:static]})"
+              elsif url_part.keys.include?(:prefix) || url_part.keys.include?(:suffix)
+                "#{url_part[:prefix]}#{filter_string}#{('?' unless url_part[:required])}#{url_part[:separator]}?#{url_part[:suffix]}"
+              elsif url_part.keys.include?(:groups)
+                slug_group_matcher_string(url_part[:groups]).to_s
+              end + suburl_separator(url_part[:required])
+            end.join
+
+            match_string.chomp!(suburl_separator(true))
+            match_string.chomp(suburl_separator(false))
           end
           def filter_string
-            '([^\/]+)'
+            '(?<slug_groups>[^\/]+)'
+          end
+          def suburl_separator(required = false)
+            "\\/#{'?' unless required}"
           end
       end
     end

data/lib/rack/rewrite/dynamic/version.rb

@@ -1,7 +1,7 @@
 module Rack
   class Rewrite
     module Dynamic
-      VERSION = "0.0.3"
+      VERSION = "0.0.4"
     end
   end
 end

data/spec/rack/rewrite/dynamic/filter_rewrite_spec.rb

@@ -13,40 +13,97 @@ describe Rack::Rewrite::Dynamic::FilterRewrite do
     end
   end
 
-  let(:opts) do
-    {
-      separator: '-', target: 'outfits', suffix: 'outfits'
-    }
-  end
-  subject { Rack::Rewrite::Dynamic::FilterRewrite.new(opts) }
   let(:base) { mock(:base) }
+  let(:rack_env) { { 'REQUEST_URI' => 'some/path' } }
 
+  let(:opts) { {} }
+  subject { Rack::Rewrite::Dynamic::FilterRewrite.new(opts) }
   its(:opts) { should eq(opts) }
 
-  it 'should apply rewrite' do
-    base.should_receive(:rewrite)
-    subject.apply_rewrite(base)
+  it 'should return the original request if assets' do
+    match = ['', 'assets']
+    subject.perform(match, rack_env).should eq('some/path')
   end
 
-  describe '#perform' do
-    let(:match) { ['', 'filter_slug-outfits'] }
-    let(:rack_env) { { 'REQUEST_URI' => 'some/path' } }
-    it 'should perform rewrite' do
-      subject.stub(:find_sluggable) { { sluggable_type: 'color', sluggable_id: 42 } }
-      subject.perform(match, rack_env).should eq('/outfits?color_ids%5B%5D=42&color_ids%5B%5D=42')
+  context 'handle SEO urls like /slug1-slug2-outfits/red-green-colored-from-nike-and-red-mountain' do
+    let(:opts) do
+      {
+        target: 'outfits',
+        url_parts: [{suffix: 'outfits', separator: '-'},
+                    {
+                      groups: [
+                                {suffix: '-colored', separator: '-'},
+                                {prefix: 'from-', separator: '-and-'}
+                              ]
+                    }
+                   ]
+      }
     end
+    let(:match) { ['', 'business-', 'red-darkblue', 'nike-and-red-mountain'] }
 
-    it 'should return the original request if assets' do
-      match[1] = 'assets'
-      subject.perform(match, rack_env).should eq('some/path')
+    it 'should apply rewrite' do
+      base.should_receive(:rewrite).with(/^\/(?<slug_groups>[^\/]+)?-?outfits\/?((?<slug_groups>[^\/]+)-colored)?-?(from-(?<slug_groups>[^\/]+))?-?/, anything)
+      subject.apply_rewrite(base)
+    end
+
+    it 'should perform rewrite' do
+      subject.stub(:find_sluggable).with('business'){ { sluggable_type: 'outfit_category', sluggable_id: 42 } }
+      subject.stub(:find_sluggable).with('red'){ { sluggable_type: 'color', sluggable_id: 42 } }
+      subject.stub(:find_sluggable).with('darkblue'){ { sluggable_type: 'color', sluggable_id: 43 } }
+      subject.stub(:find_sluggable).with('nike'){ { sluggable_type: 'brand', sluggable_id: 42 } }
+      subject.stub(:find_sluggable).with('red-mountain'){ { sluggable_type: 'brand', sluggable_id: 43 } }
+
+      subject.perform(match, rack_env).should eq('/outfits?brand_ids%5B%5D=42&brand_ids%5B%5D=43&color_ids%5B%5D=42&color_ids%5B%5D=43&outfit_category_ids%5B%5D=42')
     end
 
     it 'should not return path if slug wasn not found' do
       subject.stub(:find_sluggable)
-      subject.perform(match, rack_env).should be_nil
+      subject.perform(match, rack_env).should eq('some/path')
     end
-
   end
 
+  context 'handle SEO urls like /fashion-items/slug1-slug2/red-green-colored-from-nike-or-red-mountain' do
+    let(:opts) do
+      {
+        target: 'products',
+        url_parts: [{static: 'fashion-items'},
+                    {suffix: '', separator: '-'},
+                    {
+                      groups: [
+                        {suffix: '-colored', separator: '-'},
+                        {prefix: 'from-', separator: '-or-'}
+                      ]
+                    }
+                   ]
+      }
+    end
+    let(:match) { ['', 'tops-shirts', 'blue-red-darkgray', 'nike-or-adidas'] }
+
+    before :each do
+      subject.stub(:find_sluggable).with('tops-shirts'){ { sluggable_type: 'product_category', sluggable_id: 42 } }
+      subject.stub(:find_sluggable).with('blue'){ { sluggable_type: 'color', sluggable_id: 42 } }
+      subject.stub(:find_sluggable).with('red'){ { sluggable_type: 'color', sluggable_id: 43 } }
+      subject.stub(:find_sluggable).with('darkgray'){ { sluggable_type: 'color', sluggable_id: 44 } }
+      subject.stub(:find_sluggable).with('nike'){ { sluggable_type: 'brand', sluggable_id: 42 } }
+      subject.stub(:find_sluggable).with('adidas'){ { sluggable_type: 'brand', sluggable_id: 43 } }
+    end
+
+    it 'should apply rewrite' do
+      base.should_receive(:rewrite).with(/^\/(fashion-items)\/?(?<slug_groups>[^\/]+)?-?\/?((?<slug_groups>[^\/]+)-colored)?-?(from-(?<slug_groups>[^\/]+))?-?/, anything)
+      subject.apply_rewrite(base)
+    end
+
+    it 'should perform the rewrite' do
+      subject.perform(match, rack_env).should eq('/products?brand_ids%5B%5D=42&brand_ids%5B%5D=43&color_ids%5B%5D=42&color_ids%5B%5D=43&color_ids%5B%5D=44&product_category_ids%5B%5D=42')
+    end
+
+    it 'should perform the rewrite even if some of the slug groups are missing' do
+      match = ['', 'tops-shirts', 'blue-red-darkgray']
+
+      subject.perform(match, rack_env).should eq('/products?color_ids%5B%5D=42&color_ids%5B%5D=43&color_ids%5B%5D=44&product_category_ids%5B%5D=42')
+    end
+
+
+  end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-rewrite-dynamic
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-18 00:00:00.000000000 Z
+date: 2013-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack-rewrite