louisville 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fdc680eb9ca340621494d36950a855275314f80a
+  data.tar.gz: cdcd1db4119ae3ac44992ad07a9568f8ce1d1e6b
+SHA512:
+  metadata.gz: 93640afde3565c61129849b03f5bae891c486f82b948335329f1dd1c4fa7a779cba16f4804dafcb6c659047e567eeb14181d49133870a87b635d73ae3825ae5b
+  data.tar.gz: 0a5050f87c8db5e269acd3067b9f3741ac9470168b37c2c2c05051fa13266d81326c65bbffe278053f4d40ac98a688418d33b222a30bed9b6095bf1b4ceaf538

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+database.yml

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-gemset

@@ -0,0 +1 @@
+louisville

data/.ruby-version

@@ -0,0 +1 @@
+2.1.5

data/.travis.yml

@@ -0,0 +1,42 @@
+language: ruby
+
+services: mysql
+
+before_script:
+  - mysql -e 'create database louisville_test;'
+  - cp spec/support/database.example.yml spec/support/database.yml
+
+before_install:
+  - gem update --system 2.1.11
+  - gem --version
+
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1.5
+  - jruby
+
+gemfile:
+  - gemfiles/ar30.gemfile
+  - gemfiles/ar31.gemfile
+  - gemfiles/ar32.gemfile
+  - gemfiles/ar40.gemfile
+  - gemfiles/ar41.gemfile
+  - gemfiles/ar42.gemfile
+
+matrix:
+  exclude:
+    - rvm: 1.8.7
+      gemfile: gemfiles/ar40.gemfile
+    - rvm: 1.9.2
+      gemfile: gemfiles/ar40.gemfile
+    - rvm: 1.8.7
+      gemfile: gemfiles/ar41.gemfile
+    - rvm: 1.9.2
+      gemfile: gemfiles/ar41.gemfile
+    - rvm: 1.8.7
+      gemfile: gemfiles/ar42.gemfile
+    - rvm: 1.9.2
+      gemfile: gemfiles/ar42.gemfile

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in louisville.gemspec
+gemspec
+
+
+gem 'rake'
+gem 'mysql2'
+gem 'rspec'
+gem 'byebug'
+gem 'activerecord', '~> 4.2.0'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mike Nelson
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,124 @@
+# Louisville
+
+This is not a Swiss Army Bulldozer. This is not a Pseudocephalopod. Contrary to popular belief, this was not written in Kentucky. This is a moderately simple, moderately extensible, moderately opinionated slugging library.
+
+## Usage
+
+Just need the most basic of slugging?
+
+```ruby
+add_column :players, :slug, :string
+add_index  :players, :slug, unique: true
+```
+
+```ruby
+class Player < ActiveRecord::Base
+  include Louisville::Slugger
+
+  slug :name
+end
+```
+
+
+Need a litte more? The `slug` class method accepts an options hash.
+
+| Option Key | Option Value | Default Value | What it does |
+| ---------- | ------------ | ------------- | ------------ |
+| :column    | Any String   | "slug"        | Configures the slug column. "slug" is the default, provide to override. |
+| :finder    | true         | true          | Adds the finder extension. The finder extension allows `class.find('slug')` to work. |
+| :finder    | false        | true          | Removes the finder option, disabling the `class.find` override. |
+| :collision | :string_sequence | :none     | Handles collisions by appending a sequence to the slug. A generated slug which collides with an existing slug will gain a "--number". So if there was a record with "foobar" as it's slug and another record generated the slug "foobar", the second record would save as "foobar--2". |
+| :collision | :numeric_sequence | :none    | Handles collisions my incrementing a numeric column named `"#{slug_column}_sequence"`. With this configuration, the slug column may not be unique but the `[slug, slug_sequence]` combination would be. |
+| :setter    | Any Valid Ruby Method String | false | Allows the slug generation to be short circuited by providing a setter. Think about a user choosing their username or a page having an seo title. Collisions with the provided value will not be resolved, meaning a validation error will occur if an existing slug is provided. |
+| :history   | true         | false         | When a record's slug changes this will create a record in the slugs table. The finder and collision resolver extensions respect the existence of the history table if this option is enabled.
+
+### Collision Resolvers
+
+Two collision resolvers are included in Louisville. You can decide which to use based on the profile of your app. If you're app is read heavy and/or rarely colliding on write, :string\_sequence is fine for you. If your app is write heavy or deals with collisions often, :numeric\_sequence is a better choice.
+
+**collision: :string_sequence**
+
+To use the string sequence collision resolver, configure your schema like so:
+
+```ruby
+add_column :players, :slug, :string
+add_index  :players, :slug, unique: true
+```
+
+**collision: :numeric_sequence**
+
+To use this collision resolver configure your schema like so:
+
+```ruby
+add_column :players, :slug, :string
+add_column :players, :slug_sequence, :integer, default: 1
+add_index :players, [:slug, :slug_sequence], unique: true
+```
+
+### Setter
+
+I found this to be a shortcoming of other libraries and intended to make it dead simple to implement. Many times you want you users to be able to choose their slugs, skipping any kind of collision resolution. In Louisville it's simple:
+
+```ruby
+class Player
+  slug :name, setter: :desired_slug
+end
+```
+
+Now, you can simply do `player.desired_slug = params[:username]` and if available the record's slug will be set, otherwise the record will have a validation error.
+
+### History
+
+You'll need to create a slug table (no model) for this to work:
+
+```ruby
+create_table :slugs do |t|
+  t.string   :sluggable_type
+  t.integer  :sluggable_id
+  t.string   :slug_base
+  t.integer  :slug_sequence, :default => 1
+ end
+```
+
+Now with the table created, you can change a records slug and the previous value(s) will be stored in the slugs table. Note that the current slug is not stored in the table.
+
+
+## Creating your own extension
+
+You can provide your own extension to Louisville by creating a module within the Louisville::Extensions namespace. For instance.
+
+```ruby
+module Louisville
+  module Extensions
+    module Upcase
+      self.included(base)
+        base.class_eval do
+          alias_method_chain :sanitize_louisville_slug, :upcase
+        end
+      end
+
+      protected
+
+      def sanitize_louisville_slug_with_upcase(value)
+        value = sanitize_louisville_slug_without_upcase(value).upcase
+        value = value.gsub(/[\d]+/, '') if louisville_config.options_for(:upcase)[:remove_numbers]
+        value
+      end
+    end
+  end
+end
+```
+
+Then, in your class you would do:
+
+```ruby
+class Player
+  include Louisville::Slugger
+
+  slug :name, upcase: true
+  # or if you wanted to provide options for the module...
+  slug :name, upcase: {remove_numbers: true}
+end
+```
+
+Classes with the Louisville::Slugger module have access to the `louisville_config` both at the class and instance level. The louisville config provides you with a way to grab the options for your (or any) extension as well as determine what extensions are enabled. For instance, if you wanted to know if the history extension was being used you would do `louisville_config.option?(:history)`.

data/Rakefile

@@ -0,0 +1,9 @@
+#!/usr/bin/env rake
+require 'rake'
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+task :default  => :spec

data/gemfiles/ar30.gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in makara.gemspec
+gemspec :path => '../'
+
+
+gem 'rake'
+gem 'activerecord', '3.0.20'
+gem 'rspec'
+gem 'i18n', '~> 0.5.0'
+
+gem 'mysql2', '0.2.11', :platform => :ruby
+gem 'activerecord-jdbcmysql-adapter', :platform => :jruby

data/gemfiles/ar31.gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in makara.gemspec
+gemspec :path => '../'
+
+
+gem 'rake'
+gem 'activerecord', '3.1.12'
+gem 'rspec'
+gem 'i18n', '0.6.11'
+gem 'mysql2', :platform => :ruby
+gem 'activerecord-jdbcmysql-adapter', :platform => :jruby

data/gemfiles/ar32.gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in makara.gemspec
+gemspec :path => '../'
+
+
+gem 'rake'
+gem 'activerecord', '3.2.19'
+gem 'rspec'
+gem 'i18n', '0.6.11'
+gem 'mysql2', :platform => :ruby
+gem 'activerecord-jdbcmysql-adapter', :platform => :jruby

data/gemfiles/ar40.gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in makara.gemspec
+gemspec :path => '../'
+
+
+gem 'rake'
+gem 'activerecord', '4.0.10'
+gem 'rspec'
+gem 'rack'
+gem 'mysql2', :platform => :ruby
+gem 'activerecord-jdbcmysql-adapter', :platform => :jruby

data/gemfiles/ar41.gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in makara.gemspec
+gemspec :path => '../'
+
+
+gem 'rake'
+gem 'activerecord', '4.1.6'
+gem 'rspec'
+gem 'rack'
+gem 'mysql2', :platform => :ruby
+gem 'activerecord-jdbcmysql-adapter', :platform => :jruby

data/gemfiles/ar42.gemfile

@@ -0,0 +1,12 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in makara.gemspec
+gemspec :path => '../'
+
+
+gem 'rake'
+gem 'activerecord', '~> 4.2.0'
+gem 'rspec'
+gem 'rack'
+gem 'mysql2', :platform => :ruby
+gem 'activerecord-jdbcmysql-adapter', :platform => :jruby

data/lib/louisville/collision_resolvers/abstract.rb

@@ -0,0 +1,101 @@
+module Louisville
+  module CollisionResolvers
+    class Abstract
+
+      def initialize(instance, options = {})
+        @instance = instance
+        @options  = options
+      end
+
+
+      def unique?
+        unique_in_table? && unique_in_history?
+      end
+
+
+      def next_valid_slug
+        raise NotImplementedError
+      end
+
+
+      def provides_collision_solution?
+        false
+      end
+
+
+      def assign_slug(val)
+        @instance.send("#{config[:column]}=", val)
+      end
+
+
+      def read_slug
+        @instance.send(config[:column])
+      end
+
+
+      def slug_changed?
+        @instance.send("#{config[:column]}_changed?")
+      end
+
+
+
+      protected
+
+
+
+      def slug_base(compare = nil)
+        Louisville::Util.slug_base(compare || @instance.louisville_slug.to_s)
+      end
+
+
+      def slug_sequence(compare = nil)
+        Louisville::Util.slug_sequence(compare || @instance.louisville_slug.to_s)
+      end
+
+
+
+      def unique_in_history?
+        return true unless config.option?(:history)
+
+        scope = ::Louisville::Slug.where(:sluggable_type => ::Louisville::Util.polymorphic_name(klass))
+        scope = scope.where(:slug_base => slug_base)
+        scope = scope.where(:slug_sequence => slug_sequence)
+        scope = scope.where("#{Louisville::Slug.quoted_table_name}.sluggable_id <> ?", @instance.id) if @instance.persisted?
+
+        !scope.exists?
+      end
+
+
+      def unique_in_table?
+        scope = klass.where(config[:column] => @instance.louisville_slug)
+        scope = scope.where("#{klass.quoted_table_name}.#{klass.primary_key} <> ?", @instance.id) if @instance.persisted?
+
+        !scope.exists?
+      end
+
+
+      def config
+        @instance.louisville_config
+      end
+
+
+      def klass
+        @instance.class
+      end
+
+
+      def next_slug(slug)
+        base      = slug_base(slug)
+        sequence  = slug_sequence(slug)
+
+        "#{base}--#{sequence + 1}"
+      end
+
+
+      def provide_latest_slug(*slugs)
+        slugs.compact.sort{|a,b| a.length == b.length ? a <=> b : a.length - b.length }.last
+      end
+
+    end
+  end
+end

data/lib/louisville/collision_resolvers/none.rb

@@ -0,0 +1,11 @@
+module Louisville
+  module CollisionResolvers
+    class None < Abstract
+
+      def next_valid_slug
+        @instance.louisville_slug
+      end
+
+    end
+  end
+end

data/lib/louisville/collision_resolvers/numeric_sequence.rb

@@ -0,0 +1,78 @@
+module Louisville
+  module CollisionResolvers
+    class NumericSequence < Abstract
+
+
+      def provides_collision_solution?
+        true
+      end
+
+
+      def next_valid_slug
+        provide_latest_slug(next_valid_slug_from_table, next_valid_slug_from_history)
+      end
+
+
+      def assign_slug(val)
+        base, seq = Louisville::Util.slug_parts(val)
+
+        @instance.send("#{config[:column]}=", base)
+        @instance.send("#{config[:column]}_sequence=", seq)
+      end
+
+
+      def read_slug
+        col = config[:column]
+        seq = "#{col}_sequence"
+
+        "#{@instance.send(col)}--#{@instance.send(seq)}"
+      end
+
+
+      def slug_changed?
+        @instance.send("#{config[:column]}_changed?") || @instance.send("#{@config[:column]}_sequence_changed?")
+      end
+
+
+
+      protected
+
+
+
+      def unique_in_table?
+
+        base_method     = config[:column]
+        sequence_method = "#{config[:column]}_sequence"
+
+        scope = klass.where(config[:column] => @instance.send(base_method), sequence_method => @instance.send(sequence_method))
+        scope = scope.where("#{klass.quoted_table_name}.#{klass.primary_key} <> ?", @instance.id) if @instance.persisted?
+
+        !scope.exists?
+      end
+
+
+      def next_valid_slug_from_table
+        base_field = config[:column]
+        sequ_field = "#{config[:column]}_sequence"
+
+        scope = klass.where(base_field => slug_base)
+        scope = scope.where("#{klass.quoted_table_name}.#{klass.primary_key} <> ?", @instance.id) if @instance.persisted?
+
+        "#{slug_base}--#{scope.maximum(sequ_field).to_i + 1}"
+      end
+
+
+      def next_valid_slug_from_history
+        return nil unless config.option?(:history)
+
+        scope = ::Louisville::Slug.where(:sluggable_type => ::Louisville::Util.polymorphic_name(klass))
+        scope = scope.where(:slug_base => slug_base)
+        scope = scope.where("#{Louisville::Slug.quoted_table_name}.sluggable_id <> ?", @instance.id) if @instance.persisted?
+
+        "#{slug_base}--#{scope.maximum(:slug_sequence).to_i + 1}"
+      end
+
+    end
+
+  end
+end

data/lib/louisville/collision_resolvers/string_sequence.rb

@@ -0,0 +1,48 @@
+module Louisville
+  module CollisionResolvers
+    class StringSequence < Abstract
+
+
+      def provides_collision_solution?
+        true
+      end
+
+
+      def next_valid_slug
+        provide_latest_slug(next_valid_slug_from_table, next_valid_slug_from_history)
+      end
+
+
+
+      protected
+
+
+
+      def next_valid_slug_from_table
+        length_command  = klass.connection.adapter_name =~ /sqlserver/i ? 'LEN' : 'LENGTH'
+        pk_col          = "#{klass.quoted_table_name}.#{klass.primary_key}"
+        col             = "#{klass.quoted_table_name}.#{config[:column]}"
+
+        scope  = klass.select("#{col}")
+        scope  = scope.where("#{col} = ? OR #{col} LIKE ?", slug_base, "#{slug_base}--%")
+        scope  = scope.order("#{length_command}(#{col}) DESC, #{col} DESC")
+
+        return nil unless record = scope.first
+
+        next_slug(record.louisville_slug)
+      end
+
+
+      def next_valid_slug_from_history
+        return nil unless config.option?(:history)
+
+        scope = ::Louisville::Slug.where(:sluggable_type => ::Louisville::Util.polymorphic_name(klass))
+        scope = scope.where(:slug_base => slug_base)
+        scope = scope.where("#{Louisville::Slug.quoted_table_name}.sluggable_id <> ?", @instance.id) if @instance.persisted?
+
+        "#{slug_base}--#{scope.maximum(:slug_sequence).to_i + 1}"
+      end
+
+    end
+  end
+end

data/lib/louisville/config.rb

@@ -0,0 +1,60 @@
+module Louisville
+  class Config
+
+    DEFAULTS = {
+      :column => :slug,
+      :finder => true,
+      :collision => :none,
+      :setter => false,
+      :history => false
+    }.freeze
+
+
+    def initialize(field, options = {})
+      @options = DEFAULTS.merge(options).merge(:field => field)
+    end
+
+
+    def hook!(klass)
+      modules.each do |modul|
+        modul.configure_default_options(@options) if modul.respond_to?(:configure_default_options)
+        klass.send(:include, modul)
+      end
+    end
+
+
+    def option?(key)
+      !!option(key)
+    end
+
+
+    def option(key)
+      @options[key]
+    end
+    alias_method :[], :option
+
+
+    def options_for(key)
+      return self[key] if self[key] === Hash
+      {}
+    end
+
+
+    def extension_keys
+      (@options.keys - [:column, :field])
+    end
+
+
+
+    protected
+
+
+
+    def modules
+      extension_keys.map do |option|
+        ::Louisville::Extensions.const_get(option.to_s.classify) if self.option?(option)
+      end.compact
+    end
+
+  end
+end