rails_string_enum 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3b9e6d5bf513ef92f4a9811d1b7156db72a41a92
+  data.tar.gz: 5b72388e7ee40dc6bae33b4932c3fd43d5a3c203
+SHA512:
+  metadata.gz: b08ec344d78a24b071d4b597313e0f683f8d416e031cb9f8dee6ee8d3f3be87ee17c7043b1ccd3c7152d02675c98b22bb1733f3538afbb55c70b5d4134b34d8b
+  data.tar.gz: 1ffb81727cdf171425a883e2f123e3c95d7622d58ae7519dcf856f2616e38e2db38f8b1e91f9409fd62b886e673759a05ee2da7f9865748e701c51de1f421513

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rails_string_enum.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Ermolaev Andrey
+
+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,133 @@
+## rails_string_enum
+support in rails db enums or string (using as flexible enum)
+
+This gem inspired rails native enum and  https://github.com/zmbacker/enum_help
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rails_string_enum'
+
+
+Tested on Rails 4.2, ruby 2.2
+
+#### Native postgresql enum (migrations)
+```ruby
+
+create_enum :color, %w(red green blue) # default schema is 'public'
+create_enum :color, %w(red green blue), schema: 'cmyk'
+
+add_enum_value :color, 'black'
+add_enum_value :color, 'black', after: 'red'
+add_enum_value :color, 'black', before: 'blue'
+add_enum_value :color, 'black', schema: 'public'
+
+drop_enum :color
+drop_enum :color, schema: 'cmyk'
+
+rename_enum_value :color, 'gray', 'black'
+reorder_enum_values :order_state_enum, %w(black white) # other color will be latest
+
+delete_enum_value :color, 'black'
+# you should delete record with deleting value
+# if exists index with condition method raise exeption
+# "ERROR: operator does not exist: order_type_enum <> order_type_enum_new"
+# you should first remove and then create an index
+  Product.where(color: 'black').delete_all # or Product.where(color: 'black').update_all(state: nil)
+  remove_index :product, :color, where: "color NOT IN ('pink')"
+  delete_enum_value :color, 'black'
+  add_index :product, :color, where: "color NOT IN ('pink')"
+```
+
+###### Convert exist columns (int, string) to postgresql enum
+```ruby
+string_to_enums :product, :color, enum_name: 'product_color_enum', definitions: %w(red green blue)
+string_to_enums :product, :color, enum_name: 'product_color_enum', definitions: Product.uniq.pluck(:color)
+
+int_to_enums :product, :color, enum_name: 'product_color_enum', definitions: { red: 0, green: 1, blue: 2 }
+```
+
+
+#### Usage
+```ruby
+class CreateTables < ActiveRecord::Migration
+  def change
+    create_table :products do |t|
+      t.string :color
+    end
+    
+    create_enum :enum_color, %w(red green blue)
+    
+    create_table :pages do |t|
+      t.column :color, :enum_color, default: 'red'
+    end
+  end
+end
+
+class Product < ActiveRecord::Base
+  string_enum :color, %w(red green yellow black white), scope: true # default false
+  
+  def self.colored
+    where.not(color: [COLOR::BLACK, COLOR::WHITE])
+  end
+end
+
+class Page < ActiveRecord::Base
+  string_enum :background, %w(red green), i18n_scope: 'product.color'
+end
+
+Product::COLORS # => ["red", "green", "yellow"]
+Product::COLOR::RED # => "red"
+Product::COLOR::GREEN # => "green"
+
+@product = Product.new
+@product.color_i18n  # => nil
+@product.red!
+@product.color_i18n # => 'Красный'
+
+Product.color_i18n_for('red') # => 'Красный'
+Product.colors_i18n # => {green: 'Зеленый', red: 'Красный', yellow: 'Желтый'}
+Product.red # if scope: true
+```
+
+
+I18n local file example (compatible with https://github.com/zmbacker/enum_help):
+
+```yaml
+# config/locals/ru.yml
+ru:
+  enums:
+    product:
+      color:
+        red: Красный
+        green: Зеленый
+        yellow: Желтый
+```
+
+Support `simple_form`:
+```erb
+<%= f.input :color %>
+```
+
+#### Benchmark i18n methods (rails_string_enum faster 2x then enum_help)
+
+```ruby
+Benchmark.ips do |x|
+  x.report('rails_string_enum')   { u.social_app_i18n }
+  x.report('enum_help')           { u.social_app_i18n_eh }
+  x.report('rails_string_enum_c') { Order.states_i18n }
+  x.report('enum_help_c')         { Order.states_i18n_eh }
+end
+
+Calculating -------------------------------------
+   rails_string_enum     3.149k i/100ms
+           enum_help     1.489k i/100ms
+ rails_string_enum_c     3.002k i/100ms
+         enum_help_c     1.384k i/100ms
+-------------------------------------------------
+   rails_string_enum     42.727k (± 4.4%) i/s -    214.132k
+           enum_help     16.686k (±11.9%) i/s -     81.895k
+ rails_string_enum_c     38.159k (± 5.3%) i/s -    192.128k
+         enum_help_c     15.939k (± 4.5%) i/s -     80.272k
+```
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rails_string_enum/patch_enum_null.rb

@@ -0,0 +1,17 @@
+require 'active_record/connection_adapters/postgresql/oid/enum'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module PostgreSQL
+      module OID # :nodoc:
+        class Enum < Type::Value # :nodoc:
+          def type_cast(value)
+            unless value.nil?
+              value.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rails_string_enum/pg_enum_migration.rb

@@ -0,0 +1,143 @@
+module PgEnumMigrations
+
+  # create_enum :color, %w(red green blue) # default schema is 'public'
+  # create_enum :color, %w(red green blue), schema: 'cmyk'
+  def create_enum(enum_name, values, schema: nil)
+    execute "CREATE TYPE #{enum_name(enum_name, schema)} AS ENUM (#{escape_enum_values(values)})"
+  end
+
+
+  # add_enum_value :color, 'black'
+  # add_enum_value :color, 'purple', after: 'red'
+  # add_enum_value :color, 'pink', before: 'purple'
+  # add_enum_value :color, 'white', schema: 'public'
+  def add_enum_value(enum_name, value, before: nil, after: nil, schema: nil)
+    opts = if    before then "BEFORE #{escape_enum_value(before)}"
+           elsif after  then "AFTER #{escape_enum_value(after)}"
+           else  ''
+           end
+    execute "ALTER TYPE #{enum_name(enum_name, schema)} ADD VALUE #{escape_enum_value(value)} #{opts}"
+  end
+
+  # drop_enum :color
+  # drop_enum :color, schema: 'cmyk'
+  def drop_enum(enum_name, schema: nil)
+    execute "DROP TYPE #{enum_name(enum_name, schema)}"
+  end
+
+
+  # you should delete record with deleting value
+  # Order.back_picking.delete_all or Order.back_picking.update_all(state: nil)
+  #
+  # if exists index with condition - add_index :orders, :state, where: "state NOT IN ('closed', 'canceled', 'returned')"
+  # this method show exeption ERROR: operator does not exist: order_type_enum <> order_type_enum_new
+  # you must first remove and then create an index
+  #
+  # delete_enum_value :order_state_enum, 'back_picking'
+  def delete_enum_value(enum_name, value_name, scheme: nil)
+    old_values = select_values("SELECT enumlabel FROM pg_catalog.pg_enum WHERE enumtypid = #{enum_name_as_srt(enum_name, scheme)}::regtype::oid")
+    new_values = old_values - Array(value_name)
+
+    execute <<-SQL
+      ALTER TYPE #{enum_name} rename to #{enum_name}_old;
+      CREATE TYPE #{enum_name} AS enum (#{escape_enum_values(new_values)});
+    SQL
+
+    cols_using_enum = select_rows("SELECT table_name, column_name FROM information_schema.columns WHERE udt_name = '#{enum_name}_old'")
+    cols_using_enum.each do |table_name, column_name|
+      execute <<-SQL
+        ALTER TABLE #{table_name}
+        ALTER COLUMN #{column_name} TYPE #{enum_name} USING #{column_name}::text::#{enum_name};
+      SQL
+    end
+
+    execute <<-SQL
+      DROP TYPE #{enum_name}_old
+    SQL
+  end
+
+
+
+  # rename_enum_value :order_state_enum, 'accept', 'init'
+  def rename_enum_value(enum_name, old_value_name, new_value_name, scheme: nil)
+    execute <<-SQL
+      UPDATE pg_catalog.pg_enum
+      SET enumlabel = '#{new_value_name}'
+      WHERE enumtypid = #{enum_name_as_srt(enum_name, scheme)}::regtype::oid AND enumlabel = '#{old_value_name}'
+    SQL
+  end
+
+
+
+  # reorder_enum_values :order_state_enum, %w(lost returning obtain accept)
+  def reorder_enum_values(enum_name, ordered_values, scheme: nil)
+    all_values = select_values("SELECT enumlabel FROM pg_catalog.pg_enum WHERE enumtypid = '#{scheme}.#{enum_name}'::regtype::oid")
+    max_order =  select_value("SELECT max(enumsortorder) FROM pg_catalog.pg_enum WHERE enumtypid = '#{scheme}.#{enum_name}'::regtype::oid").to_i + 1
+
+    ordered_sql = (ordered_values | all_values).map.with_index{|v, i| "WHEN '#{v}' THEN #{i + max_order}"}.join(' ')
+
+    execute <<-SQL
+      UPDATE pg_catalog.pg_enum
+      SET enumsortorder = CASE enumlabel #{ordered_sql} END
+      WHERE enumtypid = #{enum_name_as_srt(enum_name, scheme)}::regtype::oid
+    SQL
+  end
+
+
+
+  # string_to_enums :order, :state, enum_name: 'order_state_enum', definitions: %w(accept confirmed)
+  def string_to_enums(table, col_name, enum_name:, definitions: nil, default: nil, use_exist_enum: false)
+    convert_to_enum table, col_name, enum_name, definitions, col_name, default, use_exist_enum
+  end
+
+
+
+  # int_to_enums :users, :partner_type, enum_name: 'user_partner_type_enum', definitions: { retail: 0, affiliate: 1, wholesale: 2 }
+  def int_to_enums(table, col_name, enum_name:, definitions: nil, default: nil, use_exist_enum: false)
+    convert_sql = definitions.map {|str, int| "WHEN #{int} THEN '#{str}'" }.join(' ')
+    convert_sql = "CASE #{col_name} #{convert_sql} END"
+
+    convert_to_enum table, col_name, enum_name, definitions.keys, convert_sql, default, use_exist_enum
+  end
+
+
+
+  private
+
+  def enum_name(name, schema)
+    [schema || 'public', name].map { |s|
+      %Q{"#{s}"}
+    }.join('.')
+  end
+
+  def enum_name_as_srt(name, schema)
+    [schema || 'public', name].map { |s|
+      %Q{'#{s}'}
+    }.join('.')
+  end
+
+  def escape_enum_value(value)
+    escaped_value = value.to_s.sub("'", "''")
+    "'#{escaped_value}'"
+  end
+
+  def escape_enum_values(values)
+    values.map { |value| escape_enum_value(value) }.join(',')
+  end
+
+  def convert_to_enum(table, col_name, enum_name, keys, convert_sql, default, use_exist_enum)
+    schema = select_value("SELECT table_schema FROM information_schema.columns WHERE table_name = '#{table}'")
+
+    execute "CREATE TYPE #{enum_name(enum_name, schema)} AS ENUM (#{escape_enum_values(keys)})" unless use_exist_enum
+
+    default_sql = ", ALTER COLUMN #{col_name} DROP DEFAULT" if default
+
+    execute <<-SQL
+      ALTER TABLE #{table}
+      ALTER COLUMN #{col_name} DROP DEFAULT,
+      ALTER COLUMN #{col_name} TYPE #{enum_name} USING #{convert_sql}::#{enum_name}
+    #{default_sql};
+    SQL
+  end
+
+end

data/lib/rails_string_enum/simple_form.rb

@@ -0,0 +1,69 @@
+require 'simple_form'
+
+module EnumHelp
+  module SimpleForm
+    module BuilderExtension
+
+      def default_input_type_with_enum(*args, &block)
+        attr_name = (args.first || @attribute_name).to_s
+        options = args.last
+
+        const_for_attr = object.respond_to? "#{attr_name}_i18n"
+
+        return :enum_radio_buttons if options.is_a?(Hash) && options[:as] == :radio_buttons && const_for_attr
+        return :enum if (options.is_a?(Hash) ? options[:as] : @options[:as]).nil? && const_for_attr
+
+        default_input_type_without_enum(*args, &block)
+      end
+    end
+
+    module InputExtension
+
+      def initialize(*args)
+        super
+        enum = input_options[:collection] || @builder.options[:collection]
+        raise "Attribute '#{attribute_name}' has no enum class" unless enum ||= object.class.const_get(attribute_name.to_s.pluralize.upcase)
+
+        collect = begin
+          collection = object.class.send("#{attribute_name.to_s.pluralize}_i18n")
+          collection.slice!(*enum) if enum
+          collection.invert.to_a
+        end
+
+        # collect.unshift [args.last[:prompt],''] if args.last.is_a?(Hash) && args.last[:prompt]
+
+        if respond_to?(:input_options)
+          input_options[:collection] = collect
+        else
+          @builder.options[:collection] = collect
+        end
+      end
+
+    end
+
+  end
+end
+
+
+class EnumHelp::SimpleForm::EnumInput < ::SimpleForm::Inputs::CollectionSelectInput
+  include EnumHelp::SimpleForm::InputExtension
+  def input_html_classes
+    super.push('form-control')
+  end
+end
+
+
+class EnumHelp::SimpleForm::EnumRadioButtons < ::SimpleForm::Inputs::CollectionRadioButtonsInput
+  include EnumHelp::SimpleForm::InputExtension
+end
+
+
+SimpleForm::FormBuilder.class_eval do
+  include EnumHelp::SimpleForm::BuilderExtension
+
+  map_type :enum,               :to => EnumHelp::SimpleForm::EnumInput
+  map_type :enum_radio_buttons, :to => EnumHelp::SimpleForm::EnumRadioButtons
+  alias_method :collection_enum_radio_buttons, :collection_radio_buttons
+  alias_method :collection_enum, :collection_select
+  alias_method_chain :default_input_type, :enum
+end

data/lib/rails_string_enum/string_enum.rb

@@ -0,0 +1,131 @@
+module RailsStringEnum
+
+  # product.rb
+  # string_enum :color, %w(red green yellow)
+  # page.rb
+  # string_enum :background, %w(red green), i18n_scope: 'product.color'
+
+  def string_enum(name, enums, scopes: false, i18n_scope: nil)
+    # create constant with all values
+    # Product::COLORS # => ["red", "green", "yellow"]
+    const_name_all_values = name.to_s.pluralize.upcase
+    const_set const_name_all_values, enums.map(&:to_s)
+
+    # create constant for each value
+    # Product::COLOR::RED # => "red"
+    # Product::COLOR::GREEN #=> "green"
+    new_module = const_set name.to_s.upcase, Module.new
+    enums.each { |const| new_module.const_set(const.to_s.upcase, const.to_s) }
+
+
+    klass = self
+    enums.each do |value|
+      # def red?() color == 'red' end
+      klass.send(:detect_enum_conflict!, name, "#{value}?")
+      define_method("#{value}?") { self[name] == value }
+
+      # def red!() update! color: :red end
+      klass.send(:detect_enum_conflict!, name, "#{value}!")
+      define_method("#{value}!") { update! name => value }
+
+      if scopes
+        # scope :red, -> { where color: 'red' }
+        klass.send(:detect_enum_conflict!, name, value, true)
+        klass.scope value, -> { klass.where name => value }
+      end
+    end
+
+    define_attr_i18n_method(self, name, i18n_scope)
+    define_collection_i18n_method(self, name, i18n_scope)
+    define_collection_i18n_method_for_value(self, name, i18n_scope)
+  end
+
+
+  private
+
+  ENUM_CONFLICT_MESSAGE = \
+      "You tried to define an enum named \"%{enum}\" on the model \"%{klass}\", but " \
+      "this will generate a %{type} method \"%{method}\", which is already defined " \
+      "by %{source}."
+
+  def detect_enum_conflict!(enum_name, method_name, klass_method = false)
+    if klass_method && dangerous_class_method?(method_name)
+      raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
+                             enum: enum_name,
+                             klass: self.name,
+                             type: 'class',
+                             method: method_name,
+                             source: 'Active Record'
+                         }
+    elsif !klass_method && dangerous_attribute_method?(method_name)
+      raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
+                             enum: enum_name,
+                             klass: self.name,
+                             type: 'instance',
+                             method: method_name,
+                             source: 'Active Record'
+                         }
+    elsif !klass_method && method_defined_within?(method_name, _enum_methods_module, Module)
+      raise ArgumentError, ENUM_CONFLICT_MESSAGE % {
+                             enum: enum_name,
+                             klass: self.name,
+                             type: 'instance',
+                             method: method_name,
+                             source: 'another enum'
+                         }
+    end
+  end
+
+
+  # @product.color_i18n => 'Красный'
+  def define_attr_i18n_method(klass, attr_name, i18n_scope)
+    attr_i18n_method_name = "#{attr_name}_i18n"
+
+    klass.class_eval <<-METHOD, __FILE__, __LINE__
+      def #{attr_i18n_method_name}
+        if enum_label = self.send(:#{attr_name})
+          #{ruby_string_for_enum_label(klass, attr_name, i18n_scope)}
+        else
+          nil
+        end
+      end
+
+      def #{attr_i18n_method_name}_for
+          #{ruby_string_for_enum_label(klass, attr_name, i18n_scope)}
+      end
+    METHOD
+  end
+
+  # Product.color_i18n_for('red') => 'Красный'
+  def define_collection_i18n_method_for_value(klass, attr_name, i18n_scope)
+    attr_i18n_method_name = "#{attr_name}_i18n"
+
+    klass.class_eval <<-METHOD, __FILE__, __LINE__
+      def #{attr_i18n_method_name}_for
+        #{ruby_string_for_enum_label(klass, attr_name, i18n_scope)}
+      end
+    METHOD
+  end
+
+  # Product.colors_i18n => {green: 'Зеленый', red: 'Красный', yellow: 'Желтый'}
+  def define_collection_i18n_method(klass, attr_name, i18n_scope)
+    collection_method_name = "#{attr_name.to_s.pluralize}_i18n"
+    collection_const_name = "#{attr_name.to_s.pluralize.upcase}"
+
+    klass.instance_eval <<-METHOD, __FILE__, __LINE__
+      def #{collection_method_name}
+        h = HashWithIndifferentAccess.new
+        self::#{collection_const_name}.each do |enum_label|
+          h[enum_label] = #{ruby_string_for_enum_label(klass, attr_name, i18n_scope)}
+        end
+        h
+      end
+    METHOD
+  end
+
+  def ruby_string_for_enum_label(klass, attr_name, i18n_scope)
+    part_scope = i18n_scope || "#{klass.base_class.to_s.underscore}.#{attr_name}"
+    %Q{::I18n.t(enum_label, scope: "enums.#{part_scope}", default: enum_label)}
+  end
+
+end

data/lib/rails_string_enum/version.rb

@@ -0,0 +1,3 @@
+module RailsStringEnum
+  VERSION = "0.1.0"
+end

data/lib/rails_string_enum.rb

@@ -0,0 +1,20 @@
+require 'rails_string_enum/version'
+
+
+require 'rails_string_enum/pg_enum_migration'
+require 'active_record/connection_adapters/postgresql_adapter'
+ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send :include, PgEnumMigrations
+
+
+require 'rails_string_enum/string_enum'
+ActiveRecord::Base.send :extend, RailsStringEnum
+
+
+require 'rails_string_enum/patch_enum_null' if Rails.version <= "4.2.1"
+
+
+begin
+  require 'simple_form'
+  require 'rails_string_enum/simple_form'
+rescue
+end

data/rails_string_enum.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rails_string_enum/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rails_string_enum"
+  spec.version       = RailsStringEnum::VERSION
+  spec.authors       = ["Ermolaev Andrey"]
+  spec.email         = ["andrey@ermolaev.me"]
+
+  spec.summary       = %q{support in rails db enums or string (using as flexible enum)}
+  spec.description   = %q{migration methods for postgresql, internationalization, simple_form}
+  spec.homepage      = 'https://github.com/ermolaev/rails_string_enum'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_dependency "activerecord", "~> 4.2"
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: rails_string_enum
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ermolaev Andrey
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-05-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+description: migration methods for postgresql, internationalization, simple_form
+email:
+- andrey@ermolaev.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rails_string_enum.rb
+- lib/rails_string_enum/patch_enum_null.rb
+- lib/rails_string_enum/pg_enum_migration.rb
+- lib/rails_string_enum/simple_form.rb
+- lib/rails_string_enum/string_enum.rb
+- lib/rails_string_enum/version.rb
+- rails_string_enum.gemspec
+homepage: https://github.com/ermolaev/rails_string_enum
+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.4.5
+signing_key: 
+specification_version: 4
+summary: support in rails db enums or string (using as flexible enum)
+test_files: []