schemer 0.0.10 → 0.1.0

data/README.markdown

@@ -1,15 +1,18 @@
 Schemer
 =======
 
-On-the-fly ActiveRecord schema changes for extremely rapid prototyping.
+On-the-fly schema changes for very rapid prototyping, for ActiveRecord and
+Sequel ORMs.
 
 Description
 -----------
 
-Loosely define your schema in your ActiveRecord model and have it created and
-updated for you without worrying about migrations. Useful for when you want to
-play around with real data handling during prototyping but you really don't 
-care about keeping the data or how it's defined.
+Loosely define your schema in your model and have it created and updated for
+you without worrying about migrations.
+
+Useful for when you want to play around with real data handling during
+prototyping but you really don't care about keeping the data or how it's
+defined.
 
 This isn't meant to be a replacement for migrations, it is simply a way to get
 started on a project quickly while you iron out your data definitions.
@@ -19,13 +22,20 @@ warning! Only use this with volatile data! Never attach it to an existing model
 you care about as it will start adding and dropping columns without your
 consent!
 
-Usage
------
+Install
+-------
+
+    $ gem install schemer
 
+ActiveRecord
+------------
+    
+    require "schemer/active_record"
+    
     class User < ActiveRecord::Base
       schema :username, :password
     end
-    
+
 Creates a `users` table if it doesn't exist, complete with `username` and 
 `password` columns the first time the User class is loaded.
 
@@ -34,7 +44,7 @@ Need another column to play with?
     class User < ActiveRecord::Base
       schema :username, :password, :email
     end
-    
+
 Adds an `email` column the next time `User` class is loaded.
 
 Want a relationship? (but fear commitment...)
@@ -59,13 +69,13 @@ Have a need for a particular type of column?
       schema :name, { :size => :integer }, :description
     end
     
-Will create `size` as an `:integer` column so you can take advantage of Rails'
-casting.
+Will create `size` as an `:integer` column so you can take advantage of type
+loading.
 
-Feeling more confident and ready to make that big leap to migrations? Just run:
+Feeling more confident and ready to make that big leap to migrations? Run:
 
     rake schemer:migration
-    
+
 To get:
 
     Migration from schema declarations in User, Widget
@@ -88,15 +98,34 @@ and you're on your way to the big leagues!
 
 **NOTE:** All columns are created as string columns unless type is given.
 
-Installation
-------------
+Sequel
+------
+
+    require "schemer/sequel"
+
+    class Widget < Sequel::Model
+      plugin Schemer::Sequel
+      
+      schema :name, { :size => :integer }, :description
+    end
+    
+Usage is as above w/ ActiveRecord
+
+Test
+----
+
+    $ rake
+    
+Thanks!
+-------
 
-    $ sudo gem install citrusbyte-schemer --source=http://gems.github.com
+Michel Martens ([soveran](http://github.com/soveran)) + Cyril David
+([cyx](http://github.com/cyx)) for helping with Sequel support.
 
 License
 -------
 
-Copyright (c) 2009 Ben Alavi for Citrusbyte
+Copyright (c) 2009-2011 Ben Alavi for Citrusbyte
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/Rakefile

@@ -1,35 +1,10 @@
 require 'rake'
-require 'rake/gempackagetask'
 require 'rake/testtask'
 require 'rake/clean'
 
-gem_spec_file = 'schemer.gemspec'
-
-gem_spec = eval(File.read(gem_spec_file)) rescue nil
-
 task :default => :test
 
 Rake::TestTask.new(:test) do |t|
-  t.pattern = 'test/**/*_test.rb'
+  t.pattern = "test/**/*_test.rb"
   t.verbose = false
 end
-
-Rake::GemPackageTask.new(gem_spec) do |pkg|
-  pkg.need_zip = false
-  pkg.need_tar = false
-  rm_f FileList['pkg/**/*.*']
-end if gem_spec
-
-desc "Generate the gemspec file."
-task :gemspec do
-  require 'erb'
-
-  File.open(gem_spec_file, 'w') do |f|
-    f.write ERB.new(File.read("#{gem_spec_file}.erb")).result(binding)
-  end
-end
-
-desc "Builds and installs the gem."
-task :install => :repackage do
-  `sudo gem install pkg/#{gem_spec.name}-#{gem_spec.version}.gem`
-end

data/lib/schemer.rb

@@ -1,58 +1,3 @@
-require 'activerecord'
-
 module Schemer
-  def schema(*args)
-    extend ClassMethods
-    
-    class_inheritable_accessor :schema_columns
-    self.schema_columns = {}
-    args.collect{ |a| a.is_a?(Hash) ? a.stringify_keys : { a.to_s => :string } }.each do |column|
-      self.schema_columns.merge!(column)
-    end 
-
-    update_schema
-    update_methods
-  end
-
-  module ClassMethods
-    # Columns which we don't touch regardless of not being defined in schema
-    # (and are ignored if they are defined in schema)
-    def protected_columns
-      %w( id )
-    end
-    
-    # Create the underlying table for this class
-    def create_table
-      ActiveRecord::Migration.create_table(table_name) do |t|;end;
-    end
-    
-    # Update ActiveRecord's automatically generated methods so we don't have to
-    # reload for schema changes to take effect
-    def update_methods
-      generated_methods.each { |method| remove_method(method) }
-      @columns = @column_names = @columns_hash = @generated_methods = nil
-    end
-    
-    # Update the underlying schema as defined by schema call
-    def update_schema
-      create_table unless table_exists?
-
-      columns.reject{ |column| protected_columns.include?(column.name) }.each do |column|
-        if !schema_columns.has_key?(column.name)
-          # remove any extraneous columns
-          ActiveRecord::Migration.remove_column(table_name, column.name)
-        elsif column.type != schema_columns[column.name]
-          # change any columns w/ wrong type
-          ActiveRecord::Migration.change_column(table_name, column.name, schema_columns[column.name])
-        end
-      end
-
-      # add any missing columns
-      (schema_columns.keys - column_names).each do |column|
-        ActiveRecord::Migration.add_column(table_name, column, schema_columns[column])
-      end
-    end
-  end
+  VERSION="0.1.0"
 end
-
-ActiveRecord::Base.extend(Schemer)

data/lib/schemer/active_record.rb

@@ -0,0 +1,83 @@
+require "active_record"
+
+module Schemer
+  module ActiveRecord
+    def schema(*args)
+      extend ClassMethods
+      
+      class_inheritable_accessor :schema_columns
+      self.schema_columns = {}
+      args.collect{ |a| a.is_a?(Hash) ? a.stringify_keys : { a.to_s => :string } }.each do |column|
+        self.schema_columns.merge!(column)
+      end
+
+      update_schema
+      update_methods
+    end
+
+    module ClassMethods
+      # Columns which we don't touch regardless of not being defined in schema
+      # (and are ignored if they are defined in schema)
+      def protected_columns
+        %w( id )
+      end
+    
+      # Create the underlying table for this class
+      def create_table
+        ::ActiveRecord::Migration.suppress_messages do
+          ::ActiveRecord::Migration.create_table(table_name) do |t|;end;
+        end
+      end
+    
+      # Update ActiveRecord's automatically generated methods so we don't have to
+      # reload for schema changes to take effect
+      def update_methods
+        undefine_attribute_methods
+        @columns = @column_names = @columns_hash = @generated_methods = nil
+      end
+    
+      # Update the underlying schema as defined by schema call
+      def update_schema
+        create_table unless table_exists?
+
+        columns.reject{ |column| protected_columns.include?(column.name) }.each do |column|
+          if !schema_columns.has_key?(column.name)
+            # remove any extraneous columns
+            migrate_quietly{ ::ActiveRecord::Migration.remove_column(table_name, column.name) }
+          elsif column.type != schema_columns[column.name]
+            # change any columns w/ wrong type
+            migrate_quietly{ ::ActiveRecord::Migration.change_column(table_name, column.name, schema_columns[column.name]) }
+          end
+        end
+
+        # add any missing columns
+        (schema_columns.keys - column_names).each do |column|
+          migrate_quietly{ ::ActiveRecord::Migration.add_column(table_name, column, schema_columns[column]) }
+        end
+      end
+      
+      def migrate_quietly(&block)
+        ::ActiveRecord::Migration.suppress_messages do
+          yield
+        end
+      end
+    end
+    
+    class Migrator
+      # Outputs the Rails migration for the schema defined in the given class.
+      # 
+      # Outputs an empty string if no schema is defined on the class.
+      def self.migration(klass)
+        return nil unless klass.respond_to?(:schema_columns)
+
+        "create_table :#{klass.table_name} do |t|\n" +
+        (klass.schema_columns.keys - klass.protected_columns).collect do |column| 
+          "  t.#{klass.schema_columns[column]} :#{column}"
+        end.join("\n") +
+        "\nend"
+      end
+    end    
+  end
+end
+
+ActiveRecord::Base.extend(Schemer::ActiveRecord)

data/lib/schemer/sequel.rb

@@ -0,0 +1,77 @@
+require "sequel"
+
+module Schemer
+  module Sequel
+    module ClassMethods    
+      # TODO: document
+      def schema(*args)
+        @schema_columns = {}
+        
+        args.collect{ |a| a.is_a?(Hash) ? a : { a => String } }.each do |column|
+          self.schema_columns.merge!(column)
+        end
+        
+        update_schema
+      end
+      
+      def protected_columns
+        @protected_columns = [ :id ].freeze
+      end
+      
+      def schema_columns
+        @schema_columns
+      end
+      
+      # Update ActiveRecord's automatically generated methods so we don't have to
+      # reload for schema changes to take effect
+      def update_methods
+        # undefine_attribute_methods
+        # @columns = @column_names = @columns_hash = @generated_methods = nil
+      end
+      
+      # Update the underlying schema as defined by schema call
+      def update_schema        
+        db.create_table?(self.table_name) do
+          primary_key :id
+        end
+        
+        get_db_schema.reject{ |column, definition| protected_columns.include?(column) }.each do |column, definition|
+          if !schema_columns.has_key?(column)
+            # remove any extraneous columns
+            db.drop_column(table_name, column)
+            
+            # remove the accessors (sequel doesn't appear to have a facility
+            # for this)
+            [ "#{column}", "#{column}=" ].each do |method|
+              overridable_methods_module.send(:undef_method, method) if public_instance_methods.include?(method)
+            end
+          elsif (definition[:type] || definition[:db_type]) != schema_columns[column]
+            # change any columns w/ wrong type
+            db.set_column_type(table_name, column, schema_columns[column])
+          end
+        end
+
+        # add any missing columns
+        (schema_columns.keys - columns).each do |column|
+          db.add_column(table_name, column, schema_columns[column])
+          def_column_accessor column          
+        end
+      end
+    end
+    
+    class Migrator
+      # Outputs the Rails migration for the schema defined in the given class.
+      # 
+      # Outputs an empty string if no schema is defined on the class.
+      def self.migration(klass)
+        return nil unless klass.respond_to?(:schema_columns)
+
+        "create_table :#{klass.table_name} do |t|\n" +
+        (klass.schema_columns.keys - klass::protected_columns).collect do |column| 
+          "  add_column :#{column}, " + (klass.schema_columns[column].is_a?(Symbol) ? ":#{klass.schema_columns[column]}" : klass.schema_columns[column].to_s)
+        end.join("\n") +
+        "\nend"
+      end
+    end    
+  end
+end

data/lib/schemer/tasks/schemer.rake

@@ -1,9 +1,8 @@
 namespace :schemer do
-  desc "Outputs the basis of a Rails migration from your schema declarations"
-  task :migration => :environment do
+  def migrations_for(glob, migrator)
     klasses = []
-
-    Dir.glob(File.join(Rails.root, "app", "models", "**.rb")).each do |file|
+    
+    Dir.glob(glob).each do |file|
       lineno  = 0
       result = File.readlines(file).each do |line|
         lineno += 1
@@ -13,10 +12,35 @@ namespace :schemer do
     end
     
     migration = klasses.collect do |klass|
-      Schemer::Migrator.migration(klass)
+      migrator.migration(klass)
     end.join("\n\n")
     
     puts "\nMigration from schema declarations in #{klasses.join(', ')}"
     puts "\n#{migration}\n\n"
   end
+  
+  namespace :rails do
+    desc "Outputs a Rails migration from your schema declarations"
+    task :migration => :environment do
+      migrations_for File.join(Rails.root, "app", "models", "**.rb"), Schemer::ActiveRecord::Migrator
+    end
+  end
+  
+  namespace :activerecord do
+    desc "Outputs an ActiveRecord migration from your schema declarations"
+    task :migration do
+      raise ArgumentError.new("Must provide path to your models on ENV[\"MODELS\"], i.e. rake schemer:activerecord:migration MODELS=./app/models/") unless ENV["MODELS"]
+      
+      migrations_for File.join(ENV["MODELS"], "**.rb"), Schemer::ActiveRecord::Migrator
+    end
+  end
+  
+  namespace :sequel do
+    desc "Output a Sequel migration from your schema declarations"
+    task :migration do
+      raise ArgumentError.new("Must provide path to your models on ENV[\"MODELS\"], i.e. rake schemer:sequel:migration MODELS=./app/models/") unless ENV["MODELS"]
+      
+      migrations_for File.join(ENV["MODELS"], "**.rb"), Schemer::Sequel::Migrator
+    end
+  end
 end

data/schemer.gemspec

@@ -0,0 +1,25 @@
+require "./lib/schemer"
+
+Gem::Specification.new do |s|
+  s.name = "schemer"
+  s.version = Schemer::VERSION
+  s.summary = %{On-the-fly schema changes for extremely rapid prototyping.}
+  s.date = %q{2011-08-30}
+  s.authors = ["Ben Alavi"]
+  s.email = "benalavi@gmail.com"
+  s.homepage = "http://github.com/citrusbyte/schemer"
+  
+  s.files = Dir[
+    "README.markdown",
+		"Rakefile",
+		"*.gemspec",
+		"lib/**/*.rb",
+		"lib/**/*.rake",
+		"test/**/*.rb"
+  ]
+  
+  s.add_development_dependency "contest"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "sequel"
+  s.add_development_dependency "active_record"
+end

data/test/{schemer_test.rb → active_record_test.rb}

@@ -1,19 +1,17 @@
-require 'rubygems'
-require 'contest'
-require 'override'
-require 'ruby-debug'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'schemer')
-require File.join(File.dirname(__FILE__), '..', 'lib', 'schemer', 'migrator')
+require File.join(File.dirname(__FILE__), "test_helper")
 
-ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => 'test/schemer_test.db'
-ActiveRecord::Base.logger = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+require "schemer/active_record"
 
-class Foo < ActiveRecord::Base;end;
-ActiveRecord::Migration.drop_table(Foo.table_name) if Foo.table_exists?
-class Bar < ActiveRecord::Base;end;
-ActiveRecord::Migration.drop_table(Bar.table_name) if Bar.table_exists?
+logger = Logger.new(File.join(OUTPUT, "debug.log"))
+ActiveRecord::Base.establish_connection :adapter => "sqlite3", :database => File.join(OUTPUT, "schemer_active_record_test.db")
+ActiveRecord::Base.logger = logger
 
-class FooTest < Test::Unit::TestCase  
+class ActiveRecordTest < Test::Unit::TestCase
+  class Foo < ActiveRecord::Base;end;
+  ActiveRecord::Migration.drop_table(Foo.table_name) if Foo.table_exists?
+  class Bar < ActiveRecord::Base;end;
+  ActiveRecord::Migration.drop_table(Bar.table_name) if Bar.table_exists?
+  
   context "defining the schema" do
     setup do
       Foo.schema :foo, :bar
@@ -53,7 +51,7 @@ class FooTest < Test::Unit::TestCase
   context "with types" do
     setup do
       Foo.schema :foo, { :bar => :integer }, :baz
-      @foo = Foo.find(Foo.create!(:foo => '5', :bar => 5).id)
+      @foo = Foo.find(Foo.create!(:foo => "5", :bar => 5).id)
     end
     
     should "create foo, bar and baz columns" do
@@ -67,12 +65,12 @@ class FooTest < Test::Unit::TestCase
     end
     
     should "create foo column using string datatype" do
-      assert_equal '5', @foo.foo
+      assert_equal "5", @foo.foo
     end
     
     should "recreate foo column as integer" do
       Foo.schema({ :foo => :integer }, { :bar => :integer }, :baz)
-      foo = Foo.find(Foo.create!(:foo => '5', :bar => '5').id)
+      foo = Foo.find(Foo.create!(:foo => "5", :bar => "5").id)
       assert_equal 5, foo.foo
     end
   end
@@ -87,7 +85,7 @@ class FooTest < Test::Unit::TestCase
 %Q{create_table :foos do |t|
   t.string :foo
   t.string :bar
-end}, Schemer::Migrator.migration(Foo)
+end}, Schemer::ActiveRecord::Migrator.migration(Foo)
       )
     end
   end

data/test/sequel_test.rb

@@ -0,0 +1,98 @@
+require File.join(File.dirname(__FILE__), "test_helper")
+
+require "schemer/sequel"
+
+$db = Sequel.sqlite(File.join(OUTPUT, "schemer_sequel_test.db"))
+$db.drop_table(:foos) if $db.table_exists?(:foos)
+$db.drop_table(:bars) if $db.table_exists?(:bars)
+
+class SequelTest < Test::Unit::TestCase
+  class Foo < Sequel::Model
+    plugin Schemer::Sequel
+  end
+
+  class Bar < Sequel::Model
+    plugin Schemer::Sequel
+  end
+  
+  setup do
+    Foo.schema
+    Bar.schema
+  end
+  
+  context "defining the schema" do
+    setup do
+      Foo.schema :foo, :bar
+    end
+    
+    should "create the foos table" do
+      assert Foo.db.table_exists?(Foo.table_name)
+    end
+    
+    should "define the columns on the table" do
+      assert_equal :foo, $db.schema(:foos)[1][0]
+      assert_equal :bar, $db.schema(:foos)[2][0]
+    end
+    
+    should "refresh the schema on the model" do
+      @foo = Foo.create :foo => "foo", :bar => "bar"
+      
+      assert_equal "foo", @foo.foo
+      assert_equal "bar", @foo.bar
+    end
+  end
+  
+  context "updating the schema" do
+    setup do
+      Foo.schema :foo, :bar
+      Foo.schema :foo
+      @foo = Foo.new
+    end
+    
+    should "remove the bar column" do
+      assert !@foo.respond_to?(:bar)
+    end
+  end
+  
+  context "with types" do
+    setup do
+      Foo.schema :foo, { :bar => :integer }, :baz
+      @foo = Foo[Foo.create(:foo => "5", :bar => 5).id]
+    end
+    
+    should "create foo, bar and baz columns" do
+      assert @foo.respond_to?(:foo)
+      assert @foo.respond_to?(:bar)
+      assert @foo.respond_to?(:baz)
+    end
+    
+    should "create bar column using integer datatype" do
+      assert_equal 5, @foo.bar
+    end
+    
+    should "create foo column using string datatype" do
+      assert_equal "5", @foo.foo
+    end
+    
+    should "recreate foo column as integer" do
+      Foo.schema({ :foo => :integer }, { :bar => :integer }, :baz)
+      foo = Foo[Foo.create(:foo => "5", :bar => "5").id]
+      assert_equal 5, foo.foo
+    end
+  end
+  
+  context "building a migration" do
+    setup do
+      Foo.schema :foo, { :bar => :integer }
+    end
+    
+    should "output the migration for Foo" do
+      assert_equal(
+%Q{create_table :foos do |t|
+  add_column :foo, String
+  add_column :bar, :integer
+end}, Schemer::Sequel::Migrator.migration(Foo)
+      )
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,14 @@
+$: << File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "rubygems"
+require "fileutils"
+require "contest"
+require "logger"
+
+begin
+  require "ruby-debug"
+rescue LoadError
+end
+
+OUTPUT = File.join(File.dirname(__FILE__), "out")
+FileUtils.mkdir_p(OUTPUT)

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: schemer
 version: !ruby/object:Gem::Version 
-  version: 0.0.10
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Ben Alavi
@@ -9,12 +15,66 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-05 00:00:00 -07:00
-default_executable: 
-dependencies: []
-
+date: 2011-08-30 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: contest
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: active_record
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: 
-email: ben.alavi@citrusbyte.com
+email: benalavi@gmail.com
 executables: []
 
 extensions: []
@@ -23,14 +83,15 @@ extra_rdoc_files: []
 
 files: 
 - README.markdown
-- LICENSE
 - Rakefile
-- lib/schemer/migrator.rb
+- schemer.gemspec
+- lib/schemer/active_record.rb
+- lib/schemer/sequel.rb
 - lib/schemer.rb
 - lib/schemer/tasks/schemer.rake
-- rails/init.rb
-- test/schemer_test.rb
-has_rdoc: true
+- test/active_record_test.rb
+- test/sequel_test.rb
+- test/test_helper.rb
 homepage: http://github.com/citrusbyte/schemer
 licenses: []
 
@@ -40,23 +101,29 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.8.9
 signing_key: 
 specification_version: 3
-summary: On-the-fly ActiveRecord schema changes for extremely rapid prototyping.
+summary: On-the-fly schema changes for extremely rapid prototyping.
 test_files: []
 

data/LICENSE

@@ -1,19 +0,0 @@
-Copyright (c) 2009 Ben Alavi for Citrusbyte
-
-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/lib/schemer/migrator.rb

@@ -1,18 +0,0 @@
-module Schemer
-  class Migrator
-    class << self
-      # Outputs the Rails migration for the schema defined in the given class.
-      # 
-      # Outputs an empty string if no schema is defined on the class.
-      def migration(klass)
-        return nil unless klass.respond_to?(:schema_columns)
-        
-        "create_table :#{klass.table_name} do |t|\n" +
-        (klass.schema_columns.keys - klass.protected_columns).collect do |column| 
-          "  t.#{klass.schema_columns[column]} :#{column}"
-        end.join("\n") +
-        "\nend"
-      end
-    end
-  end
-end

data/rails/init.rb

@@ -1,3 +0,0 @@
-raise "We highly suggest you only use Schemer in development or test mode (not in #{Rails.env})!" unless %w( development test ).include?(Rails.env.to_s)
-Rails.logger.warn "Loading Schemer which will consider all your data volatile!"
-require 'schemer'