enum_for_what 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 442291e3d675a7c3a17027f60fc49262a957aa13
+  data.tar.gz: f12a0d4fc21fa53f71ded0ec41ce9257478e8203
+SHA512:
+  metadata.gz: 3d6aac074f5934a13dda17ea4fb1c369ebeb103b2f42a65941d071f470172f4c454f26e6a228839fc19035589b1470cfeb7acbc2dbca745f0f80d864fb071aef
+  data.tar.gz: 2f76ea7ed227971bd8627b721d376c9b0b798c24d60d917088f6a16444138a2ff28e9e2f5e7346a8318500585694d31fa8917c565f709ec246f0e0ff85512a45

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,23 @@
+The MIT License (MIT)
+
+Copyright (c) 2010-2011 Nick Pohodnya
+Copyright (c) 2015 Sport Ngin
+
+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,83 @@
+# Enum For What!
+
+This gem is an extension to ActiveRecord which enables native support of enumerations in the database schema using the ENUM type in MySQL.
+
+Originally forked from [eletronick/enum_column][1] with several enhancements written and curated from the unenumerable forks of this
+gem (see what I did there?) with love by [Sport Ngin][2].
+
+Supported adapters:
+- mysql
+- mysql2
+- jdbcmysql (by Nilesh Trivedi)
+
+## Installation
+
+In your Gemfile:
+
+```ruby
+gem 'enum_for_what'
+```
+
+## Usage
+
+In your schema(s), specify the constraint as a limit:
+
+```ruby
+create_table :enumerations, :force => true do |t|
+  t.column :severity, :enum, :limit => [:low, :medium, :high, :critical], :default => :medium
+  t.column :color, :enum, :limit => [:red, :blue, :green, :yellow]
+end
+```
+
+In the model, you can then automatically validate this column using:
+
+```ruby
+validates_columns :severity, :color
+```
+
+The rest will be handled for you. All enumerated values will be given as symbols.
+
+```ruby
+@e = Enumeration.new
+@e.severity = :medium
+```
+
+You can always use the column reflection to get the list of possible values from the database column.
+
+```ruby
+Enumeration.columns_hash['color'].limit
+# or
+@enumeration.column_for_attribute(:color).limit
+
+# Will yield => [:red, :blue, :green, :yellow]
+```
+
+If you assign a string to the column, it will be converted to a symbol if it's valid and `nil` otherwise,
+so if this is the only way you populate color, `validates_presence_of` may be the only validation you need.
+
+```ruby
+Enumeration.new(:color => "red") (color will be :red)
+Enumeration.new(:color => "infrared") (color will be nil)
+```
+
+In views, you can use the enum_select helper to generate input for enumerated attributes:
+
+```ruby
+<%= enum_select(@enumeration, 'severity')%>
+# or
+<%= form_for @enumeration do |f| %>
+  <%= f.label :severity %>
+  <%= f.enum_select :severity %>
+<% end %>
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+[1]: https://github.com/electronick/enum_column
+[2]: http://www.codinginthecrease.com/

data/Rakefile

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

data/enum_for_what.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'enum/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "enum_for_what"
+  spec.version       = EnumForWhat::VERSION
+  spec.authors       = ["Chris Arcand", "Nick Pohodnya", "Aaron Weiner"]
+  spec.email         = ["chris.arcand@sportngin.com"]
+
+  spec.summary       = %q{MySQL's native ENUM type for Rails}
+  spec.description   = %q{Allows your Rails models and views to take advantage of MySQL's' native ENUM type
+Originally forked from various forks of https://github.com/electronick/enum_column}
+  spec.homepage      = "https://github.com/sportngin/enum_for_what"
+  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.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end
+

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + "/rails/init.rb"

data/lib/enum/active_record_helper.rb

@@ -0,0 +1,63 @@
+if defined?(Rails::Generator)
+  module Rails
+    module Generator
+      class GeneratedAttribute
+        def field_type_with_enumerated_attribute
+          return (@field_type = :enum_select) if type == :enum
+          field_type_without_enumerated_attribute
+        end
+        alias_method_chain :field_type, :enumerated_attribute
+      end
+    end
+  end
+end
+
+if defined?(ActionView::Base)
+  module ActionView
+    module Helpers
+
+      #form_options_helper.rb
+      module FormOptionsHelper
+        #def select
+        def enum_select(object, method, options={}, html_options={})
+          InstanceTag.new(object, method, self, options.delete(:object)).to_enum_select_tag(options, html_options)
+        end
+      end
+
+      class InstanceTag
+        def to_enum_select_tag(options, html_options={})
+          if self.object.respond_to?(method_name.to_sym)
+            column = self.object.column_for_attribute(method_name)
+            if (value = self.object.__send__(method_name.to_sym))
+              options[:selected] ||= value.to_s
+            else
+              options[:include_blank] = column.null if options[:include_blank].nil?
+            end
+          end
+          to_select_tag(column.limit, options, html_options)
+        end
+
+        #initialize record_name, method, self
+        if respond_to?(:to_tag)
+          def to_tag_with_enumerated_attribute(options={})
+            #look for an enum
+            if (column_type == :enum && self.object.class.respond_to?(method_name.to_sym))
+              to_enum_select_tag(options)
+            else
+              to_tag_without_enumerated_attribute(options)
+            end
+          end
+          alias_method_chain :to_tag, :enumerated_attribute
+        end
+
+      end
+
+      class FormBuilder
+        def enum_select(method, options={}, html_options={})
+          @template.enum_select(@object_name, method, objectify_options(options), @default_options.merge(html_options))
+        end
+      end
+
+    end
+  end
+end

data/lib/enum/enum_adapter.rb

@@ -0,0 +1,25 @@
+# This module provides all the column helper methods to deal with the
+# values and adds the common type management code for the adapters.
+
+adapter_class = if defined? ActiveRecord::ConnectionAdapters::Mysql2Adapter
+                  ActiveRecord::ConnectionAdapters::Mysql2Adapter
+                elsif defined? ActiveRecord::ConnectionAdapters::MysqlAdapter
+                  ActiveRecord::ConnectionAdapters::MysqlAdapter
+                end
+
+if adapter_class
+  adapter_class.class_eval do
+
+    protected
+    if instance_methods.include?(:initialize_type_map)
+      def initialize_type_map_with_enum_types(m)
+        initialize_type_map_without_enum_types(m)
+        m.register_type(%r(enum)i) do |sql_type|
+          limit = sql_type.sub(/^enum\('(.+)'\)/i, '\1').split("','").map { |v| v.intern }
+          ActiveRecord::Type::Enum.new(limit: limit)
+        end
+      end
+      alias_method_chain :initialize_type_map, :enum_types
+    end
+  end
+end

data/lib/enum/enum_column_adapter.rb

@@ -0,0 +1,105 @@
+# This module provides all the column helper methods to deal with the
+# values and adds the common type management code for the adapters.
+
+
+# try rails 3.1, then rails 3.2+, mysql column adapters
+column_class = if defined? ActiveRecord::ConnectionAdapters::Mysql2Column
+                 ActiveRecord::ConnectionAdapters::Mysql2Column
+               elsif defined? ActiveRecord::ConnectionAdapters::MysqlColumn
+                 ActiveRecord::ConnectionAdapters::MysqlColumn
+               elsif defined? ActiveRecord::ConnectionAdapters::Mysql2Adapter::Column
+                 ActiveRecord::ConnectionAdapters::Mysql2Adapter::Column
+               elsif defined? ActiveRecord::ConnectionAdapters::MysqlAdapter::Column
+                 ActiveRecord::ConnectionAdapters::MysqlAdapter::Column
+               else
+                 ObviousHint::NoMysqlAdapterFound
+               end
+
+column_class.class_eval do
+
+  alias __klass_enum klass
+  # The class for enum is Symbol.
+  def klass
+    if type == :enum
+      Symbol
+    else
+      __klass_enum
+    end
+  end
+
+  def __enum_type_cast(value)
+    if type == :enum
+      self.class.value_to_symbol(value)
+    else
+      __type_cast_enum(value)
+    end
+  end
+
+  if instance_methods.include?(:type_cast_from_database)
+    alias __type_cast_enum type_cast_from_database
+    # Convert to a symbol.
+    def type_cast_from_database(value)
+      __enum_type_cast(value)
+    end
+  elsif instance_methods.include?(:type_cast)
+    alias __type_cast_enum type_cast
+    def type_cast(value)
+      __enum_type_cast(value)
+    end
+  end
+
+  # Deprecated in Rails 4.1
+  if instance_methods.include?(:type_cast_code)
+    alias __type_cast_code_enum type_cast_code
+    # Code to convert to a symbol.
+    def type_cast_code(var_name)
+      if type == :enum
+        "#{self.class.name}.value_to_symbol(#{var_name})"
+      else
+        __type_cast_code_enum(var_name)
+      end
+    end
+  end
+
+  class << self
+    # Safely convert the value to a symbol.
+    def value_to_symbol(value)
+      case value
+      when Symbol
+        value
+      when String
+        value.empty? ? nil : value.intern
+      else
+        nil
+      end
+    end
+  end
+
+  private
+
+  # Deprecated in Rails 4.2
+  if private_instance_methods.include?(:simplified_type)
+    alias __simplified_type_enum simplified_type
+    # The enum simple type.
+    def simplified_type(field_type)
+      if field_type =~ /enum/i
+        :enum
+      else
+        __simplified_type_enum(field_type)
+      end
+    end
+  end
+
+  # Deprecated in Rails 4.2
+  if private_instance_methods.include?(:extract_limit)
+    alias __extract_limit_enum extract_limit
+    def extract_limit(sql_type)
+      if sql_type =~ /^enum/i
+        sql_type.sub(/^enum\('(.+)'\)/i, '\1').split("','").map { |v| v.intern }
+      else
+        __extract_limit_enum(sql_type)
+      end
+    end
+  end
+
+end

data/lib/enum/enum_type.rb

@@ -0,0 +1,29 @@
+if defined? ActiveRecord::Type::Value
+  module ActiveRecord
+    module Type
+      class Enum < Value # :nodoc:
+        def type
+          :enum
+        end
+
+        def type_cast_for_database(value)
+          if value.nil? || value == ''
+            nil
+          else
+            value.to_s
+          end
+        end
+
+        private
+
+        def cast_value(value)
+          if value.nil? || value == ''
+            nil
+          else
+            value.to_sym
+          end
+        end
+      end
+    end
+  end
+end

data/lib/enum/mysql_adapter.rb

@@ -0,0 +1,17 @@
+adapter_class = if defined? ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
+                  ActiveRecord::ConnectionAdapters::MySQLJdbcConnection
+                elsif defined? ActiveRecord::ConnectionAdapters::Mysql2Adapter
+                  ActiveRecord::ConnectionAdapters::Mysql2Adapter
+                elsif defined? ActiveRecord::ConnectionAdapters::MysqlAdapter
+                  ActiveRecord::ConnectionAdapters::MysqlAdapter
+                end
+
+adapter_class.module_eval do
+  alias __native_database_types_enum native_database_types
+
+  def native_database_types #:nodoc
+    types = __native_database_types_enum
+    types[:enum] = { :name => "enum" }
+    types
+  end
+end

data/lib/enum/quoting.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module Quoting
+      alias __quote_enum quote
+
+      # Quote a symbol as a normal string. This will support quoting of
+      # enumerated values.
+      def quote(value, column = nil)
+        if !value.is_a? Symbol
+          __quote_enum(value, column)
+        else
+          ActiveRecord::Base.send(:quote_bound_value, value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/enum/schema_definitions.rb

@@ -0,0 +1,11 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class TableDefinition
+      def enum(*args)
+        options = args.extract_options!
+        column_names = args
+        column_names.each { |name| column(name, 'enum', options) }
+      end
+    end
+  end
+end

data/lib/enum/schema_statements.rb

@@ -0,0 +1,27 @@
+module ActiveRecord
+  module ConnectionAdapters # :nodoc:
+    module SchemaStatements
+      alias __type_to_sql_enum type_to_sql
+
+      # Add enumeration support for schema statement creation. This
+      # will have to be adapted for every adapter if the type requires
+      # anything by a list of allowed values. The overrides the standard
+      # type_to_sql method and chains back to the default. This could
+      # be done on a per adapter basis, but is generalized here.
+      #
+      # will generate enum('a', 'b', 'c') for :limit => [:a, :b, :c]
+      def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+        if type == :enum
+          native = native_database_types[type]
+          column_type_sql = (native || {})[:name] || 'enum'
+
+          column_type_sql << "(#{limit.map { |v| quote(v) }.join(',')})"
+
+          column_type_sql
+        else
+          __type_to_sql_enum(type, limit, precision, scale)
+        end
+      end
+    end
+  end
+end

data/lib/enum/validations.rb

@@ -0,0 +1,39 @@
+module ActiveRecord
+  module Validations
+    module ClassMethods
+      # Automatically validates the column against the schema definition
+      # for nullability, format, and enumerations. Handles integers, floats,
+      # enumerations, and string limits.
+      #
+      # Usage: validates_columns :severity, :name
+      def validates_columns(*column_names)
+        begin
+          cols = columns_hash
+          column_names.each do |name|
+            col = cols[name.to_s]
+            raise ArgumentError, "Cannot find column #{name}" unless col
+
+            # test for nullability
+            validates_presence_of(name) if !col.null
+
+            # Test various known types.
+            case col.type
+            when :enum
+              validates_inclusion_of name, :in => col.limit, :allow_nil => true
+
+            when :integer, :float
+              validates_numericality_of name, :allow_nil => true
+
+            when :string
+              if col.limit
+                validates_length_of name, :maximum => col.limit, :allow_nil => true
+              end
+            end
+          end
+        rescue ActiveRecord::StatementInvalid=>e
+          raise e unless e.message.include?("42S02") # swallow the exception if its for a missing table
+        end
+      end
+    end
+  end
+end

data/lib/enum/version.rb

@@ -0,0 +1,3 @@
+module EnumForWhat
+  VERSION = '0.0.1'
+end

data/lib/enum_column.rb

@@ -0,0 +1,20 @@
+if defined?(::Rails::Railtie)
+  class EnumColumnRailtie < Rails::Railtie
+    initializer 'enum_column.initialize', :after => 'active_record.initialize_database' do |app|
+      ActiveSupport.on_load :active_record do
+        require 'enum/mysql_adapter'
+        require 'enum/enum_type'
+        require 'enum/enum_adapter'
+        require 'enum/enum_column_adapter'
+        require 'enum/schema_statements'
+        require 'enum/schema_definitions'
+        require 'enum/quoting'
+        require 'enum/validations'
+      end
+
+      ActiveSupport.on_load :action_view do
+        require 'enum/active_record_helper'
+      end
+    end
+  end
+end

data/lib/enum_column3.rb

@@ -0,0 +1 @@
+require 'enum_column'

data/lib/enum_column_strict.rb

@@ -0,0 +1 @@
+require 'enum_column'

data/lib/enum_for_what.rb

@@ -0,0 +1 @@
+require 'enum_column'

data/rails/init.rb

@@ -0,0 +1 @@
+require 'enum_column'

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: enum_for_what
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Chris Arcand
+- Nick Pohodnya
+- Aaron Weiner
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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'
+description: |-
+  Allows your Rails models and views to take advantage of MySQL's' native ENUM type
+  Originally forked from various forks of https://github.com/electronick/enum_column
+email:
+- chris.arcand@sportngin.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- enum_for_what.gemspec
+- init.rb
+- lib/enum/active_record_helper.rb
+- lib/enum/enum_adapter.rb
+- lib/enum/enum_column_adapter.rb
+- lib/enum/enum_type.rb
+- lib/enum/mysql_adapter.rb
+- lib/enum/quoting.rb
+- lib/enum/schema_definitions.rb
+- lib/enum/schema_statements.rb
+- lib/enum/validations.rb
+- lib/enum/version.rb
+- lib/enum_column.rb
+- lib/enum_column3.rb
+- lib/enum_column_strict.rb
+- lib/enum_for_what.rb
+- rails/init.rb
+homepage: https://github.com/sportngin/enum_for_what
+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.8
+signing_key: 
+specification_version: 4
+summary: MySQL's native ENUM type for Rails
+test_files: []