constant_record 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0c54e7e14d065796037c8c68789bf16ed980cbdc
+  data.tar.gz: e2756dc08f225ce136ac3f07dc20d1b773fa579e
+SHA512:
+  metadata.gz: 56847eabe09d8c35111905feca49d35e8dafc5ea70226b213e05c116ea01b75d61709aa6e553e3aa5902a22e7a910232082cf3c7663cd1f2605b64f4f254059d
+  data.tar.gz: d5c59bf34e24b0ab5b7fbfcd509de8c5e006cf164528dada95de3a6183486f412c40b4214a1eafcd5be97676c0975f6a9f9030ea2d776070bac7b0cada8bb6e8

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Nate Wiger
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,215 @@
+# ConstantRecord
+
+In-memory ActiveRecord querying and associations for static data.
+
+Compatible with all current versions of Rails, from 3.x up through 4.1
+(and beyond, theoretically).
+
+Unlike previous (ambitious) approaches that have tried to duplicate ActiveRecord
+functionality in a separate set of classes, this is a simple shim of < 200 LOC
+that creates an in-memory SQLite database for the relevant models.  This is designed
+to minimize breakage between Rails versions, and also avoids recreating ActiveRecord
+features.
+
+## Installation
+
+Add `constant_record` to your Gemfile:
+
+    gem 'constant_record'
+
+Then run `bundle install`. Or, install it yourself manually, if you're into that sort of thing:
+
+    $ gem install constant_record
+
+*Note: The gem name is constant_record with an underscore, unlike activerecord.*
+
+## Usage
+
+Just `include ConstantRecord` in any ActiveRecord class. Then, you can use `data` to add
+data directly in that class for clarity:
+
+    class Genre < ActiveRecord::Base
+      include ConstantRecord
+
+      data id: 1, name: "Rock",    slug: "rock"
+      data id: 2, name: "Hip-Hop", slug: "hiphop"
+      data id: 3, name: "Pop",     slug: "pop"
+    end
+
+Or, you can choose to keep your data in a YAML file:
+
+    class Genre < ActiveRecord::Base
+      include ConstantRecord
+      load_data File.join(Rails.root, 'config', 'data', 'genres.yml')
+    end
+
+The YAML file should be an array of hashes:
+
+    # config/data/genres.yml
+    ---
+    - id: 1
+      name: Rock
+      slug: rock
+    - id: 2
+      name: Hip-Hop
+      slug: hiphop
+    - id: 3
+      name: Pop
+      slug: hop
+
+You can omit the filename if it follows the naming convention of `config/data/[table_name].yml`:
+
+    class Genre < ActiveRecord::Base
+      include ConstantRecord
+      load_data  # config/data/genres.yml
+    end
+
+Alternatively, you can load your data via some other external method.  Note that you will need
+to reload your data each time Rails restarts, since the data is in-memory only.  This means
+adding a reload hook after Unicorn / Passenger / Puma fork:
+
+    Genre.reload!
+
+Once you define your class, this will create an in-memory `sqlite` database which is then
+hooked into ActiveRecord.  A database table is created on the fly, consisting of the columns
+you use in the *first* `data` declaration.  **Important:** This means if you have a couple
+columns that aren't always present, *make sure to include them with `column_name: nil` on
+the first `data` line:*
+
+    class Genre < ActiveRecord::Base
+      include ConstantRecord
+
+      data id: 1, name: "Rock",    slug: "rock",   region: nil, country: nil
+      data id: 2, name: "Hip-Hop", slug: "hiphop", region: 'North America'
+      data id: 3, name: "Pop",     slug: "pop",    country: 'US'
+    end
+
+Once setup, all the familiar ActiveRecord finders work:
+
+    Genre.find(1)
+    Genre.find_by_slug("pop")
+    Genre.where(name: "Rock").first
+
+Attempts to modify values will fail:
+
+    @genre = Genre.find(2)
+    @genre.slug = "hip-hop"
+    @genre.save!  # nope
+
+You'll get an `ActiveRecord::ReadOnlyRecord` exception.
+
+## Auto Constants
+
+ConstantRecord will also create constants on the fly for you if you have a `name` column.
+Revisiting our example:
+
+    class Genre < ActiveRecord::Base
+      include ConstantRecord
+
+      data id: 1, name: "Rock",    slug: "rock"
+      data id: 2, name: "Hip-Hop", slug: "hiphop"
+      data id: 3, name: "Pop",     slug: "pop"
+    end
+
+This will create:
+
+    Genre::ROCK = 1
+    Genre::HIP_HOP = 2
+    Genre::POP = 3
+
+This makes it cleaner to do queries in your app:
+
+    Genre.find(Genre::ROCK)
+    Song.where(genre_id: Genre::ROCK)
+
+And so on.
+
+## Associations
+
+Internally, ActiveRecord tries to do joins to retrieve associations.  This doesn't work, since
+the records live in different tables.  Have no fear, you just need to `include ConstantRecord::Associations`
+in the normal ActiveRecord class that is trying to associate to your ConstantRecord class:
+
+    class Genre < ActiveRecord::Base
+      include ConstantRecord
+
+      has_many :song_genres
+      has_many :songs, through: :song_genres
+
+      data id: 1, name: "Rock",    slug: "rock",   region: nil, country: nil
+      data id: 2, name: "Hip-Hop", slug: "hiphop", region: 'North America'
+      data id: 3, name: "Pop",     slug: "pop",    country: 'US'
+    end
+
+    class SongGenre < ActiveRecord::Base
+      belongs_to :genre_id
+      belongs_to :song_id
+    end
+
+    class Song < ActiveRecord::Base
+      include ConstantRecord::Associations
+      has_many :song_genres
+      has_many :songs, through: :song_genres
+    end
+
+If you forget to do this, you'll get an error like this:
+
+    irb(main):001:0> @song = Song.first
+    irb(main):002:0> @song.genres
+    ActiveRecord::StatementInvalid: Could not find table 'song_genres'
+
+It would be great to remove this shim, but I can't currently see a way without monkey-patching
+the internals of ActiveRecord, which I don't want to do for 17 different reasons.
+
+## Debugging
+
+If you forget to define data, you'll get a "table doesn't exist" error:
+
+    class Publisher < ActiveRecord::Base
+      include ConstantRecord
+
+      # Oops no data
+
+      has_many :article_publishers
+      has_many :articles, through: :article_publishers
+    end
+
+    irb(main):001:0> @publisher = Publisher.first
+    irb(main):002:0> @publisher.articles
+    ActiveRecord::StatementInvalid: Could not find table 'articles'
+
+This is because the table is created lazily when you first load data.
+
+If you try to add a custom column on a different `data` line:
+
+    class Genre < ActiveRecord::Base
+      include ConstantRecord
+
+      data id: 1, name: "Rock",    slug: "rock"
+      data id: 2, name: "Hip-Hop", slug: "hiphop"
+      data id: 3, name: "Pop",     slug: "pop", ranking: 1  # oops
+    end
+
+You'll get a table error:
+
+    ActiveRecord::UnknownAttributeError: unknown attribute: ranking
+
+The solution is to include the same columns on each `data` line.
+
+## Other Projects
+
+Inspired by a couple previous efforts:
+
+* Christoph Petschnig's [constantrecord](https://github.com/cpetschnig/constantrecord)
+* Aaron Quint's [static_model](https://github.com/quirkey/static_model)
+* Nico Taing's [yaml_record](https://github.com/nicotaing/yaml_record)
+
+Other projects seen in the wild:
+
+* [static_record](https://github.com/dejan/static_record)
+* [constant_record](https://github.com/topdan/constant_record)
+* [frozen_record](https://github.com/byroot/frozen_record)
+
+All are good efforts, but unfortunately the Rails team is known to make sweeping
+changes to internal ActiveRecord implementation details between different versions
+of Rails.  This makes it very difficult to maintain compatibility over time.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+desc "run all the specs"
+task :test do
+  sh "bacon spec/*_spec.rb"
+end
+
+task :default => :test

data/constant_record.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'constant_record/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "constant_record"
+  spec.version       = ConstantRecord::VERSION
+  spec.authors       = ["Nate Wiger"]
+  spec.email         = ["nwiger@gmail.com"]
+  spec.summary       = %q{In-memory ActiveRecord querying and associations for static data.}
+  spec.description   = <<-EndDesc
+  In-memory ActiveRecord querying and associations for static data.
+  Improves performance and decreases bugs due to data mismatches.
+  EndDesc
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  # Allow any AR versions, but need at least one. Also sqlite for the table.
+  spec.add_dependency "activerecord"
+  spec.add_dependency "sqlite3"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "bacon"
+end

data/lib/constant_record/version.rb

@@ -0,0 +1,3 @@
+module ConstantRecord
+  VERSION = "0.5.0"
+end

data/lib/constant_record.rb

@@ -0,0 +1,220 @@
+#
+# To use, `include ConstantRecord` in any ActiveRecord class. Then, you can use `data`
+# to add data directly in that class for clarity:
+#
+#     class Genre < ActiveRecord::Base
+#       include ConstantRecord
+#
+#       data id: 1, name: "Rock",    slug: "rock"
+#       data id: 2, name: "Hip-Hop", slug: "hiphop"
+#       data id: 3, name: "Pop",     slug: "pop"
+#     end
+#
+# Or, you can choose to keep your data in a YAML file:
+#
+#     class Genre < ActiveRecord::Base
+#       include ConstantRecord
+#       load_data File.join(Rails.root, 'config', 'data', 'genres.yml')
+#     end
+#
+# The YAML file should be an array of hashes.  Once initialized, all
+# familiar ActiveRecord finders and associations should work as expected.
+#
+require "active_record"
+require "constant_record/version"
+
+module ConstantRecord
+  class Error < StandardError; end
+  class BadDataFile < Error;   end
+
+  MEMORY_DBCONFIG = {adapter: 'sqlite3', database: ":memory:", pool: 5}.freeze
+
+
+  class << self
+    def memory_dbconfig
+      @memory_dbconfig || MEMORY_DBCONFIG
+    end
+
+    def memory_dbconfig=(config)
+      @memory_dbconfig = config
+    end
+
+    def data_dir
+      @data_dir || File.join('config', 'data')
+    end
+
+    def data_dir=(path)
+      @data_dir = path
+    end
+
+    def included(base)
+      base.extend DataLoading
+      base.extend Associations
+      base.send :include, ReadOnly
+      base.establish_connection(memory_dbconfig) unless base.send :connected?
+    end
+  end
+
+  #
+  # Loads data either directly in the model class, or from a YAML file.
+  #
+  module DataLoading
+    def data_file
+      @data_file || File.join(ConstantRecord.data_dir, "#{self.to_s.tableize}.yml")
+    end
+
+    def load_data(file=nil)
+      @data_file = file
+      reload!
+    end
+
+    def load(reload=false)
+      return if loaded? && !reload
+      records = YAML.load_file(data_file)
+
+      if !records.is_a?(Array) or records.empty?
+        raise BadDataFile, "Expected array in data file #{data_file}: #{records.inspect}"
+      end
+
+      # Call our method to populate data
+      records.each{|r| data r}
+
+      @loaded = true
+    end
+
+    def reload!
+      load(true)
+    end
+
+    def loaded?
+      @loaded || false
+    end
+
+    # Define a constant record: data id: 1, name: "California", slug: "CA"
+    def data(attrib)
+      attrib.symbolize_keys!
+      raise ArgumentError, "#{self}.data expects a Hash of attributes" unless attrib.is_a?(Hash)
+
+      unless attrib[primary_key.to_sym]
+        raise ArgumentError, "#{self}.data missing primary key '#{primary_key}': #{attrib.inspect}"
+      end
+
+      unless @table_was_created
+        create_memory_table(attrib)
+        @table_was_created = true
+      end
+
+      new_record = new(attrib)
+      new_record.id = attrib[primary_key.to_sym]
+
+      # Check for duplicates
+      if old_record = find_by_id(new_record.id)
+        raise ActiveRecord::RecordNotUnique,
+          "Duplicate #{self} id=#{new_record.id} found: #{new_record} vs #{old_record}"
+      end
+      new_record.save!
+
+      # create Ruby constants as well, so "id: 3, name: Sky" gets SKY=3
+      if new_record.respond_to?(:name) and name = new_record.name
+        const_name =
+          name.to_s.upcase.strip.gsub(/[-\s]+/,'_').sub(/^[0-9_]+/,'').gsub(/\W+/,'')
+        const_set const_name, new_record.id unless const_defined?(const_name)
+      end
+    end
+
+    protected
+
+    # Create our in-memory table based on columns we have defined in our data.
+    def create_memory_table(attrib)
+      db_columns = {}
+      attrib.each do |col,val|
+        next if col.to_s == 'id' # skip pk
+        db_columns[col] =
+          case val
+          when Integer then :integer
+          when Float   then :decimal
+          when Date    then :date
+          when DateTime, Time then :datetime
+          else :string
+          end
+      end
+
+      # Create the table in memory
+      connection.create_table(table_name) do |t|
+        db_columns.each do |col,type|
+          t.column col, type
+        end
+      end
+    end
+  end
+
+  #
+  # Hooks to integrate ActiveRecord associations with constant records.
+  #
+  module Associations
+    def self.included(base)
+      base.extend self # support "include" as well
+    end
+
+    #
+    # Override the default ActiveRecord.has_many(:through) that does in-database joins,
+    # with a method that makes two fetches.  It's the only reliable way to traverse
+    # databases. Hopefully one (or both) of these tables are in-memory ConstantRecords
+    # so that we're not making real DB calls.
+    #
+    def has_many(other_table, options={})
+      # puts "#{self}(#{table_name}).has_many #{other_table.inspect}, #{options.inspect}"
+      if join_tab = options[:through]
+        foreign_key = options[:foreign_key] || other_table.to_s.singularize.foreign_key
+        prime_key   = options[:primary_key] || primary_key
+        class_name  = options[:class_name]  || other_table.to_s.classify
+        join_key    = table_name.to_s.singularize.foreign_key
+
+        define_method other_table do
+          join_class = join_tab.to_s.classify.constantize
+          ids = join_class.where(join_key => send(prime_key)).pluck(foreign_key)
+          return [] if ids.empty?
+          class_name.constantize.where(id: ids)
+        end
+      else
+        super other_table, options
+      end
+    end
+  end
+
+  #
+  # Raise an error if the application attempts to change constant records.
+  #
+  module ReadOnly
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def readonly?
+      # have to allow inserts to load_data
+      new_record? ? false : true
+    end
+
+    def delete
+      raise ActiveRecord::ReadOnlyRecord
+    end
+
+    def destroy
+      raise ActiveRecord::ReadOnlyRecord
+    end
+
+    module ClassMethods
+      def delete(id_or_array)
+        raise ActiveRecord::ReadOnlyRecord
+      end
+
+      def delete_all(conditions = nil)
+        raise ActiveRecord::ReadOnlyRecord
+      end
+
+      def update_all(conditions = nil)
+        raise ActiveRecord::ReadOnlyRecord
+      end
+    end
+  end
+end

data/spec/constant_record_spec.rb

@@ -0,0 +1,161 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "ConstantRecord" do
+  describe "loading data" do
+    it "data(attr: val)" do
+      date1 = Time.now
+      date2 = Date.new
+      date3 = DateTime.new
+
+      # insert out of order to ensure we can override ID
+      Author.data(id: 1, name: "One",   birthday: date1)
+      Author.data(id: 3, name: "Three", birthday: date3)
+      Author.data(id: 2, name: "Two",   birthday: date2)
+
+      Author.count.should == 3
+      Author.find(1).name.should == "One"
+      Author.find(2).name.should == "Two"
+      Author.find(3).name.should == "Three"
+
+      author = Author.find_by_name("One")
+      author.id.should == 1
+      author.birthday.should == date1
+
+      author = Author.find_by_name("Two")
+      author.id.should == 2
+      author.birthday.should == date2
+
+      author = Author.find_by_name("Three")
+      author.id.should == 3
+      author.birthday.should == date3
+    end
+
+    it "supports AR finders" do
+      Author.where(id: [1,2]).count.should == 2
+      Author.where(['name like ?', 'Three']).count.should == 1
+      Author.where(['birthday <= ?', Time.now]).count.should == 3
+    end
+
+    it "rejects dup ID's" do
+      should.raise(ActiveRecord::RecordNotUnique){ Author.data(id: 3, name: "Three") }
+    end
+
+    it "loads a YAML file path/to/my.yml" do
+      Publisher.load_data
+      Publisher.count.should == 3
+      Publisher.find(2).name == 'Penguin'
+    end
+
+    it "supports reload!" do
+      Publisher.where('id is not null').delete_all # hackaround ReadOnlyRecord
+      Publisher.count.should == 0
+      Publisher.reload!
+      Publisher.count.should == 3
+      Publisher.data(id: 23, name: "Flop")
+      Publisher.count.should == 4
+    end
+
+    it "rejects missing data files" do
+      should.raise(Errno::ENOENT){ Publisher.load_data 'nope.yml' }
+    end
+
+    it "rejects empty data files" do
+      should.raise(ConstantRecord::BadDataFile){ Publisher.load_data 'spec/data/empty.yml' }
+    end
+  end
+
+  describe "creates constants" do
+    it "simple values" do
+      Publisher.data(id: 3, name: "Simple Value")
+      Publisher::SIMPLE_VALUE.should == 3
+    end
+    it "complex strings" do
+      Publisher.data(id: 4, name: " 2 Non-Fiction, Bestsellers! ")
+      Publisher::NON_FICTION_BESTSELLERS.should == 4
+    end
+  end
+
+  describe "associations" do
+    it "belongs_to" do
+      Article.create!(author_id: 1)
+      Article.create!(author_id: 2)
+      Article.create!(author_id: 3)
+      Article.create!(author_id: 2)
+      Article.create!(author_id: 1)
+      author  = Author.find(1)
+      article = Article.find(5)
+      article.author.id.should == author.id
+    end
+
+    it "has_many" do
+      author = Author.find(2)
+      author.articles.count.should == 2
+      author.articles.find(4).id.should == 4
+    end
+
+    it "has_many through (up)" do
+      ArticlePublisher.create!(article_id: 4,  publisher_id: 7)
+      ArticlePublisher.create!(article_id: 5,  publisher_id: 7)
+      ArticlePublisher.create!(article_id: 60, publisher_id: 7) # bogus
+      publisher = Publisher.find(7)
+      publisher.name.should == "Marvel"
+      publisher.article_publishers.count.should == 3
+      publisher.articles.count.should == 2
+      publisher.articles.each do |art|
+        art.should == Article.find(art.id)
+      end
+    end
+
+    it "has_many through (down)" do
+      ArticlePublisher.create!(article_id: 2, publisher_id: 1)
+      ArticlePublisher.create!(article_id: 2, publisher_id: 2)
+      ArticlePublisher.create!(article_id: 2, publisher_id: 30) # bogus
+      article = Article.find(2)
+      article.article_publishers.count.should == 3
+      article.publishers.count.should == 2
+    end
+  end
+
+  describe "readonly records" do
+    before do
+      @publisher = Publisher.find(1)
+    end
+
+    it "readonly? == true" do
+      @publisher.readonly?.should.be.true?
+    end
+
+    it "rejects destroy" do
+      should.raise(ActiveRecord::ReadOnlyRecord){ @publisher.destroy }
+    end
+
+    it "rejects delete" do
+      should.raise(ActiveRecord::ReadOnlyRecord){ @publisher.delete }
+    end
+
+    it "rejects update_all" do
+      should.raise(ActiveRecord::ReadOnlyRecord){ Publisher.update_all('id = null') }
+    end
+
+    # it "rejects update_all thru associations" do
+    #   should.raise(ActiveRecord::ReadOnlyRecord){ Publisher.where(id: 1).update_all('id = null') }
+    # end
+
+    it "rejects delete_all" do
+      should.raise(ActiveRecord::ReadOnlyRecord){ Publisher.delete_all }
+    end
+
+    # it "rejects delete_all thru associations" do
+    #   should.raise(ActiveRecord::ReadOnlyRecord){ Publisher.where(id: 1).delete_all }
+    # end
+
+    it "rejects destroy_all" do
+      should.raise(ActiveRecord::ReadOnlyRecord){ Publisher.destroy_all }
+    end
+
+    # it "rejects destroy_all thru associations" do
+    #   should.raise(ActiveRecord::ReadOnlyRecord){ Publisher.where(id: 1).destroy_all }
+    # end
+  end
+end
+

data/spec/data/authors.yml

@@ -0,0 +1,9 @@
+---
+- id: 1
+  publisher_id: 1
+  name: Michael Pollan
+- id: 2
+  name: Piers Anthony
+- id: 3
+  publisher_id: 2
+  name: Chuck Palahniuk

data/spec/data/publishers.yml

@@ -0,0 +1,7 @@
+---
+- id: 1
+  name: Phaidon
+- id: 2
+  name: Penguin
+- id: 7
+  name: Marvel

data/spec/spec_helper.rb

@@ -0,0 +1,70 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'bacon'
+Bacon.summary_at_exit
+if $0 =~ /\brspec$/
+  raise "\n===\nThese tests are in bacon, not rspec.  Try: bacon #{ARGV * ' '}\n===\n"
+end
+
+require 'date' # datetime
+require 'constant_record'
+require 'active_record'
+require 'sqlite3'
+
+# Override path for testing purposes
+TEST_YAML_DATA_DIR = File.join(File.dirname(__FILE__), 'data')
+ConstantRecord.data_dir = TEST_YAML_DATA_DIR
+
+# Our "persistent" sqlite database for "real" records (not in-memory)
+TEST_SQLITE_DB_FILE = File.join(File.dirname(__FILE__), 'test.sqlite3')
+File.unlink TEST_SQLITE_DB_FILE rescue nil
+at_exit do
+  File.unlink TEST_SQLITE_DB_FILE rescue nil
+end
+
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: TEST_SQLITE_DB_FILE,
+  pool: 5
+)
+
+if ENV['DEBUG']
+  ActiveRecord::Base.logger = Logger.new(STDOUT)
+  ActiveRecord::Base.logger.level = Logger::DEBUG
+end
+
+class Author < ActiveRecord::Base
+  include ConstantRecord
+
+  has_many :articles
+end
+
+class Publisher < ActiveRecord::Base
+  include ConstantRecord
+
+  has_many :article_publishers
+  has_many :articles, through: :article_publishers
+end
+
+class Article < ActiveRecord::Base
+  include ConstantRecord::Associations
+  belongs_to :author
+  has_many :article_publishers
+  has_many :publishers, through: :article_publishers
+end
+
+
+class ArticlePublisher < ActiveRecord::Base
+  belongs_to :article
+  belongs_to :publisher
+end
+
+# Setup ActiveRecord tables
+Article.connection.create_table(:articles) do |t|
+  t.string  :title
+  t.integer :author_id
+end
+
+ArticlePublisher.connection.create_table(:article_publishers) do |t|
+  t.string  :article_id
+  t.integer :publisher_id
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: constant_record
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Nate Wiger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bacon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+    In-memory ActiveRecord querying and associations for static data.
+    Improves performance and decreases bugs due to data mismatches.
+email:
+- nwiger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- constant_record.gemspec
+- lib/constant_record.rb
+- lib/constant_record/version.rb
+- spec/constant_record_spec.rb
+- spec/data/authors.yml
+- spec/data/empty.yml
+- spec/data/publishers.yml
+- spec/spec_helper.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: In-memory ActiveRecord querying and associations for static data.
+test_files:
+- spec/constant_record_spec.rb
+- spec/data/authors.yml
+- spec/data/empty.yml
+- spec/data/publishers.yml
+- spec/spec_helper.rb