Extract named methods for string operations in SchemaLoader

Replace inline string manipulations with intention-revealing
methods: association_name, foreign_key_column?, framework_column?,
table_name_for_foreign_key, user_table_names. Also extract
build_table and build_join_table from build_schema.

Author: bradgessler

lib/fixture_bot/rails/schema_loader.rb

@@ -20,65 +20,94 @@ def load
 
       private
 
-      INTERNAL_TABLES = %w[ar_internal_metadata schema_migrations].freeze
-
       def build_schema
         schema = Schema.new
-        table_names = @connection.tables - INTERNAL_TABLES
+        table_names = user_table_names
 
         join_table_names = detect_join_tables(table_names)
 
         (table_names - join_table_names).each do |name|
-          columns = @connection.columns(name)
-            .reject { |c| skip_column?(c.name) }
-            .map { |c| c.name.to_sym }
-
-          foreign_keys = @connection.foreign_keys(name)
-          associations = foreign_keys.map do |fk|
-            assoc_name = fk.column.sub(/_id$/, "")
-            Schema::BelongsTo.new(
-              name: assoc_name.to_sym,
-              table: fk.to_table.to_sym,
-              foreign_key: fk.column.to_sym
-            )
-          end
-
-          schema.add_table(Schema::Table.new(
-            name: name.to_sym,
-            singular_name: ActiveSupport::Inflector.singularize(name).to_sym,
-            columns: columns,
-            belongs_to_associations: associations
-          ))
+          schema.add_table(build_table(name))
         end
 
         join_table_names.each do |name|
-          fk_columns = @connection.columns(name)
-            .select { |c| c.name.end_with?("_id") }
-            .map { |c| c.name }
-
-          schema.add_join_table(Schema::JoinTable.new(
-            name: name.to_sym,
-            left_table: ActiveSupport::Inflector.pluralize(fk_columns[0].sub(/_id$/, "")).to_sym,
-            right_table: ActiveSupport::Inflector.pluralize(fk_columns[1].sub(/_id$/, "")).to_sym,
-            left_foreign_key: fk_columns[0].to_sym,
-            right_foreign_key: fk_columns[1].to_sym
-          ))
+          schema.add_join_table(build_join_table(name))
         end
 
         schema
       end
 
-      def skip_column?(name)
+      def build_table(name)
+        columns = @connection.columns(name)
+          .reject { |c| framework_column?(c.name) }
+          .map { |c| c.name.to_sym }
+
+        associations = @connection.foreign_keys(name).map do |fk|
+          Schema::BelongsTo.new(
+            name: association_name(fk.column),
+            table: fk.to_table.to_sym,
+            foreign_key: fk.column.to_sym
+          )
+        end
+
+        Schema::Table.new(
+          name: name.to_sym,
+          singular_name: singularize(name),
+          columns: columns,
+          belongs_to_associations: associations
+        )
+      end
+
+      def build_join_table(name)
+        fk_columns = foreign_key_columns(name)
+
+        Schema::JoinTable.new(
+          name: name.to_sym,
+          left_table: table_name_for_foreign_key(fk_columns[0]),
+          right_table: table_name_for_foreign_key(fk_columns[1]),
+          left_foreign_key: fk_columns[0].to_sym,
+          right_foreign_key: fk_columns[1].to_sym
+        )
+      end
+
+      def user_table_names
+        @connection.tables - %w[ar_internal_metadata schema_migrations]
+      end
+
+      def framework_column?(name)
         %w[id created_at updated_at].include?(name)
       end
 
+      def foreign_key_column?(column)
+        column.name.end_with?("_id")
+      end
+
+      def foreign_key_columns(table_name)
+        @connection.columns(table_name)
+          .select { |c| foreign_key_column?(c) }
+          .map { |c| c.name }
+      end
+
+      def association_name(column_name)
+        column_name.sub(/_id$/, "").to_sym
+      end
+
+      def table_name_for_foreign_key(column_name)
+        pluralize(column_name.sub(/_id$/, ""))
+      end
+
+      def singularize(word)
+        ActiveSupport::Inflector.singularize(word).to_sym
+      end
+
+      def pluralize(word)
+        ActiveSupport::Inflector.pluralize(word).to_sym
+      end
+
       def detect_join_tables(table_names)
         table_names.select do |name|
-          pk = @connection.primary_key(name)
-          next false if pk
-
-          id_cols = @connection.columns(name).select { |c| c.name.end_with?("_id") }
-          id_cols.size == 2
+          next false if @connection.primary_key(name)
+          foreign_key_columns(name).size == 2
         end
       end
     end