kabuki-heresy 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 kabuki
+
+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.rdoc

@@ -0,0 +1,50 @@
+= heresy
+
+Heresy is a schema free wrapper around your database, heavily inspired by both CouchDB and FriendFeed[1].  You create Heresy models that work with generic schema-less tables.
+
+  class Entry < Heresy::Model
+    fields do |f|
+      f.string :title
+    end
+  end
+
+  Entry.schema.create # create the table in the database
+
+This class will use a table that looks like this:
+
+  create_table :entries do |t|
+    t.primary_key :id,         :int
+    t.column      :uuid,       :binary
+    t.column      :updated_at, :timestamp
+    t.column      :body,       :blob
+  end
+
+Now you can create and retrieve models:
+
+  @entry = Entry.new :title => 'testing'
+  @entry.save
+
+  @entry = Entry.find('some_entry_uuid')
+  @entry.body = "updated"
+  @entry.save
+
+UUIDs are automatically generated and used as the main ID for each record.
+
+1: http://bret.appspot.com/entry/how-friendfeed-uses-mysql
+
+== TODO
+
+ - Indexes
+ - Associations
+ - Timezone conversions
+
+== NOT TODO
+
+ - Validations
+ - Callbacks
+
+Use Validateable, ActiveSupport::Callbacks, ActiveModel, etc
+
+== Copyright
+
+Copyright (c) 2009 kabuki. See LICENSE for details.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 1
+:patch: 0

data/lib/heresy-with-gems.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+gem 'activesupport', '~> 2.2.0'
+gem 'sequel',        '~> 2.10.0'
+gem 'uuid',          '~> 2.0.1'
+require 'heresy'

data/lib/heresy.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH << File.join(File.dirname(__FILE__))
+
+%w(array/extract_options).each { |lib| require "active_support/core_ext/#{lib}" }
+class Array #:nodoc:
+  include ActiveSupport::CoreExtensions::Array::ExtractOptions
+end
+
+%w(basic_object time_with_zone values/time_zone inflector core_ext/object core_ext/duplicable core_ext/blank core_ext/class core_ext/module core_ext/date core_ext/numeric core_ext/time duration).each { |lib| require "active_support/#{lib}" }
+%w(uuid sequel_core tzinfo heresy/schema heresy/schema/column heresy/schema/fields heresy/index heresy/model).each { |lib| require lib }
+
+module Heresy
+  class << self
+    attr_accessor :time_zone
+    attr_accessor :db
+  end
+
+  Time.zone = self.time_zone = "UTC"
+end

data/lib/heresy/formatting/json.rb

@@ -0,0 +1,28 @@
+require 'json'
+require 'zlib'
+require 'stringio'
+
+module Heresy
+  module Formatting
+    module Json
+      DATE_REGEX = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z/
+
+      extend self
+      def encode(body)
+        s = StringIO.new
+        z = Zlib::GzipWriter.new(s)
+        z.write body.to_json
+        z.close
+        s.string
+      end
+
+      def decode(body)
+        s = StringIO.new(body)
+        z = Zlib::GzipReader.new(s)
+        hash = JSON.parse(z.read)
+        z.close
+        hash
+      end
+    end
+  end
+end

data/lib/heresy/index.rb

@@ -0,0 +1,135 @@
+module Heresy
+  # This class is responsible for defining the index tables that models use. 
+  # Since model data is stored as an encoded string, it is impossible to perform
+  # any searches or queries on it.  Therefore, separate tables with these data
+  # relationships must be created.  
+  #
+  #   @index = Index.new(Heresy::Model.db, :entry_titles, :entry_id)
+  #   @index.field :title, :varchar, :size => 255
+  #   @index.create
+  #
+  # This will create a simple table that looks something like this:
+  #
+  #   create_table :entry_titles do |t|
+  #     t.column :entry_id, :binary
+  #     t.column :title,  :varchar
+  #     t.primary_key [:title, :entry_id]
+  #   end
+  #
+  # You can then fill the index as models are saved:
+  #
+  #   @entry.save
+  #   @index << {:entry_id => @entry.uuid, :title => @entry.title}
+  #
+  # Once the index is filled, you can perform searches:
+  #
+  #   uuids   = @index.find(:title => "Test")
+  #   entries = Entry.find(uuids)
+  #
+  class Index
+    attr_accessor :name, :key
+    attr_reader :fields, :field_names, :uuid_fields
+
+    def initialize(db, name, key)
+      @db          = db
+      @name        = name
+      @key         = Heresy::Schema::Column.new(key, :uuid, :unique => true)
+      @fields      = []
+      @field_names = {}
+      @uuid_fields = [@key.name]
+      yield self if block_given?
+    end
+
+    # Inserts the given data into the index.  The columns should probably
+    # match the Index's schema, or you'll probably see an error.
+    #
+    #   @index << {:entry_id => @entry.uuid, :title => @entry.title}
+    #
+    def insert(data)
+      @uuid_fields.each do |name|
+        if data.key?(name)
+          data[name] = data[name].to_a.pack("H*")
+        end
+      end
+      dataset << data
+    end
+
+    alias << insert
+
+    # Clears all data from the index.
+    def clear
+      dataset.delete
+    end
+
+    # Counts the number of indexed entries.
+    def count
+      dataset.count
+    end
+
+    # Returns all the UUIDs from a given query.  The query is first passed to #filter.
+    def find(params)
+      filter(params).to_a.map! { |row| row[@key.name].unpack("H*").first }
+    end
+
+    # Filters the Sequel dataset object with the given query.  The resulting dataset
+    # can be modified further to introduce ordering or more advanced filtering if desired.
+    def filter(options)
+      dataset.filter(options).select(@key.name)
+    end
+
+    # Index schema methods
+
+    # Adds a field to the index.  By default, a :uuid type is used.  All
+    # model-to-model associations are done via UUID.
+    def field(name, type = :uuid, options = {})
+      col = Heresy::Schema::Column.new(name, type, options)
+      @fields << col
+      @uuid_fields << col.name if col.type == :uuid
+      @field_names[name] = col
+    end
+
+    # Index database creation/deletion
+
+    # Checks if the Index table exists in the database.
+    def exists?
+      @db.table_exists?(@name)
+    end
+
+    # Creates the Index table
+    def create
+      to_sql.each { |sql| @db.execute_ddl(sql) }
+    end
+
+    # Drops the index table
+    def drop
+      @db.drop_table @name
+    end
+
+    # Returns the SQL that will be used to create the Index table.
+    def to_sql
+      @db.create_table_sql_list @name, *generate.create_info
+    end
+
+    def inspect
+      "<Heresy::Index:#{@name} #{@fields.map { |f| f.name } * ", "}>"
+    end
+
+  protected
+    def dataset
+      @dataset ||= @db[@name].select(@key.name)
+    end
+
+    def generate
+      gen = Sequel::Schema::Generator.new(@db)
+      @key.create(gen)
+      keys = []
+      @fields.each do |field|
+        keys << field.name
+        field.create(gen)
+      end
+      keys << @key.name
+      gen.primary_key keys
+      gen
+    end
+  end
+end

data/lib/heresy/model.rb

@@ -0,0 +1,188 @@
+module Heresy
+  # This class is responsible for storing and retrieving the model data in a schema-free manner.
+  class Model
+    class << self
+      attr_writer :db, :schema, :formatter
+
+      # Accesses the database schema for this model.  The basic schema will look something like this:
+      #
+      #   create_table :entries do |t|
+      #     t.primary_key :id,         :int
+      #     t.column      :uuid,       :binary
+      #     t.column      :updated_at, :timestamp
+      #     t.column      :body,       :blob
+      #   end
+      #
+      # You can modify any of those from the schema directly.
+      #
+      #   class Entry < Heresy::Model
+      #     schema :custom_table_name do |s|
+      #       s.id.type = :medium_int
+      #       s.id.options[:size] = 11
+      #       s.body.type = :medium_blob
+      #     end
+      #   end
+      #
+      # The types are any valid type from the Sequel ruby library.  There are a few convenience types, however.
+      # (See Heresy::Schema::Column)
+      #
+      # All models have the same 4 database fields:
+      #  - an auto-incremented ID and updated_at timestamp
+      #  - a 32 character hex UUID that gets stored as a 16 character binary string.  This is how items are retrieved.
+      #  - a BLOB body character for storing the model's data.
+      #
+      def schema(table_name = name.demodulize.underscore.pluralize)
+        @schema ||= Heresy::Schema.new(db, table_name.to_sym)
+        yield @schema if block_given?
+        @schema
+      end
+
+      # Yields a Schema::Fields object for specifying fields for this model.  These fields get assembled into
+      # a hash and stored in the BODY attribute of the schema.  
+      #
+      # By default, fields are all strings.  Other types such as integers and dates can be specified for automatic
+      # conversions.
+      #
+      #   class Entry < Heresy::Model
+      #     fields do |f|
+      #       f.string   :title
+      #       f.integer  :comments_count
+      #       f.datetime :published_at
+      #     end
+      #   end
+      #
+      def fields
+        yield Schema::Fields.new(self)
+      end
+
+      # This is a hash of all specified fields and their type converters.  If a type converter is set (see #fields),
+      # values are parsed in the field attribute writers, and encoded when saving to the database.
+      def body_fields
+        @body_fields ||= {}
+      end
+
+      # Finds a single or an array of entries by UUID.  
+      def find(uuid)
+        if uuid.is_a?(Array)
+          rows = dataset.filter(:uuid => uuid.map { |u| u.to_a.pack("H*") }).to_a
+          rows.map! { |row| retrieve(row) }
+        else
+          new(:uuid => uuid).reload
+        end
+      end
+
+      # Reference to the Sequel DB object
+      def db
+        @db = Heresy.db
+      end
+
+      # Reference to the Sequel dataset for this model's table.
+      def dataset
+        @dataset ||= db[schema.name]
+      end
+
+      # The formatter is what converts the assembled model hash data into the string
+      # that gets saved in the database.  The default formatter stores zlib compressed
+      # JSON hashes.
+      def formatter
+        @formatter ||= \
+          if superclass.respond_to?(:formatter)
+            superclass.formatter
+          else
+            :json
+          end
+
+        if @formatter.is_a?(Symbol)
+          require "heresy/formatting/#{@formatter}"
+          @formatter = Heresy::Formatting.const_get(@formatter.to_s.capitalize)
+        end
+
+        @formatter
+      end
+
+    protected
+      # Used by #find to fill up an empty model record with data using a row from the db.
+      def retrieve(row)
+        record = new(:uuid => row[:uuid].unpack("H*").first)
+        record.retrieve(row)
+      end
+    end
+
+    attr_reader :id
+    attr_reader :updated_at
+
+    def initialize(attributes = {})
+      set_attributes attributes
+    end
+
+    def uuid
+      @uuid ||= UUID.generate(:compact)
+    end
+
+    # Saves the record in the database.
+    def save
+      if new?
+        self.class.dataset << {:uuid => uuid.to_a.pack("H*"), :body => self.class.formatter.encode(assemble_body)}
+        reload
+      else
+        rowset.update({:updated_at => nil})
+        reload
+      end
+      true
+    end
+
+    def new?
+      @id.nil?
+    end
+
+    # Reloads a model's data from the database using the existing UUID.
+    def reload
+      retrieve(rowset.select(:id, :body, :updated_at).first)
+    end
+
+    def ==(other)
+      other.class == self.class && other.uuid == uuid
+    end
+
+    def inspect
+      "<#{self.class.name} (#{uuid}) #{self.class.body_fields.keys.map { |k| "@#{k}=#{send(k).inspect}" } * ', '}>"
+    end
+
+    def retrieve(row)
+      @id          = row[:id]
+      @updated_at  = row[:updated_at]
+      set_attributes self.class.formatter.decode(row[:body])
+      self
+    end
+
+  protected
+    # Assembles the model data into an encoded hash, ready to be formatted and stored.
+    def assemble_body
+      hash = {}
+      self.class.body_fields.each do |key, type|
+        if value = instance_variable_get("@#{key}")
+          hash[key] = type ? type.encode(value) : value
+        end
+      end
+      hash
+    end
+
+    # Performs a mass assignment of the model's data.
+    def set_attributes(attributes)
+      attributes.each do |key, value|
+        next if key.blank?
+        key = key.to_sym
+        if key == :uuid
+          @uuid = value
+        elsif self.class.body_fields.key?(key)
+          send "#{key}=", value
+        end
+      end
+    end
+
+    # A Sequel filter for the current row in the database.
+    def rowset
+      @rowset ||= self.class.dataset.filter(:uuid => uuid.to_a.pack("H*"))
+    end
+  end
+end

data/lib/heresy/schema.rb

@@ -0,0 +1,48 @@
+module Heresy
+  # This class is responsible for defining and creating the table used to store model data.
+  class Schema
+    attr_accessor :name
+    attr_reader :id, :uuid, :updated_at, :body
+
+    def initialize(db, name)
+      @db         = db
+      @name       = name
+      @id         = Column.new(:id,         :int,       :size => 11, :unsigned => true)
+      @uuid       = Column.new(:uuid,       :uuid,      :unique => true)
+      @updated_at = Column.new(:updated_at, :timestamp, :default => 'CURRENT_TIMESTAMP'.lit, :index => true)
+      @body       = Column.new(:body,       :blob)
+    end
+
+    # Checks whether the model table exists or not.
+    def exists?
+      @db.table_exists?(@name)
+    end
+
+    # Creates the model table.
+    def create
+      to_sql.each { |sql| @db.execute_ddl(sql) }
+    end
+
+    # Drops the model table.
+    def drop
+      @db.drop_table @name
+    end
+
+    # Returns an array of the SQL statements used to create the table and any indexes.
+    def to_sql
+      @db.create_table_sql_list @name, *generate.create_info
+    end
+
+    def inspect
+      "<Heresy::Schema:#{@name}>"
+    end
+
+  protected
+    def generate
+      gen = Sequel::Schema::Generator.new(@db)
+      @id.create(gen, :primary_key)
+      [@uuid, @updated_at, @body].each { |c| c.create(gen) }
+      gen
+    end
+  end
+end

data/lib/heresy/schema/column.rb

@@ -0,0 +1,34 @@
+module Heresy
+  class Schema
+    # This class defines a single column in the database, using the same options
+    # as the Sequel library.  There are a few convenience types though:
+    #
+    #  - :uuid: Creates a binary(16) database field
+    #
+    class Column
+      attr_accessor :name, :type, :options
+
+      # The actual database type.  This may be different if the given type is a 
+      # Heresy convenience type, or if the database supports the type under a different name.
+      attr_reader :db_type
+
+      def initialize(name, type, options = {})
+        if type == :uuid
+          @db_type = :binary
+          options.update(:size => 16, :null => false)
+        else
+          @db_type = type
+        end
+        @name    = name
+        @type    = type
+        @options = options
+      end
+
+      # Creates the column using the Sequel schema generator.  By default, the #column
+      # method is used.  An alternative method like :primary_key can be specified.
+      def create(gen, method = :column)
+        gen.send(method, @name, @db_type, @options)
+      end
+    end
+  end
+end

data/lib/heresy/schema/fields.rb

@@ -0,0 +1,66 @@
+module Heresy
+  class Schema
+    # This class is a helper for setting up fields in the model.  This is likely called
+    # from the model class and never used directly:
+    #
+    #   class Entry < Heresy::Model
+    #     fields do |f|
+    #       f.field :title, :string
+    #       f.string :body # Uses #string convenience method
+    #     end
+    #   end
+    #
+    class Fields
+      module Integer
+        extend self
+        def parse(input)  input.to_i end
+        def encode(input) input      end
+      end
+
+      module Float
+        extend self
+        def parse(input)  input.to_f end
+        def encode(input) input      end
+      end
+
+      module DateTime
+        extend self
+        def parse(input)
+          case input
+            when Time   then input
+            when String then Time.parse(input)
+            else input.to_time
+          end
+        end
+        def encode(input) input.xmlschema end
+      end
+
+      @@types = {}
+      def self.types() @@types end
+      def self.type(key, type = nil)
+        class_eval "def #{key}(name) field(name, :#{key}) end"
+        @@types[key] = type
+      end
+
+      type :string
+      type :integer,  Integer
+      type :float,    Float
+      type :datetime, DateTime
+
+      def initialize(model)
+        @model = model
+      end
+
+      # Adds a field of the given type to the model by creating an attribute reader and writer.
+      def field(name, type_name)
+        if type = self.class.types[type_name]
+          @model.send(:attr_reader, name)
+          @model.class_eval "def #{name}=(v) @#{name} = self.class.body_fields[:#{name}].parse(v) end"
+        else
+          @model.send(:attr_accessor, name)
+        end
+        @model.body_fields[name] = type
+      end
+    end
+  end
+end

data/test/fields_test.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+module HeresyTest
+  class FieldsTest < Heresy::TestCase
+    describe "field types from mass assignment" do
+      before :all do
+        @entry = Entry.new :title => 'whoa', :a => 'ignored', :comments_count => "3.0", :rating => '5', :published_at => Time.utc(2008, 1, 1)
+      end
+
+      it "sets a string" do
+        @entry.title.should == 'whoa'
+      end
+
+      it "sets an integer" do
+        @entry.comments_count.should == 3
+      end
+
+      it "sets a float" do
+        @entry.rating.should == 5.0
+        @entry.rating.to_s.should == "5.0"
+      end
+
+      it "sets a time" do
+        @entry.published_at.should == Time.utc(2008, 1, 1)
+      end
+    end
+
+    describe "field types from individual set" do
+      before :all do
+        @entry = Entry.new
+      end
+
+      it "sets a string" do
+        @entry.title = 'whoa'
+        @entry.title.should == 'whoa'
+      end
+
+      it "sets an integer" do
+        @entry.comments_count = '3.0'
+        @entry.comments_count.should == 3
+      end
+
+      it "sets a float" do
+        @entry.rating = 5
+        @entry.rating.should == 5.0
+        @entry.rating.to_s.should == "5.0"
+      end
+
+      it "sets a time from an xml schema" do
+        @entry.published_at = Time.utc(2008, 1, 1).xmlschema
+        @entry.published_at.should == Time.utc(2008, 1, 1)
+      end
+
+      it "sets a time from a time" do
+        @entry.published_at = Time.utc(2008, 1, 1)
+        @entry.published_at.should == Time.utc(2008, 1, 1)
+      end
+    end
+
+    describe "field types from retrieved model" do
+      before :all do
+        @entry = Entry.new :title => 'whoa', :a => 'ignored', :comments_count => "3.0", :rating => '5', :published_at => Time.utc(2008, 1, 1)
+        @entry.save
+        @entry = Entry.find(@entry.uuid)
+      end
+
+      it "sets a string" do
+        @entry.title = 'whoa'
+        @entry.title.should == 'whoa'
+      end
+
+      it "sets an integer" do
+        @entry.comments_count = '3.0'
+        @entry.comments_count.should == 3
+      end
+
+      it "sets a float" do
+        @entry.rating = 5
+        @entry.rating.should == 5.0
+        @entry.rating.to_s.should == "5.0"
+      end
+
+      it "sets a time" do
+        @entry.published_at.should == Time.utc(2008, 1, 1)
+      end
+    end
+  end
+end

data/test/formatting/json_test.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'test_helper'))
+require 'heresy/formatting/json'
+
+module HeresyTest::Formatting
+  class JsonTest < Heresy::TestCase
+    before :all do
+      @formatter = Heresy::Formatting::Json
+    end
+
+    it "encodes and decodes hash with strings" do
+      input = {:a => 1, :b => 'two'}
+      @formatter.decode(@formatter.encode(input)).should == {'a' => 1, 'b' => 'two'}
+    end
+  end
+end

data/test/index_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+module HeresyTest
+  class IndexTest < Heresy::TestCase
+    describe "Index creation" do
+      before :all do
+        @index = Heresy::Index.new(Heresy.db, :foo_bar_baz, :foo_id) { |idx| idx.field(:name, :varchar, :size => 255) }
+      end
+
+      after do
+        @index.drop rescue nil
+      end
+
+      it "generates CREATE TABLE sql" do
+        @index.to_sql.first.should =~ /CREATE TABLE/
+      end
+
+      it "detects existence of table" do
+        assert !@index.exists?
+      end
+      
+      it "creates table" do
+        assert !@index.exists?
+        @index.create
+        assert @index.exists?
+      end
+
+      it "drops table" do
+        assert !@index.exists?
+        @index.create
+        assert @index.exists?
+        @index.drop
+        assert !@index.exists?
+      end
+    end
+
+    describe "Index" do
+      before :all do
+        @index = Heresy::Index.new(Heresy.db, :foo_bar_baz, :foo_id) { |idx| idx.field(:name, :varchar, :size => 255) }
+        @index.create
+      end
+
+      it "allows data to be inserted" do
+        old = @index.count
+        @index << {:foo_id => UUID.generate(:compact), :name => 'bob'}
+        @index.count.should == old + 1
+      end
+
+      it "clears data" do
+        @index << {:foo_id => UUID.generate(:compact), :name => 'bob'}
+        @index.clear
+        @index.count.should == 0
+      end
+
+      describe "(data retrieval)" do
+        before :all do
+          @index.clear
+          @uuid1 = UUID.generate(:compact)
+          @uuid2 = UUID.generate(:compact)
+          @index << {:foo_id => @uuid1, :name => 'bob'}
+          @index << {:foo_id => @uuid2, :name => 'bob'}
+        end
+
+        it "#find fetches data" do
+          @index.find(:name => 'bob').should == [@uuid1, @uuid2]
+        end
+      end
+
+      after :all do
+        @index.drop rescue nil
+      end
+    end
+  end
+end

data/test/model_test.rb

@@ -0,0 +1,78 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+module HeresyTest
+  class ModelTest < Heresy::TestCase
+    before :all do
+      @entry = Entry.new(:title => 'whoa', :body => 'test')
+      @entry.save
+    end
+
+    describe "#save on new entry" do
+      before :all do
+        @new = Entry.new :title => 'whoa', :a => 'ignored', :comments_count => "3.0", :rating => '5'
+        @new.save
+      end
+
+      it "sets id" do
+        @new.id.should_not == nil
+      end
+
+      it "sets uuid" do
+        @new.uuid.should_not == nil
+      end
+
+      it "sets updated_at" do
+        @new.updated_at.class.should == Time
+      end
+
+      it "sets title" do
+        @new.title.should == 'whoa'
+      end
+
+      it "sets comments_count" do
+        @new.comments_count.should == 3
+      end
+
+      it "sets rating" do
+        @new.rating.should == 5.0
+      end
+    end
+
+    describe "#save on existing entry" do
+      before :all do
+        sleep 1
+        @old_id      = @entry.id
+        @old_uuid    = @entry.uuid
+        @old_updated = @entry.updated_at
+        @entry.save
+      end
+
+      it "keeps id" do
+        @entry.id.should == @old_id
+      end
+
+      it "keeps uuid" do
+        @entry.uuid.should == @old_uuid
+      end
+
+      it "sets updated_at" do
+        @entry.updated_at.should_not == @old_updated
+      end
+    end
+
+    describe "#find" do
+      before :all do
+        @entry2 = Entry.new(:title => 'whoa', :body => 'test')
+        @entry2.save
+      end
+
+      it "fetches by uuid" do
+        Entry.find(@entry.uuid).should == @entry
+      end
+
+      it "fetches by array uuids" do
+        Entry.find([@entry.uuid, @entry2.uuid]).should == [@entry, @entry2]
+      end
+    end
+  end
+end

data/test/schema_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+module HeresyTest
+  class SchemaTest < Heresy::TestCase
+    describe "Heresy Model Schema instance" do
+      it "sets model schema name to plural underscored class name" do
+        Entry.schema.name.should == :entries
+      end
+    end
+
+    describe "Schema" do
+      before :all do
+        @schema = Heresy::Schema.new(Heresy.db, :foo_bar_baz)
+      end
+
+      after do
+        @schema.drop rescue nil
+      end
+
+      it "generates CREATE TABLE sql" do
+        @schema.to_sql.first.should =~ /CREATE TABLE/
+      end
+
+      it "detects existence of table" do
+        assert !@schema.exists?
+      end
+
+      it "creates table" do
+        assert !@schema.exists?
+        @schema.create
+        assert @schema.exists?
+      end
+      
+      it "drops table" do
+        assert !@schema.exists?
+        @schema.create
+        assert @schema.exists?
+        @schema.drop
+        assert !@schema.exists?
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rubygems'
+gem 'jeremymcanally-matchy'
+gem 'jeremymcanally-context'
+gem 'rr'
+
+require 'context'
+require 'matchy'
+require 'rr'
+require 'logger'
+require 'heresy-with-gems'
+
+# TODO: remove this once it gets fixed in context
+class String
+  def to_method_name
+    self.downcase.gsub(/[\s:',;!#()\.]+/,'_')
+  end
+end
+
+module Heresy
+  class TestCase < Test::Unit::TestCase
+    include RR::Adapters::TestUnit
+  end
+end
+
+module HeresyTest
+  class Entry < Heresy::Model
+    fields do |f|
+      f.string   :title
+      f.string   :body
+      f.integer  :comments_count
+      f.float    :rating
+      f.datetime :published_at
+    end
+  end
+end
+
+Heresy.db = Sequel.connect("mysql://root@localhost/heresy_test")
+HeresyTest::Entry.schema.drop rescue nil
+HeresyTest::Entry.schema.create
+
+begin
+  require 'ruby-debug'
+  Debugger.start
+rescue LoadError
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: kabuki-heresy
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- kabuki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-29 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: 2.2.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.10.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.1.3
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: uuid
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.0.1
+    version: 
+description: 
+email: kabukiruby@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- README.rdoc
+- VERSION.yml
+- lib/heresy
+- lib/heresy/formatting
+- lib/heresy/formatting/json.rb
+- lib/heresy/index.rb
+- lib/heresy/model.rb
+- lib/heresy/schema
+- lib/heresy/schema/column.rb
+- lib/heresy/schema/fields.rb
+- lib/heresy/schema.rb
+- lib/heresy-with-gems.rb
+- lib/heresy.rb
+- test/fields_test.rb
+- test/formatting
+- test/formatting/json_test.rb
+- test/index_test.rb
+- test/model_test.rb
+- test/schema_test.rb
+- test/test_helper.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/kabuki/heresy
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --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: 2
+summary: TODO
+test_files: []
+