dart 0.0.1

data/lib/dart/database/relation.rb

@@ -0,0 +1,21 @@
+module Dart
+  module Database
+    # A Database::Relation extends Dart::Relation with naming conventions to support table reflection
+    class Relation < Dart::Relation
+      include NamingConventions::RelationHelpers
+
+      def add_many_to_one(*ass_args)
+        add_association ManyToOneAssociation.new(*ass_args)
+      end
+
+      def add_one_to_many(*ass_args)
+        add_association OneToManyAssociation.new(*ass_args)
+      end
+
+      def add_many_to_many(*ass_args)
+        add_association ManyToManyAssociation.new(*ass_args)
+      end
+
+    end
+  end
+end

data/lib/dart/database/test_helpers.rb

@@ -0,0 +1,23 @@
+module Dart
+  module Database
+
+    # Test support class used to easily construct associations
+    module TestHelpers
+      def relation(*args)
+        Relation.new(*args)
+      end
+
+      def many_to_one_ass(*args)
+        ManyToOneAssociation.new(*args)
+      end
+
+      def one_to_many_ass(*args)
+        OneToManyAssociation.new(*args)
+      end
+
+      def many_to_many_ass(*args)
+        ManyToManyAssociation.new(*args)
+      end
+    end
+  end
+end

data/lib/dart/naming_conventions.rb

@@ -0,0 +1,18 @@
+require_relative 'naming_conventions/foreign_key_finder'
+
+require_relative 'naming_conventions/relation_helpers'
+require_relative 'naming_conventions/association_helpers'
+require_relative 'naming_conventions/direct_association_helpers'
+require_relative 'naming_conventions/many_to_many_association_helpers'
+require_relative 'naming_conventions/many_to_one_association_helpers'
+require_relative 'naming_conventions/one_to_many_association_helpers'
+
+module Dart
+  module NamingConventions
+
+    # NamingConventions.instance must be set by the user of this module. It is normally a subclass of AbstractBase
+    class << self
+      attr_accessor :instance
+    end
+  end
+end

data/lib/dart/naming_conventions/abstract_base.rb

@@ -0,0 +1,71 @@
+module Dart
+  module NamingConventions
+
+    PUBLIC_API_METHODS = [:parent_table_for, :singular_association_name, :plural_association_name, :long_association_name, :conventional_join_table_names]
+
+    class AbstractBase
+      abstract_method :conventional_primary_key, :foreign_key_regex
+      abstract_method :pluralize, :singularize
+
+      # Returns the name of a possibly referenced table if the given possible_foreign_key follows the naming convention,
+      # otherwise returns nil
+      #
+      # Examples:
+      #   parent_table_for('group_id') => 'groups'
+      #   parent_table_for('created_by') => nil
+      #
+      # @param [String|Symbol] possible_foreign_key name of the possibly referencing column
+      # @return [String|NilClass] name of the possibly referenced table if found by convention
+      #
+      def parent_table_for(possible_foreign_key)
+        pluralize singular_association_name(possible_foreign_key) if possible_foreign_key =~ foreign_key_regex
+      end
+
+      # Returns a many_to_one association name based on the given foreign_key according to the naming convention
+      # Examples:
+      #   to_association('group_id') => 'group'
+      #   to_association('team_id') => 'team'
+      #   to_association('created_by') => 'created_by'
+      #
+      def singular_association_name(foreign_key)
+        if foreign_key =~ foreign_key_regex
+          foreign_key[0...foreign_key.index(foreign_key_regex)]
+        else
+          foreign_key
+        end
+      end
+
+      # Returns a one_to_many association name based on the given foreign_key according to the naming convention
+      # Examples:
+      #   to_association('group_id') => 'groups'
+      #   to_association('team_id') => 'teams'
+      #   to_association('created_by') => 'created_bies'
+      #
+      def plural_association_name(foreign_key)
+        pluralize singular_association_name(foreign_key)
+      end
+
+      # Returns a long many_to_many association name based on the given join table and foreign_keys according to the
+      # naming convention
+      # Examples:
+      #   long_association_name('topic_assignments', 'group_id', 'groups', 'user_id') => 'topic_assignment_users'
+      #   long_association_name('broadcasts', 'created_by', 'users', 'item_id') => 'broadcast_created_by_items'
+      #
+      def long_association_name(join_table, left_key, left_table, right_key)
+        left_key_qualifier = "_#{left_key}" if left_table != parent_table_for(left_key)
+        "#{singularize(join_table)}#{left_key_qualifier}_#{plural_association_name(right_key)}"
+      end
+
+      # Returns unique singular and plural combinations of the given table names that would be used in constructing a
+      # conventional join table name (assumes the given table_names are plural)
+      def conventional_join_table_names(left_table_name, right_table_name)
+        # TODO consider [left_table_name, pluralize(left_table_name), singularize(left_table_name)].uniq
+        left_names  = [left_table_name, singularize(left_table_name)].uniq
+        right_names = [right_table_name, singularize(right_table_name)].uniq
+
+        (left_names.product(right_names) + right_names.product(left_names)).map { |t1, t2| "#{t1}_#{t2}" }
+      end
+
+    end
+  end
+end

data/lib/dart/naming_conventions/association_helpers.rb

@@ -0,0 +1,16 @@
+module Dart
+  module NamingConventions
+    module AssociationHelpers
+
+      abstract_method :conventional_name, :name_is_conventional?
+
+      def naming_conventions
+        Dart::NamingConventions.instance or fail "naming conventions have not been configured"
+      end
+
+      def set_conventional_name!
+        set_name! conventional_name
+      end
+    end
+  end
+end

data/lib/dart/naming_conventions/direct_association_helpers.rb

@@ -0,0 +1,21 @@
+module Dart
+  module NamingConventions
+    module DirectAssociationHelpers
+
+      # Returns true if this association has a conventional foreign key pointing to the given table_name
+      def conventional_parent?(table_name)
+        parent_table == table_name && conventional_foreign_key?
+      end
+
+      # Returns true if this association has a conventional primary key on the parent table
+      def conventional_primary_key?
+        primary_key == naming_conventions.conventional_primary_key
+      end
+
+      # Returns true if this association has a conventionally named foreign key based on the parent table name
+      def conventional_foreign_key?
+        parent_table == naming_conventions.parent_table_for(foreign_key)
+      end
+    end
+  end
+end

data/lib/dart/naming_conventions/foreign_key_finder.rb

@@ -0,0 +1,26 @@
+module Dart
+  module NamingConventions
+    class ForeignKeyFinder
+
+      # Returns a set of possible foreign keys based on columns in this relation matching the naming convention and
+      # reference a table name that is in the given schema
+      #
+      # @param [Relation] relation the relation to search
+      # @param [Schema] schema defines the set of referenceable tables
+      #
+      def foreign_keys_for(relation, schema)
+        naming_conventions = Dart::NamingConventions.instance
+        relation.column_names.map do |possible_foreign_key|
+          if parent_table = naming_conventions.parent_table_for(possible_foreign_key)
+            if schema.has_table?(parent_table)
+              ForeignKeyInfo.new(relation.table_name,
+                                 possible_foreign_key,
+                                 parent_table,
+                                 naming_conventions.conventional_primary_key)
+            end
+          end
+        end.compact
+      end
+    end
+  end
+end

data/lib/dart/naming_conventions/many_to_many_association_helpers.rb

@@ -0,0 +1,52 @@
+module Dart
+  module NamingConventions
+    module ManyToManyAssociationHelpers
+      include AssociationHelpers
+
+      # Returns the name of a referenced association according to the naming convention
+      #
+      # @return [String] the name of the referenced association
+      #
+      def conventional_name
+        # just return e.g. 'groups' if right_ass.foreign_key is group_id
+        naming_conventions.plural_association_name(right_ass.foreign_key)
+      end
+
+      def name_is_conventional?
+        name == associated_table
+      end
+
+      def name_and_right_foreign_key_are_conventional?
+        # name == associated_table == naming_conventions.parent_table_for(right_ass.foreign_key)
+        name_is_conventional? && right_foreign_key_is_conventional?
+      end
+
+      def left_foreign_key_is_conventional?
+        left_ass.conventional_foreign_key?
+      end
+
+      def right_foreign_key_is_conventional?
+        right_ass.conventional_foreign_key?
+      end
+
+      # forces long-form name to disambiguate from other joins to same association, where short-form name is the same
+      def disambiguate_name!
+        unless is_semi_conventional_join_table?
+          # add a foreign_key disambiguator when the key referencing me is unconventional
+          set_name! naming_conventions.long_association_name(join_table, left_ass.foreign_key, left_ass.parent_table, right_ass.foreign_key)
+        end
+      end
+
+      private
+
+      # Returns true if the table joining t1 and t2 is semi-conventional, i.e. some variation of t1_t2 or t2_t1, for
+      # plural or singular forms of t1 and t2
+      def is_semi_conventional_join_table?
+        @semi_conventional_join_table ||= begin
+          naming_conventions.conventional_join_table_names(left_ass.parent_table, right_ass.parent_table).include?(join_table)
+        end
+      end
+
+    end
+  end
+end

data/lib/dart/naming_conventions/many_to_one_association_helpers.rb

@@ -0,0 +1,20 @@
+module Dart
+  module NamingConventions
+    module ManyToOneAssociationHelpers
+      include AssociationHelpers
+      include DirectAssociationHelpers
+
+      # Returns the name of a referenced association according to the naming convention
+      #
+      # @return [String] the name of the referenced association
+      #
+      def conventional_name
+        naming_conventions.singular_association_name(foreign_key)
+      end
+
+      def name_is_conventional?
+        naming_conventions.plural_association_name(foreign_key) == associated_table
+      end
+    end
+  end
+end

data/lib/dart/naming_conventions/one_to_many_association_helpers.rb

@@ -0,0 +1,26 @@
+module Dart
+  module NamingConventions
+    module OneToManyAssociationHelpers
+      include AssociationHelpers
+      include DirectAssociationHelpers
+
+      # Returns the name of a referenced association according to the naming convention
+      #
+      # @return [String] the name of the referenced association
+      #
+      def conventional_name
+        if conventional_foreign_key?
+          associated_table
+        else
+          "#{naming_conventions.singular_association_name(foreign_key)}_#{child_table}"
+        end
+      end
+
+      def name_is_conventional?
+        name == associated_table
+      end
+
+    end
+  end
+end
+

data/lib/dart/naming_conventions/relation_helpers.rb

@@ -0,0 +1,40 @@
+module Dart
+  module NamingConventions
+    module RelationHelpers
+
+      # Returns true if this relation has a many_to_one association with the given table_name
+      # @param [String] table_name
+      def has_direct_conventional_parent?(table_name)
+        parent_associations.any? { |a| a.conventional_parent?(table_name) }
+      end
+
+      # Finds joins with the same name and marks all but the conventional one as requiring a long name.
+      #
+      def disambiguate_conflicting_join_names!
+        # Corner case problem: if the schema changes and a conventional join table is added, then what was formerly
+        # foo many_to_many: :bars  join_table: poop_stinks, will need to be (manually) changed to something like
+        # foo many_to_many: :poop_stink_bars, class: :Bar,  join_table: poop_stinks
+        # and a request for foo.bars will now return bars from the foo_bars join table instead of the poop_stinks join
+        # table. Making all non-conventional joins have long names is worse since in most cases (80/20) the "real"
+        # join is just the existing unconventionally named table.
+        # many_to_many :bars seems better for a vast majority of joins that are not conventional.
+
+        duplicate_join_association_names.each do |_, join_associations|
+          join_associations.each { |join| join.disambiguate_name! }
+        end
+      end
+
+      # Returns a Hash of ass_name => number of copies for all duplicated join associations
+      def duplicate_join_association_names
+        join_associations.group_by(&:name).select { |name, join_associations| join_associations.count > 1 }
+      end
+
+      # Returns pairs of many_to_one associations that could make up a join through this relation
+      # @return [Array<[String,String]]
+      def possible_join_pairs
+        parent_associations.combination(2).to_a
+      end
+
+    end
+  end
+end

data/lib/dart/reflection/abstract_resolver.rb

@@ -0,0 +1,7 @@
+module Dart
+  module Reflection
+    class AbstractResolver
+      abstract_method :build_from_association, :association_for, :column_for, :table_name
+    end
+  end
+end

data/lib/dart/reflection/active_record_model/resolver.rb

@@ -0,0 +1,122 @@
+module Dart
+  module Reflection
+    module ActiveRecordModel
+      class Resolver < OrmModelResolver
+
+        private
+
+        def reflection_from(ass_name)
+          this_model_class.reflect_on_association(active_recordize(ass_name))
+        end
+
+        def has_column?(col_name)
+          this_model_class.column_names.include?(col_name)
+        end
+
+        # = Active Record Associations
+        #
+        # This is the root class of all associations ('+ Foo' signifies an included module Foo):
+        #
+        #   Association
+        #     SingularAssociation
+        #       HasOneAssociation + ForeignAssociation
+        #         HasOneThroughAssociation + ThroughAssociation
+        #       BelongsToAssociation
+        #         BelongsToPolymorphicAssociation
+        #     CollectionAssociation
+        #       HasManyAssociation + ForeignAssociation
+        #         HasManyThroughAssociation + ThroughAssociation
+
+        def build_association(ass_reflection)
+          # use class name because association_class is the actual class, not an instance of it, so === won't match it
+          ass = case ass_reflection.association_class.name.demodulize   # is it possible to have activerecord without activesupport?
+                when 'HasOneAssociation'
+                  OneToOneAssociation.new(child_table: ass_reflection.table_name,
+                                          foreign_key: ass_reflection.foreign_key,
+                                          parent_table: ass_reflection.active_record.table_name,
+                                          primary_key: ass_reflection.active_record_primary_key)
+
+                # TODO HasOneThroughAssociation
+                # when 'HasOneThroughAssociation'
+
+                when 'HasManyAssociation'
+                  OneToManyAssociation.new(child_table: ass_reflection.table_name,
+                                           foreign_key: ass_reflection.foreign_key,
+                                           parent_table: ass_reflection.active_record.table_name,
+                                           primary_key: ass_reflection.active_record_primary_key)
+
+                when 'BelongsToAssociation'
+                  # pk = ass_reflection.primary_key_column.name
+                  ManyToOneAssociation.new(child_table: ass_reflection.active_record.table_name,
+                                           foreign_key: ass_reflection.foreign_key,
+                                           parent_table: ass_reflection.table_name,
+                                           primary_key: ass_reflection.association_primary_key)
+
+                when 'HasManyThroughAssociation'
+                  join_ass = ass_reflection.through_reflection # has_many through:
+                  left_ass = ManyToOneAssociation.new(child_table: join_ass.table_name,
+                                                      foreign_key: join_ass.foreign_key,
+                                                      parent_table: ass_reflection.active_record.table_name,
+                                                      primary_key: ass_reflection.active_record_primary_key)
+                  right_ass = ManyToOneAssociation.new(child_table: join_ass.table_name,
+                                                       foreign_key: ass_reflection.association_foreign_key,
+                                                       parent_table: ass_reflection.table_name,
+                                                       primary_key: ass_reflection.association_primary_key)
+                  ManyToManyAssociation.new(left_ass, right_ass)
+
+                # TODO BelongsToPolymorphicAssociation
+                # when 'BelongsToPolymorphicAssociation'
+                else
+                  fail "don't yet know how to resolve associations of type '#{ass_reflection.association_class}' model=#{ass_reflection.klass} association=#{ass_reflection.name}"
+                end
+
+          ass.model_class = ass_reflection.klass
+
+          ass.scope = scope_for_association(ass_reflection)
+
+          ass.set_name!(ass_reflection.name)
+          ass
+        end
+
+        # TODO just put the association_reflection in the association and get all the SQL including the JOINs from
+        # the ORM
+        def scope_for_association(ass_reflection)
+          case ActiveRecord::VERSION::MAJOR
+          when 3
+            # in rails 3 ass_reflection.options contains everything except the where
+            non_where_scope = ass_reflection.options.slice(*QUERY_OPTIONS)
+
+            # in rails 3 where is in ass_reflection.options[:conditions]
+            conds = ass_reflection.options[:conditions]
+            conds = conds.call if conds.is_a?(Proc) # options[:conditions] could be a proc that needs to be evaluated
+            scope_hash_from(ass_reflection.klass.where(conds).to_sql).merge(non_where_scope)
+
+            # This one-liner almost works but adds an "AND fk IS NULL" that would need to be extracted out of the where
+            # sql_string = ass_reflection.klass.new.association(ass_name).send(:scoped).to_sql
+
+          when 4
+            # TODO use scope chain for through associations e.g. Broadcast.tracked_conversations
+
+            # With rails 4, it seems there is either a scope on the association reflection (which includes the target
+            # scope) or just a target scope on the association itself
+            sql_string = if scope = ass_reflection.scope
+                ass_reflection.klass.instance_exec(&scope).to_sql
+              else # just use the target scope
+                model_class.new.association(ass_name).send(:target_scope).to_sql
+              end
+
+            scope_hash_from(sql_string)
+          else
+            fail "ActiveRecord version #{ActiveRecord::VERSION::MAJOR}.x is not supported"
+          end
+        end
+
+        # Converts the given identifier to the format needed by ActiveRecord
+        def active_recordize(id)
+          id.to_sym
+        end
+
+      end
+    end
+  end
+end