slugable 0.0.4 → 1.0.0

data/lib/slugable/version.rb

@@ -1,3 +1,3 @@
 module Slugable
-  VERSION = "0.0.4"
+  VERSION = '1.0.0'
 end

data/slugable.gemspec

@@ -4,25 +4,27 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'slugable/version'
 
 Gem::Specification.new do |gem|
-  gem.name          = "slugable"
+  gem.name          = 'slugable'
   gem.version       = Slugable::VERSION
-  gem.authors       = ["Miroslav Hettes"]
-  gem.email         = ["hettes@webynamieru.sk"]
+  gem.authors       = ['Miroslav Hettes']
+  gem.email         = ['hettes@webynamieru.sk']
   gem.description   = %q{Add dsl method for automatic storing seo friendly url in database column}
   gem.summary       = %q{Storing seo friendly url in column}
-  gem.homepage      = "https://github.com/mirrec/slugable"
+  gem.homepage      = 'https://github.com/mirrec/slugable'
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  gem.require_paths = ['lib']
 
-  gem.add_runtime_dependency "activerecord", ">= 3.0"
-  gem.add_runtime_dependency "activesupport", ">= 3.0"
-  gem.add_runtime_dependency "wnm_support", "~> 0.0.4"
+  gem.add_runtime_dependency 'activerecord', '>= 3.0', '< 5.0'
 
-  gem.add_development_dependency "rspec", "~> 2.11.0"
-  gem.add_development_dependency "rake", "~> 0.9.2.2"
-  gem.add_development_dependency "sqlite3", "~> 1.3.6"
-  gem.add_development_dependency "ancestry", "~> 1.3.0"
+  gem.add_development_dependency 'appraisal', '~> 2.1.0'
+  gem.add_development_dependency 'rspec', '~> 3.4.0'
+  gem.add_development_dependency 'rake', '~> 0.9.2.2'
+  gem.add_development_dependency 'sqlite3', '~> 1.3.11'
+  gem.add_development_dependency 'ancestry', '>= 1.3.0', '< 3.0'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'codeclimate-test-reporter'
 end

data/spec/slugable/cache_layer_spec.rb

@@ -0,0 +1,35 @@
+require 'slugable/cache_layer'
+require 'active_support/core_ext/string/inflections'
+
+describe Slugable::CacheLayer do
+  MyModel = Class.new
+
+  let(:model) { MyModel }
+  let(:cache_storage) { double(:cache_storage) }
+
+  subject { Slugable::CacheLayer.new(cache_storage, model) }
+
+  describe '#read_slug' do
+    it 'use fetch for reading value for slug from cache storage' do
+      allow(cache_storage).to receive(:fetch).with('my_model/slug_column/1').and_return('hello')
+
+      expect(subject.read_slug(:slug_column, 1)).to eq 'hello'
+    end
+
+    it 'passes block that will be executed if cache storage does not have given value yet' do
+      allow(model).to receive(:find).with(1).and_return(double(:record, slug_column: 'hello'))
+
+      allow(cache_storage).to receive(:fetch).with('my_model/slug_column/1').and_yield
+
+      expect(subject.read_slug(:slug_column, 1)).to eq 'hello'
+    end
+  end
+
+  describe '#update' do
+    it 'writes new value to cache storage' do
+      expect(cache_storage).to receive(:write).with('my_model/slug_column/1', 'hello')
+
+      subject.update(:slug_column, 1, 'hello')
+    end
+  end
+end

data/spec/slugable/has_slug_spec.rb

@@ -1,280 +1,217 @@
-require "spec_helper"
+require 'spec_helper'
+require 'support/hash_cache_storage'
 
-ActiveRecord::Base.send :extend, Slugable::HasSlug
+hash_cache_storage = HashCacheStorage.new
 
-class Item < ActiveRecord::Base
-  attr_accessible :name, :slug
-
-  has_slug
-end
-
-class Page < ActiveRecord::Base
-  attr_accessible :title, :seo_url
-
-  has_slug :from => :title, :to => :seo_url
-end
-
-class Category < ActiveRecord::Base
-  attr_accessible :name, :slug
-
-  has_ancestry
-  has_slug
-end
-
-class TreeItem < ActiveRecord::Base
-  attr_accessible :name, :slug
-
-  has_ancestry
-  has_slug :cache_tree => false
-end
-
-class Product < ActiveRecord::Base
-  attr_accessible :name, :slug
-
-  has_slug :formatter => :my_formatter
+Slugable.configure do |config|
+  config.tree_cache_storage = hash_cache_storage
 end
 
+require 'support/set_up_models'
 
 describe Slugable::HasSlug do
   before(:each) do
-    Category.clear_cached_slugs
+    hash_cache_storage.clear
   end
 
-  context "default options" do
-    it "should create fill_slug_from_name_to_slug" do
-      Item.new.should respond_to :fill_slug_from_name_to_slug
-    end
-
-    it "should create format_slug_from_name_to_slug" do
-      Item.new.should respond_to :format_slug_from_name_to_slug
-    end
-
-    it "should fill in slug parameter from attribute name and parametrize it" do
-      name = "my name is"
-      name.should_receive(:parameterize).and_return("my-name-is")
-
-      item = Item.create!(:name => name)
-      item.slug.should eq "my-name-is"
-    end
-
-    it "should fill in slug from attribute name if parameterize version of slug is blank" do
-      item = Item.create!(:name => "my name is", :slug => "/")
-      item.slug.should eq "my-name-is"
+  context 'method definitions' do
+    context 'default options' do
+      it 'creates all needed methods for slug' do
+        record = FlatItem.new
+        expect(record).to respond_to :slug_builder_for_slug
+        expect(record).to respond_to :prepare_slug_in_slug
+        expect(record).to respond_to :to_slug
+        expect(record).to respond_to :to_slug_was
+        expect(record).to respond_to :to_slug_will
+      end
     end
 
-    it "should only parametrize slug attribute if slug is present" do
-      item = Item.create!(:name => "my name is", :slug => "my url")
-      item.slug.should eq "my-url"
+    context 'option with cache' do
+      it 'creates method that updates cache' do
+        record = TreeItem.new
+        expect(record).to respond_to :update_my_slug_cache
+      end
     end
   end
 
-  context "given options" do
-    it "should create fill_slug_from_title_to_seo_url" do
-      Page.new.should respond_to :fill_slug_from_title_to_seo_url
-    end
+  context 'callbacks' do
+    context 'default options' do
+      it 'fills in slug parameter from attribute apply a parameterize format to it' do
+        name = 'my name is'
 
-    it "should create format_slug_from_title_to_seo_url" do
-      Page.new.should respond_to :format_slug_from_title_to_seo_url
-    end
-
-    it "should fill in slug parameter from attribute title and parametrize it" do
-      page = Page.create!(:title => "my name is")
-      page.seo_url.should eq "my-name-is"
-    end
+        item = FlatItem.create!(name: name)
+        expect(item.slug).to eq 'my-name-is'
+      end
 
-    it "should fill in slug parameter from attribute title if parameterize version of slug is blank" do
-      page = Page.create!(:title => "my name is", :seo_url => "/")
-      page.seo_url.should eq "my-name-is"
-    end
+      it 'fills in slug from attribute name if parameterize version of slug is blank' do
+        item = FlatItem.create!(name: 'my name is', slug: '')
+        expect(item.slug).to eq 'my-name-is'
+      end
 
-    it "should only parametrize slug attribute if slug is present" do
-      page = Page.create!(:title => "my name is", :seo_url => "my url")
-      page.seo_url.should eq "my-url"
+      it 'does not change slug attribute if slug is present' do
+        item = FlatItem.create!(name: 'my name is', slug: 'my url')
+        expect(item.slug).to eq 'my-url'
+      end
     end
 
-    it "should be able to change parameterize method" do
-      name = "product"
-      name.should_receive(:my_formatter).and_return("hello")
-      product = Product.create!(:name => "my name is", :slug => name)
-      product.slug.should eq "hello"
-    end
+    context 'given options' do
+      it 'creates fill_slug_from_title_to_seo_url' do
+        expect(FlatPage.new).to respond_to :prepare_slug_in_seo_url
+      end
 
-    it "should be able to disable tree caching" do
-      tree_item = TreeItem.create!(:name => "my name is", :parent => TreeItem.create!(:name => "root"))
-      tree_item.should_receive(:path).and_return([])
-      tree_item.to_slug
-      tree_item.should_receive(:path).and_return([])
-      tree_item.to_slug
+      it 'fills in slug parameter from attribute title and parametrize it' do
+        page = FlatPage.create!(title: 'my name is')
+        expect(page.seo_url).to eq 'my-name-is'
+      end
 
-      tree_item = Category.create!(:name => "my name is", :parent => Category.create!(:name => "root"))
-      tree_item.should_not_receive(:path)
-      tree_item.to_slug
+      it 'fills in slug parameter and use custom formatter' do
+        product = FlatProduct.create!(name: 'my name is', slug: 'product')
+        expect(product.slug).to eq 'hello-all-the-time'
+      end
     end
   end
 
-  describe "to_slug" do
-    context "default options" do
-      it "should define method to_seo_url" do
-        Item.new.should respond_to :to_slug
+  describe '#to_slug' do
+    context 'default options' do
+      it 'defines to_slug method' do
+        expect(FlatItem.new).to respond_to :to_slug
       end
 
-      it "should return slug in string" do
-        item = Item.create!(:name => "my name is", :slug => "my-url")
-        item.to_slug.should eq "my-url"
+      it 'returns slug in string' do
+        item = FlatItem.create!(name: 'my name is', slug: 'my-url')
+        expect(item.to_slug).to eq 'my-url'
       end
     end
 
-    context "given options" do
-      it "should define method to_seo_url" do
-        Page.new.should respond_to :to_seo_url
+    context 'given options' do
+      it 'defines method to_seo_url' do
+        expect(FlatPage.new).to respond_to :to_seo_url
       end
 
-      it "should return slug in string" do
-        page = Page.create!(:title => "my name is", :seo_url => "my-url")
-        page.to_seo_url.should eq "my-url"
+      it 'returns slug in string' do
+        page = FlatPage.create!(title: 'my name is', seo_url: 'my-url')
+        expect(page.to_seo_url).to eq 'my-url'
+      end
+
+      it 'returns result from custom to_slug_builder' do
+        news = FlatNews.create!(name: 'news')
+        expect(news.to_slug).to eq "to_slug_#{news.id}"
       end
     end
 
-    context "ancestry model" do
-      it "should return array of slugs" do
-        root = Category.create!(:name => "root", :slug => "root")
-        child = Category.new(:name => "child", :slug => "child")
+    context 'tree models' do
+      it 'returns array of slugs' do
+        root = TreeCategory.create!(name: 'root', slug: 'root')
+        child = TreeCategory.new(name: 'child', slug: 'child')
         child.parent = root
         child.save!
 
-        child.to_slug.should eq ["root", "child"]
+        expect(child.to_slug).to eq ['root', 'child']
       end
 
-      it "should skip nil values from slug path" do
-        root = Category.create!(:name => "root", :slug => "root")
-        child = Category.new(:name => "child", :slug => "child")
+      it 'skips nil values from slug path' do
+        root = TreeCategory.create!(name: 'root', slug: 'root')
+        child = TreeCategory.new(name: 'child', slug: 'child')
         child.parent = root
         child.save!
 
-        Category.update_all({:slug => nil}, {:id => root.id})
-        Category.clear_cached_slugs
+        TreeCategory.where(id: root.id).update_all(slug: nil)
+        hash_cache_storage.clear
+
+        expect(child.to_slug).to eq ['child']
+      end
 
-        child.to_slug.should eq ["child"]
+      it 'returns correct results also with caching support' do
+        child = TreeItem.create!(slug: 'child', parent: TreeItem.create!(slug: 'root'))
+        expect(child.to_slug).to eq ['root', 'child']
+        expect(child.to_slug).to eq ['root', 'child']
       end
     end
   end
 
-  describe "to_slug_was" do
-    context "default options" do
-      it "should define method to_slug_was" do
-        Item.new.should respond_to :to_slug_was
+  describe '#to_slug_was' do
+    context 'default options' do
+      it 'defines method to_slug_was' do
+        expect(FlatItem.new).to respond_to :to_slug_was
       end
 
-      it "should return old slug in string" do
-        item = Item.create!(:name => "my name is", :slug => "my-url")
-        item.slug = "new-slug"
-        item.to_slug_was.should eq "my-url"
+      it 'returns old slug in string' do
+        item = FlatItem.create!(name: 'my name is', slug: 'my-url')
+        item.slug = 'new-slug'
+        expect(item.to_slug_was).to eq 'my-url'
       end
     end
 
-    context "given options" do
-      it "should define method to_seo_url_was" do
-        Page.new.should respond_to :to_seo_url_was
+    context 'given options' do
+      it 'defines method to_seo_url_was' do
+        expect(FlatPage.new).to respond_to :to_seo_url_was
       end
 
-      it "should return future slug in string" do
-        page = Page.create!(:title => "my name is", :seo_url => "my-url")
-        page.seo_url = "hello-world"
-        page.to_seo_url_was.should eq "my-url"
+      it 'returns future slug in string' do
+        page = FlatPage.create!(title: 'my name is', seo_url: 'my-url')
+        page.seo_url = 'hello-world'
+        expect(page.to_seo_url_was).to eq 'my-url'
+      end
+
+      it 'returns result from custom to_slug_builder' do
+        news = FlatNews.create!(name: 'news')
+        expect(news.to_slug_was).to eq "to_slug_was_#{news.id}"
       end
     end
 
-    context "ancestry model" do
-      it "should return array of old slugs" do
-        root = Category.create!(:name => "root", :slug => "root")
-        child = Category.new(:name => "child", :slug => "child")
+    context 'tree models' do
+      it 'returns array of old slugs' do
+        root = TreeCategory.create!(name: 'root', slug: 'root')
+        child = TreeCategory.new(name: 'child', slug: 'child')
         child.save!
 
         child.parent = root
-        child.slug = "moved"
-        child.to_slug_was.should eq ["child"]
+        child.slug = 'moved'
+        expect(child.to_slug_was).to eq ['child']
       end
     end
   end
 
-  describe "to_slug_will" do
-    context "default options" do
-      it "should define method to_slug_will" do
-        Item.new.should respond_to :to_slug_will
+  describe '#to_slug_will' do
+    context 'default options' do
+      it 'defines method to_slug_will' do
+        expect(FlatItem.new).to respond_to :to_slug_will
       end
 
-      it "should return future slug in string" do
-        item = Item.create!(:name => "my name is", :slug => "my-url")
-        item.slug = "new slug"
-        item.to_slug_will.should eq "new-slug"
+      it 'returns future slug in string' do
+        item = FlatItem.create!(name: 'my name is', slug: 'my-url')
+        item.slug = 'new slug'
+        expect(item.to_slug_will).to eq 'new-slug'
       end
     end
 
-    context "given options" do
-      it "should define method to_seo_url_will" do
-        Page.new.should respond_to :to_seo_url_will
+    context 'given options' do
+      it 'defines method to_seo_url_will' do
+        expect(FlatPage.new).to respond_to :to_seo_url_will
       end
 
-      it "should return slug in string" do
-        page = Page.create!(:title => "my name is", :seo_url => "my-url")
-        page.seo_url = "hello world"
-        page.to_seo_url_will.should eq "hello-world"
+      it 'returns slug in string' do
+        page = FlatPage.create!(title: 'my name is', seo_url: 'my-url')
+        page.seo_url = 'hello world'
+        expect(page.to_seo_url_will).to eq 'hello-world'
       end
-    end
 
-    context "ancestry model" do
-      it "should return array of slugs" do
-        root = Category.create!(:name => "root", :slug => "root")
-        child = Category.new(:name => "child", :slug => "child")
-        child.save!
-
-        child.parent = root
-        child.slug = "move d"
-        child.to_slug_will.should eq ["root", "move-d"]
+      it 'returns result from custom to_slug_builder' do
+        news = FlatNews.create!(name: 'news')
+        expect(news.to_slug_will).to eq "to_slug_will_#{news.id}"
       end
     end
-  end
 
-  describe "ancestry methods" do
-    describe "all_slugs" do
-      it "ancestry model class should respond to all_slugs" do
-        Category.should respond_to :all_slugs
-      end
-
-      it "should return all slugs in hash where key is id and value is slug by itself" do
-        root = Category.create!(:name => "root", :slug => "root")
-        child = Category.new(:name => "child", :slug => "child")
-        child.parent = root
+    context 'tree models' do
+      it 'returns array of slugs' do
+        root = TreeCategory.create!(name: 'root', slug: 'root')
+        child = TreeCategory.new(name: 'child', slug: 'child')
         child.save!
 
-        Category.all_slugs.should eq({root.id => "root", child.id => "child"})
-      end
-
-      it "should update slug cache after save" do
-        root = Category.create!(:name => "root", :slug => "root")
-        Category.all_slugs.should eq({root.id => "root"})
-
-        child = Category.new(:name => "child", :slug => "child")
-        child.save! # force save
-        Category.all_slugs.should eq({root.id => "root", child.id => "child"})
-
-        child.slug = "updated-child"
-        child.save # standard save
-        Category.all_slugs.should eq({root.id => "root", child.id => "updated-child"})
-      end
-    end
-
-    describe "clear_cached_slugs" do
-      it "should clear cache for slug" do
-        root = Category.create!(:name => "root", :slug => "root")
-        Category.all_slugs.should eq({root.id => "root"})
-
-        root.destroy
-        Category.all_slugs.should eq({root.id => "root"})
-
-        Category.clear_cached_slugs
-        Category.all_slugs.should eq({})
+        child.parent = root
+        child.slug = 'move d'
+        expect(child.to_slug_will).to eq ['root', 'move-d']
       end
     end
   end
-end
+end