flag_shih_tzu 0.1.0.pre

data/.gitignore

@@ -0,0 +1,10 @@
+test/debug.log
+test/flag_shih_tzu_plugin.sqlite3.db
+coverage
+.idea
+.idea/*
+.idea/**/*
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.rdoc

@@ -0,0 +1,297 @@
+=FlagShihTzu
+
+A rails plugin to store a collection of boolean attributes in a single
+ActiveRecord column as a bit field.
+
+http://github.com/xing/flag_shih_tzu
+
+This plugin lets you use a single integer column in an ActiveRecord model
+to store a collection of boolean attributes (flags). Each flag can be used
+almost in the same way you would use any boolean attribute on an
+ActiveRecord object.
+
+The benefits:
+* No migrations needed for new boolean attributes. This helps a lot
+  if you have very large db-tables where you want to avoid ALTER TABLE whenever
+  possible.
+* Only the one integer column needs to be indexed.
+
+Using FlagShihTzu, you can add new boolean attributes whenever you want,
+without needing any migration. Just add a new flag to the +has_flags+ call.
+
+And just in case you are wondering what "Shih Tzu" means:
+http://en.wikipedia.org/wiki/Shih_Tzu
+
+
+==Prerequisites
+
+FlagShihTzu assumes that your ActiveRecord model already has an integer field
+to store the flags, which should be defined to not allow NULL values and
+should have a default value of 0 (which means all flags are initially set to
+false).
+
+The plugin has been tested with Rails versions from 2.1 to 3.0 and MySQL,
+PostgreSQL and SQLite3 databases. It has been tested with ruby 1.9.2 (with
+Rails 3 only).
+
+
+==Installation
+
+===As plugin (Rails 2.x, Rails 3)
+
+  cd path/to/your/rails-project
+  ./script/plugin install git://github.com/xing/flag_shih_tzu.git
+
+===As gem (Rails 3)
+
+Add following line to your Gemfile:
+
+  gem 'flag_shih_tzu', '0.1.0.pre'
+
+Make sure to install gem with bundler:
+
+  bundle install
+
+==Usage
+
+===Defining the flags
+
+  class Spaceship < ActiveRecord::Base
+    include FlagShihTzu
+
+    has_flags 1 => :warpdrive,
+              2 => :shields,
+              3 => :electrolytes
+  end
+
++has_flags+ takes a hash. The keys must be positive integers and represent
+the position of the bit being used to enable or disable the flag.
+<b>The keys must not be changed once in use, or you will get wrong results.</b>
+That is why the plugin forces you to set them explicitly.
+The values are symbols for the flags being created.
+
+
+===Using a custom column name
+
+The default column name to store the flags is 'flags', but you can provide a
+custom column name using the <tt>:column</tt> option. This allows you to use
+different columns for separate flags:
+
+  has_flags 1 => :warpdrive,
+            2 => :shields,
+            3 => :electrolytes,
+            :column => 'features'
+
+  has_flags 1 => :spock, 
+            2 => :scott,
+            3 => :kirk,
+            :column => 'crew'
+
+
+===Generated instance methods
+
+Calling +has_flags+ as shown above creates the following instance methods
+on Spaceship:
+
+  Spaceship#warpdrive
+  Spaceship#warpdrive?
+  Spaceship#warpdrive=
+  Spaceship#shields
+  Spaceship#shields?
+  Spaceship#shields=
+  Spaceship#electrolytes
+  Spaceship#electrolytes?
+  Spaceship#electrolytes=
+
+
+===Generated named scopes
+
+The following named scopes become available:
+
+  Spaceship.warpdrive         # :conditions => "(spaceships.flags in (1,3,5,7))"
+  Spaceship.not_warpdrive     # :conditions => "(spaceships.flags not in (1,3,5,7))"
+  Spaceship.shields           # :conditions => "(spaceships.flags in (2,3,6,7))"
+  Spaceship.not_shields       # :conditions => "(spaceships.flags not in (2,3,6,7))"
+  Spaceship.electrolytes      # :conditions => "(spaceships.flags in (4,5,6,7))"
+  Spaceship.not_electrolytes  # :conditions => "(spaceships.flags not in (4,5,6,7))"
+
+If you do not want the named scopes to be defined, set the
+<tt>:named_scopes</tt> option to false when calling +has_flags+:
+
+  has_flags 1 => :warpdrive, 2 => :shields, 3 => :electrolytes, :named_scopes => false
+
+In a Rails 3 application, FlagShihTzu will use <tt>scope</tt> internally to generate
+the scopes. The option on has_flags is still named <tt>:named_scopes</tt> however.
+
+
+===Examples for using the generated methods
+
+  enterprise = Spaceship.new
+  enterprise.warpdrive = true
+  enterprise.shields = true
+  enterprise.electrolytes = false
+  enterprise.save
+
+  if enterprise.shields?
+    ...
+  end
+
+  Spaceship.warpdrive.find(:all)
+  Spaceship.not_electrolytes.count
+  ...
+
+
+===How it stores the values
+
+As said, FlagShihTzu uses a single integer column to store the values for all
+the defined flags as a bit field.
+
+The bit position of a flag corresponds to the given key.
+
+This way, we can use bit operators on the stored integer value to set, unset
+and check individual flags.
+
+                +---+---+---+                +---+---+---+
+                |   |   |   |                |   |   |   |
+  Bit position  | 3 | 2 | 1 |                | 3 | 2 | 1 |
+  (flag key)    |   |   |   |                |   |   |   |
+                +---+---+---+                +---+---+---+
+                |   |   |   |                |   |   |   |
+  Bit value     | 4 | 2 | 1 |                | 4 | 2 | 1 |
+                |   |   |   |                |   |   |   |
+                +---+---+---+                +---+---+---+
+                | e | s | w |                | e | s | w |
+                | l | h | a |                | l | h | a |
+                | e | i | r |                | e | i | r |
+                | c | e | p |                | c | e | p |
+                | t | l | d |                | t | l | d |
+                | r | d | r |                | r | d | r |
+                | o | s | i |                | o | s | i |
+                | l |   | v |                | l |   | v |
+                | y |   | e |                | y |   | e |
+                | t |   |   |                | t |   |   |
+                | e |   |   |                | e |   |   |
+                | s |   |   |                | s |   |   |
+                +---+---+---+                +---+---+---+
+                | 1 | 1 | 0 | = 4 + 2 = 6    | 1 | 0 | 1 | = 4 + 1 = 5
+                +---+---+---+                +---+---+---+
+
+Read more about bit fields here: http://en.wikipedia.org/wiki/Bit_field
+
+
+===Support for manually building conditions
+
+The following class methods may support you when manually building
+ActiveRecord conditions:
+
+  Spaceship.warpdrive_condition         # "(spaceships.flags in (1,3,5,7))"
+  Spaceship.not_warpdrive_condition     # "(spaceships.flags not in (1,3,5,7))"
+  Spaceship.shields_condition           # "(spaceships.flags in (2,3,6,7))"
+  Spaceship.not_shields_condition       # "(spaceships.flags not in (2,3,6,7))"
+  Spaceship.electrolytes_condition      # "(spaceships.flags in (4,5,6,7))"
+  Spaceship.not_electrolytes_condition  # "(spaceships.flags not in (4,5,6,7))"
+  
+These methods also accept a :table_alias option that can be used when 
+generating SQL that references the same table more than once:
+
+  Spaceship.shields_condition(:table_alias => 'evil_spaceships') # "(evil_spaceships.flags in (2,3,6,7))"
+
+
+===Choosing a query mode
+
+While the default way of building the SQL conditions uses an IN() list
+(as shown above), this approach will not work well for a high number of flags,
+as the value list for IN() grows.
+
+For MySQL, depending on your MySQL settings, this can even hit the
+'max_allowed_packet' limit with the generated query.
+
+In this case, consider changing the flag query mode to <tt>:bit_operator</tt>
+instead of <tt>:in_list</tt>, like so:
+
+  has_flags 1 => :warpdrive, 
+            2 => :shields, 
+            :flag_query_mode => :bit_operator
+
+This will modify the generated condition and named_scope methods to use bit
+operators in the SQL instead of an IN() list:
+
+  Spaceship.warpdrive_condition         # "(spaceships.flags & 1 = 1)",
+  Spaceship.not_warpdrive_condition     # "(spaceships.flags & 1 = 0)",
+  Spaceship.shields_condition           # "(spaceships.flags & 2 = 2)",
+  Spaceship.not_shields_condition       # "(spaceships.flags & 2 = 0)",
+
+  Spaceship.warpdrive         # :conditions => "(spaceships.flags & 1 = 1)"
+  Spaceship.not_warpdrive     # :conditions => "(spaceships.flags & 1 = 0)"
+  Spaceship.shields           # :conditions => "(spaceships.flags & 2 = 2)"
+  Spaceship.not_shields       # :conditions => "(spaceships.flags & 2 = 0)"
+
+The drawback is that due to the bit operator, this query can not use an index
+on the flags column.
+
+
+==Running the plugin tests
+
+1. (Rails 3 only) Add <tt>mysql2</tt>, <tt>pg</tt> and <tt>sqlite3</tt> gems to your Gemfile.
+1. Install flag_shih_tzu as plugin inside working Rails application.
+1. Modify <tt>test/database.yml</tt> to fit your test environment.
+2. If needed, create the test database you configured in <tt>test/database.yml</tt>.
+
+Then you can run
+
+  DB=mysql|postgres|sqlite3 rake test:plugins PLUGIN=flag_shih_tzu
+
+from your Rails project root or
+
+  DB=mysql|postgres|sqlite3 rake
+
+from <tt>vendor/plugins/flag_shih_tzu</tt>.
+
+
+==Authors
+
+{Patryk Peszko}[http://github.com/ppeszko],
+{Sebastian Roebke}[http://github.com/boosty],
+{David Anderson}[http://github.com/alpinegizmo]
+and {Tim Payton}[http://github.com/dizzy42]
+
+Please find out more about our work in our
+{tech blog}[http://blog.xing.com/category/english/tech-blog].
+
+
+==Contributors
+
+{TobiTobes}[http://github.com/rngtng],
+{Martin Stannard}[http://github.com/martinstannard],
+{Ladislav Martincik}[http://github.com/lacomartincik],
+{Peter Boling}[http://github.com/pboling],
+{Daniel Jagszent}[http://github.com/d--j],
+{Thorsten Boettger}[http://github.com/alto],
+{Darren Torpey}[http://github.com/darrentorpey],
+{Joost Baaij}[http://github.com/tilsammans] and
+{Musy Bite}[http://github.com/musybite]
+
+
+==License
+
+The MIT License
+
+Copyright (c) 2009 {XING AG}[http://www.xing.com/]
+
+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/Rakefile

@@ -0,0 +1,34 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the flag_shih_tzu plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the flag_shih_tzu plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'FlagShihTzu'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+namespace :test do
+  desc 'Measures test coverage'
+  task :coverage do
+    rm_f "coverage"
+    system("rcov -Ilib test/*_test.rb")
+    system("open coverage/index.html") if PLATFORM['darwin']
+  end
+end

data/flag_shih_tzu.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "flag_shih_tzu/version"
+
+Gem::Specification.new do |s|
+  s.name        = "flag_shih_tzu"
+  s.version     = FlagShihTzu::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Patryk Peszko", "Sebastian Roebke", "David Anderson", "Tim Payton"]
+  s.homepage    = "https://github.com/xing/flag_shih_tzu"
+  s.summary     = %q{A rails plugin to store a collection of boolean attributes in a single ActiveRecord column as a bit field}
+  s.description = <<-EODOC
+This plugin lets you use a single integer column in an ActiveRecord model
+to store a collection of boolean attributes (flags). Each flag can be used
+almost in the same way you would use any boolean attribute on an
+ActiveRecord object.
+  EODOC
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/init.rb

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

data/lib/flag_shih_tzu.rb

@@ -0,0 +1,210 @@
+module FlagShihTzu
+  TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE'] # taken from ActiveRecord::ConnectionAdapters::Column
+  DEFAULT_COLUMN_NAME = 'flags'
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  class IncorrectFlagColumnException < Exception; end
+  class NoSuchFlagQueryModeException < Exception; end
+  class NoSuchFlagException < Exception; end
+
+  module ClassMethods
+    def has_flags(*args)
+      flag_hash, opts = parse_options(*args)
+      opts = {
+        :named_scopes => true,
+        :column => DEFAULT_COLUMN_NAME,
+        :flag_query_mode => :in_list
+      }.update(opts)
+      colmn = opts[:column]
+
+      return unless check_flag_column(colmn)
+
+      # options are stored in a class level hash and apply per-column
+      class_inheritable_hash :flag_options
+      write_inheritable_attribute(:flag_options, {}) if flag_options.nil?
+      flag_options[colmn] = opts
+
+      # the mappings are stored in this class level hash and apply per-column
+      class_inheritable_hash :flag_mapping
+      write_inheritable_attribute(:flag_mapping, {}) if flag_mapping.nil?
+      flag_mapping[colmn] ||= {}
+
+      flag_hash.each do |flag_key, flag_name|
+        raise ArgumentError, "has_flags: flag keys should be positive integers, and #{flag_key} is not" unless is_valid_flag_key(flag_key)
+        raise ArgumentError, "has_flags: flag names should be symbols, and #{flag_name} is not" unless is_valid_flag_name(flag_name)
+        next if flag_mapping[colmn][flag_name] & (1 << (flag_key - 1)) # next if already methods defined by flagshitzu
+        raise ArgumentError, "has_flags: flag name #{flag_name} already defined, please choose different name" if method_defined?(flag_name)
+
+        flag_mapping[colmn][flag_name] = 1 << (flag_key - 1)
+
+        class_eval <<-EVAL
+          def #{flag_name}
+            flag_enabled?(:#{flag_name}, '#{colmn}')
+          end
+
+          def #{flag_name}?
+            flag_enabled?(:#{flag_name}, '#{colmn}')
+          end
+
+          def #{flag_name}=(value)
+            FlagShihTzu::TRUE_VALUES.include?(value) ? enable_flag(:#{flag_name}, '#{colmn}') : disable_flag(:#{flag_name}, '#{colmn}')
+          end
+
+          def self.#{flag_name}_condition(options = {})
+            sql_condition_for_flag(:#{flag_name}, '#{colmn}', true, options[:table_alias] || self.table_name)
+          end
+
+          def self.not_#{flag_name}_condition
+            sql_condition_for_flag(:#{flag_name}, '#{colmn}', false)
+          end
+        EVAL
+
+        # Define the named scopes if the user wants them and AR supports it
+        if flag_options[colmn][:named_scopes] && respond_to?(named_scope_method)
+          class_eval <<-EVAL
+            #{named_scope_method} :#{flag_name}, lambda { { :conditions => #{flag_name}_condition } }
+            #{named_scope_method} :not_#{flag_name}, lambda { { :conditions => not_#{flag_name}_condition } }
+          EVAL
+        end
+      end
+
+    end
+
+    def check_flag(flag, colmn)
+      raise ArgumentError, "Column name '#{colmn}' for flag '#{flag}' is not a string" unless colmn.is_a?(String)
+      raise ArgumentError, "Invalid flag '#{flag}'" if flag_mapping[colmn].nil? || !flag_mapping[colmn].include?(flag)
+    end
+
+    private
+
+      def parse_options(*args)
+        options = args.shift
+        if args.size >= 1
+          add_options = args.shift
+        else
+          add_options = options.keys.select {|key| !key.is_a?(Fixnum)}.inject({}) do |hash, key|
+            hash[key] = options.delete(key)
+            hash
+          end
+        end
+        return options, add_options
+      end
+
+      def check_flag_column(colmn, table_name = self.table_name)
+        # If you aren't using ActiveRecord (eg. you are outside rails) then do not fail here
+        # If you are using ActiveRecord then you only want to check for the table if the table exists so it won't fail pre-migration
+        has_ar = !!defined?(ActiveRecord) && self.respond_to?(:descends_from_active_record?)
+        # Supposedly Rails 2.3 takes care of this, but this precaution is needed for backwards compatibility
+        has_table = has_ar ? ActiveRecord::Base.connection.tables.include?(table_name) : true
+
+        logger.warn("Error: Table '#{table_name}' doesn't exist") and return false unless has_table
+
+        if !has_ar || (has_ar && has_table)
+          if found_column = columns.find {|column| column.name == colmn}
+            raise IncorrectFlagColumnException, "Warning: Column '#{colmn}'must be of type integer in order to use FlagShihTzu" unless found_column.type == :integer
+          else
+            # Do not raise an exception since the migration to add the flags column might still be pending
+            logger.warn("Warning: Table '#{table_name}' must have an integer column named '#{colmn}' in order to use FlagShihTzu") and return false
+          end
+        end
+
+        true
+      end
+
+      def sql_condition_for_flag(flag, colmn, enabled = true, table_name = self.table_name)
+        check_flag(flag, colmn)
+
+        if flag_options[colmn][:flag_query_mode] == :bit_operator
+          # use & bit operator directly in the SQL query.
+          # This has the drawback of not using an index on the flags colum.
+          "(#{table_name}.#{colmn} & #{flag_mapping[colmn][flag]} = #{enabled ? flag_mapping[colmn][flag] : 0})"
+        elsif flag_options[colmn][:flag_query_mode] == :in_list
+          # use IN() operator in the SQL query.
+          # This has the drawback of becoming a big query when you have lots of flags.
+          neg = enabled ? "" : "not "
+          "(#{table_name}.#{colmn} #{neg}in (#{sql_in_for_flag(flag, colmn).join(',')}))"
+        else
+          raise NoSuchFlagQueryModeException
+        end
+      end
+
+      # returns an array of integers suitable for a SQL IN statement.
+      def sql_in_for_flag(flag, colmn)
+        val = flag_mapping[colmn][flag]
+        num = 2 ** flag_mapping[flag_options[colmn][:column]].length
+        (1..num).select {|i| i & val == val}
+      end
+
+      def is_valid_flag_key(flag_key)
+        flag_key > 0 && flag_key == flag_key.to_i
+      end
+
+      def is_valid_flag_name(flag_name)
+        flag_name.is_a?(Symbol)
+      end
+
+      # Returns the correct method to create a named scope.
+      # Use to prevent deprecation notices on Rails 3 when using +named_scope+ instead of +scope+.
+      def named_scope_method
+        # Can't use respond_to because both AR 2 and 3 respond to both +scope+ and +named_scope+.
+        ActiveRecord::VERSION::MAJOR == 2 ? :named_scope : :scope
+      end
+  end
+
+  # Performs the bitwise operation so the flag will return +true+.
+  def enable_flag(flag, colmn = nil)
+    colmn = determine_flag_colmn_for(flag) if colmn.nil?
+    self.class.check_flag(flag, colmn)
+
+    set_flags(self.flags(colmn) | self.class.flag_mapping[colmn][flag], colmn)
+  end
+
+  # Performs the bitwise operation so the flag will return +false+.
+  def disable_flag(flag, colmn = nil)
+    colmn = determine_flag_colmn_for(flag) if colmn.nil?
+    self.class.check_flag(flag, colmn)
+
+    set_flags(self.flags(colmn) & ~self.class.flag_mapping[colmn][flag], colmn)
+  end
+
+  def flag_enabled?(flag, colmn = nil)
+    colmn = determine_flag_colmn_for(flag) if colmn.nil?
+    self.class.check_flag(flag, colmn)
+
+    get_bit_for(flag, colmn) == 0 ? false : true
+  end
+
+  def flag_disabled?(flag, colmn = nil)
+    colmn = determine_flag_colmn_for(flag) if colmn.nil?
+    self.class.check_flag(flag, colmn)
+
+    !flag_enabled?(flag, colmn)
+  end
+
+  def flags(colmn = DEFAULT_COLUMN_NAME)
+    self[colmn] || 0
+  end
+
+  def set_flags(value, colmn)
+    self[colmn] = value
+  end
+
+  private
+
+    def get_bit_for(flag, colmn)
+      self.flags(colmn) & self.class.flag_mapping[colmn][flag]
+    end
+
+    def determine_flag_colmn_for(flag)
+      return DEFAULT_COLUMN_NAME if self.class.flag_mapping.nil?
+      self.class.flag_mapping.each_pair do |colmn, mapping|
+        return colmn if mapping.include?(flag)
+      end
+      raise NoSuchFlagException.new("determine_flag_colmn_for: Couldn't determine column for your flags!")
+    end
+
+end
+

data/lib/flag_shih_tzu/version.rb

@@ -0,0 +1,3 @@
+module FlagShihTzu
+  VERSION = "0.1.0.pre"
+end

data/test/database.yml

@@ -0,0 +1,17 @@
+sqlite3:
+  adapter: sqlite3
+  database: test/flag_shih_tzu_plugin.sqlite3.db
+
+mysql:
+  adapter: mysql2
+  host: localhost
+  username: root
+  password: 
+  database: flag_shih_tzu_plugin_test
+
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password: 
+  database: flag_shih_tzu_plugin_test
+  min_messages: ERROR

data/test/flag_shih_tzu_test.rb

@@ -0,0 +1,499 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper.rb')
+load_schema
+
+class Spaceship < ActiveRecord::Base
+  set_table_name 'spaceships'
+  include FlagShihTzu
+
+  has_flags 1 => :warpdrive, 
+            2 => :shields, 
+            3 => :electrolytes
+end
+
+class SpaceshipWithoutNamedScopes < ActiveRecord::Base
+  set_table_name 'spaceships'
+  include FlagShihTzu
+
+  has_flags(1 => :warpdrive, :named_scopes => false)
+end
+
+class SpaceshipWithoutNamedScopesOldStyle < ActiveRecord::Base
+  set_table_name 'spaceships'
+  include FlagShihTzu
+
+  has_flags({1 => :warpdrive}, :named_scopes => false)
+end
+
+class SpaceshipWithCustomFlagsColumn < ActiveRecord::Base
+  set_table_name 'spaceships_with_custom_flags_column'
+  include FlagShihTzu
+
+  has_flags(1 => :warpdrive, 2 => :hyperspace, :column => 'bits')
+end
+
+class SpaceshipWith2CustomFlagsColumn < ActiveRecord::Base
+  set_table_name 'spaceships_with_2_custom_flags_column'
+  include FlagShihTzu
+
+  has_flags({ 1 => :warpdrive, 2 => :hyperspace }, :column => 'bits')
+  has_flags({ 1 => :jeanlucpicard, 2 => :dajanatroj }, :column => 'commanders')
+end
+
+class SpaceshipWithBitOperatorQueryMode < ActiveRecord::Base
+  set_table_name 'spaceships'
+  include FlagShihTzu
+  
+  has_flags(1 => :warpdrive, 2 => :shields, :flag_query_mode => :bit_operator)
+end
+
+class SpaceCarrier < Spaceship
+end
+
+# table planets is missing intentionally to see if flagshihtzu handles missing tables gracefully
+class Planet < ActiveRecord::Base
+end
+
+class FlagShihTzuClassMethodsTest < Test::Unit::TestCase
+  
+  def setup
+    Spaceship.destroy_all
+  end
+
+  def test_has_flags_should_raise_an_exception_when_flag_key_is_negative
+    assert_raises ArgumentError do
+      eval(<<-EOF
+        class SpaceshipWithInvalidFlagKey < ActiveRecord::Base
+          set_table_name 'spaceships'
+          include FlagShihTzu
+
+          has_flags({ -1 => :error })
+        end
+           EOF
+          )
+    end
+  end
+
+  def test_has_flags_should_raise_an_exception_when_flag_name_already_used
+    assert_raises ArgumentError do
+      eval(<<-EOF
+        class SpaceshipWithAlreadyUsedFlag < ActiveRecord::Base
+          set_table_name 'spaceships_with_2_custom_flags_column'
+          include FlagShihTzu
+
+          has_flags({ 1 => :jeanluckpicard }, :column => 'bits')
+          has_flags({ 1 => :jeanluckpicard }, :column => 'commanders')
+        end
+           EOF
+          )
+    end
+  end
+  
+  def test_has_flags_should_raise_an_exception_when_desired_flag_name_method_already_defined
+    assert_raises ArgumentError do
+      eval(<<-EOF
+        class SpaceshipWithAlreadyUsedMethod < ActiveRecord::Base
+          set_table_name 'spaceships_with_2_custom_flags_column'
+          include FlagShihTzu
+          
+          def jeanluckpicard; end
+
+          has_flags({ 1 => :jeanluckpicard }, :column => 'bits')
+        end
+           EOF
+          )
+    end
+  end
+
+  def test_has_flags_should_not_raise_an_exception_when_flag_name_method_defined_by_flagshitzu
+    assert_nothing_raised ArgumentError do
+      eval(<<-EOF
+        class SpaceshipWithAlreadyUsedMethodByFlagshitzu < ActiveRecord::Base
+          set_table_name 'spaceships_with_2_custom_flags_column'
+          include FlagShihTzu
+          
+          has_flags({ 1 => :jeanluckpicard }, :column => 'bits')
+          has_flags({ 1 => :jeanluckpicard }, :column => 'bits')
+        end
+           EOF
+          )
+    end
+  end
+
+  def test_has_flags_should_raise_an_exception_when_flag_name_is_not_a_symbol
+    assert_raises ArgumentError do
+      eval(<<-EOF
+        class SpaceshipWithInvalidFlagName < ActiveRecord::Base
+          set_table_name 'spaceships'
+          include FlagShihTzu
+
+          has_flags({ 1 => 'error' })
+        end
+           EOF
+          )
+    end
+  end
+
+  def test_should_define_a_sql_condition_method_for_flag_enabled
+    assert_equal "(spaceships.flags in (1,3,5,7))", Spaceship.warpdrive_condition
+    assert_equal "(spaceships.flags in (2,3,6,7))", Spaceship.shields_condition
+    assert_equal "(spaceships.flags in (4,5,6,7))", Spaceship.electrolytes_condition
+  end
+  
+  def test_should_accept_a_table_alias_option_for_sql_condition_method
+    assert_equal "(old_spaceships.flags in (1,3,5,7))", Spaceship.warpdrive_condition(:table_alias => 'old_spaceships')
+  end
+
+  def test_should_define_a_sql_condition_method_for_flag_enabled_with_2_colmns
+    assert_equal "(spaceships_with_2_custom_flags_column.bits in (1,3))", SpaceshipWith2CustomFlagsColumn.warpdrive_condition
+    assert_equal "(spaceships_with_2_custom_flags_column.bits in (2,3))", SpaceshipWith2CustomFlagsColumn.hyperspace_condition
+    assert_equal "(spaceships_with_2_custom_flags_column.commanders in (1,3))", SpaceshipWith2CustomFlagsColumn.jeanlucpicard_condition
+    assert_equal "(spaceships_with_2_custom_flags_column.commanders in (2,3))", SpaceshipWith2CustomFlagsColumn.dajanatroj_condition
+  end
+
+  def test_should_define_a_sql_condition_method_for_flag_not_enabled
+    assert_equal "(spaceships.flags not in (1,3,5,7))", Spaceship.not_warpdrive_condition
+    assert_equal "(spaceships.flags not in (2,3,6,7))", Spaceship.not_shields_condition
+    assert_equal "(spaceships.flags not in (4,5,6,7))", Spaceship.not_electrolytes_condition
+  end
+  
+  def test_should_define_a_sql_condition_method_for_flag_enabled_with_custom_table_name
+    assert_equal "(custom_spaceships.flags in (1,3,5,7))", Spaceship.send( :sql_condition_for_flag, :warpdrive, 'flags', true, 'custom_spaceships')
+  end  
+
+  def test_should_define_a_sql_condition_method_for_flag_enabled_with_2_colmns_not_enabled
+    assert_equal "(spaceships_with_2_custom_flags_column.bits not in (1,3))", SpaceshipWith2CustomFlagsColumn.not_warpdrive_condition
+    assert_equal "(spaceships_with_2_custom_flags_column.bits not in (2,3))", SpaceshipWith2CustomFlagsColumn.not_hyperspace_condition
+    assert_equal "(spaceships_with_2_custom_flags_column.commanders not in (1,3))", SpaceshipWith2CustomFlagsColumn.not_jeanlucpicard_condition
+    assert_equal "(spaceships_with_2_custom_flags_column.commanders not in (2,3))", SpaceshipWith2CustomFlagsColumn.not_dajanatroj_condition
+  end
+  
+  def test_should_define_a_sql_condition_method_for_flag_enabled_using_bit_operators
+    assert_equal "(spaceships.flags & 1 = 1)", SpaceshipWithBitOperatorQueryMode.warpdrive_condition
+    assert_equal "(spaceships.flags & 2 = 2)", SpaceshipWithBitOperatorQueryMode.shields_condition
+  end
+
+  def test_should_define_a_sql_condition_method_for_flag_not_enabled_using_bit_operators
+    assert_equal "(spaceships.flags & 1 = 0)", SpaceshipWithBitOperatorQueryMode.not_warpdrive_condition
+    assert_equal "(spaceships.flags & 2 = 0)", SpaceshipWithBitOperatorQueryMode.not_shields_condition
+  end
+
+  def test_should_define_a_named_scope_for_flag_enabled
+    assert_equal(["(spaceships.flags in (1,3,5,7))"], Spaceship.warpdrive.where_values)
+    assert_equal(["(spaceships.flags in (2,3,6,7))"], Spaceship.shields.where_values)
+    assert_equal(["(spaceships.flags in (4,5,6,7))"], Spaceship.electrolytes.where_values)
+  end
+
+  def test_should_define_a_named_scope_for_flag_not_enabled
+    assert_equal(["(spaceships.flags not in (1,3,5,7))"], Spaceship.not_warpdrive.where_values)
+    assert_equal(["(spaceships.flags not in (2,3,6,7))"], Spaceship.not_shields.where_values)
+    assert_equal(["(spaceships.flags not in (4,5,6,7))"], Spaceship.not_electrolytes.where_values)
+  end
+
+  def test_should_define_a_named_scope_for_flag_enabled_with_2_columns
+    assert_equal(["(spaceships_with_2_custom_flags_column.bits in (1,3))"], SpaceshipWith2CustomFlagsColumn.warpdrive.where_values)
+    assert_equal(["(spaceships_with_2_custom_flags_column.bits in (2,3))"], SpaceshipWith2CustomFlagsColumn.hyperspace.where_values)
+    assert_equal(["(spaceships_with_2_custom_flags_column.commanders in (1,3))"], SpaceshipWith2CustomFlagsColumn.jeanlucpicard.where_values)
+    assert_equal(["(spaceships_with_2_custom_flags_column.commanders in (2,3))"], SpaceshipWith2CustomFlagsColumn.dajanatroj.where_values)
+  end
+
+  def test_should_define_a_named_scope_for_flag_not_enabled_with_2_columns
+    assert_equal(["(spaceships_with_2_custom_flags_column.bits not in (1,3))"], SpaceshipWith2CustomFlagsColumn.not_warpdrive.where_values)
+    assert_equal(["(spaceships_with_2_custom_flags_column.bits not in (2,3))"], SpaceshipWith2CustomFlagsColumn.not_hyperspace.where_values)
+    assert_equal(["(spaceships_with_2_custom_flags_column.commanders not in (1,3))"], SpaceshipWith2CustomFlagsColumn.not_jeanlucpicard.where_values)
+    assert_equal(["(spaceships_with_2_custom_flags_column.commanders not in (2,3))"], SpaceshipWith2CustomFlagsColumn.not_dajanatroj.where_values)
+  end
+  
+  def test_should_define_a_named_scope_for_flag_enabled_using_bit_operators
+    assert_equal(["(spaceships.flags & 1 = 1)"], SpaceshipWithBitOperatorQueryMode.warpdrive.where_values)
+    assert_equal(["(spaceships.flags & 2 = 2)"], SpaceshipWithBitOperatorQueryMode.shields.where_values)
+  end
+
+  def test_should_define_a_named_scope_for_flag_not_enabled_using_bit_operators
+    assert_equal(["(spaceships.flags & 1 = 0)"], SpaceshipWithBitOperatorQueryMode.not_warpdrive.where_values)
+    assert_equal(["(spaceships.flags & 2 = 0)"], SpaceshipWithBitOperatorQueryMode.not_shields.where_values)
+  end
+
+  def test_should_return_the_correct_number_of_items_from_a_named_scope
+    spaceship = Spaceship.new
+    spaceship.enable_flag(:warpdrive)
+    spaceship.enable_flag(:shields)
+    spaceship.save!
+    spaceship.reload
+    spaceship_2 = Spaceship.new
+    spaceship_2.enable_flag(:warpdrive)
+    spaceship_2.save!
+    spaceship_2.reload
+    spaceship_3 = Spaceship.new
+    spaceship_3.enable_flag(:shields)
+    spaceship_3.save!
+    spaceship_3.reload
+    assert_equal 1, Spaceship.not_warpdrive.count
+    assert_equal 2, Spaceship.warpdrive.count
+    assert_equal 1, Spaceship.not_shields.count
+    assert_equal 2, Spaceship.shields.count
+    assert_equal 1, Spaceship.warpdrive.shields.count
+    assert_equal 0, Spaceship.not_warpdrive.not_shields.count
+  end
+
+  def test_should_not_define_named_scopes_if_not_wanted
+    assert !SpaceshipWithoutNamedScopes.respond_to?(:warpdrive)
+    assert !SpaceshipWithoutNamedScopesOldStyle.respond_to?(:warpdrive)
+  end
+
+  def test_should_work_with_a_custom_flags_column
+    spaceship = SpaceshipWithCustomFlagsColumn.new
+    spaceship.enable_flag(:warpdrive)
+    spaceship.enable_flag(:hyperspace)
+    spaceship.save!
+    spaceship.reload
+    assert_equal 3, spaceship.flags('bits')
+    assert_equal "(spaceships_with_custom_flags_column.bits in (1,3))", SpaceshipWithCustomFlagsColumn.warpdrive_condition
+    assert_equal "(spaceships_with_custom_flags_column.bits not in (1,3))", SpaceshipWithCustomFlagsColumn.not_warpdrive_condition
+    assert_equal "(spaceships_with_custom_flags_column.bits in (2,3))", SpaceshipWithCustomFlagsColumn.hyperspace_condition
+    assert_equal "(spaceships_with_custom_flags_column.bits not in (2,3))", SpaceshipWithCustomFlagsColumn.not_hyperspace_condition
+    assert_equal(["(spaceships_with_custom_flags_column.bits in (1,3))"], SpaceshipWithCustomFlagsColumn.warpdrive.where_values)
+    assert_equal(["(spaceships_with_custom_flags_column.bits not in (1,3))"], SpaceshipWithCustomFlagsColumn.not_warpdrive.where_values)
+    assert_equal(["(spaceships_with_custom_flags_column.bits in (2,3))"], SpaceshipWithCustomFlagsColumn.hyperspace.where_values)
+    assert_equal(["(spaceships_with_custom_flags_column.bits not in (2,3))"], SpaceshipWithCustomFlagsColumn.not_hyperspace.where_values)
+  end
+  
+  def test_should_not_error_out_when_table_is_not_present
+    assert_nothing_raised(ActiveRecord::StatementInvalid) do
+      Planet.class_eval do
+        include FlagShihTzu
+        has_flags(1 => :habitable)
+      end
+    end
+  end
+  
+end
+
+class FlagShihTzuInstanceMethodsTest < Test::Unit::TestCase
+
+  def setup
+    @spaceship = Spaceship.new
+    @big_spaceship = SpaceshipWith2CustomFlagsColumn.new
+  end
+
+  def test_should_enable_flag
+    @spaceship.enable_flag(:warpdrive)
+    assert @spaceship.flag_enabled?(:warpdrive)
+  end
+
+  def test_should_enable_flag_with_2_columns
+    @big_spaceship.enable_flag(:warpdrive)
+    assert @big_spaceship.flag_enabled?(:warpdrive)
+    @big_spaceship.enable_flag(:jeanlucpicard)
+    assert @big_spaceship.flag_enabled?(:jeanlucpicard)
+  end
+
+  def test_should_disable_flag
+    @spaceship.enable_flag(:warpdrive)
+    assert @spaceship.flag_enabled?(:warpdrive)
+
+    @spaceship.disable_flag(:warpdrive)
+    assert @spaceship.flag_disabled?(:warpdrive)
+  end
+
+  def test_should_disable_flag_with_2_columns
+    @big_spaceship.enable_flag(:warpdrive)
+    assert @big_spaceship.flag_enabled?(:warpdrive)
+    @big_spaceship.enable_flag(:jeanlucpicard)
+    assert @big_spaceship.flag_enabled?(:jeanlucpicard)
+
+    @big_spaceship.disable_flag(:warpdrive)
+    assert @big_spaceship.flag_disabled?(:warpdrive)
+    @big_spaceship.disable_flag(:jeanlucpicard)
+    assert @big_spaceship.flag_disabled?(:jeanlucpicard)
+  end
+
+  def test_should_store_the_flags_correctly
+    @spaceship.enable_flag(:warpdrive)
+    @spaceship.disable_flag(:shields)
+    @spaceship.enable_flag(:electrolytes)
+
+    @spaceship.save!
+    @spaceship.reload
+
+    assert_equal 5, @spaceship.flags
+    assert @spaceship.flag_enabled?(:warpdrive)
+    assert !@spaceship.flag_enabled?(:shields)
+    assert @spaceship.flag_enabled?(:electrolytes)
+  end
+
+  def test_should_store_the_flags_correctly_wiht_2_colmns
+    @big_spaceship.enable_flag(:warpdrive)
+    @big_spaceship.disable_flag(:hyperspace)
+    @big_spaceship.enable_flag(:dajanatroj)
+
+    @big_spaceship.save!
+    @big_spaceship.reload
+
+    assert_equal 1, @big_spaceship.flags('bits')
+    assert_equal 2, @big_spaceship.flags('commanders')
+
+    assert @big_spaceship.flag_enabled?(:warpdrive)
+    assert !@big_spaceship.flag_enabled?(:hyperspace)
+    assert @big_spaceship.flag_enabled?(:dajanatroj)
+  end
+
+  def test_enable_flag_should_leave_the_flag_enabled_when_called_twice
+    2.times do
+      @spaceship.enable_flag(:warpdrive)
+      assert @spaceship.flag_enabled?(:warpdrive)
+    end
+  end
+
+  def test_disable_flag_should_leave_the_flag_disabled_when_called_twice
+    2.times do
+      @spaceship.disable_flag(:warpdrive)
+      assert !@spaceship.flag_enabled?(:warpdrive)
+    end
+  end
+
+  def test_should_define_an_attribute_reader_method
+    assert_equal false, @spaceship.warpdrive
+  end
+
+  def test_should_define_an_attribute_reader_predicate_method
+    assert_equal false, @spaceship.warpdrive?
+  end
+
+  def test_should_define_an_attribute_writer_method
+    @spaceship.warpdrive = true
+    assert @spaceship.warpdrive
+  end
+
+  def test_should_respect_true_values_like_active_record
+    [true, 1, '1', 't', 'T', 'true', 'TRUE'].each do |true_value|
+      @spaceship.warpdrive = true_value
+      assert @spaceship.warpdrive
+    end
+
+    [false, 0, '0', 'f', 'F', 'false', 'FALSE'].each do |false_value|
+      @spaceship.warpdrive = false_value
+      assert !@spaceship.warpdrive
+    end
+  end
+  
+  def test_should_ignore_has_flags_call_if_column_does_not_exist_yet
+    assert_nothing_raised do
+      eval(<<-EOF
+        class SpaceshipWithoutFlagsColumn < ActiveRecord::Base
+          set_table_name 'spaceships_without_flags_column'
+          include FlagShihTzu
+
+          has_flags 1 => :warpdrive,
+                    2 => :shields,
+                    3 => :electrolytes
+        end
+      EOF
+      )
+    end
+    
+    assert !SpaceshipWithoutFlagsColumn.method_defined?(:warpdrive)
+  end
+  
+  def test_should_ignore_has_flags_call_if_column_not_integer
+    assert_raises FlagShihTzu::IncorrectFlagColumnException do
+      eval(<<-EOF
+        class SpaceshipWithNonIntegerColumn < ActiveRecord::Base
+          set_table_name 'spaceships_with_non_integer_column'
+          include FlagShihTzu
+
+          has_flags 1 => :warpdrive,
+                    2 => :shields,
+                    3 => :electrolytes
+        end
+      EOF
+      )
+    end
+
+    assert !SpaceshipWithoutFlagsColumn.method_defined?(:warpdrive)
+  end
+
+  def test_column_guessing_for_default_column
+    assert_equal 'flags', @spaceship.send(:determine_flag_colmn_for, :warpdrive)
+  end
+
+  def test_column_guessing_for_default_column
+    assert_raises FlagShihTzu::NoSuchFlagException do
+      @spaceship.send(:determine_flag_colmn_for, :xxx)
+    end
+  end
+
+  def test_column_guessing_for_2_columns
+    assert_equal 'commanders', @big_spaceship.send(:determine_flag_colmn_for, :jeanlucpicard)
+    assert_equal 'bits', @big_spaceship.send(:determine_flag_colmn_for, :warpdrive)
+  end
+
+end
+
+class FlagShihTzuDerivedClassTest < Test::Unit::TestCase
+
+  def setup
+    @spaceship = SpaceCarrier.new
+  end
+
+  def test_should_enable_flag
+    @spaceship.enable_flag(:warpdrive)
+    assert @spaceship.flag_enabled?(:warpdrive)
+  end
+
+  def test_should_disable_flag
+    @spaceship.enable_flag(:warpdrive)
+    assert @spaceship.flag_enabled?(:warpdrive)
+
+    @spaceship.disable_flag(:warpdrive)
+    assert @spaceship.flag_disabled?(:warpdrive)
+  end
+
+  def test_should_store_the_flags_correctly
+    @spaceship.enable_flag(:warpdrive)
+    @spaceship.disable_flag(:shields)
+    @spaceship.enable_flag(:electrolytes)
+
+    @spaceship.save!
+    @spaceship.reload
+
+    assert_equal 5, @spaceship.flags
+    assert @spaceship.flag_enabled?(:warpdrive)
+    assert !@spaceship.flag_enabled?(:shields)
+    assert @spaceship.flag_enabled?(:electrolytes)
+  end
+
+  def test_enable_flag_should_leave_the_flag_enabled_when_called_twice
+    2.times do 
+      @spaceship.enable_flag(:warpdrive)
+      assert @spaceship.flag_enabled?(:warpdrive)
+    end
+  end
+
+  def test_disable_flag_should_leave_the_flag_disabled_when_called_twice
+    2.times do 
+      @spaceship.disable_flag(:warpdrive)
+      assert !@spaceship.flag_enabled?(:warpdrive)
+    end
+  end
+
+  def test_should_define_an_attribute_reader_method
+    assert_equal false, @spaceship.warpdrive?
+  end
+
+  def test_should_define_an_attribute_writer_method
+    @spaceship.warpdrive = true
+    assert @spaceship.warpdrive
+  end
+
+  def test_should_respect_true_values_like_active_record
+    [true, 1, '1', 't', 'T', 'true', 'TRUE'].each do |true_value|
+      @spaceship.warpdrive = true_value
+      assert @spaceship.warpdrive
+    end
+
+    [false, 0, '0', 'f', 'F', 'false', 'FALSE'].each do |false_value|
+      @spaceship.warpdrive = false_value
+      assert !@spaceship.warpdrive
+    end
+  end
+end

data/test/schema.rb

@@ -0,0 +1,23 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :spaceships, :force => true do |t| 
+    t.string :type, :null => false, :default => 'Spaceship'
+    t.integer :flags, :null => false, :default => 0
+    t.string :incorrect_flags_column, :null => false, :default => ''
+  end 
+
+  create_table :spaceships_with_custom_flags_column, :force => true do |t| 
+    t.integer :bits, :null => false, :default => 0
+  end
+
+  create_table :spaceships_with_2_custom_flags_column, :force => true do |t| 
+    t.integer :bits, :null => false, :default => 0
+    t.integer :commanders, :null => false, :default => 0
+  end
+
+  create_table :spaceships_without_flags_column, :force => true do |t| 
+  end
+
+  create_table :spaceships_with_non_integer_column, :force => true do |t| 
+    t.string :flags, :null => false, :default => 'A string'
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,35 @@
+ENV['RAILS_ENV'] = 'test'
+ENV['RAILS_ROOT'] ||= File.dirname(__FILE__) + '/../../../..'
+
+#exend LOAD_PATH for test with- and without Railsframework
+$LOAD_PATH << 'lib/'
+$LOAD_PATH << 'vendor/plugins/flag_shih_tzu/lib/'
+
+require 'test/unit'
+require 'yaml'
+require 'logger'
+require 'rubygems'
+gem 'activerecord', '~> 3.0'
+require 'active_record'
+require 'flag_shih_tzu' 
+
+def load_schema
+  config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+  ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+  db_adapter = ENV['DB'] || 'sqlite3'
+  
+  # no DB passed, try sqlite3 by default
+  db_adapter ||=
+    begin
+      require 'sqlite3'
+        'sqlite3'
+    rescue MissingSourceFile 
+    end
+    
+  if db_adapter.nil? 
+    raise "No DB Adapter selected. Configure test/database.yml and use DB=mysql|postgresql|sqlite3 to pick one. sqlite3 will be used by default (gem install sqlite3-ruby)."
+  end
+  
+  ActiveRecord::Base.establish_connection(config[db_adapter])
+  load(File.dirname(__FILE__) + "/schema.rb")
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: flag_shih_tzu
+version: !ruby/object:Gem::Version 
+  hash: 961915980
+  prerelease: 6
+  segments: 
+  - 0
+  - 1
+  - 0
+  - pre
+  version: 0.1.0.pre
+platform: ruby
+authors: 
+- Patryk Peszko
+- Sebastian Roebke
+- David Anderson
+- Tim Payton
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-09 00:00:00 +03:00
+default_executable: 
+dependencies: []
+
+description: |
+  This plugin lets you use a single integer column in an ActiveRecord model
+  to store a collection of boolean attributes (flags). Each flag can be used
+  almost in the same way you would use any boolean attribute on an
+  ActiveRecord object.
+
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- flag_shih_tzu.gemspec
+- init.rb
+- lib/flag_shih_tzu.rb
+- lib/flag_shih_tzu/version.rb
+- test/database.yml
+- test/flag_shih_tzu_test.rb
+- test/schema.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/xing/flag_shih_tzu
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: A rails plugin to store a collection of boolean attributes in a single ActiveRecord column as a bit field
+test_files: 
+- test/database.yml
+- test/flag_shih_tzu_test.rb
+- test/schema.rb
+- test/test_helper.rb