dart 0.0.1

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

@@ -0,0 +1,52 @@
+module Dart
+  module Reflection
+    module SequelTable
+
+      # Schema holds all the relations in a schema
+      class Schema
+        include Sequel::Sequelizer
+
+        attr_reader :db, :relation_map
+        private :db, :relation_map
+
+        def initialize(db, db_tables=nil)
+          @db = db
+
+          # default to using all tables unless db_tables is passed in
+          table_names   = (db_tables || db.tables).map(&method(:sequelize))
+          @relation_map = Hash[table_names.map { |table| [table, Database::Relation.new(table, db[table].columns)] }]
+        end
+
+        def execute!(sql)
+          db[sql]
+        end
+
+        # Returns true if this schema has the given table
+        # @param [Symbol|String] table
+        def has_table?(table)
+          tables.include? sequelize(table)
+        end
+
+        # @return [Array<Symbol>] list of table names in this schema
+        def tables
+          relation_map.keys
+        end
+
+        # @return [Array<Relation>] list of +Relations+ in this schema
+        def relations
+          relation_map.values
+        end
+
+        # Returns a relation from this schema corresponding to the given table
+        # @param [Symbol|String] table the name of the table
+        # @return [Relation] the relation corresponding to the given table
+        def relation(table)
+          relation_map[sequelize(table)]
+        end
+        alias [] relation
+
+        private
+      end
+    end
+  end
+end

data/lib/dart/sequel_model_reflection.rb

@@ -0,0 +1,10 @@
+# require 'sequel'
+
+require_relative 'core'
+require_relative 'reflection/sequel/sequelizer'
+
+require_relative 'reflection/abstract_resolver'
+require_relative 'reflection/orm_model_resolver'
+
+require_relative 'reflection/sequel_model/resolver'
+

data/lib/dart/sequel_table_reflection.rb

@@ -0,0 +1,26 @@
+require 'sequel'
+
+# Install the Sequel table based naming conventions and resolver
+require_relative 'core'
+
+# require_relative 'naming_conventions'
+require_relative 'database'
+
+require_relative 'reflection/abstract_resolver'
+
+require_relative 'reflection/sequel/naming_conventions'
+require_relative 'reflection/sequel/sequelizer'
+
+require_relative 'reflection/sequel_table/foreign_key_finder'
+require_relative 'reflection/sequel_table/schema'
+require_relative 'reflection/sequel_table/resolver'
+require_relative 'reflection/sequel_table/reflector'
+
+# Table reflection relies on some naming conventions to discover and name many_to_many associations from foreign keys
+# has_direct_conventional_parent?      - to prevent creation of many_to_many when direct already exists
+# disambiguate_conflicting_join_names! - to allow short names in most cases and only disambiguate in conflicting cases
+
+# If/when we make the resolvers search for possible join tables only when a direct association doesn't exist, then
+# we might be able to decouple sequel table resolvers from naming conventions. However, naming conventions would be very
+# useful to choose the best join association when multiple possibilities exist.
+

data/lib/dart/version.rb

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

data/test/dart/database/many_to_many_association_test.rb

@@ -0,0 +1,80 @@
+require_relative '../../test_helper'
+require_relative '../../../lib/dart/database'
+require_relative '../../../lib/dart/database/test_helpers'
+require_relative '../../../lib/dart/reflection/sequel/naming_conventions' # install Sequel naming conventions
+
+module Dart
+  module Database
+    class ManyToManyAssociationTest < Minitest::Test
+
+      include Dart::Database::TestHelpers
+
+      ##############################################################################################################
+      # describe #disambiguate_name!
+
+      def test_disambiguate_name_with_conventional_join_table
+        join = many_to_many_ass many_to_one_ass(:groups_users, :user_id, :users, :id),
+                                many_to_one_ass(:groups_users, :group_id, :groups, :id)
+        join.disambiguate_name!
+        assert_equal 'groups', join.name
+      end
+
+      def test_disambiguate_name_with_semi_conventional_join_table
+        join = many_to_many_ass many_to_one_ass(:user_groups, :group_id, :groups, :id),
+                                many_to_one_ass(:user_groups, :user_id, :users, :id)
+        join.disambiguate_name!
+        assert_equal 'users', join.name
+      end
+
+      def test_disambiguate_name_with_unconventional_join_table
+        join = many_to_many_ass many_to_one_ass(:membership, :user_id, :users, :id),
+                                many_to_one_ass(:membership, :group_id, :groups, :id)
+        join.disambiguate_name!
+        assert_equal 'membership_groups', join.name
+      end
+
+      def test_disambiguate_name_with_unconventional_left_foreign_key
+        join = many_to_many_ass many_to_one_ass(:user_groups, :member_id, :users, :id),
+                                many_to_one_ass(:user_groups, :groups_id, :groups, :id)
+        join.disambiguate_name!
+        assert_equal 'groups', join.name
+      end
+
+      def test_disambiguate_name_with_unconventional_right_foreign_key
+        join = many_to_many_ass many_to_one_ass(:user_groups, :user_id, :users, :id),
+                                many_to_one_ass(:user_groups, :team_id, :groups, :id)
+        join.disambiguate_name!
+        assert_equal 'teams', join.name
+      end
+
+      def test_disambiguate_name_with_unconventional_left_and_right_foreign_keys
+        join = many_to_many_ass many_to_one_ass(:user_groups, :member_id, :users, :id),
+                                many_to_one_ass(:user_groups, :team_id, :groups, :id)
+        join.disambiguate_name!
+        assert_equal 'teams', join.name
+      end
+
+      def test_disambiguate_name_with_unconventional_join_table_and_left_foreign_key
+        join = many_to_many_ass many_to_one_ass(:membership, :member_id, :users, :id),
+                                many_to_one_ass(:membership, :group_id, :items, :id)
+        join.disambiguate_name!
+        assert_equal 'membership_member_id_groups', join.name
+      end
+
+      def test_disambiguate_name_with_unconventional_join_table_and_right_foreign_key
+        join = many_to_many_ass many_to_one_ass(:membership, :user_id, :users, :id),
+                                many_to_one_ass(:membership, :team_id, :items, :id)
+        join.disambiguate_name!
+        assert_equal 'membership_teams', join.name
+      end
+
+      def test_disambiguate_name_with_unconventional_join_table_and_left_and_right_foreign_keys
+        join = many_to_many_ass many_to_one_ass(:membership, :member_id, :users, :id),
+                                many_to_one_ass(:membership, :team_id, :items, :id)
+        join.disambiguate_name!
+        assert_equal 'membership_member_id_teams', join.name
+      end
+
+    end
+  end
+end

data/test/dart/naming_conventions/abstract_base_test.rb

@@ -0,0 +1,38 @@
+require_relative '../../test_helper'
+require_relative '../../../lib/dart/naming_conventions'
+require_relative '../../../lib/dart/reflection/sequel/naming_conventions' # install Sequel naming conventions
+
+module Dart
+  module NamingConventions
+    class AbstractBaseTest < Minitest::Test
+
+      def subject
+        NamingConventions.instance
+      end
+
+      def test_parent_table_for # (possible_foreign_key)
+        assert_equal 'groups', subject.parent_table_for('group_id')
+        assert_nil subject.parent_table_for('created_by')
+      end
+
+      def test_singular_association_name # (foreign_key)
+        assert_equal 'group', subject.singular_association_name('group_id')
+      end
+
+      def test_plural_association_name # (foreign_key)
+        assert_equal 'groups', subject.plural_association_name('group_id')
+      end
+
+      def test_long_association_name # (join_table, left_key, left_table, right_key)
+        assert_equal 'topic_assignment_users', subject.long_association_name('topic_assignments', 'group_id', 'groups', 'user_id')
+        assert_equal 'broadcast_created_by_items', subject.long_association_name('broadcasts', 'created_by', 'users', 'item_id')
+      end
+
+      def test_conventional_join_table_names # (left_table_name, right_table_name)
+        expected = %w(groups_users group_users groups_user group_user users_groups user_groups users_group user_group)
+        assert_equal expected.sort, subject.conventional_join_table_names('users', 'groups').sort
+      end
+
+    end
+  end
+end

data/test/dart/reflection/orm_model_resolver_test.rb

@@ -0,0 +1,66 @@
+require_relative '../../test_helper'
+require 'dart/sequel_model_reflection'
+
+module Dart
+  module Reflection
+    class OrmModelResolverTest < Minitest::Test
+
+      # describe #scope_hash_from
+
+      def subject
+        model_class = OpenStruct.new
+        OrmModelResolver.new(model_class)
+      end
+
+      def test_scope_hash_from_select_only
+        sql = "SELECT * FROM users"
+        actual = subject.scope_hash_from(sql)
+        assert_nil actual[:where]
+        assert_nil actual[:order]
+        assert_nil actual[:limit]
+      end
+
+      def test_scope_hash_from_where
+        expected_where = "occupation = 'Brewer' AND first_name = 'Samuel'"
+        sql = "SELECT * FROM users WHERE #{expected_where}"
+        actual = subject.scope_hash_from(sql)
+        assert_equal expected_where, actual[:where]
+        assert_nil actual[:order]
+        assert_nil actual[:limit]
+      end
+
+      def test_scope_hash_from_where_order
+        expected_where = "occupation = 'Brewer' AND first_name = 'Samuel'"
+        expected_order = '"users"."last_name" ASC'
+        sql = "SELECT * FROM users WHERE #{expected_where} ORDER BY #{expected_order}"
+        actual = subject.scope_hash_from(sql)
+        assert_equal expected_where, actual[:where]
+        assert_equal expected_order, actual[:order]
+        assert_nil actual[:limit]
+      end
+
+      def test_scope_hash_from_where_order_limit
+        expected_where = "occupation = 'Brewer' AND first_name = 'Samuel'"
+        expected_order = '"users"."last_name" ASC'
+        expected_limit = '5'
+        sql = "SELECT * FROM users WHERE #{expected_where} ORDER BY #{expected_order} LIMIT #{expected_limit}"
+        actual = subject.scope_hash_from(sql)
+        assert_equal expected_where, actual[:where]
+        assert_equal expected_order, actual[:order]
+        assert_equal expected_limit, actual[:limit]
+      end
+
+      def test_scope_hash_from_order_limit
+        expected_order = '"users"."last_name" ASC'
+        expected_limit = '5'
+        sql = "SELECT * FROM users ORDER BY #{expected_order} LIMIT #{expected_limit}"
+        actual = subject.scope_hash_from(sql)
+        assert_nil actual[:where]
+        assert_equal expected_order, actual[:order]
+        assert_equal expected_limit, actual[:limit]
+      end
+
+
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'minitest/autorun'
+
+require 'dart'
+
+
+

metadata

@@ -0,0 +1,182 @@
+--- !ruby/object:Gem::Specification
+name: dart
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ed Posnak
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: abstract_method
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: database association resolver toolkit for postgres, activemodel, sequel,
+  etc.
+email:
+- ed.posnak@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dart.gemspec
+- lib/dart.rb
+- lib/dart/active_record_model_reflection.rb
+- lib/dart/core.rb
+- lib/dart/core/association.rb
+- lib/dart/core/direct_association.rb
+- lib/dart/core/foreign_key_info.rb
+- lib/dart/core/many_to_many_association.rb
+- lib/dart/core/many_to_one_association.rb
+- lib/dart/core/one_to_many_association.rb
+- lib/dart/core/one_to_one_association.rb
+- lib/dart/core/relation.rb
+- lib/dart/database.rb
+- lib/dart/database/many_to_many_association.rb
+- lib/dart/database/many_to_one_association.rb
+- lib/dart/database/one_to_many_association.rb
+- lib/dart/database/relation.rb
+- lib/dart/database/test_helpers.rb
+- lib/dart/naming_conventions.rb
+- lib/dart/naming_conventions/abstract_base.rb
+- lib/dart/naming_conventions/association_helpers.rb
+- lib/dart/naming_conventions/direct_association_helpers.rb
+- lib/dart/naming_conventions/foreign_key_finder.rb
+- lib/dart/naming_conventions/many_to_many_association_helpers.rb
+- lib/dart/naming_conventions/many_to_one_association_helpers.rb
+- lib/dart/naming_conventions/one_to_many_association_helpers.rb
+- lib/dart/naming_conventions/relation_helpers.rb
+- lib/dart/reflection/abstract_resolver.rb
+- lib/dart/reflection/active_record_model/resolver.rb
+- lib/dart/reflection/orm_model_resolver.rb
+- lib/dart/reflection/sequel/naming_conventions.rb
+- lib/dart/reflection/sequel/sequelizer.rb
+- lib/dart/reflection/sequel_model/resolver.rb
+- lib/dart/reflection/sequel_table/foreign_key_finder.rb
+- lib/dart/reflection/sequel_table/reflector.rb
+- lib/dart/reflection/sequel_table/resolver.rb
+- lib/dart/reflection/sequel_table/schema.rb
+- lib/dart/sequel_model_reflection.rb
+- lib/dart/sequel_table_reflection.rb
+- lib/dart/version.rb
+- test/dart/database/many_to_many_association_test.rb
+- test/dart/naming_conventions/abstract_base_test.rb
+- test/dart/reflection/orm_model_resolver_test.rb
+- test/test_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: database association resolver toolkit
+test_files:
+- test/dart/database/many_to_many_association_test.rb
+- test/dart/naming_conventions/abstract_base_test.rb
+- test/dart/reflection/orm_model_resolver_test.rb
+- test/test_helper.rb