tapioca 0.4.6 → 0.4.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd111409d415b9a17a11cd2d1a5d6d60fdab411934fc5bd1ade87b4bee9e27a3
-  data.tar.gz: 6cc495adc75090725de7f8cb873672e804452c16931d5a995c543827ab6400cb
+  metadata.gz: ade782d63dbf52c361f3275c10366ece6db850a50a056bb6ef6ab73b3d8fe5c1
+  data.tar.gz: db41740ac452ad69cecc453cf5fc6ff6ce2634e45ba461670132d386d2a5e938
 SHA512:
-  metadata.gz: 993e27b7960ce9830d58098a3a965214342821d87c3753e3b6a72ab8d9d33e86c1a5f454141cd2f19b73565ecfe9f3454c7c7d45825256c27c02ccd2d2396780
-  data.tar.gz: bfeb2377b5a5b059ce4897cbe1b7e39cef0657d799479ffd75c646897236928cd7fe317fd9cf9a49597b8dd28fc7657e90d9386eb82927cc9cdbb806203c4538
+  metadata.gz: ca364aee459f30d35d0b62d4f48ee8bb9977ac458ca4aac74035cf97d2ff6f73571b8d6eb70689d7e389ce7ee67e5f8b7a8ad7773ef9f265c38d41aa030dd76c
+  data.tar.gz: 7c67870e40188ad371c33eda3bc44ed92077e451d05100bc7427bd143377763064ae0dad50d02b341ce34ed61ee0e8e3e7ce2b81a4b5b240fb437540cd26dc48

data/Gemfile

@@ -15,7 +15,6 @@ gem("yard", "~> 0.9.25")
 gem("pry-byebug")
 gem("minitest")
 gem("minitest-hooks")
-gem("minitest-fork_executor")
 gem("minitest-reporters")
 gem("sorbet")
 
@@ -33,4 +32,9 @@ group(:development, :test) do
   gem("activemodel-serializers-xml", "~> 1.0", require: false)
   gem("activeresource", "~> 5.1", require: false)
   gem("google-protobuf", "~>3.12.0", require: false)
+  # Fix version to 0.14.1 since it is the last version to support Ruby 2.4
+  gem("shopify-money", "= 0.14.1", require: false)
+  gem("sidekiq", "~>5.0", require: false) # Version 6 dropped support for Ruby 2.4
 end
+
+gem "rubocop-sorbet", ">= 0.4.1"

data/README.md

@@ -1,6 +1,6 @@
 # Tapioca
 
-[![Build Status](https://travis-ci.org/Shopify/tapioca.svg?branch=master)](https://travis-ci.org/Shopify/tapioca)
+![Build Status](https://github.com/Shopify/tapioca/workflows/CI/badge.svg)
 
 Tapioca is a library used to generate RBI (Ruby interface) files for use with [Sorbet](https://sorbet.org). RBI files provide the structure (classes, modules, methods, parameters) of the gem/library to Sorbet to assist with typechecking.
 
@@ -55,6 +55,8 @@ and do not forget to execute `tapioca` using `bundler`:
 ```shell
 $ bundle exec tapioca
 Commands:
+  tapioca --version, -v      # show version
+  tapioca dsl [constant...]  # generate RBIs for dynamic methods
   tapioca generate [gem...]  # generate RBIs from gems
   tapioca help [COMMAND]     # Describe available commands or one specific command
   tapioca init               # initializes folder structure
@@ -63,12 +65,12 @@ Commands:
   tapioca todo               # generate the list of unresolved constants
 
 Options:
-  --pre, -b, [--prerequire=file]              # A file to be required before Bundler.require is called
-  --post, -a, [--postrequire=file]            # A file to be required after Bundler.require is called
-  --out, -o, [--outdir=directory]             # The output directory for generated RBI files
-                                              # Default: sorbet/rbi/gems
-  --cmd, -c, [--generate-command=command]     # The command to run to regenerate RBI files
-  --typed, -t, [--typed-overrides=gem:level]  # Overrides for typed sigils for generated gem RBIs
+  --pre, -b, [--prerequire=file]                              # A file to be required before Bundler.require is called
+  --post, -a, [--postrequire=file]                            # A file to be required after Bundler.require is called
+  --out, -o, [--outdir=directory]                             # The output directory for generated RBI files
+  --cmd, -c, [--generate-command=command]                     # The command to run to regenerate RBI files
+  -x, [--exclude=gem [gem ...]]                               # Excludes the given gem(s) from RBI generation
+  --typed, -t, [--typed-overrides=gem:level [gem:level ...]]  # Overrides for typed sigils for generated gem RBIs
 ```
 
 ## Usage

data/lib/tapioca/cli.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # typed: true
+# frozen_string_literal: true
 
 require 'thor'
 
@@ -34,6 +34,8 @@ module Tapioca
                   banner: "gem:level [gem:level ...]",
                   desc: "Overrides for typed sigils for generated gem RBIs"
 
+    map T.unsafe(%w[--version -v] => :__print_version)
+
     desc "init", "initializes folder structure"
     def init
       create_file(Config::SORBET_CONFIG, skip: true) do
@@ -92,6 +94,11 @@ module Tapioca
       end
     end
 
+    desc "--version, -v", "show version"
+    def __print_version
+      puts "Tapioca v#{Tapioca::VERSION}"
+    end
+
     no_commands do
       def self.exit_on_failure?
         true

data/lib/tapioca/compilers/dsl/action_controller_helpers.rb

@@ -13,8 +13,7 @@ module Tapioca
   module Compilers
     module Dsl
       # `Tapioca::Compilers::Dsl::ActionControllerHelpers` decorates RBI files for all
-      # subclasses of `::ActionController::Base`
-      # to add helper methods (see https://api.rubyonrails.org/classes/ActionController/Helpers.html).
+      # subclasses of [`ActionController::Base`](https://api.rubyonrails.org/classes/ActionController/Helpers.html).
       #
       # For example, with the following `MyHelper` module:
       #
@@ -50,22 +49,22 @@ module Tapioca
       # # user_controller.rbi
       # # typed: strong
       # class UserController
-      #   sig { returns(UserController::HelperProxy) }
-      #   def helpers; end
-      # end
+      #   module HelperMethods
+      #     include MyHelper
       #
-      # module UserController::HelperMethods
-      #    include MyHelper
+      #     sig { params(user: T.untyped).returns(T.untyped) }
+      #     def age(user); end
       #
-      #    sig { params(user: T.untyped).returns(T.untyped) }
-      #    def age(user); end
+      #     sig { returns(T.untyped) }
+      #     def current_user_name; end
+      #   end
       #
-      #    sig { returns(T.untyped) }
-      #    def current_user_name; end
-      #  end
+      #   class HelperProxy < ::ActionView::Base
+      #     include HelperMethods
+      #   end
       #
-      # class UserController::HelperProxy < ::ActionView::Base
-      #   include UserController::HelperMethods
+      #   sig { returns(HelperProxy) }
+      #   def helpers; end
       # end
       # ~~~
       class ActionControllerHelpers < Base
@@ -77,42 +76,42 @@ module Tapioca
             .void
         end
         def decorate(root, constant)
-          helper_proxy_name = "#{constant}::HelperProxy"
-          helper_methods_name = "#{constant}::HelperMethods"
+          helper_proxy_name = "HelperProxy"
+          helper_methods_name = "HelperMethods"
           proxied_helper_methods = constant._helper_methods.map(&:to_s).map(&:to_sym)
 
-          # Create helper method module
-          root.create_module(helper_methods_name) do |helper_methods|
-            helpers_module = constant._helpers
+          # Define the helpers method
+          root.path(constant) do |controller|
+            create_method(controller, 'helpers', return_type: helper_proxy_name)
 
-            gather_includes(helpers_module).each do |ancestor|
-              helper_methods.create_include(ancestor)
-            end
+            # Create helper method module
+            controller.create_module(helper_methods_name) do |helper_methods|
+              helpers_module = constant._helpers
 
-            helpers_module.instance_methods(false).each do |method_name|
-              method = if proxied_helper_methods.include?(method_name)
-                constant.instance_method(method_name)
-              else
-                helpers_module.instance_method(method_name)
+              gather_includes(helpers_module).each do |ancestor|
+                helper_methods.create_include(ancestor)
               end
-              create_method_from_def(helper_methods, method)
-            end
-          end
 
-          # Create helper proxy class
-          root.create_class(helper_proxy_name, superclass: "::ActionView::Base") do |proxy|
-            proxy.create_include(helper_methods_name)
-          end
+              helpers_module.instance_methods(false).each do |method_name|
+                method = if proxied_helper_methods.include?(method_name)
+                  constant.instance_method(method_name)
+                else
+                  helpers_module.instance_method(method_name)
+                end
+                create_method_from_def(helper_methods, method)
+              end
+            end
 
-          # Define the helpers method
-          root.path(constant) do |controller|
-            create_method(controller, 'helpers', return_type: helper_proxy_name)
+            # Create helper proxy class
+            controller.create_class(helper_proxy_name, superclass: "::ActionView::Base") do |proxy|
+              proxy.create_include(helper_methods_name)
+            end
           end
         end
 
         sig { override.returns(T::Enumerable[Module]) }
         def gather_constants
-          ::ActionController::Base.descendants.reject(&:abstract?)
+          ::ActionController::Base.descendants.reject(&:abstract?).select(&:name)
         end
 
         private
@@ -121,7 +120,7 @@ module Tapioca
         def gather_includes(mod)
           mod.ancestors
             .reject { |ancestor| ancestor.is_a?(Class) || ancestor == mod || ancestor.name.nil? }
-            .map { |ancestor| T.must(ancestor.name) }
+            .map { |ancestor| "::#{ancestor.name}" }
             .reverse
         end
       end

data/lib/tapioca/compilers/dsl/action_mailer.rb

@@ -12,8 +12,8 @@ end
 module Tapioca
   module Compilers
     module Dsl
-      # `Tapioca::Compilers::Dsl::ActionMailer` generates RBI files for subclasses of `ActionMailer::Base`
-      # (see https://api.rubyonrails.org/classes/ActionMailer/Base.html).
+      # `Tapioca::Compilers::Dsl::ActionMailer` generates RBI files for subclasses of
+      # [`ActionMailer::Base`](https://api.rubyonrails.org/classes/ActionMailer/Base.html).
       #
       # For example, with the following `ActionMailer` subclass:
       #
@@ -40,12 +40,12 @@ module Tapioca
 
         sig { override.params(root: Parlour::RbiGenerator::Namespace, constant: T.class_of(::ActionMailer::Base)).void }
         def decorate(root, constant)
-          root.path(constant) do |k|
+          root.path(constant) do |mailer|
             constant.action_methods.to_a.each do |mailer_method|
               method_def = constant.instance_method(mailer_method)
               parameters = compile_method_parameters_to_parlour(method_def)
               create_method(
-                k,
+                mailer,
                 mailer_method,
                 parameters: parameters,
                 return_type: '::ActionMailer::MessageDelivery',

data/lib/tapioca/compilers/dsl/active_record_associations.rb

@@ -12,9 +12,9 @@ end
 module Tapioca
   module Compilers
     module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveRecordAssociations` refines RBI files for subclasses of `ActiveRecord::Base`
-      # (see https://api.rubyonrails.org/classes/ActiveRecord/Base.html). This generator is only
-      # responsible for defining the methods that would be created for the association that
+      # `Tapioca::Compilers::Dsl::ActiveRecordAssociations` refines RBI files for subclasses of
+      # [`ActiveRecord::Base`](https://api.rubyonrails.org/classes/ActiveRecord/Base.html).
+      # This generator is only responsible for defining the methods that would be created for the associations that
       # are defined in the Active Record model.
       #
       # For example, with the following model class:
@@ -36,56 +36,56 @@ module Tapioca
       #
       # class Post
       #   include Post::GeneratedAssociationMethods
-      # end
       #
-      # module Post::GeneratedAssociationMethods
-      #   sig { returns(T.nilable(::User)) }
-      #   def author; end
+      #   module Post::GeneratedAssociationMethods
+      #     sig { returns(T.nilable(::User)) }
+      #     def author; end
       #
-      #   sig { params(value: T.nilable(::User)).void }
-      #   def author=(value); end
+      #     sig { params(value: T.nilable(::User)).void }
+      #     def author=(value); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::User)) }
-      #   def build_author(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+      #     def build_author(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::Category)) }
-      #   def build_category(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+      #     def build_category(*args, &blk); end
       #
-      #   sig { returns(T.nilable(::Category)) }
-      #   def category; end
+      #     sig { returns(T.nilable(::Category)) }
+      #     def category; end
       #
-      #   sig { params(value: T.nilable(::Category)).void }
-      #   def category=(value); end
+      #     sig { params(value: T.nilable(::Category)).void }
+      #     def category=(value); end
       #
-      #   sig { returns(T::Array[T.untyped]) }
-      #   def comment_ids; end
+      #     sig { returns(T::Array[T.untyped]) }
+      #     def comment_ids; end
       #
-      #   sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
-      #   def comment_ids=(ids); end
+      #     sig { params(ids: T::Array[T.untyped]).returns(T::Array[T.untyped]) }
+      #     def comment_ids=(ids); end
       #
-      #   sig { returns(::ActiveRecord::Associations::CollectionProxy[Comment]) }
-      #   def comments; end
+      #     sig { returns(::ActiveRecord::Associations::CollectionProxy[Comment]) }
+      #     def comments; end
       #
-      #   sig { params(value: T::Enumerable[::Comment]).void }
-      #   def comments=(value); end
+      #     sig { params(value: T::Enumerable[::Comment]).void }
+      #     def comments=(value); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::User)) }
-      #   def create_author(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+      #     def create_author(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::User)) }
-      #   def create_author!(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::User) }
+      #     def create_author!(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::Category)) }
-      #   def create_category(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+      #     def create_category(*args, &blk); end
       #
-      #   sig { params(args: T.untyped, blk: T.untyped).returns(T.nilable(::Category)) }
-      #   def create_category!(*args, &blk); end
+      #     sig { params(args: T.untyped, blk: T.untyped).returns(::Category) }
+      #     def create_category!(*args, &blk); end
       #
-      #   sig { returns(T.nilable(::User)) }
-      #   def reload_author; end
+      #     sig { returns(T.nilable(::User)) }
+      #     def reload_author; end
       #
-      #   sig { returns(T.nilable(::Category)) }
-      #   def reload_category; end
+      #     sig { returns(T.nilable(::Category)) }
+      #     def reload_category; end
+      #   end
       # end
       # ~~~
       class ActiveRecordAssociations < Base
@@ -99,19 +99,20 @@ module Tapioca
         def decorate(root, constant)
           return if constant.reflections.empty?
 
-          module_name = "#{constant}::GeneratedAssociationMethods"
-          root.create_module(module_name) do |mod|
-            constant.reflections.each do |association_name, reflection|
-              if reflection.collection?
-                populate_collection_assoc_getter_setter(mod, constant, association_name, reflection)
-              else
-                populate_single_assoc_getter_setter(mod, constant, association_name, reflection)
+          root.path(constant) do |model|
+            module_name = "GeneratedAssociationMethods"
+
+            model.create_module(module_name) do |mod|
+              constant.reflections.each do |association_name, reflection|
+                if reflection.collection?
+                  populate_collection_assoc_getter_setter(mod, constant, association_name, reflection)
+                else
+                  populate_single_assoc_getter_setter(mod, constant, association_name, reflection)
+                end
               end
             end
-          end
 
-          root.path(constant) do |klass|
-            klass.create_include(module_name)
+            model.create_include(module_name)
           end
         end
 
@@ -152,7 +153,7 @@ module Tapioca
             "reload_#{association_name}",
             return_type: association_type,
           )
-          if reflection.constructable?
+          unless reflection.polymorphic?
             create_method(
               klass,
               "build_#{association_name}",
@@ -160,7 +161,7 @@ module Tapioca
                 Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
                 Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
               ],
-              return_type: association_type
+              return_type: association_class
             )
             create_method(
               klass,
@@ -169,7 +170,7 @@ module Tapioca
                 Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
                 Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
               ],
-              return_type: association_type
+              return_type: association_class
             )
             create_method(
               klass,
@@ -178,7 +179,7 @@ module Tapioca
                 Parlour::RbiGenerator::Parameter.new("*args", type: "T.untyped"),
                 Parlour::RbiGenerator::Parameter.new("&blk", type: "T.untyped"),
               ],
-              return_type: association_type
+              return_type: association_class
             )
           end
         end

data/lib/tapioca/compilers/dsl/active_record_columns.rb

@@ -12,24 +12,12 @@ end
 module Tapioca
   module Compilers
     module Dsl
-      # `Tapioca::Compilers::Dsl::ActiveRecordColumns` refines RBI files for subclasses of `ActiveRecord::Base`
-      # (see https://api.rubyonrails.org/classes/ActiveRecord/Base.html). This generator is only
-      # responsible for defining the attribute methods that would be created for the columns that
-      # are defined in the Active Record model.
-      #
-      # **Note:** This generator, by default, generates weak signatures for column methods and treats each
-      # column to be `T.untyped`. This is done on purpose to ensure that the nilability of Active Record
-      # columns do not make it hard for existing code to adopt gradual typing. It is possible, however, to
-      # generate stricter type signatures for your ActiveRecord column types. If your ActiveRecord model extends
-      # a module with name `StrongTypeGeneration`, this generator will generate stricter signatures that follow
-      # closely with the types defined in the schema.
-      #
-      # The `StrongTypeGeneration` module you define in your application should add an `after_initialize` callback
-      # to the model and ensure that all the non-nilable attributes of the model are actually initialized with non-`nil`
-      # values.
+      # `Tapioca::Compilers::Dsl::ActiveRecordColumns` refines RBI files for subclasses of
+      # [`ActiveRecord::Base`](https://api.rubyonrails.org/classes/ActiveRecord/Base.html).
+      # This generator is only responsible for defining the attribute methods that would be
+      # created for the columns that are defined in the Active Record model.
       #
       # For example, with the following model class:
-      #
       # ~~~rb
       # class Post < ActiveRecord::Base
       # end
@@ -54,54 +42,58 @@ module Tapioca
       # # post.rbi
       # # typed: true
       # class Post
-      #   sig { returns(T.nilable(::String)) }
-      #   def body; end
+      #   include GeneratedAttributeMethods
+      #
+      #   module GeneratedAttributeMethods
+      #     sig { returns(T.nilable(::String)) }
+      #     def body; end
       #
-      #   sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
-      #   def body=; end
+      #     sig { params(value: T.nilable(::String)).returns(T.nilable(::String)) }
+      #     def body=; end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def body?; end
+      #     sig { returns(T::Boolean) }
+      #     def body?; end
       #
-      #   sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
-      #   def created_at; end
+      #     sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
+      #     def created_at; end
       #
-      #   sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) }
-      #   def created_at=; end
+      #     sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) }
+      #     def created_at=; end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def created_at?; end
+      #     sig { returns(T::Boolean) }
+      #     def created_at?; end
       #
-      #   sig { returns(T.nilable(T::Boolean)) }
-      #   def published; end
+      #     sig { returns(T.nilable(T::Boolean)) }
+      #     def published; end
       #
-      #   sig { params(value: T::Boolean).returns(T::Boolean) }
-      #   def published=; end
+      #     sig { params(value: T::Boolean).returns(T::Boolean) }
+      #     def published=; end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def published?; end
+      #     sig { returns(T::Boolean) }
+      #     def published?; end
       #
-      #   sig { returns(::String) }
-      #   def title; end
+      #     sig { returns(::String) }
+      #     def title; end
       #
-      #   sig { params(value: ::String).returns(::String) }
-      #   def title=(value); end
+      #     sig { params(value: ::String).returns(::String) }
+      #     def title=(value); end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def title?(*args); end
+      #     sig { returns(T::Boolean) }
+      #     def title?; end
       #
-      #   sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
-      #   def updated_at; end
+      #     sig { returns(T.nilable(::ActiveSupport::TimeWithZone)) }
+      #     def updated_at; end
       #
-      #   sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) }
-      #   def updated_at=; end
+      #     sig { params(value: ::ActiveSupport::TimeWithZone).returns(::ActiveSupport::TimeWithZone) }
+      #     def updated_at=; end
       #
-      #   sig { params(args: T.untyped).returns(T::Boolean) }
-      #   def updated_at?; end
+      #     sig { returns(T::Boolean) }
+      #     def updated_at?; end
       #
-      #   ## Also the methods added by https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Dirty.html
-      #   ## Also the methods added by https://api.rubyonrails.org/classes/ActiveModel/Dirty.html
-      #   ## Also the methods added by https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/BeforeTypeCast.html
+      #     ## Also the methods added by https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/Dirty.html
+      #     ## Also the methods added by https://api.rubyonrails.org/classes/ActiveModel/Dirty.html
+      #     ## Also the methods added by https://api.rubyonrails.org/classes/ActiveRecord/AttributeMethods/BeforeTypeCast.html
+      #   end
       # end
       # ~~~
       class ActiveRecordColumns < Base
@@ -111,26 +103,27 @@ module Tapioca
         def decorate(root, constant)
           return unless constant.table_exists?
 
-          module_name = "#{constant}::GeneratedAttributeMethods"
-          root.create_module(module_name) do |mod|
-            constant.columns_hash.each_key do |column_name|
-              column_name = column_name.to_s
-              add_methods_for_attribute(mod, constant, column_name)
-            end
+          root.path(constant) do |model|
+            module_name = "GeneratedAttributeMethods"
+
+            model.create_module(module_name) do |mod|
+              constant.columns_hash.each_key do |column_name|
+                column_name = column_name.to_s
+                add_methods_for_attribute(mod, constant, column_name)
+              end
 
-            constant.attribute_aliases.each do |attribute_name, column_name|
-              attribute_name = attribute_name.to_s
-              column_name = column_name.to_s
-              new_method_names = constant.attribute_method_matchers.map { |m| m.method_name(attribute_name) }
-              old_method_names = constant.attribute_method_matchers.map { |m| m.method_name(column_name) }
-              methods_to_add = new_method_names - old_method_names
+              constant.attribute_aliases.each do |attribute_name, column_name|
+                attribute_name = attribute_name.to_s
+                column_name = column_name.to_s
+                new_method_names = constant.attribute_method_matchers.map { |m| m.method_name(attribute_name) }
+                old_method_names = constant.attribute_method_matchers.map { |m| m.method_name(column_name) }
+                methods_to_add = new_method_names - old_method_names
 
-              add_methods_for_attribute(mod, constant, column_name, attribute_name, methods_to_add)
+                add_methods_for_attribute(mod, constant, column_name, attribute_name, methods_to_add)
+              end
             end
-          end
 
-          root.path(constant) do |klass|
-            klass.create_include(module_name)
+            model.create_include(module_name)
           end
         end
 
@@ -318,6 +311,8 @@ module Tapioca
 
           getter_type =
             case column_type
+            when defined?(MoneyColumn) && MoneyColumn::ActiveRecordType
+              "::Money"
             when ActiveRecord::Type::Integer
               "::Integer"
             when ActiveRecord::Type::String