rail_inspector 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8e98b33289ed86129f0bf1680f8b164a9431a7e91aca0a3ee22c3e8702272a6b
+  data.tar.gz: f5cbdb492740f6c4c6e0c0b3bf394476fcbb2fe8e3cd6b94b2fddc29cf25437a
+SHA512:
+  metadata.gz: 5a1df1044157d495d1df59f772012cdef5f3dcc097cdf4a0afc3ebe287b1faa2ea01a689ad28bbb6f9bbaf401881b8b37f115326c5010c8cc3e8aa5398ad0a94
+  data.tar.gz: 622294ea305ca60aa40acf4b72188cc9ac7c1934760831019d745fc847264d78a18d703c8b2f1f8657ff5d162232db4bb6110a11565d5a7ac11f9d5b53b21036

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in rail_inspector.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    rail_inspector (0.0.1)
+      syntax_tree (= 6.1.1)
+      thor (~> 1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.18.0)
+    prettier_print (1.2.1)
+    rake (13.0.6)
+    syntax_tree (6.1.1)
+      prettier_print (>= 1.2.0)
+    thor (1.2.1)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  minitest (~> 5.0)
+  rail_inspector!
+  rake (~> 13.0)
+
+BUNDLED WITH
+   2.3.19

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Hartley McGuire
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,40 @@
+# RailInspector
+
+A collection of linters for [`rails/rails`](https://github.com/rails/rails)
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add rail_inspector
+
+If bundler is not being used to manage dependencies, install the gem by
+executing:
+
+    $ gem install rail_inspector
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and the created tag, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/skipkayhil/rail_inspector.
+
+## License
+
+The gem is available as open source under the terms of the [MIT
+License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+require "syntax_tree/rake_tasks"
+
+Minitest::TestTask.create
+
+SyntaxTree::Rake::CheckTask.new
+SyntaxTree::Rake::WriteTask.new
+
+task default: [:test, "stree:check"]

data/exe/railspect

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/rail_inspector/cli"
+
+RailInspector::Cli.start

data/lib/rail_inspector/changelog.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "strscan"
+
+class Changelog
+  class Offense
+    attr_reader :line, :line_number, :range, :message
+
+    def initialize(line, line_number, range, message)
+      @line = line
+      @line_number = line_number
+      @range = range
+      @message = message
+    end
+  end
+
+  class Entry
+    attr_reader :lines, :offenses
+
+    def initialize(lines, starting_line)
+      @lines = lines
+      @starting_line = starting_line
+
+      @offenses = []
+
+      validate_authors
+      validate_leading_whitespace
+      validate_trailing_whitespace
+    end
+
+    private
+
+    def header
+      lines.first
+    end
+
+    def validate_authors
+      authors =
+        lines.reverse.find { |line| line.match?(/\*[^\d\s]+(\s[^\d\s]+)*\*/) }
+
+      return if authors
+
+      add_offense(
+        header,
+        line_in_file(0),
+        1..header.length,
+        "CHANGELOG entry is missing authors."
+      )
+    end
+
+    def validate_leading_whitespace
+      unless header.match?(/\* {3}\S/)
+        add_offense(
+          header,
+          line_in_file(0),
+          1..4,
+          "CHANGELOG header must start with '*' and 3 spaces"
+        )
+      end
+
+      lines.each_with_index do |line, i|
+        next if i == 0
+        next if line.strip.empty?
+        next if line.start_with?(" " * 4)
+
+        add_offense(
+          line,
+          line_in_file(i),
+          1..4,
+          "CHANGELOG line must be indented 4 spaces"
+        )
+      end
+    end
+
+    def validate_trailing_whitespace
+      lines.each_with_index do |line, i|
+        next unless line.end_with?(" ", "\t")
+
+        add_offense(
+          line,
+          line_in_file(i),
+          (line.rstrip.length + 1)..line.length,
+          "Trailing whitespace detected."
+        )
+      end
+    end
+
+    private
+
+    def add_offense(...)
+      @offenses << Offense.new(...)
+    end
+
+    def line_in_file(line_in_entry)
+      @starting_line + line_in_entry
+    end
+  end
+
+  class Parser
+    def self.call(file)
+      new(file).parse
+    end
+
+    def self.to_proc
+      method(:call).to_proc
+    end
+
+    def initialize(file)
+      @buffer = StringScanner.new(file)
+      @lines = []
+      @current_line = 1
+
+      @entries = []
+    end
+
+    def parse
+      until @buffer.eos?
+        if peek_footer?
+          pop_entry
+          next parse_footer
+        end
+
+        pop_entry if peek_probably_header?
+
+        parse_line
+      end
+
+      @entries
+    end
+
+    private
+
+    def parse_line
+      @current_line += 1
+      @lines << @buffer.scan_until(/\n/)[0...-1]
+    end
+
+    FOOTER_TEXT = "Please check"
+
+    def parse_footer
+      @buffer.scan(
+        /#{FOOTER_TEXT} \[\d-\d-stable\]\(.*\) for previous changes\.\n/
+      )
+    end
+
+    def peek_probably_header?
+      return false unless @buffer.peek(1) == "*"
+
+      maybe_header = @buffer.check_until(/\n/).strip
+
+      # If there are an odd number of *, then the line is almost certainly a
+      # header since bolding requires pairs.
+      return true unless maybe_header.count("*").even?
+
+      !maybe_header.end_with?("*")
+    end
+
+    def peek_footer?
+      @buffer.peek(FOOTER_TEXT.length) == FOOTER_TEXT
+    end
+
+    def pop_entry
+      # Ensure we don't pop an entry if we only see newlines and the footer
+      return unless @lines.any? { |line| line.match?(/\S/) }
+
+      @entries << Changelog::Entry.new(@lines, @current_line - @lines.length)
+      @lines = []
+    end
+  end
+
+  class Formatter
+    def initialize
+      @changelog_count = 0
+      @offense_count = 0
+    end
+
+    def to_proc
+      method(:call).to_proc
+    end
+
+    def call(changelog)
+      @changelog_count += 1
+
+      changelog.offenses.each { |o| process_offense(changelog, o) }
+    end
+
+    def finish
+      puts "#{@changelog_count} changelogs inspected, #{@offense_count} offense#{"s" unless @offense_count == 1} detected"
+    end
+
+    private
+
+    def process_offense(file, offense)
+      @offense_count += 1
+
+      puts "#{file.path}:#{offense.line_number} #{offense.message}"
+      puts offense.line
+      puts ("^" * offense.range.count).rjust(offense.range.end)
+    end
+  end
+
+  class Runner
+    attr_reader :formatter, :rails_path
+
+    def initialize(rails_path)
+      @formatter = Formatter.new
+      @rails_path = Pathname.new(rails_path)
+    end
+
+    def call
+      invalid_changelogs =
+        changelogs.reject do |changelog|
+          output = changelog.valid? ? "." : "E"
+          $stdout.write(output)
+
+          changelog.valid?
+        end
+
+      puts "\n\n"
+      puts "Offenses:\n\n" unless invalid_changelogs.empty?
+
+      changelogs.each(&formatter)
+      formatter.finish
+
+      invalid_changelogs.empty?
+    end
+
+    private
+
+    def changelogs
+      changelog_paths.map { |path| Changelog.new(path, File.read(path)) }
+    end
+
+    def changelog_paths
+      Dir[rails_path.join("*/CHANGELOG.md")]
+    end
+  end
+
+  attr_reader :path, :content, :entries
+
+  def initialize(path, content)
+    @path = path
+    @content = content
+    @entries = parser.parse
+  end
+
+  def valid?
+    offenses.empty?
+  end
+
+  def offenses
+    @offenses ||= entries.flat_map(&:offenses)
+  end
+
+  private
+
+  def parser
+    @parser ||= Parser.new(content)
+  end
+end

data/lib/rail_inspector/cli.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "thor"
+
+module RailInspector
+  class Cli < Thor
+    class << self
+      def exit_on_failure? = true
+    end
+
+    desc "changelogs RAILS_PATH", "Check CHANGELOG files for common issues"
+    def changelogs(rails_path)
+      require_relative "./changelog"
+
+      exit Changelog::Runner.new(rails_path).call
+    end
+
+    desc "configuration RAILS_PATH", "Check various Configuration issues"
+    option :autocorrect, type: :boolean, aliases: :a
+    def configuration(rails_path)
+      require_relative "./configuring"
+
+      checker = Configuring.new(rails_path)
+      checker.check
+
+      puts checker.errors unless checker.errors.empty?
+      exit checker.errors.empty? unless options[:autocorrect]
+
+      checker.write!
+    end
+  end
+end

data/lib/rail_inspector/configuring/check/framework_defaults.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "tempfile"
+require_relative "../../visitor/framework_default"
+
+class Configuring
+  module Check
+    class FrameworkDefaults
+      class NewFrameworkDefaultsFile
+        attr_reader :checker, :visitor
+
+        def initialize(checker, visitor)
+          @checker = checker
+          @visitor = visitor
+        end
+
+        def check
+          visitor.config_map[checker.rails_version].each_key do |config|
+            app_config = config.gsub(/^self/, "config")
+
+            next if defaults_file_content.include? app_config
+
+            add_error(config)
+          end
+        end
+
+        private
+
+        def add_error(config)
+          checker.errors << <<~MESSAGE
+            #{new_framework_defaults_path}
+            Missing: #{config}
+
+          MESSAGE
+        end
+
+        def defaults_file_content
+          @defaults_file_content ||= checker.read(new_framework_defaults_path)
+        end
+
+        def new_framework_defaults_path
+          NEW_FRAMEWORK_DEFAULTS_PATH %
+            { version: checker.rails_version.gsub(".", "_") }
+        end
+      end
+
+      attr_reader :checker
+
+      def initialize(checker)
+        @checker = checker
+      end
+
+      def check
+        header, *defaults_by_version = documented_defaults
+
+        NewFrameworkDefaultsFile.new(checker, visitor).check
+
+        checker.doc.versioned_defaults =
+          header +
+            defaults_by_version
+              .map { |defaults| check_defaults(defaults) }
+              .flatten
+      end
+
+      private
+
+      def app_config_tree
+        checker.parse(APPLICATION_CONFIGURATION_PATH)
+      end
+
+      def check_defaults(defaults)
+        header, configs = defaults[0], defaults[2, defaults.length - 3]
+
+        version = header.match(/\d\.\d/)[0]
+
+        generated_doc =
+          visitor.config_map[version]
+            .map do |config, value|
+              full_config =
+                case config
+                when /^[A-Z]/
+                  config
+                when /^self/
+                  config.sub("self", "config")
+                else
+                  "config.#{config}"
+                end
+
+              "- [`#{full_config}`](##{full_config.tr("._", "-").downcase}): `#{value}`"
+            end
+            .sort
+
+        config_diff =
+          Tempfile.create("expected") do |doc|
+            doc << generated_doc.join("\n")
+            doc.flush
+
+            Tempfile.create("actual") do |code|
+              code << configs.join("\n")
+              code.flush
+
+              `git diff --color --no-index #{doc.path} #{code.path}`
+            end
+          end
+
+        checker.errors << <<~MESSAGE unless config_diff.empty?
+            #{APPLICATION_CONFIGURATION_PATH}: Incorrect load_defaults docs
+            --- Expected
+            +++ Actual
+            #{config_diff.split("\n")[5..].join("\n")}
+          MESSAGE
+
+        [header, "", *generated_doc, ""]
+      end
+
+      def documented_defaults
+        checker
+          .doc
+          .versioned_defaults
+          .slice_before { |line| line.start_with?("####") }
+          .to_a
+      end
+
+      def visitor
+        @visitor ||=
+          begin
+            visitor = Visitor::FrameworkDefault.new
+            visitor.visit(app_config_tree)
+            visitor
+          end
+      end
+    end
+  end
+end

data/lib/rail_inspector/configuring/check/general_configuration.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../../visitor/attribute"
+
+class Configuring
+  module Check
+    class GeneralConfiguration
+      attr_reader :checker
+
+      def initialize(checker)
+        @checker = checker
+      end
+
+      def check
+        header, *config_sections = documented_general_config
+
+        non_nested_accessors =
+          general_accessors.reject do |a|
+            config_sections.any? { |section| /\.#{a}\./.match?(section[0]) }
+          end
+
+        non_nested_accessors.each do |accessor|
+          config_header = "#### `config.#{accessor}`"
+
+          unless config_sections.any? { |section| section[0] == config_header }
+            checker.errors << config_header
+            config_sections << [config_header, "", "FIXME", ""]
+          end
+        end
+
+        checker.doc.general_config =
+          [header] +
+            config_sections.sort_by { |section| section[0].split("`")[1] }
+      end
+
+      private
+
+      APP_CONFIG_CONST = "Rails::Application::Configuration"
+
+      def app_config_tree
+        checker.parse(APPLICATION_CONFIGURATION_PATH)
+      end
+
+      def documented_general_config
+        checker
+          .doc
+          .general_config
+          .slice_before { |line| line.start_with?("####") }
+          .to_a
+      end
+
+      def general_accessors
+        visitor.attribute_map[APP_CONFIG_CONST]["attr_accessor"]
+      end
+
+      def visitor
+        @visitor ||=
+          begin
+            visitor = Visitor::Attribute.new
+            visitor.visit(app_config_tree)
+            visitor
+          end
+      end
+    end
+  end
+end

data/lib/rail_inspector/configuring.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "./configuring/check/general_configuration"
+require_relative "./configuring/check/framework_defaults"
+
+class Configuring
+  class CachedParser
+    def initialize
+      @cache = {}
+    end
+
+    def call(path)
+      @cache[path] ||= SyntaxTree.parse(SyntaxTree.read(path))
+    end
+  end
+
+  DOC_PATH = "guides/source/configuring.md"
+  APPLICATION_CONFIGURATION_PATH =
+    "railties/lib/rails/application/configuration.rb"
+  NEW_FRAMEWORK_DEFAULTS_PATH =
+    "railties/lib/rails/generators/rails/app/templates/config/initializers/new_framework_defaults_%{version}.rb.tt"
+
+  class Doc
+    attr_accessor :general_config, :versioned_defaults
+
+    def initialize(content)
+      @before, @versioned_defaults, @general_config, @after =
+        content
+          .split("\n")
+          .slice_before do |line|
+            [
+              "### Versioned Default Values",
+              "### Rails General Configuration",
+              "### Configuring Assets"
+            ].include?(line)
+          end
+          .to_a
+    end
+
+    def to_s
+      (@before + @versioned_defaults + @general_config + @after).join("\n") +
+        "\n"
+    end
+  end
+
+  attr_reader :errors, :parser
+
+  def initialize(rails_path)
+    @errors = []
+    @parser = CachedParser.new
+    @rails_path = Pathname.new(rails_path)
+  end
+
+  def check
+    [Check::GeneralConfiguration, Check::FrameworkDefaults].each do |check|
+      check.new(self).check
+    end
+  end
+
+  def doc
+    @doc ||=
+      begin
+        content = File.read(doc_path)
+        Configuring::Doc.new(content)
+      end
+  end
+
+  def parse(relative_path)
+    parser.call(@rails_path.join(relative_path))
+  end
+
+  def read(relative_path)
+    File.read(@rails_path.join(relative_path))
+  end
+
+  def rails_version
+    @rails_version ||= File.read(@rails_path.join("RAILS_VERSION")).to_f.to_s
+  end
+
+  def write!
+    File.write(doc_path, doc.to_s)
+  end
+
+  private
+
+  def doc_path
+    @rails_path.join(DOC_PATH)
+  end
+end

data/lib/rail_inspector/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RailInspector
+  VERSION = "0.0.1"
+end

data/lib/rail_inspector/visitor/attribute.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "syntax_tree"
+
+module Visitor
+  class Attribute < SyntaxTree::Visitor
+    attr_reader :attribute_map
+
+    def initialize
+      @attribute_map = {}
+      @namespace_stack = []
+    end
+
+    def with_namespace(node)
+      @namespace_stack << node.constant.constant.value
+      visit_child_nodes(node)
+      @namespace_stack.pop
+    end
+
+    visit_method alias_method :visit_module, :with_namespace
+
+    visit_method alias_method :visit_class, :with_namespace
+
+    visit_method def visit_command(node)
+      attr_access = node.message.value
+      return unless ATTRIBUTE_METHODS.include?(attr_access)
+
+      full_namespace = @namespace_stack.join("::")
+
+      @attribute_map[full_namespace] ||= {}
+      @attribute_map[full_namespace][attr_access] ||= Set.new
+
+      attributes = node.arguments.parts.map { |p| p.value.value }
+
+      @attribute_map[full_namespace][attr_access].merge(attributes)
+    end
+
+    private
+
+    ATTRIBUTE_METHODS = %w[attr_accessor attr_reader attr_writer]
+  end
+end

data/lib/rail_inspector/visitor/framework_default.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "syntax_tree"
+
+require_relative "./hash_to_string"
+require_relative "./multiline_to_string"
+
+module Visitor
+  class FrameworkDefault < SyntaxTree::Visitor
+    attr_reader :config_map
+
+    def initialize
+      @config_map = {}
+      @target_version_block = false
+      @current_version = nil
+      @current_framework = nil
+    end
+
+    visit_method def visit_case(node)
+      return unless target_version_case?(node.value)
+
+      @target_version_block = true
+      visit_child_nodes(node)
+      @target_version_block = false
+    end
+
+    visit_method def visit_when(node)
+      return unless @target_version_block
+
+      @current_version = node.arguments.parts[0].parts[0].value
+
+      @config_map[@current_version] = {}
+      visit_child_nodes(node)
+
+      @current_version = nil
+    end
+
+    visit_method def visit_if(node)
+      return unless @target_version_block
+
+      @current_framework =
+        case node
+        in predicate: SyntaxTree::CallNode[message: { value: "respond_to?" }]
+          node.predicate.arguments.arguments.parts[0].value.value
+        else
+          nil
+        end
+
+      visit_child_nodes(node)
+
+      @current_framework = nil
+    end
+
+    visit_method def visit_assign(node)
+      return unless @target_version_block
+
+      assert_framework(node)
+
+      target = SyntaxTree::Formatter.format(nil, node.target)
+      value =
+        case node.value
+        when SyntaxTree::HashLiteral
+          HashToString.new.tap { |v| v.visit(node.value) }.to_s
+        when SyntaxTree::StringConcat
+          MultilineToString.new.tap { |v| v.visit(node.value) }.to_s
+        else
+          SyntaxTree::Formatter.format(nil, node.value)
+        end
+      @config_map[@current_version][target] = value
+    end
+
+    private
+
+    def target_version_case?(node)
+      node in SyntaxTree::CallNode[
+        receiver: SyntaxTree::VarRef[
+          value: SyntaxTree::Ident[value: "target_version"]
+        ]
+      ]
+    end
+
+    def assert_framework(node)
+      framework =
+        case node.target.parent
+        in { value: SyntaxTree::Const } |
+             { value: SyntaxTree::Kw[value: "self"] }
+          nil
+        in receiver: { value: { value: framework } }
+          framework
+        in value: { value: framework }
+          framework
+        end
+
+      return if @current_framework == framework
+
+      raise "Expected #{@current_framework} to match #{framework}"
+    end
+  end
+end

data/lib/rail_inspector/visitor/hash_to_string.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "syntax_tree"
+
+module Visitor
+  class HashToString < SyntaxTree::Visitor
+    attr_reader :to_s
+
+    def initialize
+      @to_s = +""
+    end
+
+    visit_methods do
+      def visit_assoc(node)
+        @to_s << " "
+        visit(node.key)
+
+        case node.key
+        when SyntaxTree::StringLiteral
+          @to_s << " => "
+        end
+
+        visit(node.value)
+      end
+
+      def visit_hash(node)
+        @to_s << "{"
+
+        if node.assocs.length > 0
+          visit(node.assocs[0])
+
+          if node.assocs.length > 1
+            node.assocs[1..-1].each do |a|
+              @to_s << ","
+              visit(a)
+            end
+          end
+          @to_s << " "
+        end
+
+        @to_s << "}"
+      end
+
+      def visit_int(node)
+        @to_s << node.value
+      end
+
+      def visit_kw(node)
+        @to_s << node.value
+      end
+
+      def visit_label(node)
+        @to_s << node.value
+        @to_s << " "
+      end
+
+      def visit_tstring_content(node)
+        @to_s << '"'
+        @to_s << node.value
+        @to_s << '"'
+      end
+    end
+  end
+end

data/lib/rail_inspector/visitor/multiline_to_string.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "syntax_tree"
+
+module Visitor
+  class MultilineToString < SyntaxTree::Visitor
+    attr_reader :to_s
+
+    def initialize
+      @to_s = +""
+    end
+
+    visit_methods do
+      def visit_string_concat(node)
+        @to_s << '"'
+        super(node)
+        @to_s << '"'
+      end
+
+      def visit_tstring_content(node)
+        @to_s << node.value
+      end
+    end
+  end
+end

data/lib/rail_inspector.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require_relative "rail_inspector/version"
+
+module RailInspector
+  # Your code goes here...
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: rail_inspector
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Hartley McGuire
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-03-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: syntax_tree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 6.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 6.1.1
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description:
+email:
+- skipkayhil@gmail.com
+executables:
+- railspect
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- exe/railspect
+- lib/rail_inspector.rb
+- lib/rail_inspector/changelog.rb
+- lib/rail_inspector/cli.rb
+- lib/rail_inspector/configuring.rb
+- lib/rail_inspector/configuring/check/framework_defaults.rb
+- lib/rail_inspector/configuring/check/general_configuration.rb
+- lib/rail_inspector/version.rb
+- lib/rail_inspector/visitor/attribute.rb
+- lib/rail_inspector/visitor/framework_default.rb
+- lib/rail_inspector/visitor/hash_to_string.rb
+- lib/rail_inspector/visitor/multiline_to_string.rb
+homepage: https://github.com/skipkayhil/rail_inspector
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/skipkayhil/rail_inspector
+  source_code_uri: https://github.com/skipkayhil/rail_inspector
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A collection of linters for rails/rails
+test_files: []