louisville 0.0.3

data/spec/finder_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Louisville::Extensions::Finder do
+
+  class FinderUser < ActiveRecord::Base
+    self.table_name = :users
+
+    include Louisville::Slugger
+
+    slug :name, :finder => true
+  end
+
+  class FindeerUser < FinderUser
+
+  end
+
+  class FinderHistoryUser < ActiveRecord::Base
+    self.table_name = :users
+    include Louisville::Slugger
+
+    slug :name, :finder => true, :history => true
+  end
+
+
+  it 'should allow a model to be found via its slug' do
+    f = FinderUser.new
+    f.name = 'harold'
+    expect(f.save).to eq(true)
+
+    expect(FinderUser.find('harold')).to eq(f)
+  end
+
+  it 'should blow up when nothing can be found' do
+    expect{
+      FinderUser.find('dajlsflj290rjodsals')
+    }.to raise_error(ActiveRecord::RecordNotFound)
+  end
+
+  it 'should be fine with inhertance' do
+    f = FindeerUser.new
+    f.name = 'harmon'
+    expect(f.save).to eq(true)
+
+    expect(FindeerUser.find('harmon')).to eq(f)
+  end
+
+  it 'should raise an error with history enabled' do
+    f = FinderHistoryUser.new
+    f.name = 'happ'
+    expect(f.save).to eq(true)
+
+    f.reload
+    f.name = 'happy'
+    expect(f.save).to eq(true)
+
+    expect(f.slug).to eq('happy')
+    expect(
+      Louisville::Slug.where(:sluggable_type => 'FinderHistoryUser', :sluggable_id => f.id).count
+    ).to eq(1)
+
+    expect(FinderHistoryUser.find('happ')).to eq(f)
+    expect(FinderHistoryUser.find('happy')).to eq(f)
+
+    expect{
+      FinderHistoryUser.find('harvey')
+    }.to raise_error(ActiveRecord::RecordNotFound)
+  end
+
+
+end

data/spec/history_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe Louisville::Extensions::History do
+
+  class MinimalHistoryUser < ActiveRecord::Base
+    self.table_name = :users
+
+    include Louisville::Slugger
+
+    slug :name, :history => true
+  end
+
+  it 'should validate that the slug is present' do
+    u = MinimalHistoryUser.new
+    expect(u.save).to eq(false)
+
+    expect(u.errors[:slug].to_s).to match(/be blank/)
+  end
+
+  it 'should push the previous slug into the history if it changes' do
+    u = MinimalHistoryUser.new
+    u.name = 'joe'
+
+    expect{
+      expect(u.save).to eq(true)
+    }.not_to change(Louisville::Slug, :count)
+
+    u.name = 'joey'
+    expect{
+      expect(u.save).to eq(true)
+    }.to change(Louisville::Slug, :count).by(1)
+
+    expect(u.slug).to eq('joey')
+    history = Louisville::Slug.last
+
+    expect(history.sluggable_type).to eq('MinimalHistoryUser')
+    expect(history.sluggable_id).to eq(u.id)
+
+    expect(history.slug_base).to eq('joe')
+    expect(history.slug_sequence).to eq(1)
+  end
+
+  it 'should delete the slug from the history if it is reassigned' do
+    u = MinimalHistoryUser.new
+    u.name = 'phil'
+    expect(u.save).to eq(true)
+
+    u.name = 'philip'
+    expect(u.save).to eq(true)
+
+    expect(u.slug).to eq('philip')
+
+    history = Louisville::Slug.last
+
+    expect(history.sluggable_type).to eq(u.class.name)
+    expect(history.sluggable_id).to eq(u.id)
+
+    u.name = 'phil'
+    expect(u.save).to eq(true)
+
+    history2 = Louisville::Slug.last
+
+    expect(Louisville::Slug.where(:id => history.id).count).to eq(0)
+    expect(history2.slug_base).to eq('philip')
+  end
+
+  it 'should provide a way to find a user via the slug' do
+    u = MinimalHistoryUser.new
+    u.name = 'james'
+    expect(u.save).to eq(true)
+
+    expect(MinimalHistoryUser.find('james')).to eq(u)
+
+    u.name = 'jams'
+    expect(u.save).to eq(true)
+
+    expect(MinimalHistoryUser.find('jams')).to eq(u)
+    expect(MinimalHistoryUser.find('james')).to eq(u)
+
+  end
+
+  it 'should destroy the slugs when a record is destroyed' do
+    u = MinimalHistoryUser.new
+    u.name = 'jackford'
+    expect(u.save).to eq(true)
+
+    u.name = 'jackson'
+    expect{
+      expect(u.save).to eq(true)
+    }.to change(Louisville::Slug, :count).by(1)
+
+    expect{
+      u.destroy
+    }.to change(Louisville::Slug, :count).by(-1)
+  end
+end

data/spec/numeric_sequence_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Louisville::CollisionResolvers::NumericSequence do
+
+  class NsUser < ActiveRecord::Base
+    self.table_name = :users
+
+    include Louisville::Slugger
+
+    slug :name, :collision => :numeric_sequence
+  end
+
+  it 'should solve collisions by incrementing the sequence column' do
+    a = NsUser.new
+    a.name = 'chris'
+    expect(a.save).to eq(true)
+
+    expect(a.slug).to eq('chris')
+    expect(a.slug_sequence).to eq(1)
+
+    b = NsUser.new
+    b.name = 'chris'
+    expect(b.save).to eq(true)
+
+    expect(b.slug).to eq('chris')
+    expect(b.slug_sequence).to eq(2)
+
+    c = NsUser.new
+    c.name = 'chris'
+    expect(c.save).to eq(true)
+
+    expect(c.slug).to eq('chris')
+    expect(c.slug_sequence).to eq(3)
+  end
+
+end

data/spec/setter_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Louisville::Extensions::Setter do
+
+  class SetterUser < ActiveRecord::Base
+    self.table_name = :users
+
+    include Louisville::Slugger
+
+    slug :name, :setter => true, :collision => :string_sequence
+
+  end
+
+  it 'should provide setters for the desired slug' do
+
+    u = SetterUser.new
+    u.name = 'carl'
+    u.desired_slug = 'carljr'
+
+    expect(u.save).to eq(true)
+
+    expect(u.slug).to eq('carljr')
+
+  end
+
+  it 'should not attempt to uniquify if the desired slug is provided' do
+
+    u = SetterUser.new
+    u.name = 'carey'
+    expect(u.save).to eq(true)
+
+    u2 = SetterUser.new
+    u2.name = 'kerry'
+    u2.desired_slug = 'carey'
+
+    expect(u2.save).to eq(false)
+
+    expect(u2.errors[:slug].to_s).to match(/has already been taken/)
+
+  end
+
+end

data/spec/slugger_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Louisville::Slugger do
+
+  class MinimalUser < ActiveRecord::Base
+    self.table_name = :users
+
+    include Louisville::Slugger
+
+    slug :name
+  end
+
+  let(:config){ MinimalUser.louisville_config }
+
+  it 'should assume the appropriate defaults' do
+    expect(config[:field]).to     eq(:name)
+    expect(config[:column]).to    eq(:slug)
+    expect(config[:collision]).to eq(:none)
+    expect(config[:finder]).to    eq(true)
+    expect(config[:history]).to   eq(false)
+  end
+
+  it 'should wrap the field with louisville accessors' do
+    u = MinimalUser.new
+    u.send(:louisville_slug=, 'test')
+
+    expect(u.slug).to eq('test')
+    expect(u.louisville_slug).to eq('test')
+  end
+
+  it 'should validate that the slug is present' do
+    u = MinimalUser.new
+    expect(u.save).to eq(false)
+
+    expect(u.errors[:slug].to_s).to match(/be blank/)
+  end
+
+  it 'should validate that the slug is unique by default' do
+    u = MinimalUser.new
+    u.name = 'john'
+    expect(u.save).to eq(true)
+
+    u2 = MinimalUser.new
+    u2.name = 'john'
+    expect(u2.save).to eq(false)
+
+    expect(u2.errors[:slug].to_s).to match(/has already been taken/)
+  end
+
+  it 'should provide a way to find a user via the slug' do
+    u = MinimalUser.new
+    u.name = 'frank'
+    expect(u.save).to eq(true)
+
+    expect(MinimalUser.find('frank')).to eq(u)
+  end
+
+  it 'should not apply the slug if the field value changes but the slug base does not' do
+    u = MinimalUser.new
+    u.name = 'spencer'
+    expect(u.save).to eq(true)
+
+    u.name = 'Spencer'
+    expect(u).to be_changed
+
+    expect(u).to receive(:louisville_slug=).never
+    expect(u.save).to eq(true)
+  end
+
+  it 'should only validate when the slug changes or the record is not persisted' do
+    u = MinimalUser.new
+    u.name = 'daniel'
+    expect(u.save).to eq(true)
+
+    u.email = 'd@test.com'
+    expect(u.send(:needs_to_validate_louisville_slug?)).to eq(false)
+
+    u.name = 'danny'
+    u.send(:apply_louisville_slug) # this normally happens before validation
+    expect(u.send(:needs_to_validate_louisville_slug?)).to eq(true)
+
+    u2 = MinimalUser.new
+    expect(u2.send(:needs_to_validate_louisville_slug?)).to eq(true)
+
+    expect(u2.save).to eq(false)
+    expect(u2.errors[:slug].to_s).to match(/blank/)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+require 'active_record'
+require 'louisville'
+
+begin
+  require 'byebug'
+rescue LoadError => e
+  puts 'running without debugger'
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  ActiveRecord::Base.establish_connection(YAML.load_file(File.dirname(__FILE__) + '/support/database.yml'))
+  load(File.dirname(__FILE__) + '/support/schema.rb')
+
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/string_sequence_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Louisville::CollisionResolvers::StringSequence do
+
+  class SsUser < ActiveRecord::Base
+    self.table_name = :users
+
+    include Louisville::Slugger
+
+    slug :name, :collision => :string_sequence
+  end
+
+  it 'should solve collisions by appending the sequence to the slug' do
+    a = SsUser.new
+    a.name = 'charlie'
+    expect(a.save).to eq(true)
+
+    expect(a.slug).to eq('charlie')
+    expect(a.slug_sequence).to eq(1)
+
+    b = SsUser.new
+    b.name = 'charlie'
+    expect(b.save).to eq(true)
+
+    expect(b.slug).to eq('charlie--2')
+
+    c = SsUser.new
+    c.name = 'charlie'
+    expect(c.save).to eq(true)
+
+    expect(c.slug).to eq('charlie--3')
+
+    # ensures the sql matcher is working correctly
+    b.reload
+    b.name = 'Charlie'
+    b.save
+
+    expect(b.slug).to eq('charlie--2')
+  end
+
+end

data/spec/support/database.example.yml

@@ -0,0 +1,6 @@
+adapter: 'mysql2'
+host: localhost
+database: louisville_test
+encoding: utf8
+username: root
+password: 

data/spec/support/database.yml

@@ -0,0 +1,6 @@
+adapter: 'mysql2'
+host: localhost
+database: louisville_test
+encoding: utf8
+username: root
+password: 

data/spec/support/schema.rb

@@ -0,0 +1,20 @@
+ActiveRecord::Schema.define(:version => 20130628161227) do
+
+  create_table "users", :force => true do |t|
+    t.string   "name"
+    t.string   "email"
+    t.string   "slug"
+    t.integer  "slug_sequence",                         :default => 1
+    t.string   "other_slug"
+    t.integer   "other_slug_sequence",                   :default => 1
+    t.datetime "created_at",                            :null => false
+    t.datetime "updated_at",                            :null => false
+  end
+
+  create_table "slugs", :force => true do |t|
+    t.string   "sluggable_type"
+    t.integer  "sluggable_id"
+    t.string   "slug_base"
+    t.integer  "slug_sequence",                         :default => 1
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: louisville
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Mike Nelson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A simple and extensible slugging library for ActiveRecord.
+email:
+- mike@mnelson.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".ruby-vesion"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- gemfiles/ar30.gemfile
+- gemfiles/ar31.gemfile
+- gemfiles/ar32.gemfile
+- gemfiles/ar40.gemfile
+- gemfiles/ar41.gemfile
+- gemfiles/ar42.gemfile
+- lib/louisville.rb
+- lib/louisville/collision_resolvers/abstract.rb
+- lib/louisville/collision_resolvers/none.rb
+- lib/louisville/collision_resolvers/numeric_sequence.rb
+- lib/louisville/collision_resolvers/string_sequence.rb
+- lib/louisville/config.rb
+- lib/louisville/extensions/collision.rb
+- lib/louisville/extensions/finder.rb
+- lib/louisville/extensions/history.rb
+- lib/louisville/extensions/setter.rb
+- lib/louisville/slug.rb
+- lib/louisville/slugger.rb
+- lib/louisville/util.rb
+- lib/louisville/version.rb
+- louisville.gemspec
+- spec/collision_spec.rb
+- spec/column_spec.rb
+- spec/finder_spec.rb
+- spec/history_spec.rb
+- spec/numeric_sequence_spec.rb
+- spec/setter_spec.rb
+- spec/slugger_spec.rb
+- spec/spec_helper.rb
+- spec/string_sequence_spec.rb
+- spec/support/database.example.yml
+- spec/support/database.yml
+- spec/support/schema.rb
+homepage: http://github.com/mnelson/louisville
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Simple and Extensible Slugging
+test_files:
+- spec/collision_spec.rb
+- spec/column_spec.rb
+- spec/finder_spec.rb
+- spec/history_spec.rb
+- spec/numeric_sequence_spec.rb
+- spec/setter_spec.rb
+- spec/slugger_spec.rb
+- spec/spec_helper.rb
+- spec/string_sequence_spec.rb
+- spec/support/database.example.yml
+- spec/support/database.yml
+- spec/support/schema.rb