mongoid_localized_slug 0.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2012 Hakan Ensari
+
+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,73 @@
+Mongoid LocalizedSlug
+============
+
+WARNING: This is a simplified version of the
+[mongoid-slug gem](https://github.com/hakanensari/mongoid-slug) that supports
+localized fields. It DOES NOT support nor embedded objects neither slug history.
+If you need any of those features stick with the original gem.
+
+Mongoid LocalizedSlug generates a URL slug or permalink based on one localized
+fields in a Mongoid model. It sits idly on top of [stringex] [1], supporting
+non-Latin characters.
+
+Installation
+------------
+
+Add to your Gemfile:
+
+```ruby
+gem 'mongoid_localized_slug'
+```
+
+Usage
+-----
+
+Set up a slug:
+
+```ruby
+class Book
+  include Mongoid::Document
+  include Mongoid::LocalizedSlug
+
+  field :title, localize: true
+  slug :title, index: true
+end
+```
+
+Create a record with multiple translations:
+
+```ruby
+I18n.locale = :en
+book = Book.create(:title => "A Thousand Plateaus")
+I18n.locale = :es
+book.update_attribute :title, 'Mil Mesetas'
+```
+
+Find a record by its slug:
+
+```ruby
+# GET /books/a-thousand-plateaus
+book = Book.find_by_slug params[:book_id]
+# GET /books/mil-mesetas
+book = Book.find_by_slug params[:book_id] # matches the same Book object
+```
+
+Reserved Slugs
+--------------
+
+Pass words you do not want to be slugged using the `reserve` option:
+
+```ruby
+class Friend
+  include Mongoid::Document
+
+  field :name
+  slug :name, reserve: ['admin', 'root']
+end
+
+friend = Friend.create name: 'admin'
+Friend.find_by_slug('admin') # => nil
+friend.slug # => 'admin-1'
+```
+
+[1]: https://github.com/rsl/stringex/

data/lib/mongoid/localized_slug.rb

@@ -0,0 +1,208 @@
+module Mongoid
+  # The Slug module helps you generate a URL slug or permalink based on one or
+  # more fields in a Mongoid model.
+  module LocalizedSlug
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :slug_name,
+                     :reserved_words_in_slug,
+                     :slugged_attribute
+    end
+
+    module ClassMethods
+      # @overload slug(*fields)
+      #   Sets one ore more fields as source of slug.
+      #   @param [Symbol] The fields the slug should be based on.
+      #
+      # @overload slug(*field, options)
+      #   Sets one ore more fields as source of slug.
+      #   @param [Symbol] The the slug should be based on.
+      #   @param [Hash] options
+      #   @param options [String] :as The name of the field that stores the
+      #   slug. Defaults to `slug`.
+      #   @param options [Boolean] :index Whether an index should be defined
+      #   on the slug field. Defaults to `false`.
+      #   @param options [Boolean] :permanent Whether the slug should be
+      #   immutable. Defaults to `false`.
+      #   @param options [Array] :reserve` A list of reserved slugs
+      #
+      # @example A custom builder
+      #   class Person
+      #     include Mongoid::Document
+      #     include Mongoid::LocalizedSlug
+      #
+      #     field :name, localize: true
+      #
+      #     slug  :name, :index => true
+      #   end
+      #
+      def slug(*field_and_options)
+        options = field_and_options.extract_options!
+
+        self.reserved_words_in_slug = options[:reserve] || []
+        self.slug_name              = options[:as] || :slug
+        self.slugged_attribute      = field_and_options.first.to_s
+
+        field slug_name, :type => Array, :default => []
+        field "#{slug_name}_translations", :type => Hash, :default => {}
+
+        unless slug_name == :slug
+          alias_attribute :slug, slug_name
+          alias_attribute :slug_translations, "#{slug_name}_translations"
+        end
+
+        if options[:index]
+          index slug_name, :unique => true
+        end
+
+        set_callback options[:permanent] ? :create : :save, :before do |doc|
+          doc.build_slug if doc.slug_should_be_rebuilt?
+        end
+
+        # Build a finder for slug.
+        #
+        # Defaults to `find_by_slug`.
+        instance_eval <<-CODE
+          def self.find_by_#{slug_name}(slug)
+            where(slug_name => slug).first
+          end
+
+          def self.find_by_#{slug_name}!(slug)
+            self.find_by_#{slug_name}(slug) ||
+              raise(Mongoid::Errors::DocumentNotFound.new self, slug)
+          end
+        CODE
+
+        # Build a scope based on the slug name.
+        #
+        # Defaults to `by_slug`.
+        scope "by_#{slug_name}".to_sym, lambda { |slug|
+          where(slug_name => slug)
+        }
+      end
+
+      # Finds a unique slug, were specified string used to generate a slug.
+      #
+      # Returned slug will the same as the specified string when there are no
+      # duplicates.
+      #
+      # @param [String] desired_slug
+      # @param [Hash] options
+      # @param options [Symbol] :scope The scope that should be used to
+      # generate the slug, if the class creates scoped slugs. Defaults to
+      # `nil`.
+      # @param options [Constant] :model The model that the slug should be
+      # generated for. This option overrides `:scope`, as the scope can now
+      # be extracted from the model. Defaults to `nil`.
+      # @return [String] A unique slug
+      def find_unique_slug_for(desired_slug, options = {})
+        excluded_id = options[:model]._id if options[:model]
+
+        slug = desired_slug.to_url
+
+        # Regular expression that matches slug, slug-1, ... slug-n
+        # If slug_name field was indexed, MongoDB will utilize that
+        # index to match /^.../ pattern.
+        pattern = /^#{Regexp.escape(slug)}(?:-(\d+))?$/
+
+        where_hash = {}
+        where_hash[slug_name] = pattern
+        where_hash[:_id.ne]   = excluded_id if excluded_id
+
+        existing_slugs =
+          only(slug_name).
+          where(where_hash)
+
+        # p existing_slugs
+        existing_slugs = existing_slugs.map do |doc|
+          doc.slug
+        end.flatten
+        # p existing_slugs
+
+        # Do not allow BSON::ObjectIds as slugs
+        existing_slugs << slug if BSON::ObjectId.legal?(slug)
+
+        if reserved_words_in_slug.any? { |word| word === slug }
+          existing_slugs << slug
+        end
+
+        if existing_slugs.count > 0
+          # Sort the existing_slugs in increasing order by comparing the
+          # suffix numbers:
+          # slug, slug-1, slug-2, ..., slug-n
+          existing_slugs.sort! do |a, b|
+            (pattern.match(a)[1] || -1).to_i <=>
+            (pattern.match(b)[1] || -1).to_i
+          end
+          max = existing_slugs.last.match(/-(\d+)$/).try(:[], 1).to_i
+
+          slug += "-#{max + 1}"
+        end
+
+        slug
+      end
+
+    end
+
+    # Builds a new slug.
+    #
+    # @return [true]
+    def build_slug
+      translations = self.send("#{slugged_attribute}_translations")
+      slugs = []
+      trans_hash = {}
+      translations.each do |lang, text|
+        trans_hash[lang] = find_unique_slug_for(text)
+        slugs << trans_hash[lang]
+      end
+      self.send("#{slug_name}_translations=", trans_hash)
+      self.send("#{slug_name}=", slugs.uniq)
+      true
+    end
+
+    # Finds a unique slug, were specified string used to generate a slug.
+    #
+    # Returned slug will the same as the specified string when there are no
+    # duplicates.
+    #
+    # @param [String] Desired slug
+    # @return [String] A unique slug
+    def find_unique_slug_for(desired_slug)
+      self.class.find_unique_slug_for desired_slug, :model => self
+    end
+
+    # @return [Boolean] Whether the slug requires to be rebuilt
+    def slug_should_be_rebuilt?
+      new_record? or slug_changed? or slugged_attribute_changed?
+    end
+
+    def slugged_attribute_changed?
+      attribute_changed? slugged_attribute
+    end
+
+    # @return [String] A string which Action Pack uses for constructing an URL
+    # to this record.
+    def to_param
+      if slug.empty?
+        build_slug
+        save
+      end
+      locale = I18n.locale.to_s
+      slug_translations.each do |lang, slug|
+        return slug if lang == locale
+      end
+      slug.first
+    end
+
+    private
+
+    def find_unique_slug
+      find_unique_slug_for user_defined_slug
+    end
+
+    def user_defined_slug
+      slug if (new_record? and slug.present?) or (persisted? and slug_changed?)
+    end
+  end
+end

data/lib/mongoid/localized_slug/criterion.rb

@@ -0,0 +1,25 @@
+module Mongoid::LocalizedSlug::Criterion
+  # Override Mongoid's finder to use slug or id
+  def for_ids(*ids)
+    return super unless @klass.ancestors.include?(Mongoid::LocalizedSlug)
+
+    # We definitely don't want to rescue at the same level we call super above -
+    # that would risk applying our slug behavior to non-slug objects, in the case
+    # where their id conversion fails and super raises BSON::InvalidObjectId
+    begin
+      # note that there is a small possibility that a client could create a slug that
+      # resembles a BSON::ObjectId
+      ids.flatten!
+      BSON::ObjectId.from_string(ids.first) unless ids.first.is_a?(BSON::ObjectId)
+      super # Fallback to original Mongoid::Criterion::Optional
+    rescue BSON::InvalidObjectId
+      # slug
+      if ids.size > 1
+        where(@klass.slug_name.to_sym.in => ids)
+      else
+        where(@klass.slug_name => ids.first)
+      end
+    end
+  end
+end
+Mongoid::Criteria.send :include, Mongoid::LocalizedSlug::Criterion

data/lib/mongoid/localized_slug/version.rb

@@ -0,0 +1,5 @@
+module Mongoid #:nodoc:
+  module LocalizedSlug
+    VERSION = '0.1.1'
+  end
+end

data/lib/mongoid_localized_slug.rb

@@ -0,0 +1,4 @@
+require 'mongoid'
+require 'stringex'
+require 'mongoid/localized_slug'
+require 'mongoid/localized_slug/criterion'

data/spec/models/animal.rb

@@ -0,0 +1,8 @@
+class Animal
+  include Mongoid::Document
+  include Mongoid::LocalizedSlug
+  field :name, localize: true
+  field :nickname
+  key :name, :nickname
+  slug  :name
+end

data/spec/models/book.rb

@@ -0,0 +1,6 @@
+class Book
+  include Mongoid::Document
+  include Mongoid::LocalizedSlug
+  field :title, localize: true
+  slug  :title, :index => true
+end

data/spec/models/friend.rb

@@ -0,0 +1,6 @@
+class Friend
+  include Mongoid::Document
+  include Mongoid::LocalizedSlug
+  field :name, localize: true
+  slug  :name, :reserve => ['foo', 'bar', /^[a-z]{2}$/i]
+end

data/spec/models/person.rb

@@ -0,0 +1,6 @@
+class Person
+  include Mongoid::Document
+  include Mongoid::LocalizedSlug
+  field :name, localize: true
+  slug  :name, :as => :permalink, :permanent => true, :scope => :author
+end

data/spec/mongoid/slug_spec.rb

@@ -0,0 +1,336 @@
+#encoding: utf-8
+require "spec_helper"
+
+module Mongoid
+  describe LocalizedSlug do
+    let(:book) do
+      Book.create(:title => "A Thousand Plateaus")
+    end
+
+    context "when the object is top-level" do
+      it "generates a slug" do
+        book.to_param.should eql "a-thousand-plateaus"
+      end
+
+      it "updates the slug" do
+        book.title = "Anti Oedipus"
+        book.save
+        book.to_param.should eql "anti-oedipus"
+      end
+
+      it "generates a unique slug by appending a counter to duplicate text" do
+        15.times{ |x|
+          dup = Book.create(:title => book.title)
+          dup.to_param.should eql "a-thousand-plateaus-#{x+1}"
+        }
+      end
+
+      it "does not allow a BSON::ObjectId as use for a slug" do
+        bad = Book.create(:title => "4ea0389f0364313d79104fb3")
+        bad.to_param.should_not eql "4ea0389f0364313d79104fb3"
+      end
+
+      it "does not update slug if slugged fields have not changed" do
+        book.save
+        book.to_param.should eql "a-thousand-plateaus"
+      end
+
+      it "does not change slug if slugged fields have changed but generated slug is identical" do
+        book.title = "a thousand plateaus"
+        book.save
+        book.to_param.should eql "a-thousand-plateaus"
+      end
+
+      it "generate diffetent slugs for every traslation" do
+        I18n.locale = :en
+        book.to_param.should eql 'a-thousand-plateaus'
+        I18n.locale = :es
+        book.update_attribute :title, 'Platero y yo'
+        book.to_param.should eql 'platero-y-yo'
+      end
+
+      it "finds by slug" do
+        Book.find_by_slug(book.to_param).should eql book
+      end
+
+      it "find by any translated slug" do
+        I18n.locale = :en
+        book.to_param.should eql 'a-thousand-plateaus'
+        I18n.locale = :es
+        book.update_attribute :title, 'Platero y yo'
+        book.to_param.should eql 'platero-y-yo'
+      end
+
+      context "using find" do
+        it "finds by slug" do
+          Book.find(book.to_param).should eql book
+        end
+
+        it "finds by id as string" do
+          Book.find(book.id.to_s).should eql book
+        end
+
+        it "finds by id as array of strings" do
+          Book.find([book.id.to_s]).should eql [book]
+        end
+
+        it "finds by id as BSON::ObjectId" do
+          Book.find(book.id).should eql book
+        end
+
+        it "finds by id as an array of BSON::ObjectIds" do
+          Book.find([book.id]).should eql [book]
+        end
+
+        it "returns an empty array if given an empty array" do
+          Book.find([]).should eql []
+        end
+
+        it "find by any translated slug" do
+          book.save
+          Book.find('a-thousand-plateaus').should eql book
+          I18n.locale = :es
+          book.update_attribute :title, 'Platero y yo'
+          Book.find('platero-y-yo').should eql book
+        end
+      end
+    end
+
+    context "when :as is passed as an argument" do
+      let!(:person) do
+        Person.create(:name => "John Doe")
+      end
+
+      it "finds by slug" do
+        Person.find_by_permalink("john-doe").should eql person
+      end
+
+      it 'defines #slug' do
+        person.should respond_to :slug
+      end
+
+      it 'defines #slug_changed?' do
+        person.should respond_to :slug_changed?
+      end
+
+      it 'defines #slug_was' do
+        person.should respond_to :slug_was
+      end
+    end
+
+    context "when :permanent is passed as an argument" do
+      let(:person) do
+        Person.create(:name => "John Doe")
+      end
+
+      it "does not update the slug when the slugged fields change" do
+        person.name = "Jane Doe"
+        person.save
+        person.to_param.should eql "john-doe"
+      end
+    end
+
+    context "when slugged field contains non-ASCII characters" do
+      it "slugs Cyrillic characters" do
+        book.title = "Капитал"
+        book.save
+        book.to_param.should eql "kapital"
+      end
+
+      it "slugs Greek characters" do
+        book.title = "Ελλάδα"
+        book.save
+        book.to_param.should eql "ellada"
+      end
+
+      it "slugs Chinese characters" do
+        book.title = "中文"
+        book.save
+        book.to_param.should eql "zhong-wen"
+      end
+
+      it "slugs non-ASCII Latin characters" do
+        book.title = "Paul Cézanne"
+        book.save
+        book.to_param.should eql "paul-cezanne"
+      end
+    end
+
+    context "when :index is passed as an argument" do
+      before do
+        Book.collection.drop_indexes
+      end
+
+      context "when slug is not scoped by a reference association" do
+        it "defines an index on the slug" do
+          Book.create_indexes
+          Book.collection.index_information.should have_key "slug_1"
+        end
+
+        it "defines a unique index" do
+          Book.create_indexes
+          Book.index_information["slug_1"]["unique"].should be_true
+        end
+      end
+
+    end
+
+    context "when :index is not passed as an argument" do
+      it "does not define an index on the slug" do
+        Person.create_indexes
+        Person.collection.index_information.should_not have_key "permalink_1"
+      end
+    end
+
+    context "when :reserve is passed" do
+      it "does not use the the reserved slugs" do
+        friend1 = Friend.create(:name => "foo")
+        friend1.to_param.should_not eql("foo")
+        friend1.to_param.should eql("foo-1")
+
+        friend2 = Friend.create(:name => "bar")
+        friend2.to_param.should_not eql("bar")
+        friend2.to_param.should eql("bar-1")
+
+        friend3 = Friend.create(:name => "en")
+        friend3.to_param.should_not eql("en")
+        friend3.to_param.should eql("en-1")
+      end
+
+      it "should start with concatenation -1" do
+        friend1 = Friend.create(:name => "foo")
+        friend1.to_param.should eql("foo-1")
+        friend2 = Friend.create(:name => "foo")
+        friend2.to_param.should eql("foo-2")
+      end
+    end
+
+    describe ".find_by_slug" do
+      let!(:book) { Book.create(:title => "A Thousand Plateaus") }
+
+      it "returns nil if no document is found" do
+        Book.find_by_slug(:title => "Anti Oedipus").should be_nil
+      end
+
+      it "returns the document if it is found" do
+        Book.find_by_slug(book.to_param).should == book
+      end
+    end
+
+    describe ".find_by_slug!" do
+      let!(:book) { Book.create(:title => "A Thousand Plateaus") }
+
+      it "raises a Mongoid::Errors::DocumentNotFound error if no document is found" do
+        lambda {
+          Book.find_by_slug!(:title => "Anti Oedipus")
+        }.should raise_error(Mongoid::Errors::DocumentNotFound)
+      end
+
+      it "returns the document when it is found" do
+        Book.find_by_slug!(book.to_param).should == book
+      end
+    end
+
+    describe ".find" do
+      let!(:book) { Book.create(:title => "A Thousand Plateaus") }
+      let!(:book2) { Book.create(:title => "Difference and Repetition") }
+      let!(:friend) { Friend.create(:name => "Jim Bob") }
+      let!(:friend2) { Friend.create(:name => "Billy Bob") }
+      let!(:animal) { Animal.create(:name => "Cardu", :nickname => "Car") }
+
+      context "using slugs" do
+
+        it "raises a Mongoid::Errors::DocumentNotFound error if no document is found" do
+          lambda {
+            Book.find(:title => "Anti Oedipus")
+          }.should raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+
+        it "raises a Mongoid::Errors::DocumentNotFound error if trying to find a slug that looks like an id" do
+          tricksy = "4f69cd6dfe75bd0cce000003"
+          friend.name = tricksy
+          friend.save!
+          lambda {
+            Friend.find(tricksy)
+          }.should raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+
+      end
+
+      context "using ids" do
+
+        it "raises a Mongoid::Errors::DocumentNotFound error if no document is found" do
+          lambda {
+            Book.find(friend.id)
+          }.should raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+
+        context "given a single document" do
+          it "returns the document" do
+            Friend.find(friend.id).should == friend
+          end
+        end
+
+        context "given multiple docuemnts" do
+          it "returns the documents" do
+            Book.find([book.id, book2.id]).should == [book, book2]
+          end
+        end
+      end
+      context "when a key is in use" do
+        it "raises a document not found since you should be finding on the slug" do
+          lambda {
+            Animal.find(animal.id)
+          }.should raise_error(Mongoid::Errors::DocumentNotFound)
+        end
+        it "is still ok with the use of slug" do
+          Animal.find(animal.to_param).should == animal
+        end
+      end
+    end
+
+    describe "#to_param" do
+      context "when called on an existing record with no slug" do
+        before do
+          Book.collection.insert(:title => {I18n.locale.to_s => "Proust and Signs"})
+        end
+
+        it "generates the missing slug" do
+          book = Book.first
+          book.to_param
+          book.reload.to_param.should eql "proust-and-signs"
+        end
+      end
+    end
+
+    describe ".for_unique_slug_for" do
+      it "returns the unique slug" do
+        Book.find_unique_slug_for("A Thousand Plateaus").should eq("a-thousand-plateaus")
+      end
+
+      it "returns the unique slug with a counter if necessary" do
+        Book.create(:title => "A Thousand Plateaus")
+        Book.find_unique_slug_for("A Thousand Plateaus").should eq("a-thousand-plateaus-1")
+      end
+
+      it "returns the unique slug as if it were the provided object" do
+        book = Book.create(:title => "A Thousand Plateaus")
+        Book.find_unique_slug_for("A Thousand Plateaus", :model => book).should eq("a-thousand-plateaus")
+      end
+    end
+
+    describe "#find_unique_slug_for" do
+      let!(:book) { Book.create(:title => "A Thousand Plateaus") }
+
+      it "returns the unique slug" do
+        book.find_unique_slug_for("Anti Oedipus").should eq("anti-oedipus")
+      end
+
+      it "returns the unique slug with a counter if necessary" do
+        Book.create(:title => "Anti Oedipus")
+        book.find_unique_slug_for("Anti Oedipus").should eq("anti-oedipus-1")
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'pry'
+require 'rspec'
+
+require File.expand_path('../../lib/mongoid_localized_slug', __FILE__)
+
+Mongoid.configure do |config|
+  name = 'mongoid_slug_test'
+  config.master = Mongo::Connection.new.db(name)
+end
+
+Dir["#{File.dirname(__FILE__)}/models/*.rb"].each { |f| require f }
+
+RSpec.configure do |c|
+  c.before(:each) do
+    Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:remove)
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: mongoid_localized_slug
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Juan Schwindt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: &70295941070740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70295941070740
+- !ruby/object:Gem::Dependency
+  name: stringex
+  requirement: &70295941070240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70295941070240
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: &70295941069760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: *70295941069760
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: &70295941069280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: *70295941069280
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70295941068760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: *70295941068760
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70295941068220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: *70295941068220
+description: ! "        a                \n        a    ."
+email:
+- js@comenta-tv
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mongoid/localized_slug/criterion.rb
+- lib/mongoid/localized_slug/version.rb
+- lib/mongoid/localized_slug.rb
+- lib/mongoid_localized_slug.rb
+- LICENSE
+- README.md
+- spec/models/animal.rb
+- spec/models/book.rb
+- spec/models/friend.rb
+- spec/models/person.rb
+- spec/mongoid/slug_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/hakanensari/mongoid-localized-slug
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1768269109729011774
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1768269109729011774
+requirements: []
+rubyforge_project: mongoid_localized_slug
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Generates a URL slug in a Mongoid model for localized fields
+test_files:
+- spec/models/animal.rb
+- spec/models/book.rb
+- spec/models/friend.rb
+- spec/models/person.rb
+- spec/mongoid/slug_spec.rb
+- spec/spec_helper.rb