vorpal 0.0.6.rc4 → 0.0.6

data/lib/vorpal/aggregate_traversal.rb

@@ -1,50 +1,50 @@
 module Vorpal
-# @private
-class AggregateTraversal
-  def initialize(configs)
-    @configs = configs
-  end
+  # @private
+  class AggregateTraversal
+    def initialize(configs)
+      @configs = configs
+    end
 
-  # Traversal should always begin with an object that is known to be
-  # able to reach all other objects in the aggregate (like the root!)
-  def accept(object, visitor, already_visited=[])
-    return if object.nil?
+    # Traversal should always begin with an object that is known to be
+    # able to reach all other objects in the aggregate (like the root!)
+    def accept(object, visitor, already_visited=[])
+      return if object.nil?
 
-    config = @configs.config_for(object.class)
-    return if config.nil?
+      config = @configs.config_for(object.class)
+      return if config.nil?
 
-    return if already_visited.include?(object)
-    already_visited << object
+      return if already_visited.include?(object)
+      already_visited << object
 
-    visitor.visit_object(object, config)
+      visitor.visit_object(object, config)
 
-    config.belongs_tos.each do |belongs_to_config|
-      child = belongs_to_config.get_child(object)
-      accept(child, visitor, already_visited) if visitor.continue_traversal?(belongs_to_config)
-    end
+      config.belongs_tos.each do |belongs_to_config|
+        child = belongs_to_config.get_child(object)
+        accept(child, visitor, already_visited) if visitor.continue_traversal?(belongs_to_config)
+      end
 
-    config.has_ones.each do |has_one_config|
-      child = has_one_config.get_child(object)
-      accept(child, visitor, already_visited) if visitor.continue_traversal?(has_one_config)
-    end
+      config.has_ones.each do |has_one_config|
+        child = has_one_config.get_child(object)
+        accept(child, visitor, already_visited) if visitor.continue_traversal?(has_one_config)
+      end
 
-    config.has_manys.each do |has_many_config|
-      children = has_many_config.get_children(object)
-      children.each do |child|
-        accept(child, visitor, already_visited) if visitor.continue_traversal?(has_many_config)
+      config.has_manys.each do |has_many_config|
+        children = has_many_config.get_children(object)
+        children.each do |child|
+          accept(child, visitor, already_visited) if visitor.continue_traversal?(has_many_config)
+        end
       end
     end
   end
-end
 
-# @private
-module AggregateVisitorTemplate
-  def visit_object(object, config)
-    # override me!
-  end
+  # @private
+  module AggregateVisitorTemplate
+    def visit_object(object, config)
+      # override me!
+    end
 
-  def continue_traversal?(association_config)
-    true
+    def continue_traversal?(association_config)
+      true
+    end
   end
-end
 end

data/lib/vorpal/aggregate_utils.rb

@@ -1,6 +1,7 @@
 require 'vorpal/aggregate_traversal'
 
 module Vorpal
+  # @private
   module AggregateUtils
     extend self
 

data/lib/vorpal/config_builder.rb

@@ -1,148 +1,149 @@
 require 'simple_serializer/serializer'
 require 'simple_serializer/deserializer'
 require 'vorpal/configs'
+require 'active_support/inflector/methods'
 
 module Vorpal
-class ConfigBuilder
-
-  # @private
-  def initialize(clazz, options)
-    @domain_class = clazz
-    @class_options = options
-    @has_manys = []
-    @has_ones = []
-    @belongs_tos = []
-    @fields = []
-  end
+  class ConfigBuilder
+
+    # @private
+    def initialize(clazz, options)
+      @domain_class = clazz
+      @class_options = options
+      @has_manys = []
+      @has_ones = []
+      @belongs_tos = []
+      @fields = []
+    end
 
-  # Maps the given fields to and from the domain object and the DB. Not needed
-  # if a serializer and deserializer were provided.
-  def fields(*fields)
-    @fields = fields
-  end
+    # Maps the given fields to and from the domain object and the DB. Not needed
+    # if a serializer and deserializer were provided.
+    def fields(*fields)
+      @fields = fields
+    end
 
-  # Defines a one-to-many association with a list of objects of the same type.
-  #
-  # @param name [String] Name of the field that will refer to the other object.
-  # @param options [Hash]
-  # @option options [Boolean] :owned
-  # @option options [String] :fk
-  # @option options [String] :fk_type
-  # @option options [Class] :child_class
-  def has_many(name, options={})
-    @has_manys << {name: name}.merge(options)
-  end
+    # Defines a one-to-many association with a list of objects of the same type.
+    #
+    # @param name [String] Name of the field that will refer to the other object.
+    # @param options [Hash]
+    # @option options [Boolean] :owned
+    # @option options [String] :fk
+    # @option options [String] :fk_type
+    # @option options [Class] :child_class
+    def has_many(name, options={})
+      @has_manys << {name: name}.merge(options)
+    end
 
-  # Defines a one-to-one association with another object where the foreign key
-  # is stored on the other object.
-  #
-  # @param name [String] Name of the field that will refer to the other object.
-  # @param options [Hash]
-  # @option options [Boolean] :owned
-  # @option options [String] :fk
-  # @option options [String] :fk_type
-  # @option options [Class] :child_class
-  def has_one(name, options={})
-    @has_ones << {name: name}.merge(options)
-  end
+    # Defines a one-to-one association with another object where the foreign key
+    # is stored on the other object.
+    #
+    # @param name [String] Name of the field that will refer to the other object.
+    # @param options [Hash]
+    # @option options [Boolean] :owned
+    # @option options [String] :fk
+    # @option options [String] :fk_type
+    # @option options [Class] :child_class
+    def has_one(name, options={})
+      @has_ones << {name: name}.merge(options)
+    end
 
-  # Defines a one-to-one association with another object where the foreign key
-  # is stored on this object.
-  #
-  # This association can be polymorphic. i.e.
-  #
-  # @param name [String] Name of the field that will refer to the other object.
-  # @param options [Hash]
-  # @option options [Boolean] :owned
-  # @option options [String] :fk
-  # @option options [String] :fk_type
-  # @option options [Class] :child_class
-  # @option options [[Class]] :child_classes
-  def belongs_to(name, options={})
-    @belongs_tos << {name: name}.merge(options)
-  end
+    # Defines a one-to-one association with another object where the foreign key
+    # is stored on this object.
+    #
+    # This association can be polymorphic. i.e.
+    #
+    # @param name [String] Name of the field that will refer to the other object.
+    # @param options [Hash]
+    # @option options [Boolean] :owned
+    # @option options [String] :fk
+    # @option options [String] :fk_type
+    # @option options [Class] :child_class
+    # @option options [[Class]] :child_classes
+    def belongs_to(name, options={})
+      @belongs_tos << {name: name}.merge(options)
+    end
 
-  # @private
-  def build
-    class_config = build_class_config
-    class_config.has_manys = build_has_manys
-    class_config.has_ones = build_has_ones
-    class_config.belongs_tos = build_belongs_tos
+    # @private
+    def build
+      class_config = build_class_config
+      class_config.has_manys = build_has_manys
+      class_config.has_ones = build_has_ones
+      class_config.belongs_tos = build_belongs_tos
 
-    class_config
-  end
+      class_config
+    end
 
-  private
+    private
 
-  def build_class_config
-    Vorpal::ClassConfig.new(
-      domain_class: @domain_class,
-      db_class: @class_options[:to] || db_class,
-      serializer: @class_options[:serializer] || serializer(fields_with_id),
-      deserializer: @class_options[:deserializer] || deserializer(fields_with_id),
-    )
-  end
+    def build_class_config
+      Vorpal::ClassConfig.new(
+        domain_class: @domain_class,
+        db_class: @class_options[:to] || db_class,
+        serializer: @class_options[:serializer] || serializer(fields_with_id),
+        deserializer: @class_options[:deserializer] || deserializer(fields_with_id),
+      )
+    end
 
-  def db_class
-    "#{@domain_class.name}DB".constantize
-  end
+    def db_class
+      ActiveSupport::Inflector.constantize("#{@domain_class.name}DB")
+    end
 
-  def fields_with_id
-    [:id].concat @fields
-  end
+    def fields_with_id
+      [:id].concat @fields
+    end
 
-  def build_has_manys
-    @has_manys.map { |options| build_has_many(options) }
-  end
+    def build_has_manys
+      @has_manys.map { |options| build_has_many(options) }
+    end
 
-  def build_has_many(options)
-    options[:child_class] ||= child_class(options[:name])
-    options[:fk] ||= foreign_key(@domain_class.name)
-    options[:owned] = options.fetch(:owned, true)
-    Vorpal::HasManyConfig.new(options)
-  end
+    def build_has_many(options)
+      options[:child_class] ||= child_class(options[:name])
+      options[:fk] ||= foreign_key(@domain_class.name)
+      options[:owned] = options.fetch(:owned, true)
+      Vorpal::HasManyConfig.new(options)
+    end
 
-  def foreign_key(name)
-    name.to_s.underscore + '_id'
-  end
+    def foreign_key(name)
+      ActiveSupport::Inflector.underscore(name.to_s) + '_id'
+    end
 
-  def child_class(association_name)
-    association_name.to_s.classify.constantize
-  end
+    def child_class(association_name)
+      ActiveSupport::Inflector.constantize(ActiveSupport::Inflector.classify(association_name.to_s))
+    end
 
-  def build_has_ones
-    @has_ones.map { |options| build_has_one(options) }
-  end
+    def build_has_ones
+      @has_ones.map { |options| build_has_one(options) }
+    end
 
-  def build_has_one(options)
-    options[:child_class] ||= child_class(options[:name])
-    options[:fk] ||= foreign_key(@domain_class.name)
-    options[:owned] = options.fetch(:owned, true)
-    Vorpal::HasOneConfig.new(options)
-  end
+    def build_has_one(options)
+      options[:child_class] ||= child_class(options[:name])
+      options[:fk] ||= foreign_key(@domain_class.name)
+      options[:owned] = options.fetch(:owned, true)
+      Vorpal::HasOneConfig.new(options)
+    end
 
-  def build_belongs_tos
-    @belongs_tos.map { |options| build_belongs_to(options) }
-  end
+    def build_belongs_tos
+      @belongs_tos.map { |options| build_belongs_to(options) }
+    end
 
-  def build_belongs_to(options)
-    child_class = options[:child_classes] || options[:child_class] || child_class(options[:name])
-    options[:child_classes] = Array(child_class)
-    options[:fk] ||= foreign_key(options[:name])
-    options[:owned] = options.fetch(:owned, true)
-    Vorpal::BelongsToConfig.new(options)
-  end
+    def build_belongs_to(options)
+      child_class = options[:child_classes] || options[:child_class] || child_class(options[:name])
+      options[:child_classes] = Array(child_class)
+      options[:fk] ||= foreign_key(options[:name])
+      options[:owned] = options.fetch(:owned, true)
+      Vorpal::BelongsToConfig.new(options)
+    end
 
-  def serializer(attrs)
-    Class.new(SimpleSerializer::Serializer) do
-      hash_attributes *attrs
+    def serializer(attrs)
+      Class.new(SimpleSerializer::Serializer) do
+        hash_attributes *attrs
+      end
     end
-  end
 
-  def deserializer(attrs)
-    Class.new(SimpleSerializer::Deserializer) do
-      object_attributes *attrs
+    def deserializer(attrs)
+      Class.new(SimpleSerializer::Deserializer) do
+        object_attributes *attrs
+      end
     end
   end
 end
-end

data/lib/vorpal/configs.rb

@@ -149,11 +149,11 @@ module Vorpal
     end
 
     def get_db_object_attributes(db_object)
-      db_object.attributes.symbolize_keys
+      symbolize_keys(db_object.attributes)
     end
 
     def serialization_required?
-      !(domain_class < ActiveRecord::Base)
+      domain_class.superclass.name != 'ActiveRecord::Base'
     end
 
     def serialize(object)
@@ -172,6 +172,16 @@ module Vorpal
     def get_field(db_object, field)
       db_object.send(field)
     end
+
+    private
+
+    def symbolize_keys(hash)
+      result = {}
+      hash.each_key do |key|
+        result[key.to_sym] = hash[key]
+      end
+      result
+    end
   end
 
   # @private
@@ -192,6 +202,7 @@ module Vorpal
     end
   end
 
+  # @private
   module RemoteEndConfig
     def child_config
       association_config.local_class_config
@@ -210,6 +221,7 @@ module Vorpal
     end
   end
 
+  # @private
   module LocalEndConfig
     def child_config(db_parent)
       association_config.remote_class_config(db_parent)
@@ -224,6 +236,7 @@ module Vorpal
     end
   end
 
+  # @private
   module ToOneConfig
     def get_child(parent)
       parent.send(name)
@@ -234,6 +247,7 @@ module Vorpal
     end
   end
 
+  # @private
   module ToManyConfig
     def get_children(parent)
       parent.send(name)
@@ -258,22 +272,22 @@ module Vorpal
   end
 
   # @private
-  class BelongsToConfig
+  class HasOneConfig
     include HashInitialization
-    include LocalEndConfig
+    include RemoteEndConfig
     include ToOneConfig
 
-    attr_reader :name, :owned, :fk, :fk_type, :child_classes
+    attr_reader :name, :owned, :fk, :fk_type, :child_class
     attr_accessor :association_config
   end
 
   # @private
-  class HasOneConfig
+  class BelongsToConfig
     include HashInitialization
-    include RemoteEndConfig
+    include LocalEndConfig
     include ToOneConfig
 
-    attr_reader :name, :owned, :fk, :fk_type, :child_class
+    attr_reader :name, :owned, :fk, :fk_type, :child_classes
     attr_accessor :association_config
   end
 end