humanid 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1a64d1071c4dbf56186641557dfba393fdf97339
+  data.tar.gz: 738b2dd24a3b76c577f415e17517558912ce4c26
+SHA512:
+  metadata.gz: 39b2e31eff31f19eaa895f4db037a59879c53c38d8884a780bda2976470d3efc6d9747f67a21353ed82ed48545ee5821a57e9cff883553fcd196bef1c67b1907
+  data.tar.gz: dbec0ab755aefbc7d0c5a542804222dc8aae7e80341f56925671071a897d573e7352d8dc0e0aca8b47ccabb38f1008a63389069700229685f79207d6165edec4

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea

data/Gemfile

@@ -0,0 +1,11 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in activerecord-human-id.gemspec
+gemspec
+
+gem 'essay', path: '~/Development/essay'
+gem 'activerecord-traits', path: '~/Development/activerecord-traits'
+gem 'unicode-tools', path: '~/Development/unicode-tools'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Yaroslav Konoplov
+
+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,10 @@
+```ruby
+  class Article < ActiveRecord::Base
+    # TODO Write example
+  end
+```
+
+## Gemfile
+```ruby
+gem 'activerecord-human-id', github: 'yivo/activerecord-human-id'
+```

data/Rakefile

@@ -0,0 +1,4 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'

data/humanid.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+Gem::Specification.new do |s|
+  s.name            = 'humanid'
+  s.version         = '1.0.1'
+  s.authors         = ['Yaroslav Konoplov']
+  s.email           = ['eahome00@gmail.com']
+  s.summary         = 'ActiveRecord human id'
+  s.description     = 'ActiveRecord human id'
+  s.homepage        = 'http://github.com/yivo/activerecord-human-id'
+  s.license         = 'MIT'
+
+  s.executables     = `git ls-files -z -- bin/*`.split("\x0").map{ |f| File.basename(f) }
+  s.files           = `git ls-files -z`.split("\x0")
+  s.test_files      = `git ls-files -z -- {test,spec,features}/*`.split("\x0")
+  s.require_paths   = ['lib']
+
+  s.add_dependency 'activesupport',       '>= 3.0', '< 6.0'
+  s.add_dependency 'activerecord',        '>= 3.0', '< 6.0'
+  s.add_dependency 'activerecord-traits', '~> 1.1'
+  s.add_dependency 'unicode-tools',       '~> 1.0'
+  s.add_dependency 'rails-i18n'
+end

data/lib/humanid.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'active_support/all'
+require 'active_record'
+require 'rails-i18n'
+require 'activerecord-traits'
+require 'unicode-tools'
+
+require 'humanid/canonicalization'
+require 'humanid/transliteration'
+require 'humanid/extension'
+require 'humanid/extension/configuration'
+require 'humanid/extension/builder'
+require 'humanid/extension/pattern'
+require 'humanid/extension/persistence'
+require 'humanid/extension/generation'
+require 'humanid/extension/validation'
+require 'humanid/migration'
+require 'humanid/railtie'
+
+begin
+  require 'essay'
+  require 'humanid/essay'
+rescue LoadError
+end
+
+module HumanID
+  class << self
+    def engine(engine = :transliteration)
+      engine == :canonicalization ? Canonicalization : Transliteration
+    end
+  end
+end
+
+class ActiveRecord::Base
+  include HumanID::Extension
+end
+
+class ActiveRecord::ConnectionAdapters::TableDefinition
+  include HumanID::ColumnTypes
+end

data/lib/humanid/canonicalization.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HumanID
+  module Canonicalization
+    class << self
+      #
+      # HumanID::Canonicalization.perform('Well-known English writer')
+      #   => 'Well-known_English_writer'
+      #
+      # HumanID::Canonicalization.perform('Пушкин, Александр Сергеевич')
+      #   => 'Пушкин,_Александр_Сергеевич'
+      #
+      def perform(str)
+        separator = behaviour.separator
+
+        str = str.join(separator) if str.is_a?(Array)
+
+        # This doesn't require comments
+        str = UnicodeTools.strip_bidi_override_chars(str)
+
+        # Replace all whitespace characters (including leading,
+        # trailing and inner) with HumanID.separator
+        str = UnicodeTools.replace_whitespace(str, separator)
+
+        # Fix for Rails format in routes
+        # http://coding-journal.com/rails-3-routing-parameters-with-dots/
+        str = str.tr('.', separator)
+
+        # Strip leading and trailing separators
+        str = str.gsub(surrounding_separators_regex, '')
+
+        # Replace two or more separator sequence with one separator: '__' => '_'
+        str.gsub(separator_sequence_regex, separator)
+      end
+
+      def valid?(human_id)
+        human_id = human_id.to_s if human_id.kind_of?(Symbol)
+        human_id.kind_of?(String) &&
+          UnicodeTools.has_bidi_override?(human_id) == false &&
+          UnicodeTools.has_whitespace?(human_id)    == false
+      end
+
+      def validate!(human_id)
+        raise MalformedHumanIDError unless valid?(human_id)
+        true
+      end
+
+      def behaviour
+        Behaviour.instance
+      end
+
+      attr_accessor :surrounding_separators_regex, :separator_sequence_regex
+    end
+
+    class Behaviour
+      include Singleton
+
+      attr_accessor :separator
+
+      def initialize
+        self.separator = '_'
+      end
+
+      def separator=(new_sep)
+        @separator = new_sep
+
+        # Rebuild separator regexps
+        HumanID::Canonicalization.surrounding_separators_regex = /(\A#{new_sep}+)|(#{new_sep}+\z)/
+        HumanID::Canonicalization.separator_sequence_regex     = /#{new_sep}+/
+
+        new_sep
+      end
+    end
+
+    class MalformedHumanIDError < StandardError
+      def initialize
+        super 'Human ID is malformed'
+      end
+    end
+  end
+
+  class << self
+    def canonicalize(str)
+      Canonicalization.perform(str)
+    end
+  end
+end

data/lib/humanid/essay.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+class Essay::AttributeFeatures
+  def human_id?
+    active_record.attributes_marked_as_human_id.include?(attribute.name)
+  end
+
+  def human_id
+    @human_id || @human_id = HumanID.new(env) if human_id?
+  end
+
+  serialize do
+    { is_human_id: human_id?,
+      human_id:    human_id.try(:to_hash) }
+  end
+
+  class HumanID < Base
+    def persists?
+      !!options[:persist]
+    end
+
+    def updates_manually?
+      options[:update] == :manual
+    end
+
+    def updates_automatically?
+      !updates_manually?
+    end
+
+    def updates_if_blank?
+      options[:update] == :if_blank
+    end
+
+    def options
+      active_record.human_id_options.fetch(attribute.name)
+    end
+  end
+end

data/lib/humanid/extension.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HumanID
+  module Extension
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :human_id_options,
+        instance_reader: true, instance_writer: false, instance_predicate: false
+
+      class_attribute :attributes_marked_as_human_id,
+        instance_accessor: false, instance_predicate: false
+
+      # Hash of options for each defined human id:
+      #   => { alias: { pattern: [:id, :name], ... }, key: { pattern: [:id, :name], ... } }
+      self.human_id_options              = {}
+
+      self.attributes_marked_as_human_id = []
+    end
+
+    module ClassMethods
+      def has_human_id(*args)
+        options = args.extract_options!.reverse_merge!(HumanID::Extension.default_options)
+
+        pattern                    = options.delete(:pattern) || Pattern.guess(self)
+        options[:original_pattern] = pattern
+        options[:compiled_pattern] = Pattern.compile(pattern)
+
+        val                   = options[:validations]
+        options[:validations] = case val
+          when Hash  then val.reverse_merge!(HumanID::Extension.default_options[:validations])
+          when Array then %i( format uniqueness ).each_with_object({}) { |el, obj| obj[el] = val.include?(el) }
+          else            { format: !!val, uniqueness: !!val }
+        end
+
+        builder = Builder.new(self, options)
+
+        self.human_id_options = self.human_id_options.dup
+        args.each do |attr_name|
+          builder.build(attr_name)
+          self.human_id_options[attr_name] = options.deep_dup
+        end
+
+        self.attributes_marked_as_human_id += args
+      end
+    end
+  end
+end

data/lib/humanid/extension/builder.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HumanID
+  module Extension
+    class Builder
+      def initialize(model_class, options)
+        @model                 = model_class
+        @param                 = options[:param]
+        @persists              = options[:persist]
+        @validations           = options[:validations]
+        @validates_format      = @validations[:format]
+        @validates_uniqueness  = @validations[:uniqueness]
+      end
+
+      def build(human_id)
+        @human_id = human_id
+
+        define_base_methods
+
+        if @persists
+          define_persistence_methods
+          add_persistence_callbacks
+        else
+          define_human_id_accessor
+        end
+
+        add_format_validation     if @validates_format
+        add_uniqueness_validation if @validates_uniqueness
+
+        define_to_param_method if @param
+      end
+
+    protected
+      def define_base_methods
+        @model.class_eval <<-BODY, __FILE__, __LINE__ + 1
+          def generate_#{@human_id}
+            HumanID::Extension::Generation.generate(:#{@human_id}, self)
+          end
+
+          def options_for_#{@human_id}
+            human_id_options.fetch(:#{@human_id})
+          end
+        BODY
+      end
+
+      def define_persistence_methods
+        @model.class_eval <<-BODY, __FILE__, __LINE__ + 1
+          def need_to_update_#{@human_id}?
+            HumanID::Extension::Persistence.need_to_update?(:#{@human_id}, self)
+          end
+
+          def assign_#{@human_id}!
+            HumanID::Extension::Persistence.assign!(:#{@human_id}, self)
+            nil
+          end
+
+          def assign_#{@human_id}
+            HumanID::Extension::Persistence.assign(:#{@human_id}, self)
+            nil
+          end
+        BODY
+      end
+
+      def define_human_id_accessor
+        @model.class_eval <<-BODY, __FILE__, __LINE__ + 1
+          def #{@human_id}
+            @#{@human_id} ||= generate_#{@human_id}
+          end
+        BODY
+      end
+
+      def define_to_param_method
+        @model.class_eval <<-BODY, __FILE__, __LINE__ + 1
+          def to_param
+            self.#{@human_id}
+          end
+        BODY
+      end
+
+      def add_persistence_callbacks
+        @model.before_validation :"assign_#{@human_id}",  if: :"need_to_update_#{@human_id}?"
+        @model.after_save        :"assign_#{@human_id}!", if: :"need_to_update_#{@human_id}?"
+      end
+
+      def add_uniqueness_validation
+        @model.validates_uniqueness_of @human_id, case_sensitive: false, allow_blank: true
+      end
+
+      def add_format_validation
+        @model.validate "format_of_#{@human_id}", if: "#{@human_id}?"
+
+        @model.class_eval <<-BODY, __FILE__, __LINE__ + 1
+          def format_of_#{@human_id}
+            HumanID::Extension::Validation.validate_format_of(:#{@human_id}, self)
+          end
+        BODY
+      end
+    end
+  end
+end

data/lib/humanid/extension/configuration.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HumanID
+  module Extension
+    class << self
+      attr_accessor :default_options
+    end
+
+    self.default_options = {
+
+      # By default pattern will be guessed by steps:
+      #   - try first attribute with string type
+      #   - or try primary key attribute
+      #   - or at worst: first attribute
+      #
+      # See HumanID::Extension::PatternHelper.guess.
+      pattern: nil,
+
+      # If set to true:           all available validations will be added.
+      # If set to false:          no validations will be added.
+      # If set to hash or array:  you choose what validations you need:
+      #   => { format: true, uniqueness: false }
+      #   => [:uniqueness]
+      validations: { format: true, uniqueness: true },
+
+      # This option determines whether `to_param` method will be defined.
+      # See http://apidock.com/rails/ActiveRecord/Integration/ClassMethods/to_param
+      param: false,
+
+      # Chose what engine should be used to perform human id generation.
+      engine: :transliteration,
+
+      # If you want your human id to be persisted in database set this to true.
+      persist: true,
+
+      # This option determines whether human id will be updated.
+      # Possible values:
+      #   1. :if_blank  - human id will be updated only if it's value is blank;
+      #   2. :always    - human id will be updated on each save regardless of the value;
+      #   3. :manual    - human id will never be updated automatically.
+      update: :if_blank
+    }
+  end
+end

data/lib/humanid/extension/generation.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HumanID
+  module Extension
+    module Generation
+      class << self
+        def generate(human_id, model)
+          options = model.send("options_for_#{human_id}")
+          pattern = options.fetch(:compiled_pattern)
+          data    = HumanID::Extension::Pattern.result(pattern, model)
+          HumanID.engine(options[:engine]).perform(data)
+        end
+
+        def ready_to_generate?(model)
+          # Sometimes human id depends on record id or timestamps.
+          # When record isn't persisted human id will be generated wrong.
+          model.persisted?
+        end
+      end
+    end
+  end
+end

data/lib/humanid/extension/pattern.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HumanID
+  module Extension
+    module Pattern
+      class << self
+        def compile(handy_pattern)
+          case handy_pattern
+            # compile(['Article', :name])
+            #   => [{string: 'Article'}, {method: :name}]
+            when Array then handy_pattern
+
+            # compile(:name)
+            #   => [{ method: :name }]
+            when Symbol then [{ method: handy_pattern }]
+
+            # compile(':id_:name')
+            #   => [ [{method: :id}, {string: '_'}, {method: :name}] ]
+            #
+            # compile('_:article_name:id_')
+            #   => [ [{string: '_'}, {method: :article_name}, {method: :id}, {string: '_'}] ]
+            #
+            # compile('article_:id')
+            #   => [ [{string: 'article_'}, {method: :id}] ]
+            #
+            # http://rubular.com/r/AJFnJbmBRo
+            #
+            # http://stackoverflow.com/questions/16398471/regex-not-ending-with
+            # ?<! - not ending with
+            else [handy_pattern.scan(/([\w-]+)|(:\w+(?<![_-]))/).flatten.compact.map do |el|
+              el.start_with?(':') ? { method: el[1..-1].to_sym } : { string: el }
+            end]
+          end
+        end
+
+        # class CreateArticles < ActiveRecord::Migration
+        #   def change
+        #     create_table :articles do |t|
+        #       t.string :name
+        #       t.text :content
+        #     end
+        #   end
+        # end
+        #
+        # class Article < ActiveRecord::Base
+        # end
+        #
+        # guess(Article)
+        #   => :name
+        #
+        def guess(model_class)
+          attrs = Traits.for(model_class).attributes
+          attr  = attrs.find { |el| el.string? } || attrs.find { |el| el.primary_key? } || attrs.first
+          attr.name
+        end
+
+        def result(compiled_pattern, model)
+          compiled_pattern.map do |el|
+            case el
+              when Symbol then model.send(el)
+              when Hash   then el.key?(:method) ? model.send(el[:method]) : el.fetch(:string)
+              when Array  then result(el, model).join('')
+              else el
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/humanid/extension/persistence.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HumanID
+  module Extension
+    module Persistence
+      class << self
+        def assign!(human_id, model)
+          if Generation.ready_to_generate?(model)
+            new_value = model.send("generate_#{human_id}")
+            if model.send(human_id) != new_value
+              model[human_id] = new_value
+              model.update_column(human_id, new_value)
+              model.save!
+            end
+          end
+        end
+
+        def assign(human_id, model)
+          # Sometimes human id depends on record id or timestamps.
+          # When record isn't persisted human id will be generated wrong.
+          if Generation.ready_to_generate?(model)
+            model.send("#{human_id}=", model.send("generate_#{human_id}"))
+          end
+        end
+
+        def need_to_update?(human_id, model)
+          options = model.send("options_for_#{human_id}")
+          case options[:update]
+            when :always        then true
+            when nil, :if_blank then !model.send("#{human_id}?")
+                                else false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/humanid/extension/validation.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HumanID
+  module Extension
+    module Validation
+      class << self
+        def validate_format_of(human_id, model)
+          value   = model.send(human_id)
+          options = model.send("options_for_#{human_id}")
+          valid   = HumanID.engine(options[:engine]).valid?(value)
+          model.errors.add(human_id, :invalid) unless valid
+          valid
+        end
+      end
+    end
+  end
+end

data/lib/humanid/migration.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HumanID
+  module Migration
+    def human_id(*args)
+      options         = args.extract_options!
+      options[:index] = case options[:index]
+        when true  then { unique: true }
+        when false then false
+        else            (options[:index] || {}).reverse_merge!(unique: true)
+      end
+
+      args.each { |name| column(name, :string, options) }
+    end
+
+    # Commonly used
+    def alias(*args)
+      args << :alias if args.empty? || args.first.kind_of?(Hash)
+      human_id(*args)
+    end
+  end
+end

data/lib/humanid/railtie.rb

@@ -0,0 +1,10 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HumanID
+  class Railtie < Rails::Railtie
+    # http://blog.nathanhumbert.com/2010/02/rails-3-loading-rake-tasks-from-gem.html
+    # TODO Fix bug: task runs twice
+    rake_tasks { load 'tasks/human_id.rake' }
+  end
+end

data/lib/humanid/transliteration.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module HumanID
+  module Transliteration
+    class << self
+      #
+      # HumanID::Transliteration.perform('Well-known English writer')
+      #   => 'well-known-english-writer'
+      #
+      # HumanID::Transliteration.perform('Well-known English writer', normalize: false, downcase: false)
+      #   => 'Well-known English writer'
+      #
+      # HumanID::Transliteration.perform('Пушкин, Александр Сергеевич')
+      #   => 'pushkin-aleksandr-sergeevich'
+      #
+      # HumanID::Transliteration.perform('Пушкин, Александр Сергеевич', normalize: false, downcase: false)
+      #   => 'Pushkin, Aleksandr Sergeevich'
+      #
+      def perform(str, options = {})
+        previous_locale = I18n.locale
+        I18n.locale     = I18n.default_locale
+        separator       = options.fetch(:separator, behaviour.separator)
+        downcase        = options.fetch(:downcase, behaviour.perform_downcase?)
+        normalize       = options.fetch(:normalize, behaviour.perform_normalization?)
+
+        str = str.join(separator) if str.is_a?(Array)
+        str = I18n.transliterate(str)
+
+        str = str.downcase if downcase
+
+        if normalize
+          # Strip leading and trailing non-word and non-ASCII characters
+          str = str.gsub(/(\A\W+)|(\W+\z)/, '')
+
+          # Replace the rest of non-word and non-ASCII characters with hyphen
+          str = str.gsub(/\W+/, separator)
+        end
+
+        str
+      ensure
+        I18n.default_locale = previous_locale
+      end
+
+
+      def valid?(human_id)
+        human_id = human_id.to_s if human_id.kind_of?(Symbol)
+        human_id.kind_of?(String) && !!(human_id =~ behaviour.validation_regex)
+      end
+
+      def validate!(human_id)
+        raise MalformedHumanIDError unless valid?(human_id)
+        true
+      end
+
+      def behaviour
+        Behaviour.instance
+      end
+    end
+
+    class Behaviour
+      include Singleton
+
+      attr_accessor :separator, :downcase, :normalize, :validation_regex
+
+      def initialize
+        self.separator = '-'
+        self.downcase  = true
+        self.normalize = true
+
+        # Not starts with hyphen
+        # Contains 1 to 255 word characters and hyphens
+        # Not ends with hyphen
+        # TODO Validation with custom separator
+        self.validation_regex = /(?!-)\A[\w-]{1,255}(?<!-)\z/
+      end
+
+      def perform_downcase?
+        downcase
+      end
+
+      def perform_normalization?
+        normalize
+      end
+    end
+
+    class MalformedHumanIDError < StandardError
+      def initialize
+        super 'Human ID is malformed'
+      end
+    end
+  end
+
+  class << self
+    def transliterate(str, options = {})
+      Transliteration.perform(str, options)
+    end
+  end
+end

data/lib/tasks/human_id.rake

@@ -0,0 +1,39 @@
+task 'human_id:regenerate' => :environment do
+  force = [ENV['force'], ENV['FORCE']].include?('true')
+
+  puts "Force #{force ? 'true' : 'false'}"
+
+  Traits.each do |traits|
+    attributes = traits.attributes.select do |attr|
+      human_id = attr.features.human_id
+      human_id && human_id.persists? && human_id.updates_automatically?
+    end
+
+    next if attributes.empty?
+
+    traits.active_record.find_each do |model|
+      puts "Processing #{traits.class_name}##{traits.primary_key_attribute.value_from(model)}"
+      changes = 0
+      attributes.each do |attr|
+        current = attr.value_from(model)
+
+        next if !force && !model.send("need_to_update_#{attr.name}?")
+
+        new = model.send("generate_#{attr.name}")
+
+        if current != new
+          changes += 1
+          puts "Current #{attr.name}: #{current ? "'#{current}'" : 'nil'}"
+          puts "New #{attr.name}:     #{new     ? "'#{new}'"     : 'nil'}"
+
+          model.send("assign_#{attr.name}")
+        else
+          puts "#{attr.name} didn't change"
+        end
+
+        puts
+      end
+      model.save! if changes > 0
+    end
+  end
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: humanid
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Yaroslav Konoplov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-10-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-traits
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: unicode-tools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rails-i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ActiveRecord human id
+email:
+- eahome00@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- humanid.gemspec
+- lib/humanid.rb
+- lib/humanid/canonicalization.rb
+- lib/humanid/essay.rb
+- lib/humanid/extension.rb
+- lib/humanid/extension/builder.rb
+- lib/humanid/extension/configuration.rb
+- lib/humanid/extension/generation.rb
+- lib/humanid/extension/pattern.rb
+- lib/humanid/extension/persistence.rb
+- lib/humanid/extension/validation.rb
+- lib/humanid/migration.rb
+- lib/humanid/railtie.rb
+- lib/humanid/transliteration.rb
+- lib/tasks/human_id.rake
+homepage: http://github.com/yivo/activerecord-human-id
+licenses:
+- MIT
+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.5.1
+signing_key: 
+specification_version: 4
+summary: ActiveRecord human id
+test_files: []