datamappify 0.2.2 → 0.9.0

data/lib/datamappify/entity/associated_collection.rb

@@ -0,0 +1,28 @@
+module Datamappify
+  module Entity
+    class AssociatedCollection
+      def initialize(context, name)
+        build_collection_getter(context, name)
+        build_collection_setter(context, name)
+      end
+
+      private
+
+      def build_collection_getter(context, name)
+        context.class_eval <<-CODE
+          def #{name}
+            @#{name} ||= []
+          end
+        CODE
+      end
+
+      def build_collection_setter(context, name)
+        context.class_eval <<-CODE
+          def #{name}=(collection)
+            @#{name} = collection
+          end
+        CODE
+      end
+    end
+  end
+end

data/lib/datamappify/entity/associated_entity.rb

@@ -0,0 +1,28 @@
+module Datamappify
+  module Entity
+    class AssociatedEntity
+      def initialize(context, name)
+        build_entity_getter(context, name)
+        build_entity_setter(context, name)
+      end
+
+      private
+
+      def build_entity_getter(context, name)
+        context.class_eval <<-CODE
+          def #{name}
+            @#{name} ||= "#{name}".classify.constantize.new
+          end
+        CODE
+      end
+
+      def build_entity_setter(context, name)
+        context.class_eval <<-CODE
+          def #{name}=(entity)
+            @#{name} = entity
+          end
+        CODE
+      end
+    end
+  end
+end

data/lib/datamappify/entity/association_methods.rb

@@ -0,0 +1,20 @@
+require 'datamappify/entity/associated_entity'
+require 'datamappify/entity/associated_collection'
+
+module Datamappify
+  module Entity
+    module AssociationMethods
+      def belongs_to(name, *args)
+        AssociatedEntity.new(self, name)
+      end
+
+      def has_one(name, *args)
+        AssociatedEntity.new(self, name)
+      end
+
+      def has_many(name, *args)
+        AssociatedCollection.new(self, name)
+      end
+    end
+  end
+end

data/lib/datamappify/repository.rb

@@ -0,0 +1,65 @@
+require 'datamappify/repository/persistence'
+
+module Datamappify
+  class Repository
+    include Persistence
+
+    def initialize(entity_class)
+      @entity_class = entity_class
+
+      unless data_class_is_defined?
+        apply_validations_to_data_class
+        apply_relationships_to_data_class
+        add_entity_to_data_class
+      end
+    end
+
+    def find(entity_or_id)
+      data_class.find(extract_entity_id(entity_or_id))
+    end
+
+    def method_missing(symbol, *args)
+      data_class.send symbol, *args
+    end
+
+    private
+
+    def data_class_is_defined?
+      Data.const_defined?(@entity_class.name, false)
+    end
+
+    def apply_validations_to_data_class
+      if @entity_class.stored_validations
+        data_class.class_eval(&@entity_class.stored_validations)
+      end
+    end
+
+    def apply_relationships_to_data_class
+      if @entity_class.stored_relationships
+        data_class.class_eval(&@entity_class.stored_relationships)
+      end
+    end
+
+    def add_entity_to_data_class
+      data_class.class_eval <<-CODE
+        def entity
+          #{@entity_class.name}.new(attributes)
+        end
+      CODE
+    end
+
+    def data_class
+      @data_class ||= begin
+        if data_class_is_defined?
+          Data.const_get(@entity_class.name, false)
+        else
+          Data.const_set(@entity_class.name, Class.new(Data::Base))
+        end
+      end
+    end
+
+    def extract_entity_id(entity_or_id)
+      entity_or_id.is_a?(Integer) ? entity_or_id : entity_or_id.id
+    end
+  end
+end

data/lib/datamappify/repository/persistence.rb

@@ -0,0 +1,38 @@
+module Datamappify
+  class Repository
+    module Persistence
+      [:save, :save!].each do |save_method_name|
+        define_method save_method_name do |entity_or_collection|
+          entity = collection = entity_or_collection
+
+          if collection.is_a?(Array)
+            collection.map { |e| send(save_method_name, e) }
+          elsif entity.id
+            update_data_record(save_method_name, entity)
+          else
+            create_data_record(save_method_name, entity)
+          end
+        end
+      end
+
+      [:destroy, :destroy!].each do |destroy_method_name|
+        define_method destroy_method_name do |entity_or_id|
+          data_class.send(destroy_method_name, extract_entity_id(entity_or_id))
+        end
+      end
+
+      private
+
+      def create_data_record(save_method_name, entity)
+        data_object = data_class.new(entity.attributes)
+        data_object.send(save_method_name) && data_object.entity
+      end
+
+      def update_data_record(save_method_name, entity)
+        data_object = data_class.find(entity.id)
+        data_object.update_attributes(entity.attributes)
+        data_object.send(save_method_name) && data_object.entity
+      end
+    end
+  end
+end

data/lib/datamappify/version.rb

@@ -0,0 +1,3 @@
+module Datamappify
+  VERSION = '0.9.0'
+end

data/spec/entity_spec.rb

@@ -0,0 +1,83 @@
+require_relative 'spec_helper'
+
+describe Datamappify::Entity do
+  let(:user)    { User.new }
+  let(:role)    { Role.new }
+  let(:comment) { Comment.new }
+
+  describe "attributes" do
+    it "has defined attributes" do
+      user.first_name.must_be_nil
+    end
+
+    it "raises error on undefined attributes" do
+      -> { user.attribute_that_does_not_exist }.must_raise NoMethodError
+    end
+
+    it "assigns an attribute" do
+      user.first_name = 'Fred'
+      user.first_name.must_equal 'Fred'
+    end
+
+    it "coerces an attribute" do
+      user.age = '42'
+      user.age.must_be_kind_of Fixnum
+      user.age.must_equal 42
+    end
+  end
+
+  describe "validations" do
+    it "requires first name" do
+      user.first_name = nil
+      user.valid?.must_equal false
+
+      user.first_name = 'Fred'
+      user.valid?.must_equal true
+    end
+  end
+
+  describe "relationships" do
+    describe "getters" do
+      it "belongs_to" do
+        comment.user.must_be_kind_of User
+      end
+
+      it "has_one" do
+        user.role.must_be_kind_of Role
+      end
+
+      it "has_many" do
+        user.comments.must_be_kind_of Array
+        user.comments.must_be_empty
+      end
+    end
+
+    describe "setters" do
+      let(:entity) { Object.new }
+
+      it "belongs_to" do
+        comment.user = entity
+        comment.user.must_be_kind_of Object
+        comment.user.must_equal entity
+      end
+
+      it "has_one" do
+        user.role = entity
+        user.role.must_be_kind_of Object
+        user.role.must_equal entity
+      end
+
+      it "has_many" do
+        user.comments << entity
+        user.comments << entity
+        user.comments.must_be_kind_of Array
+        user.comments.count.must_equal 2
+        user.comments[0].must_equal entity
+
+        user.comments = [entity]
+        user.comments.count.must_equal 1
+      end
+    end
+  end
+end
+

data/spec/repository/finders_and_persistence_spec.rb

@@ -0,0 +1,71 @@
+require_relative '../spec_helper'
+
+describe Datamappify::Repository do
+  let(:user_repository) { Datamappify::Repository.new(User) }
+  let(:user)            { user_repository.first }
+  let(:user_valid)      { User.new(:first_name => 'Batman') }
+  let(:user_invalid)    { User.new(:first_name => 'a') }
+
+  before do
+    user_repository
+    Datamappify::Data::User.create!(:first_name => 'Fred')
+  end
+
+  describe "single record" do
+    it "#find via id" do
+      user_repository.find(1).must_equal user
+    end
+
+    it "#find via entity" do
+      user_repository.find(user.entity).must_equal user
+    end
+
+    it "#save success" do
+      new_user = user_repository.save(user_valid)
+      new_user.must_be_kind_of User
+      new_user.first_name.must_equal 'Batman'
+    end
+
+    it "#save! failure" do
+      -> { user_repository.save!(user_invalid) }.must_raise ActiveRecord::RecordInvalid
+    end
+
+    it "updates an existing record" do
+      user.first_name = 'Steve'
+      changed_user = User.new(user.attributes)
+      user_repository.save(changed_user).first_name.must_equal 'Steve'
+      user_repository.count.must_equal 1
+    end
+
+    it "#destroy via id" do
+      user_repository.destroy(1)
+      user_repository.count.must_equal 0
+    end
+
+    it "#destroy via entity" do
+      user_repository.destroy(user.entity)
+      user_repository.count.must_equal 0
+    end
+  end
+
+  describe "collection records" do
+    it "#find" do
+      user_repository.all.must_be_kind_of ActiveRecord::Relation::ActiveRecord_Relation_Datamappify_Data_User
+      user_repository.count.must_equal 1
+    end
+
+    it "#save" do
+      new_user_entity = user.entity
+      new_user_entity.id = nil
+
+      new_users = user_repository.save([new_user_entity, user_valid])
+      new_users[0].first_name.must_equal 'Fred'
+      new_users[1].first_name.must_equal 'Batman'
+
+      user_repository.count.must_equal 3
+      user_repository.all[0].first_name.must_equal 'Fred'
+      user_repository.all[1].first_name.must_equal 'Fred'
+      user_repository.all[2].first_name.must_equal 'Batman'
+    end
+  end
+end

data/spec/repository_spec.rb

@@ -0,0 +1,60 @@
+require_relative 'spec_helper'
+
+describe Datamappify::Repository do
+  let(:user_repository)    { Datamappify::Repository.new(User) }
+  let(:comment_repository) { Datamappify::Repository.new(Comment) }
+  let(:role_repository)    { Datamappify::Repository.new(Role) }
+
+  describe "ActiveRecord data objects" do
+    it "defines the Data::User class after the repository is initialised" do
+      user_repository
+      Datamappify::Data.const_defined?(:User, false).must_equal true
+    end
+
+    describe "data objects" do
+      subject { Datamappify::Data::User }
+
+      before do
+        user_repository
+      end
+
+      it "inherites from Datamappify::Data::Base" do
+        subject.superclass.must_equal Datamappify::Data::Base
+        subject.ancestors.must_include ActiveRecord::Base
+      end
+
+      it "has 'users' as the table name" do
+        subject.table_name.must_equal 'users'
+      end
+
+      describe "relationships" do
+        let(:user)    { Datamappify::Data::User.new }
+        let(:comment) { Datamappify::Data::Comment.new }
+        let(:role)    { Datamappify::Data::Role.new }
+
+        it "belongs_to" do
+          assert_correct_associated_data_class_name(comment, :user, 'Datamappify::Data::User')
+          comment.user.must_be_nil
+        end
+
+        it "has_one" do
+          assert_correct_associated_data_class_name(user, :role, 'Datamappify::Data::Role')
+          user.role.must_be_nil
+        end
+
+        it "has_many" do
+          assert_correct_associated_data_class_name(user, :comments, 'Datamappify::Data::Comment')
+          assert_correct_associated_data_class_name(role, :users, 'Datamappify::Data::User')
+          user.comments.must_be_empty
+          role.users.must_be_empty
+        end
+      end
+    end
+
+    def assert_correct_associated_data_class_name(klass, association_name, data_class_name)
+      klass.class.reflect_on_all_associations.find { |a|
+        a.name == association_name
+      }.klass.name.must_equal data_class_name
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'simplecov'
+require 'pry'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/colorize'
+require 'database_cleaner'
+
+SimpleCov.start
+
+SimpleCov.configure do
+  add_filter "/spec/"
+end
+
+require File.expand_path('../../lib/datamappify', __FILE__)
+
+Dir[File.expand_path('../support/**/*', __FILE__)].each { |f| require f }
+
+DatabaseCleaner.strategy = :truncation
+
+class MiniTest::Spec
+  before do
+    DatabaseCleaner.clean
+  end
+end

data/spec/support/active_record_tables.rb

@@ -0,0 +1,34 @@
+ActiveRecord::Migration.suppress_messages do
+  ActiveRecord::Base.establish_connection(
+    :adapter  => 'sqlite3',
+    :database => ':memory:'
+  )
+
+  ActiveRecord::Schema.define(:version => 0) do
+    begin
+      drop_table :users
+      drop_table :comments
+      drop_table :roles
+    rescue
+    end
+
+    create_table :users do |t|
+      t.string :first_name, :null => false
+      t.string :last_name
+      t.integer :age
+      t.references :role
+      t.timestamps
+    end
+
+    create_table :comments do |t|
+      t.string :content
+      t.references :user
+      t.timestamps
+    end
+
+    create_table :roles do |t|
+      t.string :name
+      t.timestamps
+    end
+  end
+end