babosa 0.1.1 → 0.2.0

data/README.md

@@ -1,8 +1,13 @@
 # Babosa
 
-Babosa is a library for creating slugs. It is an extraction and improvement of
-the string code from [FriendlyId](http://github.com/norman/friendly_id),
-intended to help developers create similar libraries and plugins.
+Babosa is a library for creating human-friendly identifiers. Its primary
+intended purpose is for creating URL slugs, but can also be useful for
+normalizing and sanitizing data.
+
+It is an extraction and improvement of the string code from
+[FriendlyId](http://github.com/norman/friendly_id). I have released this as a
+separate library to help developers who want to create libraries similar to
+FriendlyId.
 
 ## Features / Usage
 
@@ -15,8 +20,8 @@ intended to help developers create similar libraries and plugins.
     "Jürgen Müller".to_slug.approximate_ascii.to_s           #=> "Jurgen Muller"
     "Jürgen Müller".to_slug.approximate_ascii(:german).to_s  #=> "Juergen Mueller"
 
-Currently, only German, Spanish and Serbian are supported. I'll gladly accept
-contributions and support more languages.
+Supported language currently include Danish, German, Serbian and Spanish. I'll
+gladly accept contributions and support more languages.
 
 ### Non-ASCII removal
 
@@ -41,17 +46,47 @@ whose length is limited by bytes rather than UTF-8 characters.
 
     "Gölcük, Turkey".to_slug.normalize.to_s #=> "golcuk-turkey"
 
+### Other stuff
+
+Babosa can also generate strings for Ruby method names. (Yes, Ruby 1.9 can use UTF-8 chars
+in method names, but you may not want to):
+
+
+    "this is a method".to_slug.to_ruby_method! #=> this_is_a_method
+    "über cool stuff!".to_slug.to_ruby_method! #=> uber_cool_stuff!
+
+    # You can also disallow trailing punctuation chars
+    "über cool stuff!".to_slug.to_ruby_method(false) #=> uber_cool_stuff
+
+
+You can add not only transliterations, but expansions for some characters if you want:
+
+    Babosa::Characters.add_approximations(:user, {
+      "0" => "oh",
+      "1" => "one",
+      "2" => "two",
+      "3" => "three",
+      "." => " dot "
+    })
+    "Web 2.0".to_slug.normalize!(:transliterations => :user) #=> "web-two-dot-oh"
 
 ### UTF-8 support
 
 Babosa has no hard dependencies, but if you have either the Unicode or
 ActiveSupport gems installed and required prior to requiring "babosa", these
 will be used to perform upcasing and downcasing on UTF-8 strings. On JRuby 1.5
-and above, Java's native Unicode support will be used.
+and above, Java's native Unicode support will be used instead. Unless you're on
+JRuby, which already has excellent support for Unicode via Java's Standard
+Library, I recommend using the Unicode gem because it's the fastest Ruby
+Unicode library available.
 
 If none of these libraries are available, Babosa falls back to a simple module
-which supports only Unicode strings only with Latin characters. I recommend
-using the Unicode gem where possible since it's a C extension and is very fast.
+which only supports Latin characters.
+
+This default module is fast and can do very naive Unicode composition to ensure
+that, for example, "é" will always be composed to a single codepoint rather
+than an "e" and a "´" - making it safe to use as a hash key. But seriously -
+save yourself the headache and install a real Unicode library.
 
 
 ### Rails 3
@@ -59,15 +94,17 @@ using the Unicode gem where possible since it's a C extension and is very fast.
 Most of Babosa's functionality is already present in Active Support/Rails 3.
 Babosa exists primarily to support non-Rails applications, and Rails apps prior
 to 3.0. Most of the code here was originally written for FriendlyId. Several
-things, like tidy_bytes and ASCII transliteration, were later added to Rails and I18N.
+things, like `tidy_bytes` and ASCII transliteration, were later added to Rails
+and I18N.
 
 Babosa differs from ActiveSupport primarily in that it supports non-Latin
-strings by default. If you are considering using Babosa with Rails 3, you should first
-take a look at Active Support's
+strings by default, and has per-locale ASCII transliterations already baked-in. If
+you are considering using Babosa with Rails 3, you should first take a look at
+Active Support's
 [transliterate](http://edgeapi.rubyonrails.org/classes/ActiveSupport/Inflector.html#M000565)
 and
 [parameterize](http://edgeapi.rubyonrails.org/classes/ActiveSupport/Inflector.html#M000566)
-because it's very likely they already do what you need.
+because it may already do what you need.
 
 ### More info
 
@@ -81,8 +118,8 @@ Babosa can be installed via Rubygems:
 
 You can get the source code from its [Github repository](http://github.com/norman/babosa).
 
-Babosa is tested to be compatible with Ruby 1.8.6-1.9.2, JRuby 1.4-1.5,
-Rubinius 1.0, and is probably compatible with other Rubies as well.
+Babosa is tested to be compatible with Ruby 1.8.6-1.9.2, JRuby 1.4-1.5, and
+Rubinius 1.0.x. It's probably compatible with other Rubies as well.
 
 ## Reporting bugs
 
@@ -99,11 +136,13 @@ Please use Babosa's [Github issue tracker](http://github.com/norman/babosa/issue
 
 ## Contributors
 
+* [Molte Emil Strange Andersen](http://github.com/molte) - Danish support
 * [Milan Dobrota](http://github.com/milandobrota) - Serbian support
 
 
 ## Changelog
 
+* 0.2.0 - Added support for Danish. Added method to generate Ruby identifiers. Improved performance.
 * 0.1.1 - Added support for Serbian.
 * 0.1.0 - Initial extraction from FriendlyId.
 
@@ -111,12 +150,12 @@ Please use Babosa's [Github issue tracker](http://github.com/norman/babosa/issue
 
 Copyright (c) 2010 Norman Clarke
 
-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:
+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.

data/Rakefile

@@ -1,3 +1,5 @@
+require "rubygems"
+require "bundler/setup"
 require "rake/testtask"
 require "rake/clean"
 require "rake/gempackagetask"

data/init.rb

@@ -1,3 +1,3 @@
-$LOAD_PATH << File.expand_path("../lib", __FILE__)
-$LOAD_PATH.uniq!
+require "rubygems"
+require "bundler/setup"
 require "babosa"

data/lib/babosa.rb

@@ -5,9 +5,10 @@ module Babosa
 end
 
 class String
-  def to_slug
-    Babosa::SlugString.new self
+  def to_identifier
+    Babosa::Identifier.new self
   end
+  alias to_slug to_identifier
 
   # Compatibility with 1.8.6
   if !public_method_defined? :bytesize
@@ -19,4 +20,4 @@ end
 
 require "babosa/characters"
 require "babosa/utf8/proxy"
-require "babosa/slug_string"
+require "babosa/identifier"

data/lib/babosa/characters.rb

@@ -26,21 +26,23 @@ module Babosa
     # @param [#to_sym] name The name of the approximations to add.
     # @param Hash hash The approximations to add.
     def add_approximations(name, hash)
-      @approximations ||= {}
-      @approximations[name.to_sym] = hash.inject({}) do |memo, object|
+      approximations = @approximations ? @approximations.dup : {}
+      approximations[name.to_sym] = hash.inject({}) do |memo, object|
         key = object[0].unpack("U").shift
         value = object[1].unpack("C*")
         memo[key] = value.length == 1 ? value[0] : value
         memo
-      end
+      end.freeze
+      @approximations = approximations.freeze
     end
 
-    add_approximations :spanish, "ñ" => "ni"
-    add_approximations :german, "ä" => "ae", "ö" => "oe", "ü" => "ue"
+    add_approximations :danish,  "æ" => "ae", "ø" => "oe", "å" => "aa", "Ø" => "Oe", "Å" => "Aa"
+    add_approximations :german,  "ä" => "ae", "ö" => "oe", "ü" => "ue", "Ä" => "Ae", "Ö" => "Oe", "Ü" => "Ue"
     add_approximations :serbian, "Ð" => "Dj", "đ" => "dj" ,"Č" => "Ch", "č" => "ch", "Š" => "Sh", "š" => "sh"
+    add_approximations :spanish, "ñ" => "ni", "Ñ" => "Ni"
     add_approximations :latin, {
       "À" => "A", "Á" => "A", "Â" => "A", "Ã" => "A", "Ä" => "A", "Å" => "A",
-      "Æ" => "AE", "Ç" => "C", "È" => "E", "É" => "E", "Ê" => "E", "Ë" => "E",
+      "Æ" => "Ae", "Ç" => "C", "È" => "E", "É" => "E", "Ê" => "E", "Ë" => "E",
       "Ì" => "I", "Í" => "I", "Î" => "I", "Ï" => "I", "Ð" => "D", "Ñ" => "N",
       "Ò" => "O", "Ó" => "O", "Ô" => "O", "Õ" => "O", "Ö" => "O", "Ø" => "O",
       "Ù" => "U", "Ú" => "U", "Û" => "U", "Ü" => "U", "Ý" => "Y", "Þ" => "Th",
@@ -57,11 +59,11 @@ module Babosa
       "Ĝ" => "G", "ĝ" => "g", "Ğ" => "G", "ğ" => "g", "Ġ" => "G", "ġ" => "g",
       "Ģ" => "G", "ģ" => "g", "Ĥ" => "H", "ĥ" => "h", "Ħ" => "H", "ħ" => "h",
       "Ĩ" => "I", "ĩ" => "i", "Ī" => "I", "ī" => "i", "Ĭ" => "I", "ĭ" => "i",
-      "Į" => "I", "į" => "i", "İ" => "I", "ı" => "i", "IJ" => "IJ", "ij" => "ij",
+      "Į" => "I", "į" => "i", "İ" => "I", "ı" => "i", "IJ" => "Ij", "ij" => "ij",
       "Ĵ" => "J", "ĵ" => "j", "Ķ" => "K", "ķ" => "k", "ĸ" => "k", "Ĺ" => "L",
       "ĺ" => "l", "Ļ" => "L", "ļ" => "l", "Ľ" => "L", "ľ" => "l", "Ŀ" => "L",
       "ŀ" => "l", "Ł" => "L", "ł" => "l", "Ń" => "N", "ń" => "n", "Ņ" => "N",
-      "ņ" => "n", "Ň" => "N", "ň" => "n", "ʼn" => "n", "Ŋ" => "NG", "ŋ" => "ng",
+      "ņ" => "n", "Ň" => "N", "ň" => "n", "ʼn" => "n", "Ŋ" => "Ng", "ŋ" => "ng",
       "Ō" => "O", "ō" => "o", "Ŏ" => "O", "ŏ" => "o", "Ő" => "O", "ő" => "o",
       "Œ" => "OE", "œ" => "oe", "Ŕ" => "R", "ŕ" => "r", "Ŗ" => "R", "ŗ" => "r",
       "Ř" => "R", "ř" => "r", "Ś" => "S", "ś" => "s", "Ŝ" => "S", "ŝ" => "s",

data/lib/babosa/{slug_string.rb → identifier.rb}

@@ -1,25 +1,24 @@
 # encoding: utf-8
-
 module Babosa
 
   # This class provides some string-manipulation methods specific to slugs.
   #
   # Note that this class includes many "bang methods" such as {#clean!} and
   # {#normalize!} that perform actions on the string in-place. Each of these
-  # methods has a corresponding "bangless" method (i.e., +SlugString#clean!+
-  # and +SlugString#clean+) which does not appear in the documentation because
+  # methods has a corresponding "bangless" method (i.e., +Identifier#clean!+
+  # and +Identifier#clean+) which does not appear in the documentation because
   # it is generated dynamically.
   #
   # All of the bang methods return an instance of String, while the bangless
-  # versions return an instance of Babosa::SlugString, so that calls to methods
+  # versions return an instance of Babosa::Identifier, so that calls to methods
   # specific to this class can be chained:
   #
-  #   string = SlugString.new("hello world")
-  #   string.with_dashes! # => "hello-world"
-  #   string.with_dashes  # => <Babosa::SlugString:0x000001013e1590 @wrapped_string="hello-world">
+  #   string = Identifier.new("hello world")
+  #   string.with_separators! # => "hello-world"
+  #   string.with_separators  # => <Babosa::Identifier:0x000001013e1590 @wrapped_string="hello-world">
   #
   # @see http://www.utf8-chartable.de/unicode-utf8-table.pl?utf8=dec Unicode character table
-  class SlugString
+  class Identifier
 
     attr_reader :wrapped_string
     alias to_s wrapped_string
@@ -50,7 +49,7 @@ module Babosa
       @wrapped_string.__send__(symbol, *args, &block)
     end
 
-    # @param string [#to_s] The string to use as the basis of the SlugString.
+    # @param string [#to_s] The string to use as the basis of the Identifier.
     def initialize(string)
       @wrapped_string = string.to_s
       tidy_bytes!
@@ -61,21 +60,21 @@ module Babosa
     # characters that are Roman-alphabet characters + diacritics. Non-letter
     # characters are left unmodified.
     #
-    #   string = SlugString.new "Łódź, Poland"
-    #   string.approximate_ascii                 # => "Lodz, Poland"
-    #   string = SlugString.new "日本"
-    #   string.approximate_ascii                 # => "日本"
+    #   string = Identifier.new "Łódź, Poland"
+    #   string.transliterate                 # => "Lodz, Poland"
+    #   string = Identifier.new "日本"
+    #   string.transliterate                 # => "日本"
     #
     # You can pass any key(s) from +Characters.approximations+ as arguments. This allows
-    # for contextual approximations. By default; +:spanish+ and +:german+ are
-    # provided:
+    # for contextual approximations. Danish, German, Serbian and Spanish are currently
+    # supported.
     #
-    #   string = SlugString.new "Jürgen Müller"
-    #   string.approximate_ascii                 # => "Jurgen Muller"
-    #   string.approximate_ascii :german         # => "Juergen Mueller"
-    #   string = SlugString.new "¡Feliz año!"
-    #   string.approximate_ascii                 # => "¡Feliz ano!"
-    #   string.approximate_ascii :spanish        # => "¡Feliz anio!"
+    #   string = Identifier.new "Jürgen Müller"
+    #   string.transliterate                 # => "Jurgen Muller"
+    #   string.transliterate :german         # => "Juergen Mueller"
+    #   string = Identifier.new "¡Feliz año!"
+    #   string.transliterate                 # => "¡Feliz ano!"
+    #   string.transliterate :spanish        # => "¡Feliz anio!"
     #
     # You can modify the built-in approximations, or add your own:
     #
@@ -85,13 +84,17 @@ module Babosa
     # Notice that this method does not simply convert to ASCII; if you want
     # to remove non-ASCII characters such as "¡" and "¿", use {#to_ascii!}:
     #
-    #   string.approximate_ascii!(:spanish)       # => "¡Feliz anio!"
-    #   string.to_ascii!                          # => "Feliz anio!"
+    #   string.transliterate!(:spanish)       # => "¡Feliz anio!"
+    #   string.transliterate!                 # => "Feliz anio!"
     # @param *args <Symbol>
     # @return String
-    def approximate_ascii!(overrides = {})
-      overrides = Characters.approximations[overrides] if overrides.kind_of? Symbol
-      @wrapped_string = unpack("U*").map { |char| approx_char(char, overrides) }.flatten.pack("U*")
+    def transliterate!(transliterations = {})
+      if transliterations.kind_of? Symbol
+        transliterations = Characters.approximations[transliterations]
+      else
+        transliterations ||= {}
+      end
+      @wrapped_string = unpack("U*").map { |char| approx_char(char, transliterations) }.flatten.pack("U*")
     end
 
     # Converts dashes to spaces, removes leading and trailing spaces, and
@@ -108,22 +111,47 @@ module Babosa
       @wrapped_string = (unpack("U*") - Characters.strippable).pack("U*")
     end
 
-    # Normalize the string for use as a slug. Note that in this context,
+    # Normalize the string for use as a URL slug. Note that in this context,
     # +normalize+ means, strip, remove non-letters/numbers, downcasing,
     # truncating to 255 bytes and converting whitespace to dashes.
-    # @param Boolean ascii If true, approximate ASCII and then remove any non-ASCII characters.
+    # @param Options
     # @return String
-    def normalize!(ascii = false)
-      if ascii
-        approximate_ascii!
-        to_ascii!
+    def normalize!(options = nil)
+      # Handle deprecated usage
+      if options == true
+        warn "#normalize! now takes a hash of options rather than a boolean"
+        options = default_normalize_options.merge(:to_ascii => true)
+      else
+        options = default_normalize_options.merge(options || {})
+      end
+      if options[:transliterate]
+        transliterate!(*options[:transliterations])
       end
+      to_ascii! if options[:to_ascii]
       clean!
       word_chars!
       clean!
       downcase!
-      truncate_bytes!(255)
-      with_dashes!
+      truncate_bytes!(options[:max_length])
+      with_separators!(options[:separator])
+    end
+
+    # Normalize a string so that it can safely be used as a Ruby method name.
+    def to_ruby_method!(allow_bangs = true)
+      leader, trailer = @wrapped_string.strip.scan(/\A(.+)(.)\z/).flatten
+      if allow_bangs
+        trailer.downcase.gsub!(/[^a-z0-9!=\\\\?]/, '')
+      else
+        trailer.downcase.gsub!(/[^a-z0-9]/, '')
+      end
+      id = leader.to_identifier
+      id.transliterate!
+      id.to_ascii!
+      id.clean!
+      id.word_chars!
+      id.clean!
+      @wrapped_string = id.to_s + trailer
+      with_separators!("_")
     end
 
     # Delete any non-ascii characters.
@@ -134,7 +162,7 @@ module Babosa
 
     # Truncate the string to +max+ characters.
     # @example
-    #   "üéøá".to_slug.truncate(3) #=> "üéø"
+    #   "üéøá".to_identifier.truncate(3) #=> "üéø"
     # @return String
     def truncate!(max)
       @wrapped_string = unpack("U*")[0...max].pack("U*")
@@ -145,7 +173,7 @@ module Babosa
     # byte length. The resulting string may be less than +max+ if the string must
     # be truncated at a multibyte character boundary.
     # @example
-    #   "üéøá".to_slug.truncate_bytes(3) #=> "ü"
+    #   "üéøá".to_identifier.truncate_bytes(3) #=> "ü"
     # @return String
     def truncate_bytes!(max)
       return @wrapped_string if @wrapped_string.bytesize <= max
@@ -164,8 +192,8 @@ module Babosa
 
     # Replaces whitespace with dashes ("-").
     # @return String
-    def with_dashes!
-      @wrapped_string = @wrapped_string.gsub(/\s/u, "-")
+    def with_separators!(char = "-")
+      @wrapped_string = @wrapped_string.gsub(/\s/u, char)
     end
 
     # Perform UTF-8 sensitive upcasing.
@@ -193,31 +221,46 @@ module Babosa
       @wrapped_string = @@utf8_proxy.tidy_bytes(@wrapped_string)
     end
 
-    %w[approximate_ascii clean downcase word_chars normalize normalize_utf8
-      tidy_bytes to_ascii truncate truncate_bytes upcase with_dashes].each do |method|
-      class_eval(<<-EOM)
+    %w[transliterate clean downcase word_chars normalize normalize_utf8
+      tidy_bytes to_ascii truncate truncate_bytes upcase with_separators].each do |method|
+      class_eval(<<-EOM, __FILE__, __LINE__ +1)
         def #{method}(*args)
           send_to_new_instance(:#{method}!, *args)
         end
       EOM
     end
 
-    def to_slug
+    def to_identifier
       self
     end
 
+    # The default options for {#normalize!}. Override to set your own defaults.
+    def default_normalize_options
+      {:transliterate => true, :max_length => 255, :separator => "-"}
+    end
+
+    alias approximate_ascii transliterate
+    alias approximate_ascii! transliterate!
+    alias with_dashes with_separators
+    alias with_dashes! with_separators!
+    alias to_slug to_identifier
+
     private
 
     # Look up the character's approximation in the configured maps.
-    def approx_char(char, overrides = {})
-      overrides[char] or Characters.approximations[:latin][char] or char
+    def approx_char(char, transliterations = {})
+      transliterations[char] or Characters.approximations[:latin][char] or char
     end
 
     # Used as the basis of the bangless methods.
     def send_to_new_instance(*args)
-      string = SlugString.new self
-      string.send(*args)
-      string
+      id = Identifier.allocate
+      id.instance_variable_set :@wrapped_string, to_s
+      id.send(*args)
+      id
     end
   end
+
+  # Identifier is aliased as SlugString to support older versions of FriendlyId.
+  SlugString = Identifier
 end

data/lib/babosa/version.rb

@@ -1,5 +1,5 @@
 module Babosa
   module Version
-    STRING = "0.1.1"
+    STRING = "0.2.0"
   end
 end

data/test/babosa_test.rb

@@ -1,11 +1,8 @@
 # encoding: utf-8
 $KCODE = 'UTF8' if RUBY_VERSION < '1.9'
-$LOAD_PATH << File.expand_path("../../lib", __FILE__)
-$LOAD_PATH.uniq!
 
 require "rubygems"
-require "bundler"
-Bundler.setup
+require "bundler/setup"
 require "test/unit"
 require "babosa"
 
@@ -106,7 +103,11 @@ class  BabosaTest < Test::Unit::TestCase
   end
 
   test "should do special approximations for German" do
-    assert_equal "Juergen", "Jürgen".to_slug.approximate_ascii!(:german)
+    {
+      "Jürgen" => "Juergen",
+      "böse"   => "boese",
+      "Männer" => "Maenner"
+    }.each {|given, expected| assert_equal expected, given.to_slug.approximate_ascii!(:german)}
   end
 
   test "should do special approximations for Spanish" do
@@ -114,7 +115,21 @@ class  BabosaTest < Test::Unit::TestCase
   end
 
   test "should do special approximations for Serbian" do
-    assert_equal "Indjija", "Inđija".to_slug.approximate_ascii!(:serbian)
+    {
+      "Ðorđe"  => "Djordje",
+      "Inđija" => "Indjija",
+      "Četiri" => "Chetiri",
+      "četiri" => "chetiri",
+      "Škola"  => "Shkola",
+      "škola"  => "shkola"
+    }.each {|given, expected| assert_equal expected, given.to_slug.approximate_ascii!(:serbian)}
+  end
+
+  test "should do special approximations for Danish" do
+    {
+      "Ærøskøbing" => "Aeroeskoebing",
+      "Årslev"       => "Aarslev"
+    }.each {|given, expected| assert_equal expected, given.to_slug.approximate_ascii!(:danish)}
   end
 
   test "should work with non roman chars" do
@@ -156,9 +171,19 @@ class  BabosaTest < Test::Unit::TestCase
     assert_equal " a  bc ".bytesize, " a  bc ".to_slug.with_dashes.bytesize
   end
 
-  test "normalize! with ascii should approximate and strip non ascii" do
+  test "normalize! with ascii option should approximate and strip non ascii" do
     ss = "カタカナ: katakana is über cool".to_slug
-    assert_equal "katakana-is-uber-cool", ss.normalize!(true)
+    assert_equal "katakana-is-uber-cool", ss.normalize!(:to_ascii => true)
   end
 
+  test "normalize should use transliterations" do
+    assert_equal "juergen", "Jürgen".to_slug.normalize(:transliterations => :german).to_s
+  end
+
+  test "should get a string suitable for use as a ruby method" do
+    assert_equal "hello_world?", "¿¿¿hello... world???".to_slug.to_ruby_method!
+    assert_equal "katakana_is_uber_cool", "カタカナ: katakana is über cool".to_slug.to_ruby_method!
+    assert_equal "katakana_is_uber_cool!", "カタカナ: katakana is über cool!".to_slug.to_ruby_method!
+    assert_equal "katakana_is_uber_cool", "カタカナ: katakana is über cool".to_slug.to_ruby_method!(false)
+  end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Norman Clarke
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-09 00:00:00 -03:00
+date: 2010-08-30 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
@@ -28,7 +28,7 @@ extra_rdoc_files: []
 
 files: 
 - lib/babosa/characters.rb
-- lib/babosa/slug_string.rb
+- lib/babosa/identifier.rb
 - lib/babosa/utf8/active_support_proxy.rb
 - lib/babosa/utf8/dumb_proxy.rb
 - lib/babosa/utf8/java_proxy.rb
@@ -56,6 +56,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 1210160351012131207
       segments: 
       - 0
       version: "0"
@@ -64,6 +65,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 1210160351012131207
       segments: 
       - 0
       version: "0"