datamappify 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 [name of plugin creator]
+
+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,118 @@
+# Datamappify
+
+## Introduction
+
+ActiveRecord is without doubt the *de facto* ORM library for Rails and many Ruby web frameworks. Many developers however, do not like database migrations and prefer to use DSL for data mapping. Datamappify is created with the sole purpose of getting rid of the DB migration headaches.
+
+Brought to you by [Envato](http://envato.com) and [Wuit](http://wuit.com).
+
+## Disclaimer
+
+**This plugin is NOT production-ready yet!** Use with caution.
+
+### Todo
+
+* Add tests
+* Remove the dependency of the `auto_migrate` plugin
+* Possibly refactor `add_index` to be part of the `property` definition (as seen in the [DataMapper](http://datamapper.org/) library)
+
+## Why?
+
+### Why Not DB Migrations?
+
+Well, depending on your specific project, DB migrations might create more trouble than it's worth. Besides, your code is already version controlled, so why create a separate version control for your DB schema?
+
+### Why Not Use DataMapper, Sequel, etc?
+
+As stated in the introduction, ActiveRecord is the most popular ORM in the rails community, it is actively developed and battle-tested. If your only grief with ActiveRecord is the DB migrations, why not just eliminate it be happy? ;)
+
+## How?
+
+How does this plugin work?
+
+Basically, it -
+
+1. Uses a DSL similar to DataMapper's for defining model properties (DB mapping).
+2. `schema.rb` is automatically updated according to the model properties.
+3. Automatically 'migrates' the database according to the updated schema file.
+
+## Dependencies
+
+To use Datamappify, you will need the following libraries.
+
+* ActiveRecord
+* [auto_migrations](http://github.com/pjhyett/auto_migrations)
+
+## Usages
+
+Here's an example to get you started:
+
+  	class User < ActiveRecord::Base
+  	  include Datamappify::Resource
+      
+  	  property  :email, :string
+  	  property  :password, :string, :limit => 40
+  	  property  :first_name, :string, :limit => 50
+  	  property  :last_name, :string, :limit => 50
+  	  property  :payment_email, :string
+  	  property  :timestamps
+  	  add_index :email
+  	  add_index :payment_email
+  	  add_index :role_id
+      
+  	  belongs_to :role
+  	end
+
+It will create the following schema:
+
+  	create_table "users", :force => true do |t|
+  	  t.string   :email,               :limit => nil
+  	  t.string   :password,            :limit => nil
+  	  t.string   :first_name,          :limit => nil
+  	  t.string   :last_name,           :limit => nil
+  	  t.string   :payment_email,       :limit => nil
+  	  t.integer  :role_id,             :limit => nil
+  	  t.datetime :created_at
+  	  t.datetime :updated_at
+  	end
+
+  	add_index "users", :email
+  	add_index "users", :payment_email
+  	add_index "users", :role_id
+
+#### property()
+
+Use `property` to define and map DB columns. It accepts a number of arguments:
+
+1. Name of the column.
+2. SQL type of the column, same as the ones provided by ActiveRecord migrations.
+3. Column options, same as the ones provided by ActiveRecord migrations.
+
+#### add_index()
+
+Use `add_index` to add DB indexes. It accepts a number of arguments:
+
+1. The column(s) to index on, can be just one column or a number of columns in an array.
+3. Index options such as `name`, `unique` and `length`.
+
+### Rake Tasks
+
+To set up your database for the first time, please run:
+
+    rake db:schema:update
+    rake db:setup
+
+Later on, to only update the `schema.rb` file, run:
+
+    rake db:schema:update
+
+To update `schema.rb` and to 'migrate' the updated database structure, run:
+
+    rake db:schema:auto_migrate
+
+## Author
+
+Copyright (c) 2010 Fred Wu (<http://fredwu.me>), released under the MIT license
+
+* Envato - <http://envato.com>
+* Wuit - <http://wuit.com>

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "datamappify"
+    s.version = "0.1.0"
+    s.summary = "Turn ActiveRecord into DataMapper (sort of)!"
+    s.description = "ActiveRecord is without doubt the de facto ORM library for Rails and many Ruby web frameworks. Many developers however, do not like database migrations and prefer to use DSL for data mapping. Datamappify is created with the sole purpose of getting rid of the DB migration headaches."
+    s.email = "ifredwu@gmail.com"
+    s.homepage = "http://github.com/fredwu/datamappify"
+    s.authors = ["Fred Wu"]
+    s.add_dependency("activerecord")
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/datamappify.gemspec

@@ -0,0 +1,53 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{datamappify}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Fred Wu"]
+  s.date = %q{2010-08-04}
+  s.description = %q{ActiveRecord is without doubt the de facto ORM library for Rails and many Ruby web frameworks. Many developers however, do not like database migrations and prefer to use DSL for data mapping. Datamappify is created with the sole purpose of getting rid of the DB migration headaches.}
+  s.email = %q{ifredwu@gmail.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.md",
+     "Rakefile",
+     "datamappify.gemspec",
+     "lib/datamappify.rb",
+     "lib/datamappify/associations.rb",
+     "lib/datamappify/collection.rb",
+     "lib/datamappify/fake/column.rb",
+     "lib/datamappify/fake/connection.rb",
+     "lib/datamappify/fake/index.rb",
+     "lib/datamappify/resource.rb",
+     "lib/datamappify/schema_dumper.rb",
+     "lib/tasks/datamappify.rake"
+  ]
+  s.homepage = %q{http://github.com/fredwu/datamappify}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Turn ActiveRecord into DataMapper (sort of)!}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, [">= 0"])
+  end
+end
+

data/lib/datamappify.rb

@@ -0,0 +1,16 @@
+raise "Please install the AutoMigrations plugin from http://github.com/pjhyett/auto_migrations" unless defined?(AutoMigrations.run)
+
+require 'datamappify/associations'
+require 'datamappify/collection'
+require 'datamappify/fake/column'
+require 'datamappify/fake/connection'
+require 'datamappify/fake/index'
+require 'datamappify/resource'
+require 'datamappify/schema_dumper'
+
+module Datamappify
+  def self.run
+    Datamappify::SchemaDumper.dump_to_file
+    AutoMigrations.run
+  end
+end

data/lib/datamappify/associations.rb

@@ -0,0 +1,21 @@
+module Datamappify
+  module Associations
+    mattr_accessor :join_tables
+    
+    @@join_tables = {}
+    
+    module ClassMethods
+      def belongs_to(association_id, options = {})
+        super
+        foreign_key = options.include?(:foreign_key) ? options[:foreign_key] : association_id.to_s.foreign_key
+        property(foreign_key.to_sym, :integer)
+      end
+      
+      def has_and_belongs_to_many(association_id, options = {}, &extension)
+        super
+        reflection = self.send :create_has_and_belongs_to_many_reflection, association_id, options
+        Associations.join_tables[reflection.options[:join_table]] = [reflection.association_foreign_key, reflection.primary_key_name]
+      end
+    end
+  end
+end

data/lib/datamappify/collection.rb

@@ -0,0 +1,46 @@
+module Datamappify
+  class Collection
+    def self.get
+      collection = []
+      
+      Dir.glob(Rails.root.join('app', 'models', '**', '*.rb')).each do |file|
+        name  = file[/.*\/(.*)\.rb/, 1]
+        klass = name.camelize.constantize
+        
+        next unless klass.included_modules.include?(Datamappify::Resource) and klass.respond_to?(:properties)
+        
+        collection << {
+          :name       => name,
+          :table_name => klass.table_name,
+          :properties => klass.properties,
+          :indexes    => klass.indexes,
+        }
+      end
+      
+      Associations.join_tables.each do |table_name, ids|
+        collection << {
+          :name       => table_name,
+          :table_name => table_name,
+          :properties => [{
+            :name     => ids[0],
+            :sql_type => :integer,
+            :options  => {},
+          }, {
+            :name     => ids[1],
+            :sql_type => :integer,
+            :options  => {},
+          }],
+          :indexes    => [{
+            :columns => ids[0],
+            :options => {},
+          }, {
+            :columns => ids[1],
+            :options => {},
+          }],
+        }
+      end
+      
+      collection
+    end
+  end
+end

data/lib/datamappify/fake/column.rb

@@ -0,0 +1,15 @@
+module Datamappify
+  module Fake
+    class Column < ActiveRecord::ConnectionAdapters::Column
+      def initialize(property)
+        allow_null = property[:options].include?(:null) ? property[:options][:null] : true
+        
+        super(property[:name], property[:options][:default], property[:sql_type], allow_null)
+        
+        @limit     = property[:options][:limit]
+        @precision = property[:options][:precision]
+        @scale     = property[:options][:scale]
+      end
+    end
+  end
+end

data/lib/datamappify/fake/connection.rb

@@ -0,0 +1,77 @@
+module Datamappify
+  module Fake
+    class Connection
+      def columns(table)
+        @primary_key = "id"
+        resource     = get_resource(table)
+        columns      = []
+        
+        # manually add the primary key property (without the :primary_key option)
+        # as ActiveRecord ignores the primary_key column
+        add_primary_key_to(resource) unless is_a_join_table?(table)
+        
+        resource[:properties].map do |property|
+          if (property[:name] == :timestamps)
+            create_timestamps_for(resource)
+          else
+            columns << Column.new(property)
+          end
+        end
+        
+        columns
+      end
+      
+      def primary_key(table)
+        resource = get_resource(table)
+        primary_key_for(resource)
+      end
+      
+      def indexes(table)
+        resource = get_resource(table)
+        resource[:indexes].map do |index|
+          Index.new(resource, index)
+        end
+      end
+      
+      private
+      
+      def get_resource(table)
+        Collection.get.select do |r|
+          r[:table_name].to_s == table.to_s
+        end[0]
+      end
+      
+      def create_timestamps_for(resource)
+        resource[:properties] << {
+          :name     => :created_at,
+          :sql_type => :datetime,
+          :options  => {},
+        }
+        resource[:properties] << {
+          :name     => :updated_at,
+          :sql_type => :datetime,
+          :options  => {},
+        }
+      end
+      
+      def primary_key_for(resource)
+        resource[:properties].select do |property|
+          return property[:name].to_s if property[:options][:primary_key]
+        end
+        "id"
+      end
+      
+      def add_primary_key_to(resource)
+        resource[:properties] << {
+          :name     => primary_key_for(resource),
+          :sql_type => :datetime,
+          :options  => {},
+        }
+      end
+      
+      def is_a_join_table?(table)
+        Associations.join_tables.key?(table)
+      end
+    end
+  end
+end

data/lib/datamappify/fake/index.rb

@@ -0,0 +1,32 @@
+module Datamappify
+  module Fake
+    class Index
+      include ActiveRecord::ConnectionAdapters::SchemaStatements
+      
+      def initialize(resource, index)
+        @resource = resource
+        @index    = index
+      end
+      
+      def table
+        @resource[:table_name]
+      end
+      
+      def name
+        @index[:options].include?(:name) ? @index[:options][:name].to_s : index_name(table, :column => @index[:columns])
+      end
+      
+      def columns
+        @index[:columns]
+      end
+      
+      def unique
+        @index[:options][:unique] if @index[:options].include?(:unique)
+      end
+      
+      def lengths
+        @index[:options][:length] if @index[:options].include?(:length)
+      end
+    end
+  end
+end

data/lib/datamappify/resource.rb

@@ -0,0 +1,35 @@
+module Datamappify
+  module Resource
+    def self.included(model)
+      model.send :cattr_accessor, :properties
+      model.send :cattr_accessor, :indexes
+      
+      model.extend Resource::ClassMethods
+      model.extend Associations::ClassMethods
+    end
+    
+    module ClassMethods
+      def self.extended(model)
+        @@model = model
+        
+        @@model.properties = []
+        @@model.indexes    = []
+      end
+      
+      def property(name, sql_type=nil, options={})
+        @@model.properties << {
+          :name     => name,
+          :sql_type => sql_type,
+          :options  => options,
+        }
+      end
+      
+      def add_index(columns, options={})
+        @@model.indexes << {
+          :columns => columns,
+          :options => options,
+        }
+      end
+    end
+  end
+end

data/lib/datamappify/schema_dumper.rb

@@ -0,0 +1,21 @@
+module Datamappify
+  class SchemaDumper < ActiveRecord::SchemaDumper
+    def self.dump_to_file
+      File.open(ENV['SCHEMA'] || "#{Rails.root}/db/schema.rb", "w") do |file|
+        Datamappify::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+      end
+    end
+    
+    def initialize(connection)
+      super(connection)
+      @connection = Datamappify::Fake::Connection.new
+    end
+    
+    def tables(stream)
+      Datamappify::Collection.get.each do |entry|
+        tbl = entry[:table_name] or entry[:resource].pluralize
+        table(tbl, stream)
+      end
+    end
+  end
+end

data/lib/tasks/datamappify.rake

@@ -0,0 +1,15 @@
+namespace :db do
+  namespace :schema do
+    desc "Update schema.rb with Datamappfiy"
+    task :update => :environment do
+      Datamappify::SchemaDumper.dump_to_file
+      Rake::Task["db:schema:update"].reenable
+    end
+    
+    desc "Auto-migrate via schema.rb"
+    task :auto_migrate => :environment do
+      Rake::Task["db:schema:update"].invoke
+      Rake::Task["db:auto:migrate"].invoke
+    end
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: datamappify
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Fred Wu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-04 00:00:00 +10:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: ActiveRecord is without doubt the de facto ORM library for Rails and many Ruby web frameworks. Many developers however, do not like database migrations and prefer to use DSL for data mapping. Datamappify is created with the sole purpose of getting rid of the DB migration headaches.
+email: ifredwu@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- .gitignore
+- MIT-LICENSE
+- README.md
+- Rakefile
+- datamappify.gemspec
+- lib/datamappify.rb
+- lib/datamappify/associations.rb
+- lib/datamappify/collection.rb
+- lib/datamappify/fake/column.rb
+- lib/datamappify/fake/connection.rb
+- lib/datamappify/fake/index.rb
+- lib/datamappify/resource.rb
+- lib/datamappify/schema_dumper.rb
+- lib/tasks/datamappify.rake
+has_rdoc: true
+homepage: http://github.com/fredwu/datamappify
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Turn ActiveRecord into DataMapper (sort of)!
+test_files: []
+