upgrow 0.0.4 → 0.0.5

data/lib/generators/upgrow/model/templates/model.rb.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %> < ApplicationModel
+end
+<% end -%>

data/lib/generators/upgrow/record/record_generator.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'generators/upgrow'
+
+module Upgrow
+  module Generators
+    class RecordGenerator < Rails::Generators::NamedBase
+      include Helper
+
+      def create_record_file
+        template(
+          'record.rb',
+          File.join('app/records', class_path, "#{file_name}_record.rb")
+        )
+      end
+
+      hook_for :migration,
+        default: :active_record,
+        as: :migration do |instance, generator|
+        instance.invoke(
+          generator, ["create_#{instance.send(:table_name)}", instance.args]
+        )
+      end
+
+      hook_for :test_framework
+
+      private
+
+      def file_name
+        super.delete_suffix('_record')
+      end
+    end
+  end
+end

data/lib/generators/upgrow/record/templates/record.rb.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>Record < ApplicationRecord
+end
+<% end -%>

data/lib/generators/upgrow/repository/USAGE

@@ -0,0 +1,10 @@
+Description:
+
+    Creates a new Repository class with the given name under `app/repositories`.
+
+Example:
+
+    `bin/rails g upgrow:repository article`
+
+    create  app/repositories/article_repository.rb
+    invoke  test_unit

data/lib/generators/upgrow/repository/repository_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'generators/upgrow'
+
+module Upgrow
+  module Generators
+    class RepositoryGenerator < Rails::Generators::NamedBase
+      include Helper
+
+      def create_repository_file
+        template(
+          'repository.rb',
+          File.join('app/repositories', class_path,
+            "#{file_name}_repository.rb")
+        )
+      end
+
+      hook_for :test_framework
+
+      private
+
+      def file_name
+        super.delete_suffix('_repository')
+      end
+    end
+  end
+end

data/lib/generators/upgrow/repository/templates/repository.rb.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>Repository < ApplicationRepository
+end
+<% end -%>

data/lib/upgrow.rb

@@ -4,8 +4,11 @@ require_relative 'upgrow/action'
 require_relative 'upgrow/actions'
 require_relative 'upgrow/input'
 require_relative 'upgrow/model'
+require_relative 'upgrow/record'
 require_relative 'upgrow/repository'
 
+require 'upgrow/railtie' if defined?(Rails::Railtie)
+
 # The gem's main namespace.
 module Upgrow
 end

data/lib/upgrow/active_record_conversion.rb

@@ -29,11 +29,10 @@ module Upgrow
         association = record.association(reflection.to_sym)
         next unless association.loaded?
 
-        name = reflection.sub('_record', '').to_sym
-        [name, to_model(record.public_send(reflection))]
+        [reflection.to_sym, to_model(record.public_send(reflection))]
       end.compact.to_h
 
-      model_class = Object.const_get(record.class.name.delete_suffix('Record'))
+      model_class = Object.const_get(Naming.record_to_model(record.class.name))
 
       attributes = record.attributes.merge(associations)
 

data/lib/upgrow/active_record_queries.rb

@@ -19,8 +19,7 @@ module Upgrow
       # @return [Class] the Active Record Base class to be used as the
       #   Repository base according to the architecture's naming convention.
       def default_base
-        base_name = "#{name[/\A(.+)Repository\z/, 1]}Record"
-        Object.const_get(base_name)
+        Object.const_get(Naming.repository_to_record(name))
       end
     end
 

data/lib/upgrow/active_record_schema.rb

@@ -47,9 +47,7 @@ module Upgrow
     #
     # @return [Array<Symbol>] the list of attribute names.
     def association_names
-      association_names = base.reflections.keys.map do |key|
-        key.sub('_record', '').to_sym
-      end
+      association_names = base.reflections.keys.map(&:to_sym)
 
       association_names | @default_schema.association_names
     end

data/lib/upgrow/basic_model.rb

@@ -50,6 +50,17 @@ module Upgrow
       super(**attributes)
     end
 
+    # Returns a Hash representation of Model along with all loaded associations.
+    #
+    # @return [Hash<Symbol, Object>] the list of attribute names
+    #   and associations, if loaded.
+    def to_h
+      associations_hash = associations.compact.transform_values do |models|
+        models.respond_to?(:map) ? models.map(&:to_h) : models.to_h
+      end
+      attributes.merge(associations_hash)
+    end
+
     private
 
     def method_missing(name, *args, &block)

data/lib/upgrow/model.rb

@@ -2,6 +2,7 @@
 
 require_relative 'active_record_schema'
 require_relative 'basic_model'
+require_relative 'naming'
 
 module Upgrow
   # Models are objects that represent core entities of the app's business logic.
@@ -27,7 +28,7 @@ module Upgrow
         super
 
         subclass.schema = ActiveRecordSchema.new(
-          "#{subclass.name}Record", subclass.schema
+          Naming.model_to_record(subclass.name), subclass.schema
         )
       end
     end

data/lib/upgrow/naming.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Upgrow
+  # Functions to derive constant names and other identifiers according to
+  # Upgrow's conventions.
+  module Naming
+    extend self
+
+    # Convert a Model name to a Record name. The Record name by convention is
+    # the Model name with a `Record` suffix.
+    #
+    # @param model_name [String] the Model name.
+    #
+    # @return [String] the Record name.
+    def model_to_record(model_name)
+      "#{model_name}Record"
+    end
+
+    # Convert a Record name to a Model name. The Model name by convention is the
+    # Record name without the `Record` suffix.
+    #
+    # @param record_name [String] the Record name.
+    #
+    # @return [String] the Model name.
+    def record_to_model(record_name)
+      record_name.delete_suffix('Record')
+    end
+
+    # Convert a Repository name to a Record name. The Record name is inferred by
+    # the Repository name without the `Repository` suffix, and with the `Record`
+    # suffix added.
+    #
+    # @param repository_name [String] the Repository name.
+    #
+    # @return [String] the Record name.
+    def repository_to_record(repository_name)
+      "#{repository_name.delete_suffix("Repository")}Record"
+    end
+  end
+end

data/lib/upgrow/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Upgrow
+  # Upgrow's Railtie. This class allows Upgrow to change Rails' default configs.
+  class Railtie < Rails::Railtie
+    config.app_generators.orm(:upgrow)
+    config.app_generators.fallbacks[:upgrow] = :active_record
+  end
+end

data/lib/upgrow/record.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Upgrow
+  # Utility mixin to help adjust Active Record Base classes according to
+  # Upgrow's conventions. It allows the use of the `Record` suffix in class
+  # naming while keeping it out of table and association names, among other
+  # adaptations.
+  module Record
+    # Class methods to be extended by the class that includes the Record module.
+    module ClassMethods
+      # Overwrites the table name reader from ActiveRecord::ModelSchema,
+      # removing the `records` suffix by default while still allowing table name
+      # to be set explicitly.
+      #
+      # See https://api.rubyonrails.org/classes/ActiveRecord/ModelSchema/ClassMethods.html
+      def table_name
+        return @table_name if defined?(@table_name)
+
+        self.table_name = super&.sub('_record', '')
+      end
+
+      # Overwrites the has many association macro to adjust the default class
+      # and foreign key names to Upgrow's conventions.
+      #
+      # The default class name for the associated collection of Records is based
+      # on the association name and the `Record` suffix. The association's
+      # foreign key is derived from the caller's model name.
+      #
+      # All these values can be set explicitly according to Active Record's
+      # original behaviour.
+      #
+      # See https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html
+      def has_many(name, scope = nil, **options, &extension)
+        options = apply_default_options(name, options)
+
+        unless options.key?(:as)
+          options[:foreign_key] ||= foreign_key(model_name)
+        end
+
+        super
+      end
+
+      # Overwrites the has one association macro to adjust the default class
+      # and foreign key names to Upgrow's conventions.
+      #
+      # The default class name for the associated Record is based on the
+      # association name and the `Record` suffix. The association's foreign key
+      # is derived from the caller's model name.
+      #
+      # All these values can be set explicitly according to Active Record's
+      # original behaviour.
+      #
+      # See https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html
+      def has_one(name, scope = nil, **options, &extension)
+        options = apply_default_options(name, options)
+
+        unless options.key?(:as)
+          options[:foreign_key] ||= foreign_key(model_name)
+        end
+
+        super
+      end
+
+      # Overwrites the belongs to association macro to adjust the default class
+      # and foreign key names to Upgrow's conventions.
+      #
+      # The default class name for the associated Record is based on the
+      # association name and the `Record` suffix.
+      #
+      # All these values can be set explicitly according to Active Record's
+      # original behaviour.
+      #
+      # See https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html
+      def belongs_to(name, scope = nil, **options)
+        options = apply_default_options(name, options)
+        super
+      end
+
+      # Overwrites the has and belongs to many association macro to adjust the
+      # default class and foreign key names to Upgrow's conventions.
+      #
+      # The default class name for the associated Record is based on the
+      # association name and the `Record` suffix. The association's foreign key
+      # is derived from the caller's model name.
+      #
+      # All these values can be set explicitly according to Active Record's
+      # original behaviour.
+      #
+      # See https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html
+      def has_and_belongs_to_many(name, scope = nil, **options, &extension)
+        options = apply_default_options(name, options)
+
+        options[:foreign_key] ||= foreign_key(model_name)
+
+        options[:association_foreign_key] ||=
+          foreign_key(options.fetch(:class_name))
+
+        super
+      end
+
+      # @private
+      def apply_default_options(name, options)
+        default_options = {
+          class_name: Naming.model_to_record(name.to_s.singularize.camelize),
+        }
+
+        default_options.merge(options)
+      end
+
+      # @private
+      def foreign_key(record_name)
+        Naming.record_to_model(record_name.to_s).foreign_key
+      end
+    end
+
+    # @private
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+  end
+end

data/test/dummy/app/records/application_record.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
 class ApplicationRecord < ActiveRecord::Base
+  include Upgrow::Record
+
   self.abstract_class = true
 end

data/test/dummy/app/records/article_record.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 class ArticleRecord < ApplicationRecord
-  self.table_name = 'articles'
-  has_many :comment_records, foreign_key: :article_id, dependent: :destroy
-  belongs_to :user_record, foreign_key: :user_id
+  has_many :comments, dependent: :destroy
+  belongs_to :user
 end

data/test/dummy/app/records/comment_record.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 class CommentRecord < ApplicationRecord
-  self.table_name = 'comments'
-  belongs_to :user_record, foreign_key: :user_id
-  belongs_to :article_record, foreign_key: :article_id
+  belongs_to :user
+  belongs_to :article
 end

data/test/dummy/app/records/user_record.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 class UserRecord < ApplicationRecord
-  self.table_name = 'users'
-
   has_secure_password
 
-  has_many :article_records, foreign_key: :user_id, dependent: :destroy
-  has_many :comment_records, foreign_key: :user_id, dependent: :destroy
+  has_many :articles, dependent: :destroy
+  has_many :comments, dependent: :destroy
 end

data/test/dummy/app/repositories/article_repository.rb

@@ -2,13 +2,13 @@
 
 class ArticleRepository < Upgrow::Repository
   def all
-    to_model(base.all.includes(:user_record))
+    to_model(base.all.includes(:user))
   end
 
   def find_with_comments(id)
     record = base
-      .includes(:user_record)
-      .includes(comment_records: :user_record)
+      .includes(:user)
+      .includes(comments: :user)
       .find(id)
 
     to_model(record)

data/test/test_unit/generators/input_generator_test.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'rails/generators/test_case'
+require 'generators/test_unit/input/input_generator'
+
+module TestUnit
+  module Generators
+    class InputGeneratorTest < Rails::Generators::TestCase
+      tests InputGenerator
+      destination File.expand_path('tmp')
+      setup :prepare_destination
+
+      test 'generate Input test file' do
+        run_generator(['article'])
+
+        assert_file 'test/inputs/article_input_test.rb', <<~RUBY
+          # frozen_string_literal: true
+
+          require 'test_helper'
+
+          class ArticleInputTest < ActiveSupport::TestCase
+          end
+        RUBY
+      end
+
+      test 'generate Input test file when suffix is specified' do
+        run_generator(['ArticleInput'])
+
+        assert_file 'test/inputs/article_input_test.rb', <<~RUBY
+          # frozen_string_literal: true
+
+          require 'test_helper'
+
+          class ArticleInputTest < ActiveSupport::TestCase
+          end
+        RUBY
+      end
+
+      test 'generate namespaced Input test file' do
+        run_generator(['articles/article'])
+
+        assert_file 'test/inputs/articles/article_input_test.rb', <<~RUBY
+          # frozen_string_literal: true
+
+          require 'test_helper'
+
+          module Articles
+            class ArticleInputTest < ActiveSupport::TestCase
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end