datamappify 0.2.2 → 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5cd51d61440490e0e15894ce7243cb4c324945b5
+  data.tar.gz: cbbf430016eaf1c88b181806e3901a009ce9028f
+SHA512:
+  metadata.gz: 55ecbac18bf660597c7494a12b9adf88a1597202388ae131305653c2e5902d4d455d284b37bc1ebd0e4bec82b408ea4e778198df07e4c819c264af34658a3200
+  data.tar.gz: 5bbc77d5ef8a8522e66461bead4a94490932138464f27d912593d8bf5ef26414bb26712c63b2f2ce234ed48b99f1fe37d5ee58959057c94f471799983282c2b8

data/.gitignore

@@ -1 +1,3 @@
+Gemfile.lock
 pkg
+coverage

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## master
+
+## 0.9.0 [2013-03-14]
+
+- A total rewrite as a proof-of-concept based on the repository pattern.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in datamappify.gemspec
+gemspec

data/README.md

@@ -1,118 +1,109 @@
-# Datamappify
+# Datamappify [![Gem Version](https://badge.fury.io/rb/datamappify.png)](http://badge.fury.io/rb/datamappify) [![Build Status](https://api.travis-ci.org/fredwu/datamappify.png)](http://travis-ci.org/fredwu/datamappify) [![Code Climate](https://codeclimate.com/github/fredwu/datamappify.png)](https://codeclimate.com/github/fredwu/datamappify)
 
-## Introduction
+Separate domain logic from data persistence, based on the [Repository Pattern](http://martinfowler.com/eaaCatalog/repository.html).
 
-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.
+__This library is current in Proof-of-Concept stage, do NOT use it for anything other than experimentation.__
 
-Brought to you by [Envato](http://envato.com) and [Wuit](http://wuit.com).
+## Overview
 
-## Disclaimer
+Datamappify is a thin layer on top of ActiveRecord and [Virtus](https://github.com/solnic/virtus). The design goal is to utilise ActiveRecord but separate domain logic (behaviour) and data persistence.
 
-**This plugin is NOT production-ready yet!** Use with caution.
+Datamappify consists of three components:
 
-### Todo
+- Entity
+- Data
+- Repository
 
-* Add tests
-* Possibly refactor `add_index` to be part of the `property` definition (as seen in the [DataMapper](http://datamapper.org/) library)
+__Entity__ is your model, it is responsible for mainly storing behaviour. Some structure (i.e. model relationships) is also stored here for convenience.
 
-## Why?
+__Data__ as the name suggests, holds your model data. It is an ActiveRecord object.
 
-### Why Not DB Migrations?
+__Repository__ is responsible for data retrieval and persistence, e.g. `find`, `save` and `destroy`, etc.
 
-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?
+## Installation
 
-Basically, it -
+Add this line to your application's Gemfile:
 
-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.
+    gem 'datamappify'
 
-## Installation
+And then execute:
 
-    gem install datamappify
+    $ bundle
 
-Don't forget to include the library in your `Gemfile`:
+Or install it yourself as:
 
-    gem 'datamappify'
+    $ gem install datamappify
 
 ## Usage
 
-Here's an example to get you started:
+Model:
 
-  	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
+```ruby
+class User
+  include Datamappify::Entity
 
-It will create the following schema:
+  attribute :first_name, String
+  attribute :last_name, String
+  attribute :age, Integer
 
-  	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
+  # ActiveModel::Validations rules are wrapped in the `validations` block
+  validations do
+    validates :first_name, :presence => true
+  end
 
-  	add_index "users", :email
-  	add_index "users", :payment_email
-  	add_index "users", :role_id
+  # ActiveRelation collections are wrapped in the `relationships` block
+  relationships do
+    has_one  :role
+    has_many :comments
+  end
 
-#### property()
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+end
+```
 
-Use `property` to define and map DB columns. It accepts a number of arguments:
+Corresponding repository:
 
-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.
+```ruby
+user_repository = Datamappify::Repository.new(User)
+```
 
-#### add_index()
+Retrieving records:
 
-Use `add_index` to add DB indexes. It accepts a number of arguments:
+```ruby
+user = user_repository.find(1)
+```
 
-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`.
+Saving/updating a record:
 
-### Rake Tasks
+```ruby
+user_repository.save(user)
+```
 
-To set up your database for the first time, please run:
+Destroying a record:
 
-    rake db:schema:update
-    rake db:setup
+```ruby
+user_repository.destroy(user)
+```
 
-Later on, to only update the `schema.rb` file, run:
+## Todo
 
-    rake db:schema:update
+- Entity should dictate Data, so schema and migrations should be automatically generated
+- Support for `set_primary_key` (currently the PK is hard coded to `id`)
+- Support for HABTM association type
+- Support for entity attribute and data column mapping
+- Repository should handle asscociated data
 
-To update `schema.rb` and to 'migrate' the updated database structure, run:
+## Similar Projects
 
-    rake db:schema:auto_migrate
+- [Curator](https://github.com/braintree/curator)
+- [Edr](https://github.com/nulogy/edr)
 
 ## Author
 
-Copyright (c) 2010 Fred Wu (<http://fredwu.me>), released under the MIT license
+[Fred Wu](http://fredwu.me/)
+
+## License
 
-* Envato - <http://envato.com>
-* Wuit - <http://wuit.com>
+Licensed under [MIT](http://fredwu.mit-license.org/)

data/Rakefile

@@ -1,18 +1,25 @@
-require 'rake'
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs.push 'lib'
+  t.test_files = FileList['spec/**/*_spec.rb']
+  t.verbose = true
+end
 
 begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = "datamappify"
-    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.require_paths = ["lib", "vendor/auto_migrations/lib"]
-    s.add_dependency("activerecord")
+  require 'cane/rake_task'
+
+  desc "Run cane to check quality metrics"
+  Cane::RakeTask.new(:quality) do |cane|
+    cane.abc_max       = 8
+    cane.no_doc        = true
+    cane.style_glob    = './lib/**/*.rb'
+    cane.style_measure = 120
+    cane.abc_exclude   = []
   end
-  Jeweler::GemcutterTasks.new
 rescue LoadError
-  puts "Jeweler not available. Install it with: gem install jeweler"
+  warn "cane not available, quality task not provided."
 end
+
+task :default => [:test, :quality]

data/datamappify.gemspec

@@ -1,62 +1,34 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'datamappify/version'
 
-Gem::Specification.new do |s|
-  s.name = %q{datamappify}
-  s.version = "0.2.2"
+Gem::Specification.new do |spec|
+  spec.name          = "datamappify"
+  spec.version       = Datamappify::VERSION
+  spec.authors       = ["Fred Wu"]
+  spec.email         = ["ifredwu@gmail.com"]
+  spec.description   = %q{Separate domain logic from data persistence.}
+  spec.summary       = spec.description
+  spec.homepage      = "https://github.com/fredwu/datamappify"
+  spec.license       = "MIT"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Fred Wu"]
-  s.date = %q{2010-09-24}
-  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",
-     "VERSION",
-     "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/railtie.rb",
-     "lib/datamappify/resource.rb",
-     "lib/datamappify/schema_dumper.rb",
-     "lib/tasks/datamappify.rake",
-     "vendor/auto_migrations/MIT-LICENSE",
-     "vendor/auto_migrations/README",
-     "vendor/auto_migrations/Rakefile",
-     "vendor/auto_migrations/init.rb",
-     "vendor/auto_migrations/lib/auto_migrations.rb",
-     "vendor/auto_migrations/lib/tasks/auto_migrations_tasks.rake",
-     "vendor/auto_migrations/test/auto_migrations_test.rb"
-  ]
-  s.homepage = %q{http://github.com/fredwu/datamappify}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib", "vendor/auto_migrations/lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Turn ActiveRecord into DataMapper (sort of)!}
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
+  spec.add_dependency "virtus",        "~> 0.5"
+  spec.add_dependency "activesupport", ">= 4.0.0.beta1", "< 5"
+  spec.add_dependency "activerecord",  ">= 4.0.0.beta1", "< 5"
 
-    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
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-colorize"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "cane"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "database_cleaner", ">= 1.0.0.RC1", "< 2"
 end
-

data/lib/datamappify.rb

@@ -1,18 +1,9 @@
-raise "ActiveRecord is not present!" unless defined?(ActiveRecord)
-
-require 'auto_migrations'
-require 'datamappify/associations'
-require 'datamappify/collection'
-require 'datamappify/fake/column'
-require 'datamappify/fake/connection'
-require 'datamappify/fake/index'
-require 'datamappify/railtie'
-require 'datamappify/resource'
-require 'datamappify/schema_dumper'
+require "active_support/inflector"
+require "active_record"
+require "datamappify/version"
+require "datamappify/entity"
+require "datamappify/data"
+require "datamappify/repository"
 
 module Datamappify
-  def self.run
-    Datamappify::SchemaDumper.dump_to_file
-    AutoMigrations.run
-  end
-end
+end

data/lib/datamappify/data.rb

@@ -0,0 +1,6 @@
+require 'datamappify/data/base'
+
+module Datamappify
+  module Data
+  end
+end

data/lib/datamappify/data/association_methods.rb

@@ -0,0 +1,29 @@
+module Datamappify
+  module Data
+    module AssociationMethods
+      def belongs_to(name, scope = nil, options = {})
+        build_associated_repository(name)
+
+        super(name, scope = nil, options)
+      end
+
+      def has_one(name, scope = nil, options = {})
+        build_associated_repository(name)
+
+        super(name, scope = nil, options)
+      end
+
+      def has_many(name, scope = nil, options = {}, &extension)
+        build_associated_repository(name)
+
+        super(name, scope = nil, options, &extension)
+      end
+
+      private
+
+      def build_associated_repository(entity_or_collection_name)
+        Datamappify::Repository.new(entity_or_collection_name.to_s.classify.constantize)
+      end
+    end
+  end
+end

data/lib/datamappify/data/base.rb

@@ -0,0 +1,11 @@
+require 'datamappify/data/association_methods'
+
+module Datamappify
+  module Data
+    class Base < ActiveRecord::Base
+      extend Data::AssociationMethods
+
+      self.abstract_class = true
+    end
+  end
+end

data/lib/datamappify/entity.rb

@@ -0,0 +1,44 @@
+require 'virtus'
+require 'datamappify/entity/association_methods'
+
+module Datamappify
+  module Entity
+    def self.included(klass)
+      klass.class_eval do
+        include Virtus
+
+        attribute :id, Integer
+
+        extend Behaviour
+        extend Structure
+        extend AssociationMethods
+      end
+    end
+
+    module Behaviour
+      def self.extended(klass)
+        klass.class_eval do
+          include ActiveModel::Validations
+        end
+      end
+
+      attr_accessor :stored_validations
+
+      def validations(&block)
+        self.stored_validations = block
+
+        instance_eval(&block)
+      end
+    end
+
+    module Structure
+      attr_accessor :stored_relationships
+
+      def relationships(&block)
+        self.stored_relationships = block
+
+        instance_eval(&block)
+      end
+    end
+  end
+end