dynamic_migrations 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd85087e52878be82f2733bc12a2949cff8cd25b5b52a6b0e820e760ad7d8ea0
-  data.tar.gz: a22b55bec2b78053ccca5541eeb55b33c78007d01f5af22997b8498a8631fbbb
+  metadata.gz: d576c2761325b577a0e175e24a59833dc595212900f953ee494d71d4a635beef
+  data.tar.gz: 47911ce666cdd465a8f57a54263155c92ba8d37339cf7bf3c2a6a3fcde549e99
 SHA512:
-  metadata.gz: c5a4322f59ab8d3fd626136633f6a9e1faeab846fb3165257a216347d232a5ea44363e0d9b0fc4ebad8a128e05beb0a78e9cbefe6710d6312cd5d4326e976747
-  data.tar.gz: 387790fda8976ade419f384e70171e2a89c1392756d8aae4e5915230a90dcb27eaf1a256f241f55dc0296d31f67bee6c565528194bda0e97e0c849d18ea7e663
+  metadata.gz: 6a05c58150c20cdf1a19f14e2d931e7a48e4220531cc5f1f25d9cf0740554fe01a3b3db7e2ea7e12d4d06732c0fa472fdd6652cf27fffdad8a82039f73163eeb
+  data.tar.gz: 0ae100cf8c850cde3de93c4fd86df3487c1b4f7b7f25de65d9fab6b0dfde020bf4d4f09b802c37c92fe5d26fb0b6b73d12d641cb6f6c0fb3567e8e97f047ce87

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [2.0.0](https://github.com/craigulliott/dynamic_migrations/compare/v1.1.1...v2.0.0) (2023-07-27)
+
+
+### ⚠ BREAKING CHANGES
+
+* changing all name related methods from %object%_name to just name (i.e. `table.table_name` is now just `table.name`)
+
+### Features
+
+* changing all name related methods from %object%_name to just name (i.e. `table.table_name` is now just `table.name`) ([77f18ae](https://github.com/craigulliott/dynamic_migrations/commit/77f18ae168c2449fa437fa7692ff9339931f9076))
+
 ## [1.1.1](https://github.com/craigulliott/dynamic_migrations/compare/v1.1.0...v1.1.1) (2023-07-17)
 
 

data/lib/dynamic_migrations/postgres/server/database/connection.rb

@@ -15,9 +15,9 @@ module DynamicMigrations
           end
 
           def connect
-            raise MissingDatabaseNameError unless database_name
+            raise MissingDatabaseNameError unless name
             raise AlreadyConnectedError if @connection
-            @connection = Postgres::Connections.create_connection server.host, server.port, server.username, server.password, database_name
+            @connection = Postgres::Connections.create_connection server.host, server.port, server.username, server.password, name
           end
 
           def connection

data/lib/dynamic_migrations/postgres/server/database/differences.rb

@@ -107,7 +107,7 @@ module DynamicMigrations
                 matches: (comparison_table && comparison_table.description == table.description) || false
               },
               primary_key: compare_record(primary_key, comparison_primary_key, [
-                :primary_key_name,
+                :name,
                 :index_type
               ]),
               columns: compare_columns(table.columns_hash, comparison_columns),
@@ -159,9 +159,9 @@ module DynamicMigrations
           def self.compare_unique_constraints unique_constraints, comparison_unique_constraints
             result = {}
             # the base unique_constraints
-            unique_constraints.each do |unique_constraint_name, unique_constraint|
+            unique_constraints.each do |name, unique_constraint|
               # compare this unique_constraint to the equivilent in the comparison list
-              result[unique_constraint_name] = compare_record unique_constraint, comparison_unique_constraints[unique_constraint_name], [
+              result[name] = compare_record unique_constraint, comparison_unique_constraints[name], [
                 :column_names,
                 :index_type,
                 :deferrable,
@@ -169,9 +169,9 @@ module DynamicMigrations
               ]
             end
             # look for any unique_constraints in the comparison list which were not in the base list
-            comparison_unique_constraints.each do |unique_constraint_name, unique_constraint|
-              unless result.key? unique_constraint_name
-                result[unique_constraint_name] = {
+            comparison_unique_constraints.each do |name, unique_constraint|
+              unless result.key? name
+                result[name] = {
                   exists: false
                 }
               end
@@ -185,9 +185,9 @@ module DynamicMigrations
           def self.compare_indexes indexes, comparison_indexes
             result = {}
             # the base indexes
-            indexes.each do |index_name, index|
+            indexes.each do |name, index|
               # compare this index to the equivilent in the comparison list
-              result[index_name] = compare_record index, comparison_indexes[index_name], [
+              result[name] = compare_record index, comparison_indexes[name], [
                 :column_names,
                 :unique,
                 :where,
@@ -199,9 +199,9 @@ module DynamicMigrations
               ]
             end
             # look for any indexes in the comparison list which were not in the base list
-            comparison_indexes.each do |index_name, index|
-              unless result.key? index_name
-                result[index_name] = {
+            comparison_indexes.each do |name, index|
+              unless result.key? name
+                result[name] = {
                   exists: false
                 }
               end
@@ -215,9 +215,9 @@ module DynamicMigrations
           def self.compare_validations validations, comparison_validations
             result = {}
             # the base validations
-            validations.each do |validation_name, validation|
+            validations.each do |name, validation|
               # compare this validation to the equivilent in the comparison list
-              result[validation_name] = compare_record validation, comparison_validations[validation_name], [
+              result[name] = compare_record validation, comparison_validations[name], [
                 :check_clause,
                 :column_names,
                 :deferrable,
@@ -225,9 +225,9 @@ module DynamicMigrations
               ]
             end
             # look for any validations in the comparison list which were not in the base list
-            comparison_validations.each do |validation_name, validation|
-              unless result.key? validation_name
-                result[validation_name] = {
+            comparison_validations.each do |name, validation|
+              unless result.key? name
+                result[name] = {
                   exists: false
                 }
               end
@@ -241,9 +241,9 @@ module DynamicMigrations
           def self.compare_foreign_key_constraints foreign_key_constraints, comparison_foreign_key_constraints
             result = {}
             # the base foreign_key_constraints
-            foreign_key_constraints.each do |foreign_key_constraint_name, foreign_key_constraint|
+            foreign_key_constraints.each do |name, foreign_key_constraint|
               # compare this foreign_key_constraint to the equivilent in the comparison list
-              result[foreign_key_constraint_name] = compare_record foreign_key_constraint, comparison_foreign_key_constraints[foreign_key_constraint_name], [
+              result[name] = compare_record foreign_key_constraint, comparison_foreign_key_constraints[name], [
                 :column_names,
                 :foreign_schema_name,
                 :foreign_table_name,
@@ -253,9 +253,9 @@ module DynamicMigrations
               ]
             end
             # look for any foreign_key_constraints in the comparison list which were not in the base list
-            comparison_foreign_key_constraints.each do |foreign_key_constraint_name, foreign_key_constraint|
-              unless result.key? foreign_key_constraint_name
-                result[foreign_key_constraint_name] = {
+            comparison_foreign_key_constraints.each do |name, foreign_key_constraint|
+              unless result.key? name
+                result[name] = {
                   exists: false
                 }
               end

data/lib/dynamic_migrations/postgres/server/database/schema/table/column.rb

@@ -12,7 +12,7 @@ module DynamicMigrations
               end
 
               attr_reader :table
-              attr_reader :column_name
+              attr_reader :name
               attr_reader :description
               attr_reader :null
               attr_reader :default
@@ -29,13 +29,13 @@ module DynamicMigrations
               attr_reader :updatable
 
               # initialize a new object to represent a column in a postgres table
-              def initialize source, table, column_name, data_type, null: true, default: nil, description: nil, character_maximum_length: nil, character_octet_length: nil, numeric_precision: nil, numeric_precision_radix: nil, numeric_scale: nil, datetime_precision: nil, interval_type: nil, udt_schema: nil, udt_name: nil, updatable: true
+              def initialize source, table, name, data_type, null: true, default: nil, description: nil, character_maximum_length: nil, character_octet_length: nil, numeric_precision: nil, numeric_precision_radix: nil, numeric_scale: nil, datetime_precision: nil, interval_type: nil, udt_schema: nil, udt_name: nil, updatable: true
                 super source
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
 
-                raise ExpectedSymbolError, column_name unless column_name.is_a? Symbol
-                @column_name = column_name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @name = name
 
                 @data_type = data_type
 

data/lib/dynamic_migrations/postgres/server/database/schema/table/columns.rb

@@ -16,16 +16,16 @@ module DynamicMigrations
 
               # returns the column object for the provided column name, and raises an
               # error if the column does not exist
-              def column column_name
-                raise ExpectedSymbolError, column_name unless column_name.is_a? Symbol
-                raise ColumnDoesNotExistError unless has_column? column_name
-                @columns[column_name]
+              def column name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                raise ColumnDoesNotExistError unless has_column? name
+                @columns[name]
               end
 
               # returns true if this table has a column with the provided name, otherwise false
-              def has_column? column_name
-                raise ExpectedSymbolError, column_name unless column_name.is_a? Symbol
-                @columns.key? column_name
+              def has_column? name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @columns.key? name
               end
 
               # returns an array of this tables columns
@@ -38,20 +38,20 @@ module DynamicMigrations
               end
 
               # adds a new column to this table, and returns it
-              def add_column column_name, data_type, **column_options
-                if has_column? column_name
-                  raise(DuplicateColumnError, "Column #{column_name} already exists")
+              def add_column name, data_type, **column_options
+                if has_column? name
+                  raise(DuplicateColumnError, "Column #{name} already exists")
                 end
                 included_target = self
                 if included_target.is_a? Table
-                  new_column = @columns[column_name] = Column.new source, included_target, column_name, data_type, **column_options
+                  new_column = @columns[name] = Column.new source, included_target, name, data_type, **column_options
                 else
                   raise ModuleIncludedIntoUnexpectedTargetError, included_target
                 end
                 # sort the hash so that the columns are in alphabetical order by name
                 sorted_columns = {}
-                @columns.keys.sort.each do |column_name|
-                  sorted_columns[column_name] = @columns[column_name]
+                @columns.keys.sort.each do |name|
+                  sorted_columns[name] = @columns[name]
                 end
                 @columns = sorted_columns
                 # return the new column

data/lib/dynamic_migrations/postgres/server/database/schema/table/foreign_key_constraint.rb

@@ -22,12 +22,12 @@ module DynamicMigrations
 
               attr_reader :table
               attr_reader :foreign_table
-              attr_reader :foreign_key_constraint_name
+              attr_reader :name
               attr_reader :deferrable
               attr_reader :initially_deferred
 
               # initialize a new object to represent a foreign_key_constraint in a postgres table
-              def initialize source, table, columns, foreign_table, foreign_columns, foreign_key_constraint_name, deferrable: false, initially_deferred: false
+              def initialize source, table, columns, foreign_table, foreign_columns, name, deferrable: false, initially_deferred: false
                 super source
 
                 raise ExpectedTableError, table unless table.is_a? Table
@@ -43,7 +43,7 @@ module DynamicMigrations
                   raise ExpectedArrayOfColumnsError
                 end
 
-                if table.table_name == foreign_table.table_name && table.schema.schema_name == foreign_table.schema.schema_name
+                if table.name == foreign_table.name && table.schema.name == foreign_table.schema.name
                   raise ExpectedDifferentTablesError
                 end
 
@@ -61,8 +61,8 @@ module DynamicMigrations
                   add_column column, true
                 end
 
-                raise ExpectedSymbolError, foreign_key_constraint_name unless foreign_key_constraint_name.is_a? Symbol
-                @foreign_key_constraint_name = foreign_key_constraint_name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @name = name
 
                 raise ExpectedBooleanError, deferrable unless [true, false].include?(deferrable)
                 @deferrable = deferrable
@@ -88,11 +88,11 @@ module DynamicMigrations
               end
 
               def foreign_schema_name
-                @foreign_table.schema.schema_name
+                @foreign_table.schema.name
               end
 
               def foreign_table_name
-                @foreign_table.table_name
+                @foreign_table.name
               end
 
               private
@@ -113,15 +113,15 @@ module DynamicMigrations
                 end
 
                 # assert that the provided column exists within this foreign_key_constraints table
-                unless t.has_column? column.column_name
+                unless t.has_column? column.name
                   raise ExpectedArrayOfColumnsError, "One or more columns do not exist in this foreign_key_constraints table"
                 end
 
-                if cs.key? column.column_name
-                  raise(DuplicateColumnError, "Column #{column.column_name} already exists")
+                if cs.key? column.name
+                  raise(DuplicateColumnError, "Column #{column.name} already exists")
                 end
 
-                cs[column.column_name] = column
+                cs[column.name] = column
               end
             end
           end

data/lib/dynamic_migrations/postgres/server/database/schema/table/foreign_key_constraints.rb

@@ -16,16 +16,16 @@ module DynamicMigrations
 
               # returns the foreign_key_constraint object for the provided foreign_key_constraint name, and raises an
               # error if the foreign_key_constraint does not exist
-              def foreign_key_constraint foreign_key_constraint_name
-                raise ExpectedSymbolError, foreign_key_constraint_name unless foreign_key_constraint_name.is_a? Symbol
-                raise ForeignKeyConstraintDoesNotExistError unless has_foreign_key_constraint? foreign_key_constraint_name
-                @foreign_key_constraints[foreign_key_constraint_name]
+              def foreign_key_constraint name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                raise ForeignKeyConstraintDoesNotExistError unless has_foreign_key_constraint? name
+                @foreign_key_constraints[name]
               end
 
               # returns true if this table has a foreign_key_constraint with the provided name, otherwise false
-              def has_foreign_key_constraint? foreign_key_constraint_name
-                raise ExpectedSymbolError, foreign_key_constraint_name unless foreign_key_constraint_name.is_a? Symbol
-                @foreign_key_constraints.key? foreign_key_constraint_name
+              def has_foreign_key_constraint? name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @foreign_key_constraints.key? name
               end
 
               # returns an array of this tables foreign_key_constraints
@@ -38,9 +38,9 @@ module DynamicMigrations
               end
 
               # adds a new foreign_key_constraint to this table, and returns it
-              def add_foreign_key_constraint foreign_key_constraint_name, column_names, foreign_schema_name, foreign_table_name, foreign_column_names, **foreign_key_constraint_options
-                if has_foreign_key_constraint? foreign_key_constraint_name
-                  raise(ForeignKeyConstraintAlreadyExistsError, "foreign_key_constraint #{foreign_key_constraint_name} already exists")
+              def add_foreign_key_constraint name, column_names, foreign_schema_name, foreign_table_name, foreign_column_names, **foreign_key_constraint_options
+                if has_foreign_key_constraint? name
+                  raise(ForeignKeyConstraintAlreadyExistsError, "foreign_key_constraint #{name} already exists")
                 end
                 columns = column_names.map { |column_name| column column_name }
                 foreign_schema = schema.database.schema foreign_schema_name, source
@@ -48,14 +48,14 @@ module DynamicMigrations
                 foreign_columns = foreign_column_names.map { |column_name| foreign_table.column column_name }
                 included_target = self
                 if included_target.is_a? Table
-                  new_foreign_key_constraint = @foreign_key_constraints[foreign_key_constraint_name] = ForeignKeyConstraint.new source, included_target, columns, foreign_table, foreign_columns, foreign_key_constraint_name, **foreign_key_constraint_options
+                  new_foreign_key_constraint = @foreign_key_constraints[name] = ForeignKeyConstraint.new source, included_target, columns, foreign_table, foreign_columns, name, **foreign_key_constraint_options
                 else
                   raise ModuleIncludedIntoUnexpectedTargetError, included_target
                 end
                 # sort the hash so that the foreign_key_constraints are in alphabetical order by name
                 sorted_foreign_key_constraints = {}
-                @foreign_key_constraints.keys.sort.each do |foreign_key_constraint_name|
-                  sorted_foreign_key_constraints[foreign_key_constraint_name] = @foreign_key_constraints[foreign_key_constraint_name]
+                @foreign_key_constraints.keys.sort.each do |name|
+                  sorted_foreign_key_constraints[name] = @foreign_key_constraints[name]
                 end
                 @foreign_key_constraints = sorted_foreign_key_constraints
                 # return the new foreign_key_constraint

data/lib/dynamic_migrations/postgres/server/database/schema/table/index.rb

@@ -31,7 +31,7 @@ module DynamicMigrations
               end
 
               attr_reader :table
-              attr_reader :index_name
+              attr_reader :name
               attr_reader :unique
               attr_reader :where
               attr_reader :type
@@ -41,7 +41,7 @@ module DynamicMigrations
               attr_reader :nulls_position
 
               # initialize a new object to represent a index in a postgres table
-              def initialize source, table, columns, index_name, unique: false, where: nil, type: :btree, deferrable: false, initially_deferred: false, include_columns: [], order: :asc, nulls_position: :last
+              def initialize source, table, columns, name, unique: false, where: nil, type: :btree, deferrable: false, initially_deferred: false, include_columns: [], order: :asc, nulls_position: :last
                 super source
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
@@ -57,8 +57,8 @@ module DynamicMigrations
                   add_column column
                 end
 
-                raise ExpectedSymbolError, index_name unless index_name.is_a? Symbol
-                @index_name = index_name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @name = name
 
                 raise ExpectedBooleanError, unique unless [true, false].include?(unique)
                 @unique = unique
@@ -121,18 +121,18 @@ module DynamicMigrations
                 end
 
                 # assert that the provided column exists within this indexes table
-                unless @table.has_column? column.column_name
+                unless @table.has_column? column.name
                   raise ExpectedArrayOfColumnsError, "One or more columns do not exist in this indexes table"
                 end
 
-                if @columns.key?(column.column_name) || @include_columns.key?(column.column_name)
-                  raise(DuplicateColumnError, "Column #{column.column_name} already exists in index, or is already included")
+                if @columns.key?(column.name) || @include_columns.key?(column.name)
+                  raise(DuplicateColumnError, "Column #{column.name} already exists in index, or is already included")
                 end
 
                 if is_include_column
-                  @include_columns[column.column_name] = column
+                  @include_columns[column.name] = column
                 else
-                  @columns[column.column_name] = column
+                  @columns[column.name] = column
                 end
               end
             end

data/lib/dynamic_migrations/postgres/server/database/schema/table/indexes.rb

@@ -16,16 +16,16 @@ module DynamicMigrations
 
               # returns the index object for the provided index name, and raises an
               # error if the index does not exist
-              def index index_name
-                raise ExpectedSymbolError, index_name unless index_name.is_a? Symbol
-                raise IndexDoesNotExistError unless has_index? index_name
-                @indexes[index_name]
+              def index name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                raise IndexDoesNotExistError unless has_index? name
+                @indexes[name]
               end
 
               # returns true if this table has a index with the provided name, otherwise false
-              def has_index? index_name
-                raise ExpectedSymbolError, index_name unless index_name.is_a? Symbol
-                @indexes.key? index_name
+              def has_index? name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @indexes.key? name
               end
 
               # returns an array of this tables indexes
@@ -41,22 +41,22 @@ module DynamicMigrations
               # include_column_names in broken out from index_options, because it is converted from an
               # array of column names into an array of columns, and then recombined with the other
               # options which are sent to the index initialize method
-              def add_index index_name, column_names, include_column_names: [], **index_options
-                if has_index? index_name
-                  raise(IndexAlreadyExistsError, "index #{index_name} already exists")
+              def add_index name, column_names, include_column_names: [], **index_options
+                if has_index? name
+                  raise(IndexAlreadyExistsError, "index #{name} already exists")
                 end
                 columns = column_names.map { |column_name| column column_name }
                 include_columns = include_column_names.map { |column_name| column column_name }
                 included_target = self
                 if included_target.is_a? Table
-                  new_index = @indexes[index_name] = Index.new source, included_target, columns, index_name, include_columns: include_columns, **index_options
+                  new_index = @indexes[name] = Index.new source, included_target, columns, name, include_columns: include_columns, **index_options
                 else
                   raise ModuleIncludedIntoUnexpectedTargetError, included_target
                 end
                 # sort the hash so that the indexes are in alphabetical order by name
                 sorted_indexes = {}
-                @indexes.keys.sort.each do |index_name|
-                  sorted_indexes[index_name] = @indexes[index_name]
+                @indexes.keys.sort.each do |name|
+                  sorted_indexes[name] = @indexes[name]
                 end
                 @indexes = sorted_indexes
                 # return the new index

data/lib/dynamic_migrations/postgres/server/database/schema/table/primary_key.rb

@@ -23,11 +23,11 @@ module DynamicMigrations
               end
 
               attr_reader :table
-              attr_reader :primary_key_name
+              attr_reader :name
               attr_reader :index_type
 
               # initialize a new object to represent a primary_key in a postgres table
-              def initialize source, table, columns, primary_key_name, index_type: :btree
+              def initialize source, table, columns, name, index_type: :btree
                 super source
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
@@ -42,8 +42,8 @@ module DynamicMigrations
                   add_column column
                 end
 
-                raise ExpectedSymbolError, primary_key_name unless primary_key_name.is_a? Symbol
-                @primary_key_name = primary_key_name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @name = name
 
                 raise UnexpectedIndexTypeError, index_type unless INDEX_TYPES.include?(index_type)
                 @index_type = index_type
@@ -64,15 +64,15 @@ module DynamicMigrations
                 end
 
                 # assert that the provided column exists within this primary keys table
-                unless @table.has_column? column.column_name
+                unless @table.has_column? column.name
                   raise ExpectedArrayOfColumnsError, "One or more columns do not exist in this primary keys table"
                 end
 
-                if @columns.key?(column.column_name)
-                  raise(DuplicateColumnError, "Column #{column.column_name} already exists in primary_key, or is already included")
+                if @columns.key?(column.name)
+                  raise(DuplicateColumnError, "Column #{column.name} already exists in primary_key, or is already included")
                 end
 
-                @columns[column.column_name] = column
+                @columns[column.name] = column
               end
             end
           end

data/lib/dynamic_migrations/postgres/server/database/schema/table/unique_constraint.rb

@@ -29,13 +29,13 @@ module DynamicMigrations
               end
 
               attr_reader :table
-              attr_reader :unique_constraint_name
+              attr_reader :name
               attr_reader :index_type
               attr_reader :deferrable
               attr_reader :initially_deferred
 
               # initialize a new object to represent a unique_constraint in a postgres table
-              def initialize source, table, columns, unique_constraint_name, index_type: :btree, deferrable: false, initially_deferred: false
+              def initialize source, table, columns, name, index_type: :btree, deferrable: false, initially_deferred: false
                 super source
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
@@ -50,8 +50,8 @@ module DynamicMigrations
                   add_column column
                 end
 
-                raise ExpectedSymbolError, unique_constraint_name unless unique_constraint_name.is_a? Symbol
-                @unique_constraint_name = unique_constraint_name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @name = name
 
                 raise UnexpectedIndexTypeError, index_type unless INDEX_TYPES.include?(index_type)
                 @index_type = index_type
@@ -82,15 +82,15 @@ module DynamicMigrations
                 end
 
                 # assert that the provided column exists within this unique_constraints table
-                unless @table.has_column? column.column_name
+                unless @table.has_column? column.name
                   raise ExpectedArrayOfColumnsError, "One or more columns do not exist in this unique_constraints table"
                 end
 
-                if @columns.key?(column.column_name)
-                  raise(DuplicateColumnError, "Column #{column.column_name} already exists in unique_constraint, or is already included")
+                if @columns.key?(column.name)
+                  raise(DuplicateColumnError, "Column #{column.name} already exists in unique_constraint, or is already included")
                 end
 
-                @columns[column.column_name] = column
+                @columns[column.name] = column
               end
             end
           end

data/lib/dynamic_migrations/postgres/server/database/schema/table/unique_constraints.rb

@@ -16,16 +16,16 @@ module DynamicMigrations
 
               # returns the unique_constraint object for the provided unique_constraint name, and raises an
               # error if the unique_constraint does not exist
-              def unique_constraint unique_constraint_name
-                raise ExpectedSymbolError, unique_constraint_name unless unique_constraint_name.is_a? Symbol
-                raise UniqueConstraintDoesNotExistError unless has_unique_constraint? unique_constraint_name
-                @unique_constraints[unique_constraint_name]
+              def unique_constraint name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                raise UniqueConstraintDoesNotExistError unless has_unique_constraint? name
+                @unique_constraints[name]
               end
 
               # returns true if this table has a unique_constraint with the provided name, otherwise false
-              def has_unique_constraint? unique_constraint_name
-                raise ExpectedSymbolError, unique_constraint_name unless unique_constraint_name.is_a? Symbol
-                @unique_constraints.key? unique_constraint_name
+              def has_unique_constraint? name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @unique_constraints.key? name
               end
 
               # returns an array of this tables unique_constraints
@@ -38,21 +38,21 @@ module DynamicMigrations
               end
 
               # adds a new unique_constraint to this table, and returns it
-              def add_unique_constraint unique_constraint_name, column_names, **unique_constraint_options
-                if has_unique_constraint? unique_constraint_name
-                  raise(UniqueConstraintAlreadyExistsError, "unique_constraint #{unique_constraint_name} already exists")
+              def add_unique_constraint name, column_names, **unique_constraint_options
+                if has_unique_constraint? name
+                  raise(UniqueConstraintAlreadyExistsError, "unique_constraint #{name} already exists")
                 end
                 columns = column_names.map { |column_name| column column_name }
                 included_target = self
                 if included_target.is_a? Table
-                  new_unique_constraint = @unique_constraints[unique_constraint_name] = UniqueConstraint.new source, included_target, columns, unique_constraint_name, **unique_constraint_options
+                  new_unique_constraint = @unique_constraints[name] = UniqueConstraint.new source, included_target, columns, name, **unique_constraint_options
                 else
                   raise ModuleIncludedIntoUnexpectedTargetError, included_target
                 end
                 # sort the hash so that the unique_constraints are in alphabetical order by name
                 sorted_unique_constraints = {}
-                @unique_constraints.keys.sort.each do |unique_constraint_name|
-                  sorted_unique_constraints[unique_constraint_name] = @unique_constraints[unique_constraint_name]
+                @unique_constraints.keys.sort.each do |name|
+                  sorted_unique_constraints[name] = @unique_constraints[name]
                 end
                 @unique_constraints = sorted_unique_constraints
                 # return the new unique_constraint

data/lib/dynamic_migrations/postgres/server/database/schema/table/validation.rb

@@ -18,13 +18,13 @@ module DynamicMigrations
               end
 
               attr_reader :table
-              attr_reader :validation_name
+              attr_reader :name
               attr_reader :check_clause
               attr_reader :deferrable
               attr_reader :initially_deferred
 
               # initialize a new object to represent a validation in a postgres table
-              def initialize source, table, columns, validation_name, check_clause, deferrable: false, initially_deferred: false
+              def initialize source, table, columns, name, check_clause, deferrable: false, initially_deferred: false
                 super source
                 raise ExpectedTableError, table unless table.is_a? Table
                 @table = table
@@ -39,8 +39,8 @@ module DynamicMigrations
                   add_column column
                 end
 
-                raise ExpectedSymbolError, validation_name unless validation_name.is_a? Symbol
-                @validation_name = validation_name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @name = name
 
                 raise ExpectedStringError, check_clause unless check_clause.is_a? String
                 @check_clause = check_clause
@@ -71,15 +71,15 @@ module DynamicMigrations
                 end
 
                 # assert that the provided column exists within this validations table
-                unless @table.has_column? column.column_name
+                unless @table.has_column? column.name
                   raise ExpectedArrayOfColumnsError, "One or more columns do not exist in this validations table"
                 end
 
-                if @columns.key? column.column_name
-                  raise(DuplicateColumnError, "Column #{column.column_name} already exists")
+                if @columns.key? column.name
+                  raise(DuplicateColumnError, "Column #{column.name} already exists")
                 end
 
-                @columns[column.column_name] = column
+                @columns[column.name] = column
               end
             end
           end

data/lib/dynamic_migrations/postgres/server/database/schema/table/validations.rb

@@ -16,16 +16,16 @@ module DynamicMigrations
 
               # returns the validation object for the provided validation name, and raises an
               # error if the validation does not exist
-              def validation validation_name
-                raise ExpectedSymbolError, validation_name unless validation_name.is_a? Symbol
-                raise ValidationDoesNotExistError unless has_validation? validation_name
-                @validations[validation_name]
+              def validation name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                raise ValidationDoesNotExistError unless has_validation? name
+                @validations[name]
               end
 
               # returns true if this table has a validation with the provided name, otherwise false
-              def has_validation? validation_name
-                raise ExpectedSymbolError, validation_name unless validation_name.is_a? Symbol
-                @validations.key? validation_name
+              def has_validation? name
+                raise ExpectedSymbolError, name unless name.is_a? Symbol
+                @validations.key? name
               end
 
               # returns an array of this tables validations
@@ -38,21 +38,21 @@ module DynamicMigrations
               end
 
               # adds a new validation to this table, and returns it
-              def add_validation validation_name, column_names, check_clause, **validation_options
-                if has_validation? validation_name
-                  raise(ValidationAlreadyExistsError, "Validation #{validation_name} already exists")
+              def add_validation name, column_names, check_clause, **validation_options
+                if has_validation? name
+                  raise(ValidationAlreadyExistsError, "Validation #{name} already exists")
                 end
                 columns = column_names.map { |column_name| column column_name }
                 included_target = self
                 if included_target.is_a? Table
-                  new_validation = @validations[validation_name] = Validation.new source, included_target, columns, validation_name, check_clause, **validation_options
+                  new_validation = @validations[name] = Validation.new source, included_target, columns, name, check_clause, **validation_options
                 else
                   raise ModuleIncludedIntoUnexpectedTargetError, included_target
                 end
                 # sort the hash so that the validations are in alphabetical order by name
                 sorted_validations = {}
-                @validations.keys.sort.each do |validation_name|
-                  sorted_validations[validation_name] = @validations[validation_name]
+                @validations.keys.sort.each do |name|
+                  sorted_validations[name] = @validations[name]
                 end
                 @validations = sorted_validations
                 # return the new validation

data/lib/dynamic_migrations/postgres/server/database/schema/table.rb

@@ -20,20 +20,20 @@ module DynamicMigrations
             include UniqueConstraints
 
             attr_reader :schema
-            attr_reader :table_name
+            attr_reader :name
             attr_reader :description
 
             # initialize a new object to represent a postgres table
-            def initialize source, schema, table_name, description = nil
+            def initialize source, schema, name, description = nil
               super source
               raise ExpectedSchemaError, schema unless schema.is_a? Schema
-              raise ExpectedSymbolError, table_name unless table_name.is_a? Symbol
+              raise ExpectedSymbolError, name unless name.is_a? Symbol
               unless description.nil?
                 raise ExpectedStringError, description unless description.is_a? String
                 @description = description
               end
               @schema = schema
-              @table_name = table_name
+              @name = name
               @columns = {}
               @validations = {}
               @indexes = {}
@@ -47,10 +47,10 @@ module DynamicMigrations
             end
 
             # add a primary key to this table
-            def add_primary_key primary_key_name, column_names, **primary_key_options
+            def add_primary_key name, column_names, **primary_key_options
               raise PrimaryKeyAlreadyExistsError if @primary_key
               columns = column_names.map { |column_name| column column_name }
-              @primary_key = PrimaryKey.new source, self, columns, primary_key_name, **primary_key_options
+              @primary_key = PrimaryKey.new source, self, columns, name, **primary_key_options
             end
 
             # returns true if this table has a primary key, otherwise false

data/lib/dynamic_migrations/postgres/server/database/schema.rb

@@ -18,15 +18,15 @@ module DynamicMigrations
           end
 
           attr_reader :database
-          attr_reader :schema_name
+          attr_reader :name
 
           # initialize a new object to represent a postgres schema
-          def initialize source, database, schema_name
+          def initialize source, database, name
             super source
             raise ExpectedDatabaseError, database unless database.is_a? Database
-            raise ExpectedSymbolError, schema_name unless schema_name.is_a? Symbol
+            raise ExpectedSymbolError, name unless name.is_a? Symbol
             @database = database
-            @schema_name = schema_name
+            @name = name
             @tables = {}
           end
 

data/lib/dynamic_migrations/postgres/server/database.rb

@@ -18,14 +18,14 @@ module DynamicMigrations
         include LoadedSchemasBuilder
 
         attr_reader :server
-        attr_reader :database_name
+        attr_reader :name
 
         # initialize a new object to represent a postgres database
-        def initialize server, database_name
+        def initialize server, name
           raise ExpectedServerError, server unless server.is_a? Server
-          raise ExpectedSymbolError, database_name unless database_name.is_a? Symbol
+          raise ExpectedSymbolError, name unless name.is_a? Symbol
           @server = server
-          @database_name = database_name
+          @name = name
           @configured_schemas = {}
           @loaded_schemas = {}
         end

data/lib/dynamic_migrations/postgres/server.rb

@@ -18,15 +18,15 @@ module DynamicMigrations
         @databases = {}
       end
 
-      def add_database database_name
-        raise ExpectedSymbolError, database_name unless database_name.is_a? Symbol
-        raise DatabaseAlreadyExistsError, "database `#{database_name}` already exists" if @databases.key? database_name
-        @databases[database_name] = Database.new self, database_name
+      def add_database name
+        raise ExpectedSymbolError, name unless name.is_a? Symbol
+        raise DatabaseAlreadyExistsError, "database `#{name}` already exists" if @databases.key? name
+        @databases[name] = Database.new self, name
       end
 
-      def database database_name
-        raise ExpectedSymbolError, database_name unless database_name.is_a? Symbol
-        @databases[database_name]
+      def database name
+        raise ExpectedSymbolError, name unless name.is_a? Symbol
+        @databases[name]
       end
 
       def databases

data/lib/dynamic_migrations/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DynamicMigrations
-  VERSION = "1.1.1"
+  VERSION = "2.0.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_migrations
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Craig Ulliott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-07-17 00:00:00.000000000 Z
+date: 2023-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg