enum_table 0.0.1

data/lib/enum_table/schema_dumper.rb

@@ -0,0 +1,51 @@
+module EnumTable
+  module SchemaDumper
+    extend ActiveSupport::Concern
+
+    included do
+      alias_method_chain :tables, :enum_table
+      alias_method_chain :ignore_tables, :enum_table
+    end
+
+    def tables_with_enum_table(stream)
+      tables_without_enum_table(stream)
+      table_names = @connection.enum_tables
+      table_names.each do |table_name|
+        stream.puts "  create_enum_table #{table_name.inspect}, force: true do |t|"
+        enum_table_column(stream, table_name, 'id', SchemaStatements::DEFAULT_ID_ATTRIBUTES)
+        enum_table_column(stream, table_name, 'value', SchemaStatements::DEFAULT_VALUE_ATTRIBUTES)
+        @connection.execute("SELECT id, value FROM #{table_name} ORDER BY id").each do |row|
+          stream.puts "    t.add #{row[1].to_s.inspect}, #{row[0]}"
+        end
+        stream.puts "  end"
+        stream.puts
+      end
+    end
+
+    def ignore_tables_with_enum_table
+      ignore_tables_without_enum_table + @connection.enum_tables << 'enum_tables'
+    end
+
+    private
+
+    def enum_table_column(stream, table_name, column_name, defaults)
+      column = @connection.columns(table_name).find { |c| c.name == column_name }
+      custom_attributes = {}
+      COLUMN_ATTRIBUTES.each do |attribute|
+        value = column.send(attribute)
+        value == defaults[attribute] or
+          custom_attributes[attribute] = value
+      end
+      if custom_attributes.present?
+        formatted = custom_attributes.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')
+        stream.puts "    t.#{column_name} #{formatted}"
+      end
+    end
+
+    COLUMN_ATTRIBUTES = [:default, :type, :limit, :null, :precision, :scale]
+  end
+end
+
+# This is not loaded in enum_table.rb as it's only needed when dumping the
+# schema. Instead, we make rake tasks load this file explicitly.
+ActiveRecord::SchemaDumper.send :include, EnumTable::SchemaDumper

data/lib/enum_table/schema_statements.rb

@@ -0,0 +1,86 @@
+module EnumTable
+  module SchemaStatements
+    def create_enum_table(table_name, options={})
+      table = NewTable.new(self, table_name, options)
+      yield table if block_given?
+      table._create
+    end
+
+    def change_enum_table(table_name)
+      yield Table.new(self, table_name)
+    end
+
+    def drop_enum_table(table_name)
+      drop_table table_name
+      execute "DELETE FROM enum_tables WHERE table_name = '#{table_name}'"
+    end
+
+    def enum_tables
+      return [] if !table_exists?('enum_tables')
+      execute("SELECT table_name FROM enum_tables").map do |row|
+        row[0]
+      end.sort
+    end
+
+    DEFAULT_ID_ATTRIBUTES = {type: :integer, limit: 1, null: false}.freeze
+    DEFAULT_VALUE_ATTRIBUTES = {type: :string, limit: 255, null: false}.freeze
+
+    class NewTable
+      def initialize(connection, name, options)
+        @connection = connection
+        @name = name
+        @options = options
+        @id = DEFAULT_ID_ATTRIBUTES.dup
+        @value = DEFAULT_VALUE_ATTRIBUTES.dup
+        @adds = []
+        values = options.delete(:values) and
+          values.each { |args| add(*args) }
+      end
+
+      def _create
+        @connection.create_table @name, @options.merge(id: false) do |t|
+          t.column :id, @id.delete(:type), @id
+          t.column :value, @value.delete(:type), @value
+        end
+        unless @connection.table_exists?(:enum_tables)
+          @connection.create_table :enum_tables, id: false, force: true do |t|
+            t.string :table_name, null: false
+          end
+        end
+        @connection.execute "INSERT INTO enum_tables(table_name) VALUES('#{@name}')"
+        table = Table.new(@connection, @name, 0)
+        @adds.each { |args| table.add(*args) }
+      end
+
+      def id(options)
+        @id.update(options)
+      end
+
+      def value(options)
+        @value.update(options)
+      end
+
+      def add(*args)
+        @adds << args
+      end
+    end
+
+    class Table
+      def initialize(connection, name, max_id=nil)
+        @connection = connection
+        @name = name
+        @max_id = @connection.execute("SELECT max(id) FROM #{@name}").to_a[0][0] || 0
+      end
+
+      def add(value, id=nil)
+        id ||= @max_id + 1
+        @max_id = id if id > @max_id
+        @connection.execute "INSERT INTO #{@name}(id, value) VALUES(#{id}, '#{value}')"
+      end
+
+      def remove(value)
+        @connection.execute "DELETE FROM #{@name} WHERE value = '#{value}'"
+      end
+    end
+  end
+end

data/lib/enum_table/version.rb

@@ -0,0 +1,11 @@
+module EnumTable
+  VERSION = [0, 0, 1]
+
+  class << VERSION
+    include Comparable
+
+    def to_s
+      join('.')
+    end
+  end
+end

data/test/database.yml

@@ -0,0 +1,19 @@
+sqlite3:
+  database: ':memory:'
+mysql:
+  username: root
+  password:
+  database: db_nazi_test
+mysql2:
+  username: root
+  password:
+  database: db_nazi_test
+postgresql:
+  username: postgres
+  password:
+  database: db_nazi_test
+  min_messages: warning
+jdbcmysql:
+  username: root
+  password:
+  database: db_nazi_test

data/test/enum_table/test_record.rb

@@ -0,0 +1,578 @@
+require_relative '../test_helper'
+
+describe EnumTable do
+  use_database
+
+  before do
+    connection.create_table :users do |t|
+      t.integer :gender_id
+      t.integer :status_id
+      t.string :user_type
+    end
+  end
+
+  before { Object.const_set :User, Class.new(ActiveRecord::Base) }
+  after { Object.send :remove_const, :User }
+
+  describe '.enum' do
+    before do
+      connection.create_table(:user_genders) { |t| t.string :value }
+      connection.execute "INSERT INTO user_genders(id, value) VALUES (1, 'female'), (2, 'male')"
+    end
+
+    it "defines an enum by a conventionally named table by default" do
+      User.enum :gender
+      User.enums[:gender].value(1).must_equal(:female)
+    end
+
+    it "returns the reflection" do
+      reflection = User.enum :gender
+      reflection.must_be_kind_of EnumTable::Reflection
+      reflection.name.must_equal :gender
+    end
+
+    it "accepts the :table name as a string" do
+      connection.create_table(:custom_table) { |t| t.string :value }
+      connection.execute "INSERT INTO custom_table(id, value) VALUES (1, 'male'), (2, 'female')"
+      User.enum :gender, table: 'custom_table'
+      User.enums[:gender].value(1).must_equal(:male)
+    end
+
+    it "accepts the :table name as a symbol" do
+      connection.create_table(:custom_table) { |t| t.string :value }
+      connection.execute "INSERT INTO custom_table(id, value) VALUES (1, 'male'), (2, 'female')"
+      User.enum :gender, table: :custom_table
+      User.enums[:gender].value(1).must_equal(:male)
+    end
+
+    it "accepts the :table directly as a hash" do
+      User.enum :gender, table: {male: 1, female: 2}
+      User.enums[:gender].value(1).must_equal :male
+    end
+
+    it "accepts the :table as an array" do
+      User.enum :gender, table: [:male, :female]
+      User.enums[:gender].value(1).must_equal :male
+    end
+
+    it "raises an ArgumentError if :table is something else" do
+      ->{ User.enum :gender, table: Object.new }.must_raise ArgumentError, /invalid :table specifier/
+    end
+
+    it "passes other options to the Reflection" do
+      User.enum :gender, id_name: :gender_number
+      enum = User.enums[:gender]
+      enum.id_name.must_equal :gender_number
+    end
+
+    describe "on a subclass" do
+      before do
+        User.inheritance_column = :user_type
+        Object.const_set :Subuser, Class.new(User)
+      end
+
+      after do
+        Object.send :remove_const, :Subuser
+      end
+
+      it "makes any values in the superclass available in the subclass" do
+        User.enum :gender, table: {female: 1}
+        Subuser.enum :gender, table: {male: 2}
+        Subuser.reflect_on_enum(:gender).id(:female).must_equal 1
+      end
+
+      it "makes any values added in the subclass not available to the superclass" do
+        User.enum :gender, table: {female: 1}
+        Subuser.enum :gender, table: {male: 2}
+        User.reflect_on_enum(:gender).id(:male).must_be_nil
+      end
+
+      it "inherits options from the superclass that aren't given for the subclass" do
+        User.enum :gender, table: {female: 1, male: 2}, type: :string, id_name: :status_id
+        Subuser.enum :gender
+        reflection = Subuser.reflect_on_enum(:gender)
+        reflection.id(:female).must_equal 1
+        reflection.type.must_equal :string
+        reflection.id_name.must_equal :status_id
+      end
+
+      it "inherits options from the superclass if no enum call is made in the subclass" do
+        User.enum :gender, table: {female: 1, male: 2}
+        Subuser.reflect_on_enum(:gender).id(:female).must_equal 1
+      end
+
+      it "allows overriding the :type option in the subclass" do
+        User.enum :gender, type: :symbol
+        Subuser.enum :gender, type: :string
+        User.reflect_on_enum(:gender).type.must_equal :symbol
+        Subuser.reflect_on_enum(:gender).type.must_equal :string
+      end
+
+      it "allows overriding the :id_name option in the subclass" do
+        User.enum :gender, id_name: :status_id, type: :symbol
+        Subuser.enum :gender, id_name: :status_id, type: :string
+        User.reflect_on_enum(:gender).type.must_equal :symbol
+        Subuser.reflect_on_enum(:gender).type.must_equal :string
+      end
+    end
+  end
+
+  describe ".reflect_on_enum" do
+    before { User.enum :gender, table: {} }
+
+    it "returns the reflection for the named enum" do
+      reflection = User.reflect_on_enum(:gender)
+      reflection.name.must_equal :gender
+    end
+
+    it "returns nil if there is no such enum" do
+      User.reflect_on_enum(:invalid).must_be_nil
+    end
+  end
+
+  describe ".enum_id" do
+    before { User.enum :gender, table: {female: 1} }
+
+    it "raises an ArgumentError if the enum name is invalid" do
+      ->{ User.enum_id(:bad) }.must_raise ArgumentError
+    end
+
+    it "returns the id for the given enum value" do
+      User.enum_id(:gender, :female).must_equal 1
+    end
+  end
+
+  describe ".initialize_attributes" do
+    before { User.enum :gender, table: {female: 1, male: 2} }
+
+    it "converts enums to their underlying IDs" do
+      attributes = User.initialize_attributes('gender' => 'female')
+      attributes.must_equal('gender_id' => 1)
+    end
+
+    it "does not prevent optimistic locking from working, which also uses this internal method" do
+      attributes = User.initialize_attributes('lock_version' => nil)
+      attributes.must_equal('lock_version' => 0)
+    end
+
+    it "should favor the ID if both the id and value are present in the attributes hash (so enums override columns)" do
+      attributes = User.initialize_attributes('gender_id' => 1, 'gender' => :male)
+      attributes['gender_id'].must_equal 1
+      attributes.key?('gender').must_equal false
+    end
+  end
+
+  describe "#enum_id" do
+    before { User.enum :gender, table: {female: 1} }
+
+    it "raises an ArgumentError if the enum name is invalid" do
+      user = User.new
+      ->{ user.enum_id(:bad) }.must_raise ArgumentError
+    end
+
+    it "returns the id for the given enum value" do
+      user = User.new
+      user.enum_id(:gender, :female).must_equal 1
+    end
+  end
+
+  describe "#read_enum" do
+    before { User.enum :gender, table: {female: 1, male: 2} }
+
+    it "raises an ArgumentError if the enum name is invalid" do
+      user = User.new
+      ->{ user.read_enum(:bad) }.must_raise ArgumentError
+    end
+
+    it "returns the value mapped to the id" do
+      user = User.new(gender_id: 1)
+      user.read_enum(:gender).must_equal :female
+    end
+
+    it "returns nil if the id is not mapped" do
+      user = User.new(gender_id: 3)
+      user.read_enum(:gender).must_be_nil
+    end
+
+    describe "when loading an existing record" do
+      before do
+        connection.execute "INSERT INTO users(id, gender_id) VALUES(1, 1)"
+      end
+
+      it "returns the correct value" do
+        user = User.find(1)
+        user.read_enum(:gender).must_equal :female
+      end
+    end
+  end
+
+  describe "#write_enum" do
+    before { User.enum :gender, table: {female: 1, male: 2} }
+
+    it "raises an ArgumentError if the enum name is invalid" do
+      user = User.new
+      ->{ user.write_enum(:bad, :female) }.must_raise ArgumentError
+    end
+
+    it "sets the id to the id mapped to the given value" do
+      user = User.new
+      user.write_enum(:gender, :female)
+      user.gender_id.must_equal 1
+    end
+
+    it "sets the id to nil if the given value is not mapped to an id" do
+      user = User.new
+      user.write_enum(:gender, :other)
+      user.gender_id.must_be_nil
+    end
+  end
+
+  describe "#read_attribute" do
+    before { User.enum :gender, table: {female: 1, male: 2} }
+
+    it "reads enums" do
+      user = User.new(gender_id: 1)
+      user.read_attribute(:gender).must_equal :female
+    end
+
+    it "allows string names for enums" do
+      user = User.new(gender_id: 1)
+      user.read_attribute('gender').must_equal :female
+    end
+
+    it "still reads attributes" do
+      user = User.new(gender_id: 1)
+      user.read_attribute(:gender_id).must_equal 1
+    end
+  end
+
+  describe "#write_attribute" do
+    before { User.enum :gender, table: {female: 1, male: 2} }
+
+    it "writes enums" do
+      user = User.new
+      user.write_attribute(:gender, :female)
+      user.gender_id.must_equal 1
+    end
+
+    it "allows string names for enums" do
+      user = User.new
+      user.write_attribute('gender', :female)
+      user.gender_id.must_equal 1
+    end
+
+    it "still writes attributes" do
+      user = User.new
+      user.write_attribute(:gender_id, 1)
+      user.gender_id.must_equal 1
+    end
+  end
+
+  describe "#query_enum" do
+    before { User.enum :gender, table: {female: 1, male: 2} }
+
+    it "raises an ArgumentError if the enum name is invalid" do
+      user = User.new
+      ->{ user.query_enum(:bad) }.must_raise ArgumentError
+    end
+
+    it "returns true if the is mapped to a value" do
+      user = User.new(gender_id: 1)
+      user.query_enum(:gender).must_equal true
+    end
+
+    it "returns false if the given value is not mapped to an id" do
+      user = User.new(gender_id: 3)
+      user.query_enum(:gender).must_equal false
+    end
+  end
+
+  describe "#enum_changed?" do
+    before do
+      User.enum :gender, table: {female: 1, male: 2}
+      User.create(gender_id: 1)
+    end
+
+    it "raises an ArgumentError if the enum name is invalid" do
+      user = User.first
+      ->{ user.enum_changed?(:bad) }.must_raise ArgumentError
+    end
+
+    it "returns true if the enum value changed" do
+      user = User.first
+      user.gender = :male
+      user.enum_changed?(:gender).must_equal true
+    end
+
+    it "returns true if the id attribute changed" do
+      user = User.first
+      user.gender_id = 2
+      user.enum_changed?(:gender).must_equal true
+    end
+
+    it "returns false if the attribute value has not changed" do
+      user = User.first
+      user.enum_changed?(:gender).must_equal false
+    end
+  end
+
+  describe "#enum_was" do
+    before do
+      User.enum :gender, table: {female: 1, male: 2}
+      User.create(gender_id: 1)
+    end
+
+    it "raises an ArgumentError if the enum name is invalid" do
+      user = User.first
+      ->{ user.enum_was(:bad) }.must_raise ArgumentError
+    end
+
+    it "returns the old value if the enum value changed" do
+      user = User.first
+      user.gender = :male
+      user.enum_was(:gender).must_equal :female
+    end
+
+    it "returns the old value if the id attribute changed" do
+      user = User.first
+      user.gender_id = 2
+      user.enum_was(:gender).must_equal :female
+    end
+
+    it "returns the current value if the enum has not changed" do
+      user = User.first
+      user.enum_was(:gender).must_equal :female
+    end
+  end
+
+  describe "#enum_change" do
+    before do
+      User.enum :gender, table: {female: 1, male: 2}
+      User.create(gender_id: 1)
+    end
+
+    it "raises an ArgumentError if the enum name is invalid" do
+      user = User.first
+      ->{ user.enum_change(:bad) }.must_raise ArgumentError
+    end
+
+    it "returns the old and new values if the enum value changed" do
+      user = User.first
+      user.gender = :male
+      user.enum_change(:gender).must_equal [:female, :male]
+    end
+
+    it "returns the old and new values if the enum id changed" do
+      user = User.first
+      user.gender_id = 2
+      user.enum_change(:gender).must_equal [:female, :male]
+    end
+
+    it "returns nil if the enum has not changed" do
+      user = User.first
+      user.enum_change(:gender).must_be_nil
+    end
+  end
+
+  describe "#ENUM" do
+    before { User.enum :gender, table: {female: 1, male: 2} }
+
+    it "returns the enum value" do
+      user = User.new(gender_id: 1)
+      user.gender.must_equal :female
+    end
+  end
+
+  describe "#ENUM=" do
+    before { User.enum :gender, table: {female: 1, male: 2} }
+
+    it "sets the enum value" do
+      user = User.new
+      user.gender = :female
+      user.gender_id.must_equal 1
+    end
+  end
+
+  describe "#ENUM?" do
+    before { User.enum :gender, table: {female: 1, male: 2} }
+
+    it "returns true if the enum value is present" do
+      user = User.new(gender_id: nil)
+      user.gender?.must_equal false
+
+      user = User.new(gender_id: 1)
+      user.gender?.must_equal true
+    end
+  end
+
+  describe "#ENUM_changed?" do
+    before do
+      User.enum :gender, table: {female: 1, male: 2}
+      User.create(gender_id: 1)
+    end
+
+    it "returns the changed flag for the enum" do
+      user = User.first
+      user.gender_changed?.must_equal false
+
+      user.gender_id = 2
+      user.gender_changed?.must_equal true
+    end
+  end
+
+  describe "#ENUM_was" do
+    before do
+      User.enum :gender, table: {female: 1, male: 2}
+      User.create(gender_id: 1)
+    end
+
+    it "returns the changed flag for the enum" do
+      user = User.first
+      user.gender_was.must_equal :female
+    end
+  end
+
+  describe "#ENUM_change" do
+    before do
+      User.enum :gender, table: {female: 1, male: 2}
+      User.create(gender_id: 1)
+    end
+
+    it "returns the old and new values for the enum" do
+      user = User.first
+      user.gender_change.must_be_nil
+
+      user.gender_id = 2
+      user.gender_change.must_equal [:female, :male]
+    end
+  end
+
+  describe "roundtripping" do
+    it "roundtrips a value through write and read" do
+      User.enum :gender, table: {female: 1, male: 2}
+      user = User.new
+      user.gender = :female
+      user.gender.must_equal :female
+    end
+
+    it "roundtrips a value through persistence" do
+      User.enum :gender, table: {female: 1, male: 2}
+      User.create(gender: :female)
+      User.first.gender.must_equal :female
+    end
+
+    it "supports strings values" do
+      User.enum :gender, table: {female: 1, male: 2}, type: :string
+      User.create(gender: 'female')
+      User.first.gender.must_equal 'female'
+    end
+  end
+
+  describe ".where" do
+    it "supports filtering by enums with symbol keys" do
+      User.enum :gender, table: {female: 1, male: 2}
+      female = User.create(gender_id: 1)
+      male   = User.create(gender_id: 2)
+      User.where(gender: :female).all.must_equal [female]
+    end
+
+    it "supports filtering by enums with string keys" do
+      User.enum :gender, table: {female: 1, male: 2}
+      female = User.create(gender_id: 1)
+      male   = User.create(gender_id: 2)
+      User.where('gender' => :female).all.must_equal [female]
+    end
+
+    it "supports filtering by multiple values" do
+      User.enum :gender, table: {female: 1, male: 2, other: 3}
+      female = User.create(gender_id: 1)
+      male   = User.create(gender_id: 2)
+      other  = User.create(gender_id: 3)
+      User.where(gender: [:female, :male]).all.must_equal [female, male]
+    end
+
+    it "still supports filtering by other attributes" do
+      User.enum :gender, table: {female: 1, male: 2}
+      female1 = User.create(gender_id: 1, status_id: 1)
+      male1   = User.create(gender_id: 2, status_id: 1)
+      male2   = User.create(gender_id: 2, status_id: 2)
+      User.where(gender: :male, status_id: 1).all.must_equal [male1]
+    end
+  end
+
+  describe "dynamic finders" do
+    it "support retrieval by enums" do
+      User.enum :gender, table: {female: 1, male: 2}
+      female = User.create(gender_id: 1)
+      male   = User.create(gender_id: 2)
+
+      User.find_by_gender(:female).must_equal female
+      User.find_all_by_gender(:female).must_equal [female]
+    end
+  end
+
+  describe "when the inheritance column is an enum" do
+    before do
+      connection.add_column :users, :type_id, :integer
+      User.enum :type, table: {Admin: 1, Member: 2}
+      Object.const_set :Admin, Class.new(User)
+      Object.const_set :Member, Class.new(User)
+    end
+
+    after do
+      Object.send :remove_const, :Admin
+      Object.send :remove_const, :Member
+
+      # Instantiating STI classes goes through ActiveSupport::Dependencies.
+      ActiveSupport::Dependencies.clear
+    end
+
+    it "sets the type ID when instantiating" do
+      admin = Admin.create
+      admin.type_id.must_equal 1
+    end
+
+    it "instantiates the correct class through the superclass" do
+      admin = Admin.create
+      user = User.find(admin.id)
+      user.class.must_equal Admin
+      user.id.must_equal admin.id
+    end
+
+    it "finds and instantiates the correct class through the subclass" do
+      admin = Admin.create
+      found = Admin.find(admin.id)
+      found.class.must_equal Admin
+      found.id.must_equal admin.id
+    end
+
+    it "filters correctly when finding through the subclass" do
+      admin = Admin.create
+      Admin.find(admin.id).must_equal admin
+      Member.find_by_id(admin.id).must_be_nil
+    end
+  end
+
+  describe "when an enum has the same name as a column" do
+    before do
+      connection.add_column :users, :gender, :string
+      User.enum :gender, table: {female: 1, male: 2}
+    end
+
+    # TODO: It's probably desirable to write the column if it's present, for
+    # transitioning to an enum.
+    it "only writes the enum id" do
+      User.create(gender_id: 1)
+      results = connection.execute("SELECT gender_id, gender FROM users").to_a
+      results.size.must_equal 1
+      results[0][0].must_equal 1
+      results[0][1].must_equal nil
+    end
+
+    it "favors the enum when loading" do
+      connection.execute "INSERT INTO users(gender_id, gender) VALUES(1, 'male')"
+      User.first.gender_id.must_equal 1
+      User.first.gender.must_equal :female
+    end
+  end
+end