zilkey-active_hash 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,6 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+.idea

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jeff Dean
+
+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,168 @@
+# ActiveHash
+
+ActiveHash is a simple base class that allows you to use a ruby hash as a readonly datasource for an ActiveRecord-like model.
+
+ActiveHash assumes that every hash has an :id key, which is what you would probably store in a database.  This allows you to seemlessly upgrade from ActiveHash objects to full ActiveRecord objects without having to change any code in your app, or any foreign keys in your database.
+
+It also allows you to use #belongs_to in your AR objects.
+
+ActiveHash can also be useful to create simple test classes that run without a database - ideal for testing plugins or gems that rely on simple AR behavior, but don't want to deal with databases or migrations for the spec suite.
+
+ActiveHash also ships with:
+
+  * ActiveFile: a base class that will reload data from a flat file every time the flat file is changed
+  * ActiveYaml: a base class that will turn YAML into a hash and load the data into an ActiveHash object
+
+## Installation
+
+    sudo gem install zilkey-active_hash
+
+## Usage
+
+To use ActiveHash, you need to:
+
+ * Inherit from ActiveHash::Base
+ * Define your fields
+ * Define your data
+
+A quick example would be:
+
+    class Country < ActiveHash::Base
+      field :name
+      self.data = [
+        {:id => 1, :name => "US"},
+        {:id => 2, :name => "Canada"}
+      ]
+    end
+
+## Defining Fields
+
+You can define fields in 2 ways, using the :fields method, or using the :field method, which allows you to specify a default value for the field:
+
+    class Country < ActiveHash::Base
+      fields  :name, :population
+      field   :is_axis_of_evil, :default => false
+    end
+
+## Defining Data
+
+You can define data inside your class or outside.  For example, you might have a class like this:
+
+    # app/models/country.rb
+    class Country < ActiveHash::Base
+      fields  :name, :population
+    end
+
+    # config/initializers/data.rb
+    Country.data = [
+        {:id => 1, :name => "US"},
+        {:id => 2, :name => "Canada"}
+    ]
+
+If you prefer to store your data in YAML, see below.
+
+## Class Methods
+
+ActiveHash gives you ActiveRecord-esque methods like:
+
+    Country.all             # => returns all Country objects
+    Country.count           # => returns the length of the .data array
+    Country.first           # => returns the first country object
+    Country.last            # => returns the last country object
+    Country.find 1          # => returns the first country object with that id
+    Country.find [1,2]      # => returns all Country objects with ids in the array
+    Country.find :all       # => same as .all
+    Country.find :all, args # => the second argument is totally ignored, but allows it to play nicely with AR
+    Country.find_by_id 1    # => find the first object that matches the id
+
+It also gives you a few dynamic finder methods.  For example, if you defined :name as a field, you'd get:
+
+    Country.find_by_name "foo"      # => returns the first object matching that name
+    Country.find_all_by_name "foo"  # => returns an array of the objects with matching names
+
+## Instance Methods
+
+ActiveHash objects implement enough of the ActiveRecord api to satisfy most common needs.  For example:
+
+    Country#id          # => returns the numeric id or nil
+    Country#quoted_id   # => returns the numeric id
+    Country#to_param    # => returns the id as a string
+    Country#new_record? # => false
+    Country#readonly?   # => true
+    Country#hash        # => the hash of the id (or the hash of nil)
+    Country#eql?        # => compares type and id, returns false if id is nil
+
+ActiveHash also gives you methods related to the fields you defined.  For example, if you defined :name as a field, you'd get:
+
+    Country#name        # => returns the passed in name
+    Country#name?       # => returns true if the name is not blank
+
+## Integration with Rails
+
+You can create .belongs_to associations from rails objects, like so:
+
+    class Country < ActiveHash::Base
+      fields  :name, :population
+    end
+
+    class Person < ActiveRecord::Base
+      belongs_to :country
+    end
+
+You can also use standard rails view helpers, like #collection_select:
+
+    <%= collection_select :person, :country_id, Country.all, :id, :name %>
+
+## ActiveYaml
+
+If you want to store your data in YAML files, just inherit from ActiveYaml and specify your path information:
+
+    class Country < ActiveYaml::Base
+      field :name
+    end
+
+By default, this class will look for a yml file named "countries.yml" in the same directory as the file.  You can either change the directory it looks in, the filename it looks for, or both:
+
+    class Country < ActiveYaml::Base
+      set_root_path "/u/data"
+      set_filename "sample"
+      field :name
+    end
+
+The above example will look for the file "/u/data/sample.yml".
+
+ActiveYaml, as well as ActiveFile, check the mtime of the file you specified, and reloads the data if the mtime has changed.  So you can replace the data in the files even if your app is running in production mode in rails.
+
+## ActiveFile
+
+If you store encrypted data, or you'd like to store your flat files as CSV or XML or any other format, you can easily extend ActiveHash to parse and load your file.  Just add a custom ::load_file method, and define the extension you want the file to use:
+
+    class Country < ActiveFile::Base
+      set_root_path "/u/data"
+      set_filename "sample"
+      field :name
+
+      class << self
+        def extension
+          ".super_secret"
+        end
+
+        def load_file
+          MyAwesomeDecoder.load_file(full_path)
+        end
+      end
+    end
+
+The two methods you need to implement are load_file, which needs to return a hash, and .extension, which returns the file extension you are using.  You have full_path available to you if you wish, or you can provide your own path.
+
+## Authors
+
+Written by Mike Dalessio and Jeff Dean
+
+## Development
+
+The only thing I think I'd really like to add here is support for typecasting the fields.
+
+== Copyright
+
+Copyright (c) 2009 Jeff Dean. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "active_hash"
+    gem.summary = %Q{An ActiveRecord-like model that uses a hash as a datasource}
+    gem.email = "jeff@zilkey.com"
+    gem.homepage = "http://github.com/zilkey/active_hash"
+    gem.authors = ["Jeff Dean", "Mike Dalessio"]
+    gem.add_dependency('activesupport')
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "active_hash #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/active_file/base.rb

@@ -0,0 +1,66 @@
+module ActiveFile
+
+  class Base < ActiveHash::Base
+    class_inheritable_accessor :filename, :root_path, :cached_mtime
+
+    class << self
+      def all
+        reload
+        super
+      end
+
+      def reload
+        if should_reload?
+          self.data = load_file
+        end
+      end
+
+      protected :reload
+
+      def set_filename(name)
+        write_inheritable_attribute :filename, name
+      end
+
+      protected :set_filename
+
+      def set_root_path(path)
+        write_inheritable_attribute :root_path, path
+      end
+
+      protected :set_root_path
+
+      def load_file
+        raise "Override Me"
+      end
+
+      protected :load_file
+
+      def extension
+        raise "Override Me"
+      end
+
+      protected :extension
+
+      def full_path
+        root_path = read_inheritable_attribute(:root_path)  || File.dirname(__FILE__)
+        filename  = read_inheritable_attribute(:filename)   || name.tableize
+        File.join(root_path, "#{filename}.#{extension}")
+      end
+
+      private :full_path
+
+      def should_reload?
+        if (mtime = File.mtime(full_path)) == read_inheritable_attribute(:cached_mtime)
+          false
+        else
+          write_inheritable_attribute :cached_mtime, mtime
+          true
+        end
+      end
+
+      private :should_reload?
+
+    end
+  end
+
+end

data/lib/active_hash.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'activesupport'
+require 'active_hash/base'
+require 'active_file/base'
+require 'active_yaml/base'

data/lib/active_hash/base.rb

@@ -0,0 +1,132 @@
+module ActiveHash
+  class Base
+    class_inheritable_accessor :data
+    class << self
+
+      def data=(array_of_hashes)
+        @records = nil
+        write_inheritable_attribute(:data, array_of_hashes)
+      end
+
+      def all
+        @records ||= read_inheritable_attribute(:data).collect {|hash| new(hash)}
+      end
+
+      def count
+        all.length
+      end
+
+      def find(id, *args)
+        case id
+          when :all
+            all
+          when Array
+            all.select {|record| id.map(&:to_i).include?(record.id) }
+          else
+            find_by_id(id)
+        end
+      end
+
+      def find_by_id(id)
+        all.detect {|record| record.id == id.to_i}
+      end
+
+      delegate :first, :last, :to => :all
+
+      def fields(*args)
+        options = args.extract_options!
+        args.each do |field|
+          field(field, options)
+        end
+      end
+
+      def field(field_name, options = {})
+        define_getter_method(field_name, options[:default])
+        define_interrogator_method(field_name)
+        define_custom_find_method(field_name)
+        define_custom_find_all_method(field_name)
+      end
+
+      def define_getter_method(field, default_value)
+        define_method field do
+          attributes[field] || default_value
+        end
+      end
+
+      private :define_getter_method
+
+      def define_interrogator_method(field)
+        define_method "#{field}?" do
+          attributes[field].present?
+        end
+      end
+
+      private :define_interrogator_method
+
+      def define_custom_find_method(field_name)
+        meta_class.instance_eval do
+          define_method "find_by_#{field_name}" do |name|
+            all.detect {|record| record.send(field_name) == name }
+          end
+        end
+      end
+
+      private :define_custom_find_method
+
+      def define_custom_find_all_method(field_name)
+        meta_class.instance_eval do
+          define_method "find_all_by_#{field_name}" do |name|
+            all.select {|record| record.send(field_name) == name }
+          end
+        end
+      end
+
+      private :define_custom_find_all_method
+
+      def meta_class
+        class << self
+          self
+        end
+      end
+
+      private :meta_class
+
+    end
+
+    attr_reader :attributes
+
+    def initialize(options = {})
+      options.symbolize_keys!
+      @attributes = options
+    end
+
+    def id
+      attributes[:id] ? attributes[:id].to_i : nil
+    end
+
+    alias quoted_id id
+
+    def new_record?
+      false
+    end
+
+    def readonly?
+      true
+    end
+
+    def to_param
+      id.to_s
+    end
+
+    def eql?(other)
+      other.instance_of?(self.class) and not id.nil? and (id == other.id)
+    end
+
+    alias == eql?
+
+    def hash
+      id.hash
+    end
+
+  end
+end

data/lib/active_yaml/base.rb

@@ -0,0 +1,15 @@
+module ActiveYaml
+
+  class Base < ActiveFile::Base
+    class << self
+      def load_file
+        YAML.load_file(full_path)
+      end
+
+      def extension
+        "yml"
+      end
+    end
+  end
+
+end

data/spec/active_file/base_spec.rb

@@ -0,0 +1,142 @@
+require 'spec/spec_helper'
+
+describe ActiveFile::Base do
+
+  describe ".filename=" do
+    before do
+      class Foo < ActiveFile::Base
+        self.filename = "foo-izzle"
+      end
+
+      class Bar < ActiveFile::Base
+        self.filename = "bar-izzle"
+      end
+    end
+
+    it "sets the filename on a per-subclass basis" do
+      Foo.filename.should == "foo-izzle"
+      Bar.filename.should == "bar-izzle"
+    end
+  end
+
+  describe ".set_filename" do
+    before do
+      class Foo < ActiveFile::Base
+        set_filename "foo-izzle"
+      end
+
+      class Bar < ActiveFile::Base
+        set_filename "bar-izzle"
+      end
+    end
+
+    it "sets the filename on a per-subclass basis" do
+      Foo.filename.should == "foo-izzle"
+      Bar.filename.should == "bar-izzle"
+    end
+  end
+
+  describe ".root_path=" do
+    before do
+      class Foo < ActiveFile::Base
+        self.root_path = "foo-izzle"
+      end
+
+      class Bar < ActiveFile::Base
+        self.root_path = "bar-izzle"
+      end
+    end
+
+    it "sets the root_path on a per-subclass basis" do
+      Foo.root_path.should == "foo-izzle"
+      Bar.root_path.should == "bar-izzle"
+    end
+  end
+
+  describe ".set_root_path" do
+    before do
+      class Foo < ActiveFile::Base
+        set_root_path "foo-izzle"
+      end
+
+      class Bar < ActiveFile::Base
+        set_root_path "bar-izzle"
+      end
+    end
+
+    it "sets the root_path on a per-subclass basis" do
+      Foo.root_path.should == "foo-izzle"
+      Bar.root_path.should == "bar-izzle"
+    end
+  end
+
+  describe ".all" do
+    before do
+      class MyClass
+      end
+    end
+
+    it "loads the data from the load_file method" do
+      class Foo01 < ActiveFile::Base
+        class << self
+          def extension
+            "myfile"
+          end
+
+          def load_file
+            MyClass.load_file(full_path)
+          end
+        end
+      end
+
+      File.stub!(:mtime).and_return(1234)
+      MyClass.should_receive(:load_file).and_return([{:id => 1}, {:id => 2}, {:id => 3}])
+
+      records = Foo01.all
+      records.length.should == 3
+      records.should =~ [Foo01.new(:id => 1), Foo01.new(:id => 2), Foo01.new(:id => 3)]
+    end
+
+    it "does not re-fetch the data if the file's mtime has not changed" do
+      class SomeSampleClass < ActiveFile::Base
+        class << self
+          def extension
+            "myfile"
+          end
+
+          def load_file
+            MyClass.load_file(full_path)
+          end
+        end
+      end
+
+      File.stub!(:mtime).and_return(1234)
+      MyClass.should_receive(:load_file).once.and_return([{:foo => :bar}])
+      SomeSampleClass.all
+      SomeSampleClass.all
+    end
+
+    it "does re-fetch the data if the yaml file's mtime has changed" do
+      class SomeSampleClass2 < ActiveFile::Base
+        class << self
+          def extension
+            "myfile"
+          end
+
+          def load_file
+            MyClass.load_file(full_path)
+          end
+        end
+      end
+
+      MyClass.should_receive(:load_file).twice.and_return([{:foo => :bar}])
+
+      File.stub!(:mtime).and_return(1234)
+      SomeSampleClass2.all
+
+      File.stub!(:mtime).and_return(3456)
+      SomeSampleClass2.all
+    end
+  end
+
+end

data/spec/active_hash/base_spec.rb

@@ -0,0 +1,414 @@
+require 'spec/spec_helper'
+
+describe ActiveHash::Base do
+
+  before do
+    class Country < ActiveHash::Base
+    end
+  end
+
+  describe ".fields" do
+    before do
+      Country.fields :name, :iso_name
+    end
+
+    it "defines a reader for each field" do
+      Country.new.should respond_to(:name)
+      Country.new.should respond_to(:iso_name)
+    end
+
+    it "defines interrogator methods for each field" do
+      Country.new.should respond_to(:name?)
+      Country.new.should respond_to(:iso_name?)
+    end
+
+    it "defines single finder methods for each field" do
+      Country.should respond_to(:find_by_name)
+      Country.should respond_to(:find_by_iso_name)
+    end
+
+    it "defines array finder methods for each field" do
+      Country.should respond_to(:find_all_by_name)
+      Country.should respond_to(:find_all_by_iso_name)
+    end
+  end
+
+  describe ".data=" do
+    before do
+      class Region < ActiveHash::Base
+        field :description
+      end
+    end
+
+    it "populates the object with data" do
+      Country.data = [{:name => "US"}, {:name => "Canada"}]
+      Country.data.should == [{:name => "US"}, {:name => "Canada"}]
+    end
+
+    it "allows each of it's subclasses to have it's own data" do
+      Country.data = [{:name => "US"}, {:name => "Canada"}]
+      Region.data = [{:description => "A big region"}, {:description => "A remote region"}]
+
+      Country.data.should == [{:name => "US"}, {:name => "Canada"}]
+      Region.data.should == [{:description => "A big region"}, {:description => "A remote region"}]
+    end
+  end
+
+  describe ".all" do
+    before do
+      Country.field :name
+      Country.data = [
+        {:id => 1, :name => "US"},
+        {:id => 2, :name => "Canada"}
+      ]
+    end
+
+    it "returns all data as inflated objects" do
+      Country.all.all?{|country| country.should be_kind_of(Country)}
+    end
+
+    it "populates the data correctly" do
+      records = Country.all
+      records.first.id.should == 1
+      records.first.name.should == "US"
+      records.last.id.should == 2
+      records.last.name.should == "Canada"
+    end
+
+    it "re-populates the records after data= is called" do
+      Country.data = [
+        {:id => 45, :name => "Canada"}
+      ]
+      records = Country.all
+      records.first.id.should == 45
+      records.first.name.should == "Canada"
+      records.length.should == 1
+    end
+  end
+
+  describe ".count" do
+    before do
+      Country.data = [
+        {:id => 1, :name => "US"},
+        {:id => 2, :name => "Canada"}
+      ]
+    end
+
+    it "returns the number of elements in the array" do
+      Country.count.should == 2
+    end
+  end
+
+  describe ".first" do
+    before do
+      Country.data = [
+        {:id => 1, :name => "US"},
+        {:id => 2, :name => "Canada"}
+      ]
+    end
+
+    it "returns the first object" do
+      Country.first.should == Country.new(:id => 1)
+    end
+  end
+
+  describe ".last" do
+    before do
+      Country.data = [
+        {:id => 1, :name => "US"},
+        {:id => 2, :name => "Canada"}
+      ]
+    end
+
+    it "returns the last object" do
+      Country.last.should == Country.new(:id => 2)
+    end
+  end
+
+  describe ".find" do
+    before do
+      Country.data = [
+        {:id => 1, :name => "US"},
+        {:id => 2, :name => "Canada"}
+      ]
+    end
+
+    context "with an id" do
+      it "finds the record with the specified id" do
+        Country.find(2).id.should == 2
+      end
+
+      it "finds the record with the specified id as a string" do
+        Country.find("2").id.should == 2
+      end
+    end
+
+    context "with :all" do
+      it "returns all records" do
+        Country.find(:all).should =~ [Country.new(:id => 1), Country.new(:id => 2)]
+      end
+    end
+
+    context "with 2 arguments" do
+      it "returns the record with the given id and ignores the conditions" do
+        Country.find(1, :conditions => "foo=bar").should == Country.new(:id => 1)
+        Country.find(:all, :conditions => "foo=bar").length.should == 2
+      end
+    end
+
+    context "with an array of ids" do
+      before do
+        Country.data = [
+          {:id => 1},
+          {:id => 2},
+          {:id => 3}
+        ]
+      end
+
+      it "returns all matching ids" do
+        Country.find([1,3]).should =~ [Country.new(:id => 1), Country.new(:id => 3)]
+      end
+    end
+  end
+
+  describe ".find_by_id" do
+    before do
+      Country.data = [
+        {:id => 1, :name => "US"},
+        {:id => 2, :name => "Canada"}
+      ]
+    end
+
+    context "with an id" do
+      it "finds the record with the specified id" do
+        Country.find_by_id(2).id.should == 2
+      end
+    end
+
+    context "with nil" do
+      it "returns nil" do
+        Country.find_by_id(nil).should be_nil
+      end
+    end
+
+    context "with an id not present" do
+      it "returns nil" do
+        Country.find_by_id(4567).should be_nil
+      end
+    end
+  end
+
+  describe "custom finders" do
+    before do
+      Country.field :name
+      Country.data = [
+        {:id => 1, :name => "US"},
+        {:id => 2, :name => "US"},
+        {:id => 3, :name => "Canada"}
+      ]
+    end
+
+    describe "find_by_<field_name>" do
+      context "with a name" do
+        it "returns the first record matching that name" do
+          Country.find_by_name("US").id.should == 1
+        end
+      end
+
+      context "with nil" do
+        it "returns nil" do
+          Country.find_by_name(nil).should be_nil
+        end
+      end
+
+      context "with a name not present" do
+        it "returns nil" do
+          Country.find_by_name("foo").should be_nil
+        end
+      end
+    end
+
+    describe "find_all_by_<field_name>" do
+      context "with a name" do
+        it "returns the records matching that name" do
+          countries = Country.find_all_by_name("US")
+          countries.length.should == 2
+          countries.first.name.should == "US"
+          countries.last.name.should == "US"
+        end
+      end
+
+      context "with a name not present" do
+        it "returns an empty array" do
+          Country.find_all_by_name("foo").should be_empty
+        end
+      end
+    end
+  end
+
+
+  describe "#attributes" do
+    it "returns the hash passed in the initializer" do
+      country = Country.new(:foo => :bar)
+      country.attributes.should == {:foo => :bar}
+    end
+
+    it "symbolizes keys" do
+      country = Country.new("foo" => :bar)
+      country.attributes.should == {:foo => :bar}
+    end
+  end
+
+  describe "reader methods" do
+    context "for regular fields" do
+      before do
+        Country.fields :name, :iso_name
+      end
+
+      it "returns the given attribute when present" do
+        country = Country.new(:name => "Spain")
+        country.name.should == "Spain"
+      end
+
+      it "returns nil when not present" do
+        country = Country.new
+        country.name.should be_nil
+      end
+    end
+
+    context "for fields with default values" do
+      before do
+        Country.field :name, :default => "foobar"
+      end
+
+      it "returns the given attribute when present" do
+        country = Country.new(:name => "Spain")
+        country.name.should == "Spain"
+      end
+
+      it "returns the default value when not present" do
+        country = Country.new
+        country.name.should == "foobar"
+      end
+    end
+  end
+
+  describe "interrogator methods" do
+    before do
+      Country.fields :name, :iso_name
+    end
+
+    it "returns true if the given attribute is non-blank" do
+      country = Country.new(:name => "Spain")
+      country.should be_name
+    end
+
+    it "returns false if the given attribute is blank" do
+      country = Country.new(:name => " ")
+      country.should_not be_name
+    end
+
+    it "returns false if the given attribute was not passed" do
+      country = Country.new
+      country.should_not be_name
+    end
+  end
+
+  describe "#id" do
+    context "when passed an id" do
+      it "returns the id as an integer" do
+        country = Country.new :id => "1"
+        country.id.should == 1
+      end
+    end
+    context "when not passed an id" do
+      it "returns nil" do
+        country = Country.new
+        country.id.should be_nil
+      end
+    end
+  end
+
+  describe "#new_record?" do
+    it "should be false" do
+      Country.new.should_not be_new_record
+    end
+  end
+
+  describe "#quoted_id" do
+    it "should return id" do
+      Country.new(:id => 2).quoted_id.should == 2
+    end
+  end
+
+  describe "#to_param" do
+    it "should return id as a string" do
+      Country.new(:id => 2).to_param.should == "2"
+    end
+  end
+
+  describe "#eql?" do
+    before do
+      class Region < ActiveHash::Base
+      end
+    end
+
+    it "should return true with the same class and id" do
+      Country.new(:id => 23).eql?(Country.new(:id => 23)).should be_true
+    end
+
+    it "should return false with the same class and different ids" do
+      Country.new(:id => 24).eql?(Country.new(:id => 23)).should be_false
+    end
+
+    it "should return false with the different classes and the same id" do
+      Country.new(:id => 23).eql?(Region.new(:id => 23)).should be_false
+    end
+
+    it "returns false when id is nil" do
+      Country.new.eql?(Country.new).should be_false
+    end
+  end
+
+  describe "#==" do
+    before do
+      class Region < ActiveHash::Base
+      end
+    end
+
+    it "should return true with the same class and id" do
+      Country.new(:id => 23).should == Country.new(:id => 23)
+    end
+
+    it "should return false with the same class and different ids" do
+      Country.new(:id => 24).should_not == Country.new(:id => 23)
+    end
+
+    it "should return false with the different classes and the same id" do
+      Country.new(:id => 23).should_not == Region.new(:id => 23)
+    end
+
+    it "returns false when id is nil" do
+      Country.new.should_not == Country.new
+    end
+  end
+
+  describe "#hash" do
+    it "returns id for hash" do
+      Country.new(:id => 45).hash.should == 45.hash
+      Country.new.hash.should == nil.hash
+    end
+
+    it "is hashable" do
+      { Country.new(:id => 4) => "bar"}.should == {Country.new(:id => 4) => "bar" }
+      { Country.new(:id => 3) => "bar"}.should_not == {Country.new(:id => 4) => "bar" }
+    end
+  end
+
+  describe "#readonly?" do
+    it "returns true" do
+      Country.new.should be_readonly
+    end
+  end
+
+end

data/spec/active_yaml/base_spec.rb

@@ -0,0 +1,19 @@
+require 'spec/spec_helper'
+
+describe ActiveYaml::Base do
+
+  describe ".all" do
+    it "loads the data from the yml file" do
+      class SomeArbitraryClass < ActiveYaml::Base
+        set_root_path File.dirname(__FILE__)
+        set_filename "sample"
+        field :name
+      end
+
+      records = SomeArbitraryClass.all
+      records.length.should == 3
+      records.should =~ [SomeArbitraryClass.new(:id => 1), SomeArbitraryClass.new(:id => 2), SomeArbitraryClass.new(:id => 3)]
+      records.first.name.should == "US"
+    end
+  end
+end

data/spec/active_yaml/sample.yml

@@ -0,0 +1,6 @@
+- id: 1
+  name: US
+- id: 2
+  name: Canada
+- id: 3
+  name: Mexico

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'active_hash'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+name: zilkey-active_hash
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jeff Dean
+- Mike Dalessio
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-22 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: jeff@zilkey.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- lib/active_file/base.rb
+- lib/active_hash.rb
+- lib/active_hash/base.rb
+- lib/active_yaml/base.rb
+- spec/active_file/base_spec.rb
+- spec/active_hash/base_spec.rb
+- spec/active_yaml/base_spec.rb
+- spec/active_yaml/sample.yml
+- spec/spec_helper.rb
+has_rdoc: false
+homepage: http://github.com/zilkey/active_hash
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: An ActiveRecord-like model that uses a hash as a datasource
+test_files: 
+- spec/active_file/base_spec.rb
+- spec/active_hash/base_spec.rb
+- spec/active_yaml/base_spec.rb
+- spec/spec_helper.rb