quirkey-static_model 0.2.0

data/History.txt

@@ -0,0 +1,26 @@
+== 0.2.0 2008-10-27
+	
+	* 2 major enhancements
+			
+		* StaticModel generator
+		* 'class_attributes' and ability to set default for record attributes
+		* Real documentation on the website: http://quirkey.rubyforge.org/static_model
+
+== 0.1.5 2008-09-18
+
+* 1 minor enhancement
+	
+	* better handling of empty YAML files (ienders)
+
+== 0.1.0 2008-08-27
+
+* 1 minor enchancement
+	
+	* fixed the dynamic finders to match AR's behavior AKA find_by === find_first_by
+
+== 0.1.0 2008-07-09
+
+* 1 major enhancement:
+  * Initial release
+		- Basic functionality
+		- Full test suite using shoulda

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Aaron Quint, Quirkey NYC, LLC
+
+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/Manifest.txt

@@ -0,0 +1,17 @@
+History.txt
+License.txt
+Manifest.txt
+README.rdoc
+generators/static_model/USAGE
+generators/static_model/static_model_generator.rb
+generators/static_model/templates/model.rb.erb
+generators/static_model/templates/models.yml.erb
+lib/static_model.rb
+lib/static_model/active_record.rb
+lib/static_model/associations.rb
+lib/static_model/base.rb
+lib/static_model/comparable.rb
+lib/static_model/errors.rb
+lib/static_model/rails.rb
+lib/static_model/scope.rb
+lib/static_model/version.rb

data/README.rdoc

@@ -0,0 +1,53 @@
+= static_model
+
+http://quirkey.rubyforge.org/static_model/
+
+== DESCRIPTION:
+
+ActiveRecord like functionalities for reading from YAML with a simple class implementation
+
+== SYNOPSIS:
+
+Use like ActiveRecord::Base, except no database, just a YAML file. The YAML should contain an array of records.
+
+For usage and setup check out the project's site:
+
+http://quirkey.rubyforge.org/static_model/
+
+== REQUIREMENTS:
+
+YAML 
+activesupport >= 2.1.0
+
+== INSTALL:
+
+	sudo gem install static_model 
+	
+The source is at github:
+
+http://github.com/quirkey/static_model/
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2008 Aaron Quint, Quirkey NYC, LLC
+
+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/generators/static_model/USAGE

@@ -0,0 +1,8 @@
+Description:
+  
+  Generates an empty StaticModel class/model
+
+Usage:
+  
+	./script/generate static_model ModelName --data=config/data/ --lib=app/models/
+	

data/generators/static_model/static_model_generator.rb

@@ -0,0 +1,57 @@
+class StaticModelGenerator < RubiGen::Base
+
+  default_options :author => nil
+
+  attr_reader :name, :lib_dir, :data_dir
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name = args.shift
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      # Ensure appropriate folder(s) exists
+      m.directory data_dir
+      m.directory lib_dir
+      m.template 'model.rb.erb', File.join(lib_dir, name.underscore + ".rb")
+      m.template 'models.yml.erb', File.join(data_dir, table_name + ".yml")
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a ...
+
+USAGE: #{$0} #{spec.name} ModelName
+EOS
+    end
+    
+    def class_name
+      @name.classify
+    end
+    
+    def table_name
+      @name.tableize
+    end
+    
+    def add_options!(opts)
+      # opts.separator ''
+      # opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |options[:author]| }
+      opts.on("-l", "--lib=your/path/", String, "Put the model.rb in a specific lib dir (default = app/models/)") {|o| options[:lib_dir] = o }
+      opts.on("-d", "--data=your/path/", String, "Put the models.yml data file in a specific data dir (default = config/data/)") {|o| options[:data_dir] = o }
+    end
+
+    def extract_options
+      @lib_dir = options[:lib_dir] || File.join('app', 'models')
+      @data_dir = options[:data_dir] || File.join('config', 'data')
+    end
+end

data/generators/static_model/templates/model.rb.erb

@@ -0,0 +1,4 @@
+class <%= class_name %> < StaticModel::Base
+  set_data_file File.join('<%= data_dir %>', '<%= table_name %>.yml')
+
+end

data/generators/static_model/templates/models.yml.erb

@@ -0,0 +1,6 @@
+---
+records:
+  - id: 1
+    name: One
+  - id: 2
+    name: Two

data/lib/static_model/active_record.rb

@@ -0,0 +1,11 @@
+module StaticModel
+  module ActiveRecord
+    # Stubbing out ActiveRecord methods so that associations work
+    
+    def new_record?
+      false
+    end
+    
+
+  end
+end

data/lib/static_model/associations.rb

@@ -0,0 +1,82 @@
+module StaticModel
+  module Associations
+
+    def self.included(klass)
+      klass.extend MacroMethods
+    end
+
+    module MacroMethods
+
+      def associations
+        @associations ||= {}
+      end
+
+      def has_many(association_name, options = {})
+        self.associations[association_name.to_sym] = HasManyAssociation.new(self, association_name.to_sym, {:foreign_key => "#{self.to_s.foreign_key}"}.merge(options))
+      end
+      
+      def belongs_to(association_name, options = {})
+        self.associations[association_name.to_sym] = BelongsToAssociation.new(self, association_name.to_sym, {:foreign_key => "#{association_name.to_s.foreign_key}"}.merge(options))
+      end
+
+    end
+
+
+    class Association
+      attr_reader :klass, :name, :options, :foreign_key
+
+      def initialize(klass, name, options = {})
+        @klass = klass
+        @name = name
+        @options = options
+        @reflection_klass_name = @options[:class_name] || @name.to_s.classify
+        @foreign_key = @options[:foreign_key]
+        define_association_methods
+      end
+      
+      def reflection_klass
+        Object.const_get(@reflection_klass_name)
+      rescue 
+        eval <<-EOT
+          class #{@reflection_klass_name}; end;
+          #{@reflection_klass_name}
+        EOT
+      end
+
+      def define_association_methods
+        raise 'Should only use descendants of Association'
+      end
+    end
+
+    class HasManyAssociation < Association
+
+      def define_association_methods
+        if reflection_klass.respond_to?(:scoped)
+          klass.module_eval <<-EOT
+            def #{name}
+              #{reflection_klass}.scoped(:conditions => {:#{foreign_key} => id})
+            end
+          EOT
+        else
+          klass.module_eval <<-EOT
+          def #{name}
+            #{reflection_klass}.send(:find_all_by_#{foreign_key}, id)
+          end
+          EOT
+        end
+      end
+    end
+
+    class BelongsToAssociation < Association
+      
+      def define_association_methods
+        klass.module_eval <<-EOT
+          def #{name}
+            #{reflection_klass}.send(:find, #{foreign_key})
+          end
+        EOT
+      end
+    end
+
+  end
+end

data/lib/static_model/base.rb

@@ -0,0 +1,169 @@
+module StaticModel  
+  class Base
+    include StaticModel::Associations
+    include StaticModel::ActiveRecord
+    include StaticModel::Comparable
+    
+    @@load_path = File.join('config', 'data')
+
+    attr_reader :id
+    
+    
+    def initialize(attribute_hash = {})
+      raise(StaticModel::BadOptions, "Initializing a model is done with a Hash {} given #{attribute_hash.inspect}") unless attribute_hash.is_a?(Hash)
+      @id = attribute_hash.delete('id') || attribute_hash.delete(:id) || (self.class.count + 1)
+      self.attributes = attribute_hash
+    end
+
+    def to_s
+      self.inspect
+    end
+
+    def attributes
+      @attributes ||= HashWithIndifferentAccess.new
+    end
+
+    def attributes=(attribute_hash)
+      attribute_hash.each {|k,v| set_attribute(k,v) }
+    end
+
+    def attribute_names
+      (attributes.keys | self.class.class_attributes.keys).collect {|k| k.to_s }
+    end
+
+    class << self
+
+      def find(what, *args, &block)
+        case what
+        when Symbol
+          send("find_#{what}")
+        when Integer
+          find_by_id(what)
+        end
+      end
+
+      def find_by_id(id)
+        record = records.detect {|r| r.id == id }
+        raise(StaticModel::RecordNotFound, "Could not find record with id = #{id}") unless record
+        record
+      end
+
+      def [](id)
+        find_by_id(id)
+      end
+
+      def find_all
+        records
+      end
+      alias_method :all, :find_all
+
+      def find_first
+        records[0]
+      end
+      alias_method :first, :find_first
+
+      def find_all_by(attribute, value)
+        records.find_all {|r| r.send(attribute) == value }
+      end
+
+      def find_first_by(attribute, value)
+        records.find {|r| r.send(attribute) == value }
+      end
+      alias_method :find_by, :find_first_by
+
+      def load(reload = false)
+        return if loaded? && !reload
+        raise(StaticModel::DataFileNotFound, "You must set a data file to load from") unless File.readable?(data_file) 
+        data = YAML::load_file(data_file)
+        records = []
+        if data.is_a?(Hash) && data.has_key?('records')
+          records = data.delete('records')
+          @class_attributes = HashWithIndifferentAccess.new(data)
+        elsif data.is_a?(Array)
+          records = data
+        end
+        @records = records && !records.empty? ? records.dup.collect {|r| new(r) } : []
+        @loaded = true
+      # rescue
+      #   raise(StaticModel::BadDataFile, "The data file you specified '#{data_file}' was not in a readable format.")
+      end
+
+      def loaded?
+        @loaded ||= false
+      end
+
+      def data_file
+        @data_file ||= default_data_file_path
+      end
+
+      def set_data_file(file_path)
+        raise(StaticModel::DataFileNotFound, "Could not find data file #{file_path}") unless File.readable?(file_path)
+        @data_file = file_path
+        # force reload
+        @loaded = false
+        @records = nil
+      end
+    
+      def count
+        records.length
+      end
+      
+      def class_attributes
+        load
+        @class_attributes ||= {}
+      end
+      
+      def class_attribute(name)
+        class_attributes[name]
+      end
+      
+      def records
+        load
+        @records
+      end
+
+      protected
+      def default_data_file_path
+        File.join(@@load_path, "#{self.to_s.tableize}.yml")
+      end
+
+      private
+      def method_missing(meth, *args)
+        meth_name = meth.to_s
+        if meth_name =~ /^find_(all_by|first_by|by)_(.+)/
+          attribute_name = meth_name.gsub(/^find_(all_by|first_by|by)_/, '')
+          finder    = meth_name.gsub(/_#{attribute_name}/, '')
+          return self.send(finder, attribute_name, *args)
+        elsif class_attributes.has_key? meth_name
+          return class_attributes[meth_name]
+        end
+        super
+      end
+    end  
+
+    protected
+    def set_attribute(name, value)
+      self.attributes[name] = value
+    end
+    
+    def get_attribute(name)
+      attributes.has_key?(name) ? attributes[name] : self.class.class_attribute(name)
+    end
+
+    private
+    def method_missing(meth, *args)
+      attribute_name = meth.to_s.gsub(/=$/,'')
+      if attribute_names.include?(attribute_name)
+        if meth.to_s =~ /=$/
+          # set
+          return set_attribute(attribute_name, args[0])
+        else
+          # get
+          return get_attribute(attribute_name)
+        end
+      end
+      super
+    end
+    
+  end
+end

data/lib/static_model/comparable.rb

@@ -0,0 +1,14 @@
+module StaticModel
+  module Comparable
+    include ::Comparable
+
+    def <=>(other)
+      if self.class == other.class 
+        self.id <=> other.id
+      else
+        -1
+      end
+    end
+    
+  end
+end

data/lib/static_model/errors.rb

@@ -0,0 +1,7 @@
+module StaticModel
+  class Error < RuntimeError; end;
+  class RecordNotFound < Error; end;
+  class DataFileNotFound < Error; end;
+  class BadDataFile < Error; end;
+  class BadOptions < Error; end;
+end

data/lib/static_model/rails.rb

@@ -0,0 +1,7 @@
+if defined?(Rails)
+  module StaticModel
+    class Base
+      @@load_path = File.join(Rails.root,'config', 'data')
+    end
+  end
+end

data/lib/static_model/scope.rb

@@ -0,0 +1,15 @@
+module StaticModel
+  module Scope
+   
+    private
+    class << self
+      def with_scope
+        
+      end
+      
+      def scoped_conditions
+      end
+    end
+    
+  end
+end

data/lib/static_model/version.rb

@@ -0,0 +1,9 @@
+module StaticModel #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/static_model.rb

@@ -0,0 +1,16 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'yaml'
+
+require 'active_support/inflector'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/string'
+
+
+require 'static_model/errors'
+require 'static_model/associations'
+require 'static_model/active_record'
+require 'static_model/comparable'
+require 'static_model/base'
+require 'static_model/rails'

data/test/test_generator_helper.rb

@@ -0,0 +1,29 @@
+begin
+  require File.dirname(__FILE__) + '/test_helper'
+rescue LoadError
+  require 'test/unit'
+end
+require 'fileutils'
+
+# Must set before requiring generator libs.
+TMP_ROOT = File.dirname(__FILE__) + "/tmp" unless defined?(TMP_ROOT)
+PROJECT_NAME = "myproject" unless defined?(PROJECT_NAME)
+app_root = File.join(TMP_ROOT, PROJECT_NAME)
+if defined?(APP_ROOT)
+  APP_ROOT.replace(app_root)
+else
+  APP_ROOT = app_root
+end
+if defined?(RAILS_ROOT)
+  RAILS_ROOT.replace(app_root)
+else
+  RAILS_ROOT = app_root
+end
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/helpers/generator_test_helper'

data/test/test_helper.rb

@@ -0,0 +1,80 @@
+require 'test/unit'
+require 'rubygems'
+require 'shoulda'
+require 'mocha'
+
+require File.dirname(__FILE__) + '/../lib/static_model'
+
+class Book < StaticModel::Base
+  set_data_file File.join(File.dirname(__FILE__), 'data', 'books.yml')
+end
+
+unless defined?(ActiveRecord::Base)
+  module ActiveRecord
+    class Base
+      def self.scoped(*args)
+      end
+    end
+  end
+end
+
+class Article < ActiveRecord::Base
+end
+
+class Publisher < StaticModel::Base
+  set_data_file File.join(File.dirname(__FILE__), 'data', 'publishers.yml')
+  
+  has_many :authors
+end
+
+class Author < StaticModel::Base
+  set_data_file File.join(File.dirname(__FILE__), 'data','authors.yml')
+  has_many :books
+  has_many :articles
+  belongs_to :publisher
+end
+
+class Page < StaticModel::Base
+  set_data_file File.join(File.dirname(__FILE__), 'data', 'pages.yml')
+  
+end
+  
+
+
+
+class Test::Unit::TestCase
+  
+  def assert_all(collection)
+    collection.each do |one|
+      assert yield(one), "#{one} is not true"
+    end
+  end
+
+
+  def assert_any(collection, &block)
+    has = collection.any? do |one|
+      yield(one)
+    end
+    assert has
+  end
+
+  def assert_ordered(array_of_ordered_items, message = nil, &block)
+    raise "Parameter must be an Array" unless array_of_ordered_items.is_a?(Array)
+    message ||= "Items were not in the correct order"
+    i = 0
+    # puts array_of_ordered_items.length
+    while i < (array_of_ordered_items.length - 1)
+      # puts "j"
+      a, b = array_of_ordered_items[i], array_of_ordered_items[i+1]
+      comparison = yield(a,b)
+      # raise "#{comparison}"
+      assert(comparison, message + " - #{a}, #{b}")
+      i += 1
+    end
+  end
+  
+  def assert_set_of(klass, set)
+    assert set.respond_to?(:each), "#{set} is not a set (does not include Enumerable)"
+    assert_all(set) {|a| a.is_a?(klass) }
+  end
+end

data/test/test_static_model.rb

@@ -0,0 +1,350 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestStaticModel < Test::Unit::TestCase
+
+  context "StaticModel" do
+    context "A class that inherits from Base" do      
+      context "an instance" do
+
+        setup do
+          @book = Book.new(book_params)
+        end
+
+        context "initialization" do
+
+          should "set attributes with a hash" do
+            assert @book.id
+          end
+
+          should "raise error if passed anything but hash" do
+            assert_raise(StaticModel::BadOptions) do
+              Book.new("im bad")
+            end
+          end      
+        end
+
+        context "attributes" do
+          should "get attributes by methods" do
+            assert_equal book_params[:title], @book.title
+            assert_equal book_params[:genre], @book.genre
+          end
+
+          should "set attributes by methods" do
+            @book.title = 'New Title'
+            assert_equal 'New Title', @book.title
+          end
+        end
+
+        context "to_s" do
+          should "inspect" do
+            assert_equal @book.inspect, @book.to_s
+          end
+        end
+
+        context "comparing" do
+
+          should "be equal to an instance of the same class with same id" do
+            assert_equal @book, Book.new(book_params)
+          end
+
+          should "not be equal to an instance with the same class with different ids" do
+            assert_not_equal Book[1], @book
+          end
+
+          should "not be equal to an instance with different classes and the same ids" do
+            assert_not_equal Book[1], Author[1]
+          end
+        end
+
+      end
+
+      context "on the class" do
+        context "set data file" do
+          context "After the class is defined" do
+
+            setup do
+              @book = Book.find(1)
+              @author = Author.find(1)
+              @original_data_file = Book.data_file
+              @data_file = File.join(File.dirname(__FILE__), 'data', 'authors.yml')
+              Book.set_data_file @data_file
+              @new_book = Book.find(1)
+            end
+
+            should "set the @data_file" do
+              assert_equal @data_file, Book.data_file
+            end
+
+            should "reload with next find" do
+              assert @author.attributes, @new_book.attributes
+            end
+
+            teardown do
+              Book.set_data_file @original_data_file
+            end
+          end
+        end
+
+        context "find" do
+
+          context "with an integer" do
+            setup do
+              @book = Book.find(1)
+            end
+
+            should "set loaded?" do
+              assert Book.loaded?
+            end
+
+            should "load by id" do
+              assert_equal 1, @book.id
+            end
+
+            should "return instance of klass" do
+              assert @book.is_a?(Book)
+            end
+
+            should "raise error if cant find record with id" do
+              assert_raise(StaticModel::RecordNotFound) do
+                @book = Book.find(1000)
+              end
+            end
+          end
+        end
+
+        context "[]" do
+          should "be an alias for find by id" do
+            assert_equal Book.find(1), Book[1]
+          end
+        end
+
+        context "find(:all)" do
+          should "be an alias for find_all" do
+            assert_equal Book.find_all, Book.find(:all)
+          end
+        end
+        context "find(:first)" do
+          should "be an alias for find_first" do
+            assert_equal Book.find_first, Book.find(:first)
+          end
+        end
+
+        context "all" do
+          should "be an alias for find_all" do
+            assert_equal Book.all, Book.find(:all)
+          end
+        end
+        context "first" do
+          should "be an alias for find_first" do
+            assert_equal Book.first, Book.find(:first)
+          end
+        end
+
+        context "find_first" do
+          setup do
+            @book = Book.find_first
+          end
+
+          should "return the first instance from all records" do
+            assert_equal Book.find_all.first, @book
+          end
+
+          should "return instance of klass" do
+            assert @book.is_a?(Book)
+          end
+        end
+
+        context "find_all" do
+          setup do
+            @books = Book.find_all
+          end
+
+          should "return an array" do
+            assert @books.is_a?(Array)
+          end
+
+          should "return all records" do
+            assert_equal 4, @books.length
+          end
+
+          should "return set of klass instances" do
+            @books.each do |book|
+              assert book.is_a?(Book)
+            end
+          end
+
+          context "with an empty data file" do
+            setup do
+              @original_data_file = Book.data_file
+              @data_file = File.join(File.dirname(__FILE__), 'data', 'empty.yml')
+              Book.set_data_file @data_file
+            end
+
+            should "return an empty array" do
+              assert_equal [], Book.find_all
+            end
+
+            teardown do
+              Book.set_data_file @original_data_file
+            end
+
+          end
+        end
+
+        context "find_first_by" do
+          setup do
+            @author = 'Michael Pollan'
+            @book = Book.find_first_by(:author,@author)
+          end
+
+          should "return an instance of klass" do
+            assert @book.is_a?(Book)
+          end
+
+          should "return record matching search" do
+            assert @author, @book.author
+          end
+
+          context "when there is no match" do
+            should "return nil" do
+              assert_nil Book.find_first_by(:author,'Aaron Quint')
+            end
+          end
+        end
+
+        context "find_by" do
+          setup do
+            @author = 'Michael Pollan'
+            @book = Book.find_by(:author,@author)
+          end
+
+          should "return an instance of klass" do
+            assert @book.is_a?(Book)
+          end
+
+          should "return record matching search" do
+            assert @author, @book.author
+          end
+
+          context "when there is no match" do
+            should "return nil" do
+              assert_nil Book.find_by(:author,'Aaron Quint')
+            end
+          end
+
+        end
+
+        context "find_all_by" do
+          setup do
+            @author = 'Michael Pollan'
+            @books = Book.find_all_by(:author,@author)
+          end
+
+          should "return an array" do
+            assert @books.is_a?(Array)
+          end
+
+          should "return all records that match search" do
+            @books.each {|b| assert_equal @author, b.author}
+          end
+
+          should "return set of klass instances" do
+            @books.each {|b| assert b.is_a?(Book) }
+          end
+
+          context "when there is no match" do
+            should "return an empty array" do
+              assert_equal [], Book.find_all_by(:author,'Aaron Quint')
+            end
+          end
+          context "when there is only one match" do
+            should "return an array" do
+              assert_equal [Book.find(3)], Book.find_all_by(:author,'Piers Anthony')
+            end
+          end
+        end
+
+        context "dynamic finders" do
+          setup do
+            @book = Book.first
+          end
+
+          context "find_by_*attribute*" do
+            should "be equivalent to find_first_by(attribute,)" do
+              assert_equal @book, Book.find_first_by(:genre, 'Non-Fiction')
+              assert_equal Book.find_first_by(:genre, 'Non-Fiction'), Book.find_by_genre('Non-Fiction')
+            end
+          end
+
+          context "find_first_by_*attribute*" do
+            should "be equivalent to find_first_by(attribute,)" do
+              assert_equal @book, Book.find_first_by(:genre, 'Non-Fiction')
+              assert_equal Book.find_first_by(:genre, 'Non-Fiction'), Book.find_first_by_genre('Non-Fiction')
+            end
+          end
+
+          context "find_all_by_*attribute*" do
+            should "be equivalent to find_all_by(attribute,)" do
+              assert_equal Book.find_all_by(:genre, 'Non-Fiction'), Book.find_all_by_genre('Non-Fiction')
+            end
+          end
+        end
+
+        context "count" do
+          should "return the count of all records" do
+            assert_equal Book.all.length, Book.count
+          end
+        end
+        
+        context "with a class with yaml class vars" do
+          setup do
+            @pages = Page.all
+          end
+          
+          should "load :records into @records" do
+            assert_set_of Page, @pages
+            assert Page.loaded?
+          end
+          
+          should "give access to top level attributes as class methods" do
+            assert_equal 'http://www.quirkey.com', Page.url
+            assert_equal 'The Best Ever', Page.title
+          end
+          
+          should "return a hash for class attribute" do
+            assert Page.settings.is_a?(Hash)
+            assert_equal 'test', Page.settings['username']
+          end
+          
+          should "have class attributes appear as record accessor defaults if none exist" do
+            assert_equal 'http://www.quirkey.com', Page[1].url
+          end
+          
+          should "not overwrite record specific methods" do
+            assert_equal 'http://github.com', Page[2].url
+          end
+          
+          context "class_attributes" do
+            setup do
+              @attributes = Page.class_attributes
+            end
+            
+            should "return a hash of all top level settings" do
+              assert @attributes.is_a?(Hash)
+              assert_equal 3, @attributes.length
+              assert_equal 'http://www.quirkey.com', @attributes['url']
+            end
+          end
+        end
+
+      end
+    end
+  end
+
+  protected
+  def book_params
+    {:id => 15, :title => 'Lord of the Rings', :author => 'J.R. Tolkien', :genre => 'Fantasy'}
+  end
+
+
+end

data/test/test_static_model_associations.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestStaticModelAssociations < Test::Unit::TestCase
+
+  context "a static model class" do
+
+    context "with a has many association" do
+      context "to another static model" do
+        # Author has many books
+        setup do
+          @author = Author.find(1)
+        end
+
+        should "respond to association name" do
+          assert @author.books
+        end
+
+        should "return an array of association instances if association is a StaticModel" do
+          assert_set_of Book, @author.books
+        end
+
+        should "find books by foreign_key" do
+          assert_equal Book.find_all_by_author_id(@author.id), @author.books
+        end
+
+        should "add association to associations" do
+          assert Author.associations.has_key?(:books)
+        end
+
+        should "have HasManyAssociation in associations" do
+          assert Author.associations[:books].is_a?(StaticModel::Associations::HasManyAssociation)
+        end
+      end
+
+      context "to an active record model" do
+        setup do
+          @author = Author.find(1)
+          Article.expects(:scoped).returns([Article.new, Article.new])
+        end
+
+        should "respond to association name" do
+          assert @author.articles
+        end
+
+        should "return an array of association instances if association is a StaticModel" do
+          assert_set_of Article, @author.articles
+        end
+
+      end
+    end
+
+
+    context "with a belongs to association" do
+      context "to another static model" do
+        # Author belongs to publisher
+        setup do
+          @author = Author.find(1)
+        end
+
+        should "respond to association name" do
+          assert @author.publisher
+        end
+
+        should "return a single instance" do
+          assert @author.publisher.is_a?(Publisher)
+        end
+
+        should "find publisher by foreign key" do
+          assert_equal Publisher.find(1), @author.publisher
+        end
+
+        should "add association to associations" do
+          assert Author.associations.has_key?(:publisher)
+        end
+
+        should "have BelongsTo association in associations" do
+          assert Author.associations[:publisher].is_a?(StaticModel::Associations::BelongsToAssociation)
+        end
+
+        context "when foreign key is nil" do
+          setup do
+            @author = Author.find(2)
+          end
+
+          should "respond to association name and return nil" do
+            assert_nil @author.publisher
+          end
+        end
+      end
+    end
+
+  end
+end

data/test/test_static_model_generator.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__), "test_generator_helper.rb")
+
+
+class TestStaticModelGenerator < Test::Unit::TestCase
+  include RubiGen::GeneratorTestHelper
+
+  def setup
+    bare_setup
+  end
+
+  def teardown
+    bare_teardown
+  end
+
+  # Some generator-related assertions:
+  #   assert_generated_file(name, &block) # block passed the file contents
+  #   assert_directory_exists(name)
+  #   assert_generated_class(name, &block)
+  #   assert_generated_module(name, &block)
+  #   assert_generated_test_for(name, &block)
+  # The assert_generated_(class|module|test_for) &block is passed the body of the class/module within the file
+  #   assert_has_method(body, *methods) # check that the body has a list of methods (methods with parentheses not supported yet)
+  #
+  # Other helper methods are:
+  #   app_root_files - put this in teardown to show files generated by the test method (e.g. p app_root_files)
+  #   bare_setup - place this in setup method to create the APP_ROOT folder for each test
+  #   bare_teardown - place this in teardown method to destroy the TMP_ROOT or APP_ROOT folder after each test
+
+  def test_generator_with_name_as_a_class_name
+    name = "StaticPage"
+    run_generator('static_model', [name], sources)
+    assert_directory_exists 'config/data'
+    assert_generated_file 'config/data/static_pages.yml'
+    assert_generated_file 'app/models/static_page.rb' do |content|
+      assert_match(/class StaticPage/, content)
+    end
+  end
+
+  private
+  def sources
+    [RubiGen::PathSource.new(:test, File.join(File.dirname(__FILE__),"..", generator_path))
+    ]
+  end
+
+  def generator_path
+    "generators"
+  end
+end

data/test/test_static_model_scope.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestStaticModelScope < Test::Unit::TestCase
+
+  # context "a static model class" do
+  #   context "A class with scope" do
+  #     
+  #   end
+  # end
+  
+  def test_truth
+    assert true
+  end
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: quirkey-static_model
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Aaron Quint
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-28 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: ActiveRecord like functionalities for reading from YAML with a simple class implementation
+email: 
+- aaron@quirkey.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.rdoc
+files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.rdoc
+- generators/static_model/USAGE
+- generators/static_model/static_model_generator.rb
+- generators/static_model/templates/model.rb.erb
+- generators/static_model/templates/models.yml.erb
+- lib/static_model.rb
+- lib/static_model/active_record.rb
+- lib/static_model/associations.rb
+- lib/static_model/base.rb
+- lib/static_model/comparable.rb
+- lib/static_model/errors.rb
+- lib/static_model/rails.rb
+- lib/static_model/scope.rb
+- lib/static_model/version.rb
+- test/test_generator_helper.rb
+- test/test_helper.rb
+- test/test_static_model.rb
+- test/test_static_model_associations.rb
+- test/test_static_model_generator.rb
+- test/test_static_model_scope.rb
+has_rdoc: true
+homepage: http://quirkey.rubyforge.org
+post_install_message: ""
+rdoc_options: 
+- --main
+- README.rdoc
+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: quirkey
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: ActiveRecord like functionalities for reading from YAML with a simple class implementation
+test_files: 
+- test/test_generator_helper.rb
+- test/test_helper.rb
+- test/test_static_model.rb
+- test/test_static_model_associations.rb
+- test/test_static_model_generator.rb
+- test/test_static_model_scope.rb