vidibus-permalink 0.0.1

data/spec/permalink_spec.rb

@@ -0,0 +1,223 @@
+require "spec_helper"
+
+describe "Permalink" do
+  let(:asset) {Asset.create!(:label => "Something")}
+  let(:category) {Category.create!(:label => "Else")}
+  let(:this) {Permalink.create!(:value => "Hey Joe!", :linkable => asset)}
+  let(:another) {Permalink.create!(:value => "Something", :linkable => asset)}
+
+  def create_permalink(options = {})
+    options[:value] ||= "Super Trouper"
+    options[:linkable] ||= asset
+    Permalink.create!(options)
+  end
+
+  def stub_stopwords(list)
+    I18n.backend.store_translations :en, :vidibus => {:stopwords => list}
+  end
+
+  describe "validation" do
+    it "should pass with valid attributes" do
+      this.should be_valid
+    end
+
+    it "should fail without a value" do
+      this.value = nil
+      this.should be_invalid
+    end
+
+    it "should fail without an UUID given on linkable" do
+      asset.uuid = nil
+      expect {this.linkable}.to raise_error(Permalink::UuidRequiredError)
+    end
+
+    it "should fail if linkable_uuid is invalid" do
+      this.linkable_uuid = "something"
+      this.should be_invalid
+    end
+
+    it "should fail if linkable_uuid is missing" do
+      this.linkable_class = nil
+      this.should be_invalid
+    end
+  end
+
+  describe "deleting" do
+    let(:last) {Permalink.create!(:value => "Buh!", :linkable => asset)}
+
+    before do
+      stub_time!("04.11.2010")
+      this
+      stub_time!("05.11.2010")
+      another
+    end
+
+    it "should not affect other permalinks of the same linkable unless the deleted permalink was the current one" do
+      this.reload.destroy.should be_true
+      another.reload.current?.should be_true
+    end
+
+    it "should set the lastly updated permalink as current if the deleted permalink was the current one" do
+      last.destroy.should be_true
+      another.reload.current?.should be_true
+    end
+
+    it "should not affect other permalinks but the last one if the deleted permalink was the current one" do
+      last.destroy.should be_true
+      this.reload.current?.should be_false
+    end
+  end
+
+  describe "#linkable=" do
+    let(:this) { Permalink.new }
+
+    it "should set linkable_uuid" do
+      this.linkable = asset
+      this.linkable_uuid.should eql(asset.uuid)
+    end
+
+    it "should set linkable_class" do
+      this.linkable = asset
+      this.linkable_class.should eql("Asset")
+    end
+  end
+
+  describe "#linkable" do
+    before {this.instance_variable_set("@linkable", nil)}
+
+    it "should fetch the linkable object" do
+      this.linkable.should eql(asset)
+    end
+
+    it "should return nil if no linkable_class has been set" do
+      this.linkable_class = nil
+      this.linkable.should be_nil
+    end
+
+    it "should return nil if no linkable_uuid has been set" do
+      this.linkable_uuid = nil
+      this.linkable.should be_nil
+    end
+  end
+
+  describe "#value" do
+    it "should be sanitized when set" do
+      this.value = "Hey Joe!"
+      this.value.should eql("hey-joe")
+    end
+
+    context "with stop words" do
+      before {stub_stopwords(%w[its a])}
+
+      it "should be cleaned from stop words before validation" do
+        this.value = "It's a beautiful day."
+        this.value.should eql("beautiful-day")
+      end
+
+      it "should not be cleaned from stop words if the resulting value would be empty" do
+        this.value = "It's a..."
+        this.value.should eql("it-s-a")
+      end
+
+      it "should not be cleaned from stop words if the resulting value already exists" do
+        Permalink.create!(:value => "It's a beautiful day.", :linkable => asset)
+        this = Permalink.new(:value => "It's a beautiful day.")
+        this.value.should eql("it-s-a-beautiful-day")
+      end
+    end
+
+    describe "incrementation" do
+      it "should be performed unless value is unique" do
+        this.value = another.value
+        this.save.should be_true
+        this.value.should_not eql(another.value)
+      end
+
+      it "should not be performed unless value did change" do
+        this.update_attributes(:value => "It's a beautiful day.")
+        dont_allow(this).increment
+        this.value = "It's a beautiful day."
+      end
+
+      it "should append 2 as first number" do
+        first = create_permalink
+        create_permalink.value.should eql("super-trouper-2")
+      end
+
+      it "should append 3 if 2 is already taken" do
+        create_permalink
+        create_permalink
+        create_permalink.value.should eql("super-trouper-3")
+      end
+
+      it "should append 2 if 3 is taken but 2 has been deleted" do
+        create_permalink
+        second = create_permalink
+        create_permalink
+        second.reload.destroy
+        create_permalink.value.should eql("super-trouper-2")
+      end
+    end
+  end
+
+  describe "#current?" do
+    it "should return true after creation" do
+      this.current?.should be_true
+    end
+
+    it "should return true after update" do
+      another
+      this.save
+      this.reload.current?.should be_true
+    end
+
+    it "should return false on all other permalinks of the assigned linkable" do
+      first = create_permalink
+      second = create_permalink
+      third = create_permalink
+      first.reload.current?.should be_false
+      second.reload.current?.should be_false
+      third.reload.current?.should be_true
+    end
+
+    it "should not affect permalinks of other linkables" do
+      this
+      another = Permalink.create!(:value => "Buh!", :linkable => category)
+      another.current?.should be_true
+      this.reload.current?.should be_true
+    end
+  end
+
+  describe "#current" do
+    before {this; another}
+
+    it "should return self for the current permalink" do
+      another.reload.current.should eql(another)
+    end
+
+    it "should return the current permalink of the given linkable" do
+      this.reload.current.should eql(another)
+    end
+  end
+
+  describe ".for_value" do
+    it "should return finder conditions to retreive permalinks for the given value" do
+      this; another
+      Permalink.for_value("Hey Joe!").to_a.should have(1).permalink
+    end
+  end
+
+  describe ".for_linkable" do
+    it "should return finder conditions to retreive permalinks for the given object" do
+      this
+      Permalink.create!(:value => "Buh!", :linkable => category)
+      Permalink.for_linkable(asset).to_a.should have(1).permalink
+    end
+  end
+
+  describe ".dispatch" do
+    it "should return a Vidibus::Permalink::Dispatcher object" do
+      Permalink.dispatch("/something").should be_a(Vidibus::Permalink::Dispatcher)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,41 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "rubygems"
+require "rspec"
+require "rr"
+require "mongoid"
+require "active_support/core_ext"
+require "vidibus-core_extensions"
+require "vidibus-uuid"
+require "vidibus-words"
+
+require "models"
+require "vidibus-permalink"
+require "app/models/permalink"
+
+Mongoid.configure do |config|
+  name = "vidibus-permalink_test"
+  host = "localhost"
+  config.master = Mongo::Connection.new.db(name)
+  config.logger = nil
+end
+
+RSpec.configure do |config|
+  config.mock_with :rr
+  config.before(:each) do
+    Mongoid.master.collections.select {|c| c.name !~ /system/}.each(&:drop)
+  end
+end
+
+I18n.load_path += Dir[File.join('config', 'locales', '**', '*.{rb,yml}')]
+
+# Helper for stubbing time. Define String to be set as Time.now.
+# Usage:
+#   stub_time!('01.01.2010 14:00')
+#   stub_time!(2.days.ago)
+def stub_time!(string = nil)
+  now = string ? Time.parse(string.to_s) : Time.now
+  stub(Time).now { now }
+  now
+end

data/spec/vidibus/permalink/dispatcher_spec.rb

@@ -0,0 +1,122 @@
+require "spec_helper"
+
+describe "Vidibus::Permalink::Dispatcher" do
+  describe "Dispatcher" do
+
+    let(:category) {Category.create!}
+    let(:asset) {Asset.create!}
+    let(:category_permalink) {Permalink.create!(:value => "Something", :linkable => category)}
+    let(:asset_permalink) {Permalink.create!(:value => "Pretty", :linkable => asset)}
+    let(:this) {Vidibus::Permalink::Dispatcher.new("/something/pretty")}
+
+    describe "initializing" do
+      it "should require a path" do
+        expect {Vidibus::Permalink::Dispatcher.new}.to raise_error(ArgumentError)
+      end
+
+      it "should require an absolute request path" do
+        expect {Vidibus::Permalink::Dispatcher.new("something/pretty")}.
+          to raise_error(Vidibus::Permalink::Dispatcher::PathError)
+      end
+
+      it "should accept an absolute request path" do
+        this.should be_a(Vidibus::Permalink::Dispatcher)
+      end
+    end
+
+    describe "#path" do
+      it "should return the given request path" do
+        this.path.should eql("/something/pretty")
+      end
+    end
+
+    describe "#parts" do
+      it "should contain the parts of the given path" do
+        this.parts.should eql(%w[something pretty])
+      end
+    end
+
+    describe "#objects" do
+      before do
+        category_permalink
+        asset_permalink
+      end
+
+      it "should contain all permalinks of given path" do
+        this.objects.should eql([category_permalink, asset_permalink])
+      end
+
+      it "should reflect the order of the parts in request path" do
+        this = Vidibus::Permalink::Dispatcher.new("/pretty/something")
+        this.objects.should eql([asset_permalink, category_permalink])
+      end
+
+      it "should contain empty records for unresolvable parts of the path" do
+        this = Vidibus::Permalink::Dispatcher.new("/some/pretty")
+        this.objects.should eql([nil, asset_permalink])
+      end
+
+      it "should not contain more than one permalink per linkable" do
+        Permalink.create!(:value => "New", :linkable => asset)
+        this = Vidibus::Permalink::Dispatcher.new("/pretty/new")
+        this.objects.should eql([asset_permalink, nil])
+      end
+    end
+
+    describe "found?" do
+      before do
+        category_permalink
+        asset_permalink
+      end
+
+      it "should return true if all parts of the request path could be resolved" do
+        this.found?.should be_true
+      end
+
+      it "should return false if any part of the request path could not be resolved" do
+        this = Vidibus::Permalink::Dispatcher.new("/some/pretty")
+        this.found?.should be_false
+      end
+    end
+
+    describe "#redirect?" do
+      before do
+        category_permalink
+        asset_permalink
+        Permalink.create!(:value => "New", :linkable => asset)
+      end
+
+      it "should return true if any part of the path is not current" do
+        this.redirect?.should be_true
+      end
+
+      it "should return false if all parts of the request path are current" do
+        this = Vidibus::Permalink::Dispatcher.new("/something/new")
+        this.redirect?.should be_false
+      end
+
+      it "should return nil if path could not be resolved" do
+        this = Vidibus::Permalink::Dispatcher.new("/something/ugly")
+        this.redirect?.should be_nil
+      end
+    end
+
+    describe "#redirect_path" do
+      before do
+        category_permalink
+        asset_permalink
+        Permalink.create!(:value => "New", :linkable => asset)
+      end
+
+      it "should return the current request path" do
+        this = Vidibus::Permalink::Dispatcher.new("/something/pretty")
+        this.redirect_path.should eql("/something/new")
+      end
+
+      it "should return nil if redirecting is not necessary" do
+        this = Vidibus::Permalink::Dispatcher.new("/something/new")
+        this.redirect_path.should be_nil
+      end
+    end
+  end
+end

data/spec/vidibus/permalink/mongoid_spec.rb

@@ -0,0 +1,147 @@
+require "spec_helper"
+
+class Model
+  include Mongoid::Document
+  include Vidibus::Uuid::Mongoid
+  include Vidibus::Permalink::Mongoid
+  field :name
+  permalink :name
+end
+
+class Appointment
+  include Mongoid::Document
+  include Vidibus::Uuid::Mongoid
+  include Vidibus::Permalink::Mongoid
+  field :reason
+  field :location
+  permalink :reason, :location
+end
+
+class Car
+  include Mongoid::Document
+  include Vidibus::Uuid::Mongoid
+  include Vidibus::Permalink::Mongoid
+  field :make
+end
+
+describe "Vidibus::Permalink::Mongoid" do
+
+  let(:john) {Model.new(:name => "John Malkovich")}
+  let(:appointment) {Appointment.create(:location => "Bistro", :reason => "Lunch")}
+
+  describe "permalink" do
+    it "should set permalink attribute before validation" do
+      john.valid?
+      john.permalink.should eql("john-malkovich")
+    end
+
+    it "should persist the permalink" do
+      john.save
+      john = Model.first
+      john.permalink.should eql("john-malkovich")
+    end
+
+    it "should create a permalink object from given attribute after creation" do
+      john.save
+      permalink = Permalink.first
+      permalink.value.should eql("john-malkovich")
+    end
+
+    it "should not store a new permalink object unless attribute value did change" do
+      john.save
+      john.save
+      Permalink.all.to_a.should have(1).object
+    end
+
+    it "should store a new permalink if attributes change" do
+      john.save
+      john.update_attributes(:name => "Inkognito")
+      john.reload.permalink.should eql("inkognito")
+    end
+
+    it "should store a new permalink object if permalink changes" do
+      john.save
+      john.update_attributes(:name => "Inkognito")
+      permalinks = Permalink.all.to_a
+      permalinks.should have(2).permalinks
+      permalinks.last.value.should eql("inkognito")
+      permalinks.last.should be_current
+    end
+
+    it "should should set a former permalink object as current if possible" do
+      john.save
+      john.update_attributes(:name => "Inkognito")
+      john.update_attributes(:name => "John Malkovich")
+      permalinks = Permalink.all.to_a
+      permalinks.should have(2).objects
+      permalinks.first.should be_current
+    end
+
+    it "should accept multiple attributes" do
+      appointment.permalink.should eql("lunch-bistro")
+    end
+
+    it "should be updatable" do
+      appointment.update_attributes(:reason => "Drinking")
+      appointment.permalink.should eql("drinking-bistro")
+    end
+
+    it "should raise an error unless permalink attributes have been defined" do
+      expect {Car.create(:make => "Porsche")}.to raise_error(Car::PermalinkConfigurationError)
+    end
+  end
+
+  describe "destroying" do
+    it "should trigger deleting of all permalink objects with linkable" do
+      appointment.destroy
+      Permalink.all.to_a.should have(:no).permalinks
+    end
+
+    it "should not delete permalink objects of other linkables" do
+      john.save
+      appointment.destroy
+      Permalink.all.to_a.should have(1).permalink
+    end
+  end
+
+  describe "#permalink" do
+    it "should trigger an error if blank" do
+      model = Model.new(:permalink => "")
+      model.should be_invalid
+      model.errors[:permalink].should have(1).error
+    end
+  end
+
+  describe "#permalink_object" do
+    it "should return the current permalink object" do
+      appointment.update_attributes(:reason => "Drinking")
+      permalink = appointment.permalink_object
+      permalink.should be_a(Permalink)
+      permalink.value.should eql(appointment.permalink)
+      permalink.should be_current
+    end
+
+    it "should return the permalink object assigned recently" do
+      appointment.reason = "Drinking"
+      appointment.valid?
+      appointment.permalink_object.should be_a_new_record
+    end
+  end
+
+  describe "#permalink_objects" do
+    it "should return all permalink objects ordered by time of update" do
+      stub_time!("04.11.2010")
+      appointment.update_attributes(:reason => "Drinking")
+      stub_time!("05.11.2010")
+      appointment.update_attributes(:reason => "Lunch")
+      permalinks = appointment.permalink_objects
+      permalinks[0].value.should eql("drinking-bistro")
+      permalinks[1].value.should eql("lunch-bistro")
+    end
+
+    it "should only return permalink objects assigned to the current linkable" do
+      john.save
+      appointment.permalink_objects.to_a.should have(1).permalink
+    end
+  end
+end

data/vidibus-permalink.gemspec

@@ -0,0 +1,80 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{vidibus-permalink}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Andre Pankratz"]
+  s.date = %q{2010-11-16}
+  s.description = %q{Allows changeable permalinks (good for SEO).}
+  s.email = %q{andre@vidibus.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".bundle/config",
+     ".document",
+     ".gitignore",
+     ".rspec",
+     "Gemfile",
+     "Gemfile.lock",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "app/models/permalink.rb",
+     "lib/vidibus-permalink.rb",
+     "lib/vidibus/permalink.rb",
+     "lib/vidibus/permalink/dispatcher.rb",
+     "lib/vidibus/permalink/mongoid.rb",
+     "spec/models.rb",
+     "spec/permalink_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/vidibus/permalink/dispatcher_spec.rb",
+     "spec/vidibus/permalink/mongoid_spec.rb",
+     "vidibus-permalink.gemspec"
+  ]
+  s.homepage = %q{http://github.com/vidibus/vidibus-permalink}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Permalink handling}
+  s.test_files = [
+    "spec/models.rb",
+     "spec/permalink_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/vidibus/permalink/dispatcher_spec.rb",
+     "spec/vidibus/permalink/mongoid_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, ["~> 3.0.0"])
+      s.add_runtime_dependency(%q<mongoid>, ["~> 2.0.0.beta.20"])
+      s.add_runtime_dependency(%q<vidibus-core_extensions>, [">= 0"])
+      s.add_runtime_dependency(%q<vidibus-uuid>, [">= 0"])
+      s.add_runtime_dependency(%q<vidibus-words>, [">= 0"])
+    else
+      s.add_dependency(%q<rails>, ["~> 3.0.0"])
+      s.add_dependency(%q<mongoid>, ["~> 2.0.0.beta.20"])
+      s.add_dependency(%q<vidibus-core_extensions>, [">= 0"])
+      s.add_dependency(%q<vidibus-uuid>, [">= 0"])
+      s.add_dependency(%q<vidibus-words>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rails>, ["~> 3.0.0"])
+    s.add_dependency(%q<mongoid>, ["~> 2.0.0.beta.20"])
+    s.add_dependency(%q<vidibus-core_extensions>, [">= 0"])
+    s.add_dependency(%q<vidibus-uuid>, [">= 0"])
+    s.add_dependency(%q<vidibus-words>, [">= 0"])
+  end
+end
+