dart 0.0.1

data/lib/dart/reflection/orm_model_resolver.rb

@@ -0,0 +1,64 @@
+module Dart
+  module Reflection
+    class OrmModelResolver < AbstractResolver
+
+      abstract_method :build_association, :has_column?, :reflection_from
+
+      attr_reader :this_model_class
+      private :this_model_class
+
+      def initialize(model_class)
+        @this_model_class = model_class
+      end
+
+      def build_from_association(association)
+        self.class.new(association.model_class)
+      end
+
+      # Returns the association with the given ass_name or nil if one does not exist
+      # @param [String] ass_name
+      # @return [Association]
+      def association_for(ass_name)
+        if ass_reflection = reflection_from(ass_name)
+          build_association(ass_reflection)
+        end
+      end
+
+      # Returns the column with the given col_name or nil if one does not exist
+      # @param [String] col_name
+      # @return [String]
+      def column_for(col_name)
+        col_name if has_column?(col_name)
+      end
+
+      def table_name
+        this_model_class.table_name.to_s
+      end
+
+      # Helpers
+
+
+      QUERY_OPTIONS = [:where, :order, :limit]
+      QUERY_OPTION_REGEXS = [/WHERE\s*(?<where>.*)/, /ORDER\s+BY\s*(?<order>.*)/, /LIMIT\s*(?<limit>.*)/]
+
+      # Returns parts of the given sql_string in a hash of the form {where: ..., order: ..., limit: ...}
+      def scope_hash_from(sql_string)
+        # TODO: cleanup - this is some of the ugliest code I've ever written
+        result = {}
+        re_start_pairs = QUERY_OPTION_REGEXS.map {|re| [re, sql_string =~ re]}.reject {|_, i| i.nil?}.sort_by {|_, i| i}
+        re_start_pairs.each_with_index do |re_start, i|
+          re, start_index = re_start
+          end_index = -1
+          if next_match = re_start_pairs[i+1]
+            end_index = next_match[1]-1
+          end
+          sql_string[start_index..end_index] =~ re
+          QUERY_OPTIONS.each {|o| result[o] = $~[o].strip if ($~[o] rescue nil)}
+        end
+
+        result
+      end
+
+    end
+  end
+end

data/lib/dart/reflection/sequel/naming_conventions.rb

@@ -0,0 +1,25 @@
+require 'sequel'
+
+module Dart
+  module Reflection
+    module Sequel
+      class NamingConventions < Dart::NamingConventions::AbstractBase
+
+        include ::Sequel::Inflections # for pluralize and singularize
+
+        def conventional_primary_key
+          'id'
+        end
+
+        def foreign_key_regex
+          /_id$/
+        end
+
+      end
+    end
+
+    Dart::NamingConventions.instance = Sequel::NamingConventions.new
+  end
+end
+
+

data/lib/dart/reflection/sequel/sequelizer.rb

@@ -0,0 +1,14 @@
+module Dart
+  module Reflection
+    module Sequel
+      module Sequelizer
+
+        # Converts the given identifier to the format needed by Sequel gem
+        def sequelize(id)
+          id.to_sym
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+module Dart
+  module Reflection
+    module SequelModel
+      class Resolver < OrmModelResolver
+        include Sequel::Sequelizer
+
+        private
+
+        def reflection_from(ass_name)
+          # TODO assert this_model_class == ass_reflection[:model]
+          this_model_class.association_reflection(sequelize(ass_name))
+        end
+
+        def has_column?(col_name)
+          sequelized_col_name = sequelize(col_name)
+          this_model_class.columns.include?(sequelized_col_name)
+        end
+
+        ONE_TO_MANY_TYPE = :one_to_many
+        MANY_TO_ONE_TYPE = :many_to_one
+        MANY_TO_MANY_TYPE = :many_to_many
+
+        def build_association(ass_reflection)
+          associated_model_class = Module.const_get(ass_reflection[:class_name])
+
+          ass = case ass_reflection[:type]
+                when :one_to_one
+                  OneToOneAssociation.new(child_table: associated_model_class.table_name, foreign_key: ass_reflection[:key],
+                                          parent_table: this_model_class.table_name, primary_key: ass_reflection.primary_key)
+
+                when :one_to_many
+                  OneToManyAssociation.new(child_table: associated_model_class.table_name, foreign_key: ass_reflection[:key],
+                                           parent_table: this_model_class.table_name, primary_key: ass_reflection.primary_key)
+
+                when :many_to_one
+                  ManyToOneAssociation.new(child_table: this_model_class.table_name, foreign_key: ass_reflection[:key],
+                                           parent_table: associated_model_class.table_name, primary_key: ass_reflection.primary_key)
+
+                when :many_to_many
+                  left_ass = ManyToOneAssociation.new(child_table: ass_reflection[:join_table], foreign_key: ass_reflection[:left_key],
+                                                      parent_table: this_model_class.table_name, primary_key: ass_reflection[:left_primary_key])
+                  right_ass = ManyToOneAssociation.new(child_table: ass_reflection[:join_table], foreign_key: ass_reflection[:right_key],
+                                                       parent_table: ass_reflection.associated_dataset.first_source, primary_key: ass_reflection.right_primary_key)
+                  ManyToManyAssociation.new(left_ass, right_ass)
+
+                # TODO :one_through_one
+                # when :one_through_one
+
+                else
+                  raise "don't yet know how to resolve associations of type '#{ass_reflection[:type]}' model=#{associated_model_class} association=#{ass_reflection[:name]}"
+                end
+
+          ass.model_class = associated_model_class
+
+          # ass.sql = ass_reflection.associated_dataset.sql
+          ass.scope = scope_for_association(ass_reflection)
+
+          ass.set_name!(ass_reflection[:name])
+          ass
+        end
+
+
+        def scope_for_association(ass_reflection)
+          dataset = ass_reflection.associated_dataset.qualify
+
+          if block = ass_reflection[:block]
+            dataset = dataset.instance_exec(dataset, &block)
+          end
+
+          opts = dataset.opts
+          result = QUERY_OPTIONS.map {|cond| [cond, opts[cond] && dataset.literal_append('', opts[cond])]}
+          Hash[result]
+        end
+
+      end
+    end
+  end
+end

data/lib/dart/reflection/sequel_table/foreign_key_finder.rb

@@ -0,0 +1,50 @@
+module Dart
+  module Reflection
+    module SequelTable
+      class ForeignKeyFinder
+
+        # Returns the set of foreign keys on the given relation based on foreign key constraints defined in the db
+        # @param [Relation] relation the relation to search
+        # @param [Schema] schema defines the set of referenceable tables (and the db to search)
+        # @return [Array<ForeignKeyInfo>] info for foreign keys in the given table and db
+        #
+        def foreign_keys_for(relation, schema)
+          rows = schema.execute!(constraint_query(relation.table_name))
+          rows.all.map { |attrs| ForeignKeyInfo.from_hash(attrs) }
+        end
+
+        private
+
+
+        # @param [String|Symbol] table_name
+        def constraint_query(table_name)
+          # TODO incorporate namespaces
+
+          # TODO reduce coupling with ForeignKeyInfo and Association fields by using constants from that class e.g.
+          # "AS #{ForeignKeyInfo::CHILD_TABLE}"
+
+          <<-CONSTRAINT_QUERY_SQL
+                SELECT pg_constraint.conname AS constraint_name,
+                       pg_class_con.relname AS child_table,
+                       pg_attribute_con.attname AS foreign_key,
+                       pg_class_ref.relname AS parent_table,
+                       pg_attribute_ref.attname AS primary_key
+
+                FROM pg_constraint,
+                     pg_class pg_class_con,
+                     pg_class pg_class_ref,
+                     pg_attribute
+                     pg_attribute_con,
+                     pg_attribute pg_attribute_ref
+
+                WHERE pg_class_con.relname = '#{table_name}' AND pg_constraint.contype = 'f' AND
+                      pg_constraint.conrelid = pg_class_con.oid AND pg_attribute_con.attrelid = pg_constraint.conrelid AND pg_attribute_con.attnum = ANY (pg_constraint.conkey) AND
+                      pg_constraint.confrelid = pg_class_ref.oid AND pg_attribute_ref.attrelid = pg_constraint.confrelid AND pg_attribute_ref.attnum = ANY (pg_constraint.confkey)
+
+          CONSTRAINT_QUERY_SQL
+        end
+
+      end
+    end
+  end
+end

data/lib/dart/reflection/sequel_table/reflector.rb

@@ -0,0 +1,151 @@
+module Dart
+  module Reflection
+    module SequelTable
+      class Reflector
+
+        attr_reader :db
+        private :db
+
+        # @param [String] database_url specifies database to reflect on
+        #
+        def initialize(database_url)
+          @db = ::Sequel.connect(database_url)
+        end
+
+        # @param [Hash] options
+        # @option options exclude_tables an Array or Regexp defining tables to exclude from the reflection
+        # @option options naming_conventions identify direct associations by column naming conventions (e.g. users.group_id => Group one_to_many users)
+        # @return [Array<Relation>]
+        #
+        def get_relations_for_code_gen(options={})
+          schema = get_schema(options)
+          create_join_associations_for_codegen!(schema, options)
+
+          schema.relations
+        end
+
+        # @param [Hash] options
+        # @option options exclude_tables an Array or Regexp defining tables to exclude from the reflection
+        # @option options naming_conventions identify direct associations by column naming conventions (e.g. users.group_id => Group one_to_many users)
+        # @return [Array<Relation>]
+        #
+        def get_schema_for_resolver(options={})
+          schema = get_schema(options)
+          create_join_associations_for_resolver!(schema, options)
+          schema
+        end
+
+        private
+
+        # @param [Hash] options
+        # @option options exclude_tables an Array or Regexp defining tables to exclude from the reflection
+        # @option options naming_conventions identify direct associations by column naming conventions (e.g. users.group_id => Group one_to_many users)
+        # @return [Array<Relation>]
+        #
+        def get_schema(options={})
+          exclude_tables = options.delete(:exclude_tables)
+          db_tables      = case exclude_tables
+                           when Enumerable
+                             db.tables - exclude_tables.map(&:to_sym)
+                           when Regexp
+                             db.tables.reject { |t| exclude_tables.match(t) }
+                           else # don't exclude any tables
+                             db.tables
+                           end
+
+          fk_finder = if options[:naming_conventions]
+                        NamingConventions::ForeignKeyFinder.new
+                      else
+                        SequelTable::ForeignKeyFinder.new
+                      end
+
+
+          schema = Schema.new(db, db_tables)
+          create_direct_associations!(schema, fk_finder)
+          schema
+        end
+
+        def create_direct_associations!(schema, foreign_key_finder)
+          schema.relations.each do |relation|
+            foreign_keys = foreign_key_finder.foreign_keys_for(relation, schema)
+
+            foreign_keys.each do |foreign_key|
+              if one_relation = schema.relation(foreign_key.parent_table)
+                relation.add_many_to_one foreign_key
+                one_relation.add_one_to_many foreign_key
+              else
+                fail "schema does not contain a table named '#{foreign_key.parent_table}'. Perhaps it was excluded accidentally?"
+              end
+            end
+          end
+        end
+
+
+        # there are 2 ways to infer join association names from the database
+        # 1. by assigning short names and then disambiguating conflicts
+        #    example: Group many_to_many :topics, join_table: :topic_assignments
+        # 2. by assigning longs names that don't conflict (either with direct associations or other joins)
+        #    example: Group many_to_many :topic_assignment_topics, join_table: :topic_assignments
+        #
+        # neither method will correctly guess Group many_to_many :assigned_topics, join_table: :topic_assignments
+        #
+        # Method 1 is useful for generating code with suggested association names from an existing db.
+        # Method 2 is useful for resolving association names from the schema. However, a major drawback of 2 is it will
+        #          almost always guess wrong for conventional joins, for example, by generating
+        #          Group many_to_many :groups_users_users, join_table: groups_users
+        #          instead of
+        #          Group many_to_many :users, join_table: groups_users
+        #
+        # Method 2 could be 'improved' by a strictish option that uses long names except in the case where a
+        # conventional join table name is used. The -ish means any combination of 'groups_users', 'group_users',
+        # 'group_user', 'user_groups', etc. is allowed. This can lead to conflicts if there were multiple join tables
+        # that meet the criteria of -ish.
+        #
+        # Or better yet ...
+        #
+        # A resolver could start with some association name, e.g. groups.users and, seeing that there is no direct
+        # association, then look for all possible join tables (i.e. those with parent associations to both users and
+        # groups) and choose the best one (i.e. the one named groups_users, or users_groups, or ...)
+        #
+        # For now, they are one and the same ...
+        #
+        def create_join_associations_for_codegen!(schema, options={})
+          create_join_associations!(schema, options)
+        end
+
+        def create_join_associations_for_resolver!(schema, options={})
+          create_join_associations!(schema, options)
+        end
+
+        def create_join_associations!(schema, options={})
+          schema.relations.each do |relation|
+            relation.possible_join_pairs.each do |ass1, ass2|
+              r1, r2 = schema[ass1.parent_table], schema[ass2.parent_table]
+
+              # skip if either relation already has a direct, conventional association to the other
+              # e.g. don't users many_to_many groups if users has group_id
+              # e.g do users many_to_many groups if users has reporting_group_id (many_to_one reporting_group, and many_to_many groups)
+              next if r1.has_direct_conventional_parent?(r2.table_name) || r2.has_direct_conventional_parent?(r1.table_name)
+
+              r1.add_many_to_many ass1, ass2
+              r2.add_many_to_many ass2, ass1
+            end
+          end
+
+          # By default joins are given short names. When multiple joins conflict on name, we ask the relation to
+          # disambiguate them
+          schema.relations.each(&:disambiguate_conflicting_join_names!)
+
+          schema.relations.each do |relation|
+            relation.duplicate_join_association_names.each do |k, v|
+              puts "AFTER DISAMBIGUATION #{relation} has #{v.count} m2m associations named #{k}"
+            end
+          end
+        end
+
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,60 @@
+module Dart
+  module Reflection
+    module SequelTable
+      class Resolver < AbstractResolver
+
+        attr_reader :relation
+        private :relation
+
+        def initialize(table_name)
+          @table_name = table_name
+          @relation   = TheSchema.instance.relation_for(table_name)
+        end
+
+        def build_from_association(association)
+          self.class.new(association.associated_table)
+        end
+
+        # Returns the association with the given ass_name or nil if one does not exist
+        # @param [String] ass_name
+        # @return [Association]
+        #
+        def association_for(ass_name)
+          ass = relation.all_associations.detect { |ass| ass.name == ass_name }
+          ass.scope = {} # no scope can be determined by SQL reflection
+          ass
+        end
+
+        # Returns the column with the given col_name or nil if one does not exist
+        # @param [String] col_name
+        # @return [String]
+        def column_for(col_name)
+          relation.column_names.detect { |col| col == col_name }
+        end
+
+        def table_name
+          @table_name
+        end
+
+        private
+
+        class TheSchema
+          include Singleton
+
+          def relation_for(table_name)
+            schema[table_name] or raise "no relation for '#{table_name}' was found in the schema"
+          end
+
+          def schema
+            # Dart::Reflection::SequelTable::Reflector.new('postgres://smcc@localhost:5432/iapps_development').get_associations(:groups, naming_conventions: true) # setting naming_conventions to true might cause simple ass names to become more complex
+            @schema ||= begin
+              # TODO Benchmark.realtime
+              Reflector.new('postgres://smcc@localhost:5432/iapps_development').get_schema_for_resolver(exclude_tables: /migration/)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end