rails-annotate-solargraph 0.2.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0f1d0f284eac106e51e1abc19eec0d7b8790aab9ee188e1cabea5defb04417da
-  data.tar.gz: 392519ce6da6313e8a3308dee6f54b66629ee108120b8abcb94e1d838dc86470
+  metadata.gz: 641aad34ff5a1a7f98a1eca52baf74c311308b2e9e062cf8c5ac3c0186d1f1ec
+  data.tar.gz: 70657a49775862f8b50dc2e04f7b489b04f124cbfb4893f777f5a11f69b0ba51
 SHA512:
-  metadata.gz: 23e25ae122d969be4f5d4081638592e3db7d6ab46adf60cdaf82057953441576d842bc2db79af664371637e332b25c5fee091fe930e53ffd88f97d78a04533c9
-  data.tar.gz: 43d0752100b231426877a84665ba8030d5121b8f0d7b07549f2312c7e30cb7f1c0f9c9807b99bc085394fd369cb81a95ec63c15366e92a9eb96116fdb91b8fee
+  metadata.gz: 8a2c58e2d0dbb0dd0df66d1f2f04242095081c4159059c8830021cc16f9ece5222dc9fee73392757b88cf1798f5e53256a09fc2291585b8474c36db8777d64f2
+  data.tar.gz: 6335dab053b82ff232fdcc69c3453eea68ae44432bd6f4032f29ab812072e9053795955556f14578479bd47ebd37a3bfc6ac592254de63801d38369834dcc358

data/.vscode/settings.json

@@ -1,6 +1,11 @@
 {
   "cSpell.words": [
     "activerecord",
+    "citext",
+    "datetime",
+    "gsub",
+    "inet",
+    "klass",
     "rakefile",
     "solargraph",
     "yieldparam"

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [0.5.0] - 2022-04-19
+
+- Add some static comments to the schema file to improve general Rails intellisense
+- Rename schema file from `app/models/annotate_solargraph_schema.rb` to `.annotate-solargraph-schema`
+- Generate schema file as a regular ruby file
+- Add `yard` and `solargraph` as dependencies
+- Add `.solargraph.yml` to the installation generator
+
+## [0.4.0] - 2022-04-17
+
+- Annotations get saved to a schema file by default `app/models/annotate_solargraph_schema.rb`
+
+## [0.3.0] - 2022-04-17
+
+- `has_many :through` and `has_one :through` relations get documented
+
 ## [0.2.3] - 2022-04-16
 
 - A nicer fix for the previous problem
@@ -15,6 +31,7 @@
 ## [0.2.0] - 2022-04-16
 
 - Associations get fully documented
+- `has_many`, `has_one` and `belongs_to` relations get documented
 
 ## [0.1.1] - 2022-04-15
 
@@ -24,4 +41,5 @@
 
 - Initial release
 - Automatic generation of annotations after migrations
+- Database fields get documented
 - Manual rake tasks `annotate:solargraph:generate`, `annotate:solargraph:remove`

data/Gemfile.lock

@@ -1,8 +1,10 @@
 PATH
   remote: .
   specs:
-    rails-annotate-solargraph (0.2.3)
+    rails-annotate-solargraph (0.5.0)
       rails (>= 5.0, < 8.0)
+      solargraph
+      yard
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -63,11 +63,31 @@ You can change the gem's default configuration like so:
 ```ruby
 # config/initializers/rails_annotate_solargraph.rb
 
-Rails::Annotate::Solargraph.configure do |conf|
-    conf.annotation_position = :top # `:bottom` by default
+if ::Rails.env.development?
+    ::Rails::Annotate::Solargraph.configure do |conf|
+        conf.annotation_position = :top # `:schema_file` by default
+    end
 end
 ```
 
+#### annotation_position
+
+There are a few values for this option:
+
+- `:schema_file` -- default value, annotations get saved to a special file `app/models/annotate_solargraph_schema.rb`
+- `:bottom` -- annotations are appended to the model files
+- `:top` -- annotations are prepended to the model files
+
+### Update
+
+To update this gem you should generate the rakefiles once again. Overwrite them.
+
+```sh
+$ rails g annotate:solargraph:install
+$ rake annotate:solargraph:remove
+$ rake annotate:solargraph:generate
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/generators/annotate/solargraph/install_generator.rb

@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'set'
+
 module Annotate
   module Solargraph
     module Generators
@@ -8,6 +13,17 @@ module Annotate
         # copy rake tasks
         def copy_tasks
           template ::Rails::Annotate::Solargraph::RAKEFILE_NAME, ::File.join('lib', 'tasks', ::Rails::Annotate::Solargraph::RAKEFILE_NAME)
+          template ::Rails::Annotate::Solargraph::SCHEMA_FILE_NAME, ::Rails::Annotate::Solargraph::SCHEMA_RAILS_PATH
+
+          solargraph_config_file = ::File.join(::Rails.root, ::Rails::Annotate::Solargraph::SOLARGRAPH_FILE_NAME)
+          system 'solargraph config' unless ::File.exist? solargraph_config_file
+          solargraph_config = ::YAML.load_file solargraph_config_file
+          solargraph_config['include'] = solargraph_config['include'] || []
+          solargraph_config['include'].unshift ::Rails::Annotate::Solargraph::SCHEMA_RAILS_PATH
+          # make sure there are no duplicated entries
+          solargraph_config['include'] = solargraph_config['include'].to_set.to_a
+
+          ::File.write(solargraph_config_file, solargraph_config.to_yaml)
         end
       end
     end

data/lib/generators/annotate/solargraph/templates/.annotate_solargraph_schema

@@ -0,0 +1,69 @@
+# This is a dummy file generated by `rails-annotate-solargraph`
+# to extend solargraph's understanding of your Rails app.
+# You should probably add it to `.gitignore`
+
+# Some static comments to fill a few gaps
+# in Rails comprehension.
+
+class ActionController::Base
+  include ActionController::MimeResponds
+  include ActionController::Redirecting
+  include ActionController::Cookies
+  include AbstractController::Rendering
+  extend ActiveSupport::Callbacks::ClassMethods
+  extend ActiveSupport::Rescuable::ClassMethods
+  extend AbstractController::Callbacks::ClassMethods
+  extend ActionController::RequestForgeryProtection::ClassMethods
+end
+class ActiveRecord::Base
+  extend ActiveRecord::Reflection::ClassMethods
+  extend ActiveModel::SecurePassword::ClassMethods
+  extend ActiveModel::Attributes::ClassMethods
+  include ActiveModel::Attributes
+  include ActiveModel::Dirty
+  extend ActiveRecord::Validations::ClassMethods
+  include ActiveRecord::Validations
+  extend ActiveModel::Validations::ClassMethods
+  include ActiveModel::Validations
+  extend ActiveRecord::Calculations
+  extend ActiveRecord::Batches
+  extend ActiveRecord::QueryMethods
+  extend ActiveRecord::FinderMethods
+  extend ActiveRecord::Associations::ClassMethods
+  extend ActiveRecord::Inheritance::ClassMethods
+  extend ActiveRecord::ModelSchema::ClassMethods
+  extend ActiveRecord::Transactions::ClassMethods
+  extend ActiveRecord::Scoping::Named::ClassMethods
+  include ActiveRecord::Persistence
+
+<% (ActiveRecord::Callbacks::CALLBACKS rescue []).each do |callback| -%>
+  # Registers a callback to be called <%= callback.to_s.gsub('_', ' ') %>.
+  # See `ActiveRecord::Callbacks` for more information.
+  # @return [void]
+  def self.<%= callback %>(*args, &block); end
+<% end -%>
+
+end
+class Rails
+  # @return [Rails::Application]
+  def self.application; end
+end
+class Rails::Application
+  # @return [ActionDispatch::Routing::RouteSet]
+  def routes; end
+end
+class ActionDispatch::Routing::Mapper
+  include ActionDispatch::Routing::Mapper::Base
+  include ActionDispatch::Routing::Mapper::HttpHelpers
+  include ActionDispatch::Routing::Mapper::Redirection
+  include ActionDispatch::Routing::Mapper::Scoping
+  include ActionDispatch::Routing::Mapper::Concerns
+  include ActionDispatch::Routing::Mapper::Resources
+  include ActionDispatch::Routing::Mapper::CustomUrls
+end
+class ActionDispatch::Routing::RouteSet
+  # @yieldself [ActionDispatch::Routing::Mapper]
+  def draw; end
+end
+
+# Dynamically generated documentation

data/lib/generators/annotate/solargraph/templates/rails_annotate_solargraph.rake

@@ -19,6 +19,7 @@ if ::Rails.env.development?
       next unless ::Rake::Task.task_defined?(task)
 
       ::Rake::Task[task].enhance do
+        system 'yard gems' unless ENV['TEST']
         ::Rake::Task['annotate:solargraph:generate'].invoke
       end
     end

data/lib/rails/annotate/solargraph/configuration.rb

@@ -9,10 +9,10 @@ module Rails
         # @return [Symbol]
         attr_reader :annotation_position
 
-        ANNOTATION_POSITIONS = ::Set[:bottom, :top].freeze
+        ANNOTATION_POSITIONS = ::Set[:bottom, :top, :schema_file].freeze
 
         def initialize
-          @annotation_position = :bottom
+          @annotation_position = :schema_file
         end
 
         # @param val [Symbol]
@@ -22,6 +22,10 @@ module Rails
 
           @annotation_position = val
         end
+
+        def schema_file?
+          @annotation_position == :schema_file
+        end
       end
     end
   end

data/lib/rails/annotate/solargraph/model.rb

@@ -1,44 +1,55 @@
 # frozen_string_literal: true
 
+require 'fileutils'
+
 module Rails
   module Annotate
     module Solargraph
       class Model
         using TerminalColors::Refinement
 
-        # @return [String]
-        ANNOTATION_START = "\n# %%<RailsAnnotateSolargraph:Start>%%"
-        # @return [String]
-        ANNOTATION_END = "%%<RailsAnnotateSolargraph:End>%%\n\n"
-        # @return [Regexp]
-        ANNOTATION_REGEXP = /#{ANNOTATION_START}.*#{ANNOTATION_END}/m.freeze
         # @return [Regexp]
         MAGIC_COMMENT_REGEXP = /(^#\s*encoding:.*(?:\n|r\n))|(^# coding:.*(?:\n|\r\n))|(^# -\*- coding:.*(?:\n|\r\n))|(^# -\*- encoding\s?:.*(?:\n|\r\n))|(^#\s*frozen_string_literal:.+(?:\n|\r\n))|(^# -\*- frozen_string_literal\s*:.+-\*-(?:\n|\r\n))/.freeze
 
+        # @return [Hash{Symbol => String}]
+        TYPE_MAP = {
+          float: 'BigDecimal',
+          decimal: 'BigDecimal',
+          integer: 'Integer',
+          datetime: 'ActiveSupport::TimeWithZone',
+          date: 'Date',
+          string: 'String',
+          boolean: 'Boolean',
+          text: 'String',
+          jsonb: 'Hash',
+          citext: 'String',
+          json: 'Hash',
+          bigint: 'Integer',
+          uuid: 'String',
+          inet: 'IPAddr'
+        }
+        TYPE_MAP.default = 'Object'
+        TYPE_MAP.freeze
+
         class << self
-          # @param type [Symbol, String, nil]
+          # @param klass [Class]
           # @return [String]
-          def active_record_type_to_yard(type)
-            case type&.to_sym
-            when :float
-              ::Float.to_s
-            when :integer
-              ::Integer.to_s
-            when :decimal
-              ::BigDecimal.to_s
-            when :datetime, :timestamp, :time
-              ::Time.to_s
-            when :json, :jsonb
-              ::Hash.to_s
-            when :date
-              ::Date.to_s
-            when :text, :string, :binary, :inet, :uuid
-              ::String.to_s
-            when :boolean
-              'Boolean'
-            else
-              ::Object.to_s
-            end
+          def annotation_start(klass = nil)
+            table_name = klass && CONFIG.schema_file? ? ":#{klass.table_name}" : ''
+            "\n# %%<RailsAnnotateSolargraph:Start#{table_name}>%%"
+          end
+
+          # @param klass [Class]
+          # @return [String]
+          def annotation_end(klass = nil)
+            table_name = klass && CONFIG.schema_file? ? ":#{klass.table_name}" : ''
+            "%%<RailsAnnotateSolargraph:End#{table_name}>%%\n\n"
+          end
+
+          # @param klass [Class]
+          # @return [Regexp]
+          def annotation_regexp(klass = nil)
+            /#{annotation_start(klass)}.*#{annotation_end(klass)}/m
           end
         end
 
@@ -51,7 +62,22 @@ module Rails
         # @param klass [Class]
         def initialize(klass)
           @klass = klass
-          @file_name = ::File.join(::Rails.root, MODEL_DIR, "#{klass.to_s.underscore}.rb")
+          @file_name = CONFIG.schema_file? ? SCHEMA_RAILS_PATH : ::File.join(::Rails.root, MODEL_DIR, "#{klass.to_s.underscore}.rb")
+        end
+
+        # @return [String]
+        def annotation_start
+          self.class.annotation_start(@klass)
+        end
+
+        # @return [String]
+        def annotation_end
+          self.class.annotation_end(@klass)
+        end
+
+        # @return [Regexp]
+        def annotation_regexp
+          self.class.annotation_regexp(@klass)
         end
 
         # @param :write [Boolean]
@@ -79,8 +105,10 @@ module Rails
         # @param :write [Boolean]
         # @return [Array<String>] Old file content followed by new content.
         def remove_annotation(write: true)
+          return ['', ''] unless ::File.exist?(@file_name)
+
           file_content = ::File.read(@file_name)
-          new_file_content = file_content.sub(ANNOTATION_REGEXP, '')
+          new_file_content = file_content.sub(annotation_regexp, '')
           result = [file_content, new_file_content]
           return result unless write
           return result if file_content == new_file_content
@@ -93,8 +121,8 @@ module Rails
         def annotation
           doc_string = ::String.new
           doc_string << <<~DOC
-            #{ANNOTATION_START}
-            # @!parse
+            #{annotation_start}
+            ##{parse_clause}
             #   class #{@klass} < #{@klass.superclass}
           DOC
 
@@ -117,12 +145,23 @@ module Rails
 
           doc_string << <<~DOC.chomp
             #   end
-            # #{ANNOTATION_END}
+            # #{annotation_end}
           DOC
+
+          # uncomment the generated annotations if they're saved in the schema file
+          return doc_string.gsub(/^#\ {3}/, '').gsub(/^#\n/, "\n") if CONFIG.schema_file?
+
+          doc_string
         end
 
         private
 
+        def parse_clause
+          return if CONFIG.schema_file?
+
+          " @!parse\n#"
+        end
+
         # @param file_name [String]
         # @return [String]
         def relative_file_name(file_name)
@@ -133,6 +172,7 @@ module Rails
         # @param content [String]
         # @return [void]
         def write_file(file_name, content)
+          ::FileUtils.touch(file_name) unless ::File.exists?(file_name)
           ::File.write(file_name, content)
           puts "modify".rjust(12).with_styles(:bold, :green) + "  #{relative_file_name(file_name)}"
         end
@@ -142,37 +182,57 @@ module Rails
           @klass.table_name[..-2]
         end
 
+        # @param reflection [ActiveRecord::Reflection::AbstractReflection]
+        # @return [Class]
+        def reflection_class(reflection)
+          reflection.klass
+        rescue ::NameError
+          Object
+        end
+
+        # @param reflection [ActiveRecord::Reflection::AbstractReflection]
+        # @return [String]
+        def reflection_foreign_key(reflection)
+          reflection.try(:foreign_key) || '<unknown>'
+        end
+
+        # @param klass [Class]
+        # @return [String]
+        def class_table_name(klass)
+          klass.try(:table_name) || '<unknown>'
+        end
+
         # @param doc_string [String]
         # @param attr_name [String]
         # @param reflection [ActiveRecord::Reflection::AbstractReflection]
         # @return [void]
         def document_relation(doc_string, attr_name, reflection)
-          reflection_class = begin
-            reflection.klass
-          rescue ::NameError
-            Object
-          end
-
-          associated_table_name = reflection_class.try(:table_name) || '<unknown>'
-          foreign_key = reflection.try(:foreign_key) || '<unknown>'
-          db_description = \
+          reflection_klass = reflection_class(reflection)
+          type_docstring, db_description = \
             case reflection
             when ::ActiveRecord::Reflection::BelongsToReflection
-              type_docstring = reflection_class
-              "`belongs_to` relation with `#{reflection_class}`. Database column `#{@klass.table_name}.#{foreign_key}`."
+              belongs_to_description(reflection_klass,
+                                     class_table_name(@klass),
+                                     reflection_foreign_key(reflection))
             when ::ActiveRecord::Reflection::HasOneReflection
-              type_docstring = reflection_class
-              "`has_one` relation with `#{reflection_class}`. Database column `#{associated_table_name}.#{foreign_key}`."
+              has_one_description(reflection_klass,
+                                  class_table_name(reflection_klass),
+                                  reflection_foreign_key(reflection))
             when ::ActiveRecord::Reflection::HasManyReflection
-              type_docstring = "Array<#{reflection_class}>"
-              "`has_many` relation with `#{reflection_class}`. Database column `#{associated_table_name}.#{foreign_key}`."
+              has_many_description(reflection_klass,
+                                   class_table_name(reflection_klass),
+                                   reflection_foreign_key(reflection))
+            when ::ActiveRecord::Reflection::ThroughReflection
+              through_description(reflection)
+            else
+              [::Object.to_s, '']
             end
 
           doc_string << <<~DOC
-            #     # #{db_description}
+            #     ##{db_description}
             #     # @param val [#{type_docstring}, nil]
             #     def #{attr_name}=(val); end
-            #     # #{db_description}
+            #     ##{db_description}
             #     # @return [#{type_docstring}, nil]
             #     def #{attr_name}; end
           DOC
@@ -187,7 +247,7 @@ module Rails
             model_class.reflections[klass_relation_name]&.options&.[](:as)&.to_sym == attr_name.to_sym
           end
 
-          classes_string = classes.join(', ')
+          classes_string = classes.empty? ? ::Object.to_s : classes.join(', ')
           doc_string << <<~DOC
             #     # Polymorphic relation. Database columns `#{@klass.table_name}.#{attr_name}_id` and `#{@klass.table_name}.#{attr_name}_type`.
             #     # @param val [#{classes_string}, nil]
@@ -198,13 +258,98 @@ module Rails
           DOC
         end
 
+        # @param reflection [ActiveRecord::Reflection::AbstractReflection]
+        # @return [Array<String>]
+        def through_description(reflection)
+          through_klass = reflection_class(reflection.through_reflection)
+
+          case (reflection.__send__(:delegate_reflection) rescue nil)
+          when ::ActiveRecord::Reflection::HasOneReflection
+            has_one_description(reflection_class(reflection.source_reflection),
+                                class_table_name(through_klass),
+                                reflection_foreign_key(reflection.source_reflection),
+                                through: through_klass)
+          when ::ActiveRecord::Reflection::HasManyReflection
+            has_many_description(reflection_class(reflection.source_reflection),
+                                 class_table_name(through_klass),
+                                 reflection_foreign_key(reflection.source_reflection),
+                                 through: through_klass)
+          else
+            [::Object.to_s, '']
+          end
+        end
+
+        # @param through [Class, nil]
+        # @return [String]
+        def through_sentence(through = nil)
+          return '' unless through
+
+          " through `#{through}`"
+        end
+
+        # @param table_name [String]
+        # @param foreign_key [String]
+        # @param through [Class, nil]
+        # @return [String]
+        def column_description(table_name, foreign_key, through = nil)
+          return '' if through
+
+          " Database column `#{table_name}.#{foreign_key}`."
+        end
+
+        # @param relation [Symbol, String]
+        # @param klass [Class]
+        # @param table_name [String]
+        # @param foreign_key [String]
+        # @param through [Class, nil]
+        # @return [String]
+        def relation_description(relation, klass, table_name, foreign_key, through = nil)
+          " `#{relation}` relation with `#{klass}`#{through_sentence(through)}.#{column_description(table_name, foreign_key, through)}"
+        end
+
+
+        # @param klass [Class]
+        # @param table_name [String]
+        # @param foreign_key [String]
+        # @param :through [Class, nil]
+        # @return [Array<String>] Type docstring followed by the description of the method.
+        def has_many_description(klass, table_name, foreign_key, through: nil)
+          type_docstring = "Array<#{klass}>"
+          desc = relation_description(:has_many, klass, table_name, foreign_key, through)
+
+          [type_docstring, desc]
+        end
+
+        # @param klass [Class]
+        # @param table_name [String]
+        # @param foreign_key [String]
+        # @param :through [Class, nil]
+        # @return [Array<String>] Type docstring followed by the description of the method.
+        def has_one_description(klass, table_name, foreign_key, through: nil)
+          type_docstring = klass
+          desc = relation_description(:has_one, klass, table_name, foreign_key, through)
+
+          [type_docstring, desc]
+        end
+
+        # @param klass [Class]
+        # @param table_name [String]
+        # @param foreign_key [String]
+        # @return [Array<String>] Type docstring followed by the description of the method.
+        def belongs_to_description(klass, table_name, foreign_key)
+          type_docstring = klass
+          desc = relation_description(:belongs_to, klass, table_name, foreign_key)
+
+          [type_docstring, desc]
+        end
+
         # @param attr_type [ActiveModel::Type::Value]
         # @return [String]
         def yard_type(attr_type)
           return attr_type.coder.object_class.to_s if attr_type.respond_to?(:coder) && attr_type.coder.respond_to?(:object_class)
           return 'Object' if attr_type.respond_to?(:coder) && attr_type.coder.is_a?(::ActiveRecord::Coders::JSON)
 
-          self.class.active_record_type_to_yard(attr_type.type)
+          TYPE_MAP[attr_type.type]
         end
       end
     end

data/lib/rails/annotate/solargraph/version.rb

@@ -3,7 +3,7 @@
 module Rails
   module Annotate
     module Solargraph
-      VERSION = '0.2.3'
+      VERSION = '0.5.0'
     end
   end
 end

data/lib/rails/annotate/solargraph.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'set'
+require 'fileutils'
 
 require_relative "solargraph/version"
 require_relative "solargraph/configuration"
@@ -19,11 +20,20 @@ module Rails
       CONFIG = Configuration.new
       # @return [Set<Symbol>]
       VALID_MODIFICATION_METHODS = ::Set[:annotate, :remove_annotation].freeze
+      # @return [String]
+      SCHEMA_CLASS_NAME = 'AnnotateSolargraphSchema'
+      # @return [String]
+      SOLARGRAPH_FILE_NAME = '.solargraph.yml'
+      # @return [String]
+      SCHEMA_FILE_NAME = '.annotate_solargraph_schema'
+      # @return [String]
+      SCHEMA_RAILS_PATH = SCHEMA_FILE_NAME
 
       class << self
         # @return [Array<String>] Array of changed files.
         def generate
           title 'Generating model schema annotations'
+          create_schema_file
           modify_models :annotate
         end
 
@@ -49,6 +59,13 @@ module Rails
 
         include TerminalColors
 
+        def create_schema_file
+          schema_file = ::File.join ::Rails.root, SCHEMA_RAILS_PATH
+          return if ::File.exist?(schema_file)
+
+          system 'rails g annotate:solargraph:install'
+        end
+
         # @param method [Symbol] Name of the method that will be called on every loaded Model
         # @return [Array<String>] Array of changed files.
         def modify_models(method)

data/rails-annotate-solargraph.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://gitlab.com/mateuszdrewniak/rails-annotate-solargraph"
-  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  spec.metadata["changelog_uri"] = "https://gitlab.com/mateuszdrewniak/rails-annotate-solargraph/-/raw/main/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -31,6 +31,8 @@ Gem::Specification.new do |spec|
 
   # Uncomment to register a new dependency of your gem
   spec.add_dependency 'rails', ">= 5.0", '< 8.0'
+  spec.add_dependency 'solargraph'
+  spec.add_dependency 'yard'
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-annotate-solargraph
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Mateusz Drewniak
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-16 00:00:00.000000000 Z
+date: 2022-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -30,6 +30,34 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: solargraph
+  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: yard
+  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'
 description: Annotate ActiveRecord models with schema comments formatted in YARD that
   are compatible with Solargraph.
 email:
@@ -53,6 +81,7 @@ files:
 - bin/console
 - bin/setup
 - lib/generators/annotate/solargraph/install_generator.rb
+- lib/generators/annotate/solargraph/templates/.annotate_solargraph_schema
 - lib/generators/annotate/solargraph/templates/rails_annotate_solargraph.rake
 - lib/rails/annotate/solargraph.rb
 - lib/rails/annotate/solargraph/configuration.rb
@@ -67,6 +96,7 @@ licenses:
 metadata:
   homepage_uri: https://gitlab.com/mateuszdrewniak/rails-annotate-solargraph
   source_code_uri: https://gitlab.com/mateuszdrewniak/rails-annotate-solargraph
+  changelog_uri: https://gitlab.com/mateuszdrewniak/rails-annotate-solargraph/-/raw/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths: