vorpal 0.0.1

data/lib/vorpal/configs.rb

@@ -0,0 +1,274 @@
+require 'vorpal/hash_initialization'
+
+module Vorpal
+
+# @private
+class MasterConfig
+  def initialize(class_configs)
+    @class_configs = class_configs
+    initialize_association_configs
+  end
+
+  def config_for(clazz)
+    @class_configs.detect { |conf| conf.domain_class == clazz }
+  end
+
+  def config_for_db(clazz)
+    @class_configs.detect { |conf| conf.db_class == clazz }
+  end
+
+  private
+
+  def initialize_association_configs
+    @class_configs.each do |config|
+      (config.has_ones + config.has_manys).each do |association_config|
+        association_config.init_relational_association(
+          config_for(association_config.child_class),
+          config
+        )
+      end
+      config.belongs_tos.each do |association_config|
+        association_config.init_relational_association(
+          association_config.child_classes.map(&method(:config_for)),
+          config
+        )
+      end
+    end
+  end
+end
+
+# @private
+class ClassConfig
+  attr_reader :serializer, :deserializer, :domain_class, :table_name
+  attr_accessor :has_manys, :belongs_tos, :has_ones
+
+  def initialize(attrs)
+    @has_manys = []
+    @belongs_tos = []
+    @has_ones = []
+
+    attrs.each do |k,v|
+      instance_variable_set("@#{k}", v)
+    end
+  end
+
+  def get_primary_keys(count)
+    result = ActiveRecord::Base.connection.execute("select nextval('#{sequence_name}') from generate_series(1,#{count});")
+    result.column_values(0).map(&:to_i)
+  end
+
+  def db_class
+    @db_class ||= ActiveRecord::Base.descendants.detect { |ar| ar.table_name == table_name }
+  end
+
+  def find_in_db(object)
+    db_class.find(object.id)
+  end
+
+  def load_by_id(id)
+    db_class.where(id: id).first
+  end
+
+  def load_by_foreign_key(id, foreign_key_info)
+    arel = db_class.where(foreign_key_info.fk_column => id)
+    arel = arel.where(foreign_key_info.fk_type_column => foreign_key_info.fk_type) if foreign_key_info.polymorphic?
+    arel.order(:id).all
+  end
+
+  def destroy(db_object)
+    db_object.destroy
+  end
+
+  def save(db_object)
+    db_object.save!
+  end
+
+  def build_db_object(attributes)
+    db_class.new(attributes)
+  end
+
+  def set_db_object_attributes(db_object, attributes)
+    db_object.attributes = attributes
+  end
+
+  def get_db_object_attributes(db_object)
+    db_object.attributes.symbolize_keys
+  end
+
+  def serialization_required?
+    !(domain_class < ActiveRecord::Base)
+  end
+
+  def serialize(object)
+    serializer.serialize(object)
+  end
+
+  def deserialize(db_object)
+    attributes = get_db_object_attributes(db_object)
+    serialization_required? ? deserializer.deserialize(domain_class.new, attributes) : db_object
+  end
+
+  def set_field(db_object, field, value)
+    db_object.send("#{field}=", value)
+  end
+
+  def get_field(db_object, field)
+    db_object.send(field)
+  end
+
+  private
+
+  def sequence_name
+    "#{table_name}_id_seq"
+  end
+end
+
+# @private
+class ForeignKeyInfo
+  attr_reader :fk_column, :fk_type_column, :fk_type, :polymorphic
+
+  def initialize(fk_column, fk_type_column, fk_type, polymorphic)
+    @fk_column = fk_column
+    @fk_type_column = fk_type_column
+    @fk_type = fk_type
+    @polymorphic = polymorphic
+  end
+
+  def polymorphic?
+    @polymorphic
+  end
+end
+
+# @private
+# Object associations:
+# - All object associations are uni-directional
+# - The end that holds the association is the 'Parent' and the end that
+#   is refered to is the 'Child' or 'Children'
+#
+# Relational associations:
+# - Local end: has FK
+# - Remote end: has no FK
+#
+class RelationalAssociation
+  include HashInitialization
+  attr_reader :fk, :fk_type, :local_config, :remote_configs
+
+  # Can't pass in a remote db model for last param because when saving we only have
+  # a db model if the model is part of the aggregate and not just referenced by the
+  # aggregate
+  def set_foreign_key(local_db_model, remote_model)
+    local_config.set_field(local_db_model, fk, remote_model.try(:id))
+    local_config.set_field(local_db_model, fk_type, remote_model.class.name) if polymorphic?
+  end
+
+  def load_locals(remote_db_model)
+    id = remote_db_model.id
+    # TODO: this method should probably be able to determine the config for the remote models
+    raise "Only supports having one remote configuration when navigating from the remote side to the local side of an association." if remote_configs.size != 1
+    remote_config = remote_configs.first
+    local_config.load_by_foreign_key(id, foreign_key_info(remote_config))
+  end
+
+  def load_remote(local_db_model)
+    remote_config = polymorphic? ? remote_config_for_local_db_object(local_db_model) : remote_configs.first
+    remote_config.load_by_id(get_foreign_key(local_db_model))
+  end
+
+  private
+
+  def polymorphic?
+    !fk_type.nil?
+  end
+
+  def foreign_key_info(class_config)
+    ForeignKeyInfo.new(fk, fk_type, class_config.domain_class.name, polymorphic?)
+  end
+
+  def remote_config_for_local_db_object(local_db_model)
+    class_name = local_config.get_field(local_db_model, fk_type)
+    remote_configs.detect { |config| config.domain_class.name == class_name }
+  end
+
+  def get_foreign_key(local_db_model)
+    local_config.get_field(local_db_model, fk)
+  end
+end
+
+# @private
+class HasManyConfig
+  include HashInitialization
+  attr_reader :name, :owned, :fk, :fk_type, :child_class
+
+  def init_relational_association(child_config, parent_config)
+    @relational_association = RelationalAssociation.new(fk: fk, fk_type: fk_type, local_config: child_config, remote_configs: [parent_config])
+  end
+
+  def get_children(parent)
+    parent.send(name)
+  end
+
+  def set_children(parent, children)
+    parent.send("#{name}=", children)
+  end
+
+  def set_foreign_key(db_child, parent)
+    @relational_association.set_foreign_key(db_child, parent)
+  end
+
+  def load_children(db_parent)
+    @relational_association.load_locals(db_parent)
+  end
+end
+
+# @private
+class BelongsToConfig
+  include HashInitialization
+  attr_reader :name, :owned, :fk, :fk_type, :child_classes
+
+  def init_relational_association(child_configs, parent_config)
+    @relational_association = RelationalAssociation.new(fk: fk, fk_type: fk_type, local_config: parent_config, remote_configs: child_configs)
+  end
+
+  def get_child(parent)
+    parent.send(name)
+  end
+
+  def set_child(parent, child)
+    parent.send("#{name}=", child)
+  end
+
+  def set_foreign_key(db_parent, child)
+    @relational_association.set_foreign_key(db_parent, child)
+  end
+
+  def load_child(db_parent)
+    @relational_association.load_remote(db_parent)
+  end
+end
+
+# @private
+class HasOneConfig
+  include HashInitialization
+  attr_reader :name, :owned, :fk, :fk_type, :child_class
+
+  def init_relational_association(child_config, parent_config)
+    @relational_association = RelationalAssociation.new(fk: fk, fk_type: fk_type, local_config: child_config, remote_configs: [parent_config])
+  end
+
+  def get_child(parent)
+    parent.send(name)
+  end
+
+  def set_child(parent, child)
+    parent.send("#{name}=", child)
+  end
+
+  def set_foreign_key(db_child, parent)
+    @relational_association.set_foreign_key(db_child, parent)
+  end
+
+  def load_child(db_parent)
+    @relational_association.load_locals(db_parent).first
+  end
+end
+end

data/lib/vorpal/configuration.rb

@@ -0,0 +1,61 @@
+require 'vorpal/aggregate_repository'
+require 'vorpal/config_builder'
+
+module Vorpal
+# Allows easy creation of {Vorpal::AggregateRepository}
+# instances.
+#
+# ```ruby
+# repository = Vorpal::Configuration.define do
+#   map Tree do
+#     fields :name
+#     belongs_to :trunk
+#     has_many :branches
+#   end
+#
+#   map Trunk do
+#     fields :length
+#     has_one :tree
+#   end
+#
+#   map Branch do
+#     fields :length
+#     belongs_to :tree
+#   end
+# end
+# ```
+module Configuration
+  extend self
+
+  # Configures and creates a {Vorpal::AggregateRepository} instance.
+  #
+  # @return [Vorpal::AggregateRepository] Repository instance.
+  def define(&block)
+    @class_configs = []
+    self.instance_exec(&block)
+    AggregateRepository.new(@class_configs)
+  end
+
+  # Maps a domain class to a relational table.
+  #
+  # @param domain_class [Class] Type of the domain model to be mapped
+  # @param options [Hash] Configure how to map the domain model
+  # @option options [String] :table_name (Name of the domain class snake-cased and pluralized.)
+  #   Name of the relational DB table.
+  # @option options [Object] :serializer (map the {ConfigBuilder#fields} directly)
+  #   Object that will convert the domain objects into a hash.
+  #
+  #   Must have a `(Hash) serialize(Object)` method.
+  # @option options [Object] :deserializer (map the {ConfigBuilder#fields} directly)
+  #   Object that will set a hash of attribute_names->values onto a new domain
+  #   object.
+  #
+  #   Must have a `(Object) deserialize(Object, Hash)` method.
+  def map(domain_class, options={}, &block)
+    builder = ConfigBuilder.new(domain_class, options)
+    builder.instance_exec(&block) if block_given?
+
+    @class_configs << builder.build
+  end
+end
+end

data/lib/vorpal/hash_initialization.rb

@@ -0,0 +1,10 @@
+module Vorpal
+  # @private
+  module HashInitialization
+    def initialize(attrs)
+      attrs.each do |k,v|
+        instance_variable_set("@#{k}", v)
+      end
+    end
+  end
+end

data/lib/vorpal/identity_map.rb

@@ -0,0 +1,26 @@
+module Vorpal
+class IdentityMap
+  def initialize
+    @entities = {}
+  end
+
+  def get(key_object)
+    @entities[key_object]
+  end
+
+  def set(key_object, object)
+    @entities[key_object] = object
+  end
+
+  def get_and_set(key_object)
+    object = get(key_object)
+    object = yield(key_object) if object.nil?
+    set(key_object, object)
+    object
+  end
+
+  def map(key_objects)
+    key_objects.map { |k| @entities[k] }
+  end
+end
+end

data/lib/vorpal/version.rb

@@ -0,0 +1,3 @@
+module Vorpal
+  VERSION = "0.0.1"
+end

data/lib/vorpal.rb

@@ -0,0 +1,5 @@
+require "vorpal/version"
+
+module Vorpal
+  # Your code goes here...
+end

data/spec/integration_spec_helper.rb

@@ -0,0 +1,41 @@
+require 'active_record'
+require 'pg' # or 'mysql2' or 'sqlite3'
+
+# Change the following to reflect your database settings
+ActiveRecord::Base.establish_connection(
+  adapter:  'postgresql', # or 'mysql2' or 'sqlite3'
+  host:     'localhost',
+  database: 'vorpal_test',
+  username: 'vorpal',
+  password: 'pass',
+  min_messages: 'error'
+)
+
+RSpec.configure do |config|
+  # ## Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+
+  # implements use_transactional_fixtures = true
+  # from lib/active_record/fixtures.rb
+  # works with Rails 3.2. Probably not with Rails 4
+  config.before(:each) do
+    connection = ActiveRecord::Base.connection
+    connection.increment_open_transactions
+    connection.transaction_joinable = false
+    connection.begin_db_transaction
+  end
+
+  config.after(:each) do
+    connection = ActiveRecord::Base.connection
+    if connection.open_transactions != 0
+      connection.rollback_db_transaction
+      connection.decrement_open_transactions
+    end
+    ActiveRecord::Base.clear_active_connections!
+  end
+end