railsforge 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b004345e61120afc6f11432c72baeddb6981aee6e504d50b5eedf5b0334f71d6
-  data.tar.gz: 51bae87bc37e99da845f89ea3e9af014a2d9b6d85128417223978e5ffef14958
+  metadata.gz: 97a2aa54dd6324b6a8237f33d2d45abdff8e33903e0cc63f1def08b6cea5f39b
+  data.tar.gz: 8a0ca64024fa1eec71cc892aba1ac8e66903e0e801259999fd9b4cfac5484e12
 SHA512:
-  metadata.gz: 1bc07580544ae7d06679dd03986cf6268b7598ead40a495a54ff8b2f8d0da1730871d01738ec419455998992f85cbda3619dbd60ccf77fb6ea73cce53ce7179c
-  data.tar.gz: 7b1b7c639d4da0968d6db7ea4e2a9d98a28398186f93ffeaddab9ee86c60c9481296d72ab64c0c9d552e795f635de3d146664e7cc6415d9c919db16bfe68aa18
+  metadata.gz: 4d4da0f8ee77c37302c61c3a72fcee87bd786c710d40d2b9da0c94c818df150b6f8f8f2ea66b78786c2be415f4e07f06eb2c2cc130187b86d4cc5b4489a1d935
+  data.tar.gz: 63410692a4e0dd42712e543c4aff3ba19cd1230c17cabd3b12122183fa63c0017e4ae6699ae1b9b3935d5550cb66a61b1c2f1c2dd74f1ea622c25b3dff9892e9

data/lib/railsforge/analyzers/database_analyzer.rb

@@ -1,5 +1,5 @@
 # Database analyzer for RailsForge
-# Scans database schema for issues
+# Scans database schema for structural and index issues
 
 require_relative "base_analyzer"
 
@@ -15,26 +15,90 @@ module RailsForge
         schema_file = File.join(base_path, "db", "schema.rb")
         return [] unless File.exist?(schema_file)
 
-        content = File.read(schema_file)
-        tables  = content.scan(/create_table\s+"(\w+)"/).flatten
-        issues  = []
-
-        tables.each do |table|
-          table_section = content[/create_table\s+"#{table}".*?(?=create_table|\z)/m]
-          next unless table_section&.include?("t.datetime")
-
-          issues << RailsForge::Issue.new(
-            analyzer:   :database,
-            type:       :missing_index,
-            severity:   "medium",
-            file:       "db/schema.rb",
-            line:       nil,
-            message:    "Table `#{table}` has datetime columns without an index",
-            suggestion: "add_index :#{table}, :created_at"
-          )
+        new(schema_file).find_issues
+      end
+
+      def initialize(schema_file)
+        @schema_file = schema_file
+        @content     = File.read(schema_file)
+        @issues      = []
+      end
+
+      def find_issues
+        check_missing_fk_indexes
+        check_unindexed_datetime_queries
+        @issues
+      end
+
+      private
+
+      # Check for foreign key columns (_id suffix) without a corresponding index
+      def check_missing_fk_indexes
+        @content.scan(/create_table\s+"(\w+)"(.*?)(?=\s*create_table|\z)/m) do |table, body|
+          fk_columns  = body.scan(/t\.(?:integer|bigint|string|uuid)\s+"(\w+_id)"/).flatten
+          indexed     = indexed_columns_in(table, body)
+
+          fk_columns.each do |col|
+            next if indexed.include?(col)
+
+            @issues << RailsForge::Issue.new(
+              analyzer:   :database,
+              type:       :missing_fk_index,
+              severity:   "high",
+              file:       "db/schema.rb",
+              line:       nil,
+              message:    "Table `#{table}` has foreign key `#{col}` without an index",
+              suggestion: "add_index :#{table}, :#{col}"
+            )
+          end
         end
+      end
+
+      # Flag datetime columns that are queried by range but lack an index
+      # Specifically: tables that have a datetime column with no index at all on that column
+      def check_unindexed_datetime_queries
+        @content.scan(/create_table\s+"(\w+)"(.*?)(?=\s*create_table|\z)/m) do |table, body|
+          # Collect explicitly named datetime columns (not created_at/updated_at which Rails rarely queries by range)
+          dt_columns = body.scan(/t\.datetime\s+"(\w+)"/).flatten
+                          .reject { |c| c == "created_at" || c == "updated_at" }
+
+          indexed = indexed_columns_in(table, body)
 
-        issues
+          dt_columns.each do |col|
+            next if indexed.include?(col)
+
+            @issues << RailsForge::Issue.new(
+              analyzer:   :database,
+              type:       :missing_datetime_index,
+              severity:   "medium",
+              file:       "db/schema.rb",
+              line:       nil,
+              message:    "Table `#{table}` has datetime column `#{col}` without an index",
+              suggestion: "add_index :#{table}, :#{col} if you query or order by this column"
+            )
+          end
+        end
+      end
+
+      # Collect all indexed columns for a given table from the schema body and
+      # any trailing add_index lines at the bottom of the schema
+      def indexed_columns_in(table, body)
+        cols = []
+        # t.index ["col"] or t.index ["col1", "col2"]
+        body.scan(/t\.index\s+\[([^\]]+)\]/).each do |match|
+          match[0].scan(/"(\w+)"/).each { |m| cols << m[0] }
+        end
+        # t.index "col" (single column, no brackets)
+        body.scan(/t\.index\s+"(\w+)"/).each { |m| cols << m[0] }
+        # add_index "table", ["col"] or add_index "table", "col"
+        @content.scan(/add_index\s+"#{Regexp.escape(table)}",\s+(?:\[([^\]]+)\]|"(\w+)")/).each do |arr, single|
+          if arr
+            arr.scan(/"(\w+)"/).each { |m| cols << m[0] }
+          elsif single
+            cols << single
+          end
+        end
+        cols
       end
     end
   end

data/lib/railsforge/analyzers/performance_analyzer.rb

@@ -1,5 +1,6 @@
 # Performance analyzer for RailsForge
-# Checks for common performance issues
+# Checks for common performance issues in app code.
+# Schema-level index issues are handled by DatabaseAnalyzer.
 
 require "fileutils"
 
@@ -8,22 +9,19 @@ module RailsForge
     class PerformanceAnalyzer < BaseAnalyzer
       ISSUE_TYPES = {
         n_plus_one:        "N+1 Query",
-        missing_index:     "Missing Database Index",
         slow_method:       "Slow Method",
-        inefficient_query: "Inefficient Query",
-        cache_miss:        "Cache Miss",
-        eager_loading:     "Unnecessary Eager Loading"
+        inefficient_query: "Inefficient Query"
       }.freeze
 
       SUGGESTIONS = {
         n_plus_one:        "Use eager loading: includes(:association) or preload(:association)",
-        missing_index:     "Add a database index to the foreign key column",
-        slow_method:       "Consider async processing or caching for slow operations",
-        inefficient_query: "Refactor query to avoid loading unnecessary records",
-        cache_miss:        "Consider caching with Rails.cache or HTTP caching",
-        eager_loading:     "Remove unnecessary includes() if association is not used"
+        slow_method:       "Consider async processing (ActiveJob) or caching for this operation",
+        inefficient_query: "Refactor query to avoid loading unnecessary records"
       }.freeze
 
+      # AR query methods that signal a DB hit inside a loop
+      QUERY_METHODS = /\.(find|find_by|find_by!|where|first|last|count|sum|pluck|select|exists\?)\s*[(\s]/
+
       def self.analyze(base_path = nil)
         base_path ||= find_rails_app_path
         return [] unless base_path
@@ -38,7 +36,6 @@ module RailsForge
 
       def find_issues
         check_n_plus_one
-        check_missing_indexes
         check_slow_methods
         check_inefficient_queries
         @issues
@@ -47,23 +44,59 @@ module RailsForge
       private
 
       def check_n_plus_one
-        patterns = [/\.each\s+do.*\.find/, /\.map.*\.where/, /@.*\.all\.each/]
-        scan_files("app/controllers/**/*.rb", patterns, :n_plus_one)
-        scan_files("app/views/**/*.erb", patterns, :n_plus_one)
-      end
+        # Sliding window: if a line has an iteration method and the next 5 lines
+        # contain a raw ActiveRecord query, flag it as a potential N+1.
+        loop_pattern = /\.(each|map|each_with_object|flat_map|collect|each_with_index|each_slice)\b/
+
+        ["app/controllers/**/*.rb", "app/views/**/*.erb"].each do |glob|
+          Dir.glob(File.join(@base_path, glob)).each do |file|
+            lines = File.read(file).lines
+            lines.each_with_index do |line, i|
+              next unless line =~ loop_pattern
+              next if line =~ /^\s*#/
 
-      def check_missing_indexes
-        patterns = [/belongs_to\s+:\w+/, /add_reference/]
-        scan_files("db/migrate/**/*.rb", patterns, :missing_index)
+              window = lines[i + 1, 5].to_a.join
+              next unless window =~ QUERY_METHODS
+              # Skip if eager loading is already set up nearby
+              context = lines[[i - 5, 0].max, 15].to_a.join
+              next if context =~ /\.(includes|preload|eager_load)\s*\(/
+
+              @issues << RailsForge::Issue.new(
+                analyzer:   :performance,
+                type:       :n_plus_one,
+                severity:   "high",
+                file:       file.delete_prefix("#{@base_path}/"),
+                line:       i + 1,
+                message:    "N+1 Query: #{line.strip}",
+                suggestion: SUGGESTIONS[:n_plus_one]
+              )
+            end
+          end
+        end
       end
 
       def check_slow_methods
-        patterns = [/\.each\s+do\s*\n.*\.save/, /Process\.spawn/, /\.read/, /\.open\(.*\)/]
+        # Target synchronous external HTTP calls and process spawning
+        patterns = [
+          /Net::HTTP\.(get|post|start)\b/,
+          /HTTParty\.(get|post|put|delete|patch)\b/,
+          /RestClient\.(get|post|put|delete|patch)\b/,
+          /Faraday\.new.*\.(?:get|post|put|delete)\b/,
+          /\bProcess\.spawn\b/,
+          /`[^`]{4,}`/,   # non-trivial backtick shell commands
+          /IO\.read\b/,
+          /File\.read\b/  # reading entire files synchronously in request cycle
+        ]
         scan_files("app/**/*.rb", patterns, :slow_method)
       end
 
       def check_inefficient_queries
-        patterns = [/\.order\(.*\)\.last/, /\.where\(.*\)\.first\! /, /\.all\.to_a/, /\.select\(.+\)\.map\//]
+        patterns = [
+          /\.all\.each\b/,           # loads all records to iterate
+          /\.all\.to_a\b/,           # .to_a forces load; .all is redundant
+          /\.where\b.*\.count\b/,    # consider .size or a counter cache
+          /\.select\([^)]+\)\.map\b/ # select + map can often be a single query
+        ]
         scan_files("app/models/**/*.rb", patterns, :inefficient_query)
         scan_files("app/controllers/**/*.rb", patterns, :inefficient_query)
       end
@@ -72,8 +105,11 @@ module RailsForge
         Dir.glob(File.join(@base_path, glob)).each do |file|
           lines = File.read(file).lines
           lines.each_with_index do |line, index|
+            stripped = line.strip
+            next if stripped.start_with?("#")
+
             patterns.each do |pattern|
-              next unless line =~ pattern
+              next unless stripped =~ pattern
 
               @issues << RailsForge::Issue.new(
                 analyzer:   :performance,
@@ -81,7 +117,7 @@ module RailsForge
                 severity:   severity_for(issue_type),
                 file:       file.delete_prefix("#{@base_path}/"),
                 line:       index + 1,
-                message:    "#{ISSUE_TYPES[issue_type]}: #{line.strip}",
+                message:    "#{ISSUE_TYPES[issue_type]}: #{stripped}",
                 suggestion: SUGGESTIONS[issue_type]
               )
             end
@@ -91,9 +127,9 @@ module RailsForge
 
       def severity_for(issue_type)
         case issue_type
-        when :n_plus_one, :missing_index then "high"
-        when :inefficient_query          then "medium"
-        else                                  "low"
+        when :n_plus_one    then "high"
+        when :inefficient_query then "medium"
+        else                     "low"
         end
       end
     end

data/lib/railsforge/analyzers/refactor_analyzer.rb

@@ -8,10 +8,7 @@ module RailsForge
     class RefactorAnalyzer < BaseAnalyzer
       class RefactorError < StandardError; end
 
-      CONTROLLER_MAX_LINES   = 150
-      CONTROLLER_MAX_METHODS = 10
-      MODEL_MAX_LINES        = 200
-      MODEL_MAX_METHOD_LINES = 15
+      MAX_METHOD_LINES = 15
 
       def self.analyze(base_path = nil)
         analyze_controllers(base_path) + analyze_models(base_path)
@@ -48,51 +45,14 @@ module RailsForge
 
       def self.analyze_file(file_path, type)
         content  = File.read(file_path)
-        lines    = content.lines.count
         methods  = extract_methods(content)
         basename = File.basename(file_path)
         issues   = []
 
-        if type == :controller
-          if lines > CONTROLLER_MAX_LINES
-            issues << RailsForge::Issue.new(
-              analyzer:   :refactor,
-              type:       :oversized_controller,
-              severity:   "medium",
-              file:       basename,
-              line:       nil,
-              message:    "#{basename} has #{lines} lines (max #{CONTROLLER_MAX_LINES})",
-              suggestion: "Extract business logic to Service objects"
-            )
-          end
-
-          if methods.count > CONTROLLER_MAX_METHODS
-            issues << RailsForge::Issue.new(
-              analyzer:   :refactor,
-              type:       :too_many_methods,
-              severity:   "low",
-              file:       basename,
-              line:       nil,
-              message:    "#{basename} has #{methods.count} methods (max #{CONTROLLER_MAX_METHODS})",
-              suggestion: "Consider splitting into focused controllers"
-            )
-          end
-        else
-          if lines > MODEL_MAX_LINES
-            issues << RailsForge::Issue.new(
-              analyzer:   :refactor,
-              type:       :oversized_model,
-              severity:   "medium",
-              file:       basename,
-              line:       nil,
-              message:    "#{basename} has #{lines} lines (max #{MODEL_MAX_LINES})",
-              suggestion: "Consider extracting concerns or service objects"
-            )
-          end
-        end
-
+        # Only flag individual methods that are too long.
+        # File-level size and method-count checks are owned by ControllerAnalyzer / ModelAnalyzer.
         methods.each do |method|
-          next unless method[:lines] > MODEL_MAX_METHOD_LINES
+          next unless method[:lines] > MAX_METHOD_LINES
 
           issues << RailsForge::Issue.new(
             analyzer:   :refactor,
@@ -112,25 +72,51 @@ module RailsForge
         methods      = []
         in_method    = false
         method_name  = nil
-        method_lines = []
-
-        content.lines.each do |line|
-          if line =~ /\bdef\s+(\w+)/
-            methods << { name: method_name, lines: method_lines.count } if in_method && method_name
-            in_method    = true
-            method_name  = $1
-            method_lines = [line]
-          elsif in_method
-            method_lines << line
-            if line.strip == "end" && method_lines.count > 1
-              methods << { name: method_name, lines: method_lines.count }
-              in_method    = false
-              method_name  = nil
-              method_lines = []
+        method_start = 0
+        depth        = 0
+
+        content.lines.each_with_index do |line, idx|
+          stripped = line.strip
+          next if stripped.start_with?("#")
+
+          if stripped =~ /\bdef\s+([\w?!]+)/
+            if in_method
+              # Nested def opens a new block that needs its own end
+              depth += 1
+            else
+              in_method    = true
+              method_name  = Regexp.last_match(1)
+              method_start = idx
+              depth        = 1
             end
+            next
+          end
+
+          next unless in_method
+
+          # Count block-opening keywords that each require a matching `end`
+          opens  = 0
+          opens += stripped.scan(/\b(?:class|module)\b/).count
+          # if/unless/case/while/until/for/begin only open a block when they start
+          # the statement (not when used as trailing modifiers after other code)
+          opens += stripped.scan(/(?:^|;)\s*(?:if|unless|case|while|until|for|begin)\b/).count
+          # `do` at end of line (iterator block)
+          opens += stripped.scan(/\bdo\b(?:\s*(?:\|[^|]*\|))?\s*(?:#.*)?$/).count
+
+          closes = stripped.scan(/\bend\b/).count
+
+          depth += opens - closes
+
+          if depth <= 0
+            methods << { name: method_name, lines: idx - method_start + 1 }
+            in_method = false
+            depth     = 0
           end
         end
 
+        # Capture method that reaches end of file without an explicit `end`
+        methods << { name: method_name, lines: content.lines.count - method_start } if in_method && method_name
+
         methods
       end
     end

data/lib/railsforge/analyzers/security_analyzer.rb

@@ -7,21 +7,21 @@ module RailsForge
   module Analyzers
     class SecurityAnalyzer < BaseAnalyzer
       ISSUE_TYPES = {
-        sql_injection:    "SQL Injection",
-        mass_assignment:  "Unsafe Mass Assignment",
-        xss:              "Cross-Site Scripting (XSS)",
-        sensitive_data:   "Sensitive Data Exposure",
-        weak_crypto:      "Weak Cryptography",
+        sql_injection:     "SQL Injection",
+        mass_assignment:   "Unsafe Mass Assignment",
+        xss:               "Cross-Site Scripting (XSS)",
+        sensitive_data:    "Sensitive Data Exposure",
+        weak_crypto:       "Weak Cryptography",
         command_injection: "Command Injection"
       }.freeze
 
       SUGGESTIONS = {
-        sql_injection:    "Use parameterized queries: Model.where(column: value)",
-        mass_assignment:  "Use strong parameters with permit() instead of attr_accessible",
-        xss:              "Avoid raw/html_safe; use Rails' built-in escaping",
-        sensitive_data:   "Move secrets to environment variables or Rails credentials",
-        weak_crypto:      "Use bcrypt for passwords; SHA-256 or better for hashing",
-        command_injection: "Avoid shell interpolation; use array form of system()"
+        sql_injection:     "Use parameterized queries: Model.where(column: value)",
+        mass_assignment:   "Replace permit! with an explicit list: params.require(:model).permit(:field1, :field2)",
+        xss:               "Avoid raw/html_safe; use Rails' built-in escaping",
+        sensitive_data:    "Move secrets to environment variables or Rails credentials",
+        weak_crypto:       "Use bcrypt for passwords; SHA-256 or better for hashing",
+        command_injection: "Avoid shell interpolation; use array form of system() or Open3"
       }.freeze
 
       def self.analyze(base_path = nil)
@@ -42,6 +42,7 @@ module RailsForge
         check_xss
         check_sensitive_data
         check_weak_crypto
+        check_command_injection
         @issues
       end
 
@@ -49,42 +50,84 @@ module RailsForge
 
       def check_sql_injection
         patterns = [
-          /\.where\s*\(\s*params\./,
-          /find_by\(.*\#\{.*\}/,
-          /execute\s*\(.*\#\{.*\}/
+          # String interpolation inside where/having/order/group — the classic injection vector
+          # Use [^"]*#\{ so single-quoted content inside the string doesn't break the match
+          /\.(where|having|order|group)\s*\(.*#\{/,
+          # .order(params[...]) or .where(params[...]) — passing params directly
+          /\.(order|where|group)\s*\(\s*params[\[.]/,
+          # Raw execute with interpolation
+          /\.execute\s*\(.*#\{/,
+          # find_by with interpolation
+          /find_by[(!]?\(.*#\{/
         ]
         scan_files("app/models/**/*.rb", patterns, :sql_injection)
         scan_files("app/controllers/**/*.rb", patterns, :sql_injection)
       end
 
       def check_mass_assignment
-        patterns = [/attr_accessible/, /attr_protected/]
-        scan_files("app/models/**/*.rb", patterns, :mass_assignment)
+        # params.permit! bypasses strong parameters entirely — the modern Rails vulnerability
+        patterns = [
+          /params\.permit!\s*(?!\(.*\))/,
+          /\.permit!\s*$/
+        ]
+        scan_files("app/controllers/**/*.rb", patterns, :mass_assignment)
       end
 
       def check_xss
-        patterns = [/raw\s*\(/, /html_safe\s*$/, /\<\%=\s*[^>]+without/]
+        patterns = [
+          /\braw\s*\(/,
+          /\.html_safe\b/,        # .html_safe anywhere, not just end of line
+          /\bContent-Security-Policy.*unsafe-inline/
+        ]
         scan_files("app/views/**/*.erb", patterns, :xss)
         scan_files("app/helpers/**/*.rb", patterns, :xss)
       end
 
       def check_sensitive_data
-        patterns = [/password/, /secret/, /token/, /api_key/, /private_key/]
-        scan_files("app/models/**/*.rb", patterns, :sensitive_data)
+        # Look for hardcoded secret values (string literals), not just field names
+        # Matches: password = "abc123", api_key: "sk-...", secret: 'hardcoded'
+        # Excludes: password: <%= ENV[...] %>, password: Rails.application.credentials...
+        patterns = [
+          # Case-insensitive: catches API_KEY = "...", password: "...", SECRET_TOKEN = '...'
+          /(?:password|secret|token|api_key|private_key)\s*(?:=|:)\s*['"][^'"<\s]{6,}['"]/i
+        ]
         scan_files("config/**/*.rb", patterns, :sensitive_data)
+        scan_files("config/**/*.yml", patterns, :sensitive_data)
+        # Skip initializers that intentionally assign from env — still scan for raw literals
+        scan_files("app/models/**/*.rb", patterns, :sensitive_data)
       end
 
       def check_weak_crypto
-        patterns = [/MD5/, /SHA1/, /DES\.encrypt/, /\.encrypt\s+[^:]+$/]
+        patterns = [
+          /\bMD5\b/,
+          /\bSHA1\b/,
+          /Digest::SHA1/,
+          /\.encrypt\s*\(/,
+          /DES\.encrypt/
+        ]
         scan_files("app/**/*.rb", patterns, :weak_crypto)
       end
 
+      def check_command_injection
+        patterns = [
+          /`[^`]*#\{/,                  # backtick shell execution with interpolation
+          /system\s*\([^)]*#\{/,        # system() with interpolation
+          /exec\s*\([^)]*#\{/,          # exec() with interpolation
+          /Open3\.\w+\s*\([^)]*#\{/,   # Open3 with interpolation
+          /IO\.popen\s*\([^)]*#\{/      # IO.popen with interpolation
+        ]
+        scan_files("app/**/*.rb", patterns, :command_injection)
+      end
+
       def scan_files(glob, patterns, issue_type)
         Dir.glob(File.join(@base_path, glob)).each do |file|
           lines = File.read(file).lines
           lines.each_with_index do |line, index|
+            stripped = line.strip
+            next if stripped.start_with?('#')
+
             patterns.each do |pattern|
-              next unless line =~ pattern
+              next unless stripped =~ pattern
 
               @issues << RailsForge::Issue.new(
                 analyzer:   :security,
@@ -92,7 +135,7 @@ module RailsForge
                 severity:   severity_for(issue_type),
                 file:       file.delete_prefix("#{@base_path}/"),
                 line:       index + 1,
-                message:    "#{ISSUE_TYPES[issue_type]}: #{line.strip}",
+                message:    "#{ISSUE_TYPES[issue_type]}: #{stripped}",
                 suggestion: SUGGESTIONS[issue_type]
               )
             end

data/lib/railsforge/analyzers/spec_analyzer.rb

@@ -6,7 +6,16 @@ require_relative "base_analyzer"
 module RailsForge
   module Analyzers
     class SpecAnalyzer < BaseAnalyzer
-      GENERATOR_TYPES = %w[services queries jobs forms presenters policies serializers].freeze
+      # Explicit singular mapping — .chop fails for irregular plurals like queries→querie, policies→policie
+      SPEC_TYPES = {
+        "services"    => "service",
+        "queries"     => "query",
+        "jobs"        => "job",
+        "forms"       => "form",
+        "presenters"  => "presenter",
+        "policies"    => "policy",
+        "serializers" => "serializer"
+      }.freeze
 
       def self.analyze(base_path = nil)
         base_path ||= find_rails_app_path
@@ -14,14 +23,15 @@ module RailsForge
 
         issues = []
 
-        GENERATOR_TYPES.each do |type|
-          singular   = type.chop
+        SPEC_TYPES.each do |type, singular|
           app_path   = File.join(base_path, "app", singular)
           spec_path  = File.join(base_path, "spec", type)
 
           next unless Dir.exist?(app_path)
 
-          app_files  = Dir.glob(File.join(app_path, "**", "*.rb")).map { |f| File.basename(f, ".rb") }
+          app_files  = Dir.glob(File.join(app_path, "**", "*.rb"))
+                         .reject { |f| File.basename(f) =~ /^application_/ }
+                         .map { |f| File.basename(f, ".rb") }
           spec_files = Dir.exist?(spec_path) ? Dir.glob(File.join(spec_path, "**", "*_spec.rb")).map { |f| File.basename(f, "_spec.rb") } : []
 
           (app_files - spec_files).each do |missing|

data/lib/railsforge/version.rb

@@ -1,5 +1,5 @@
 # Version module for RailsForge gem
 # Defines the current version of the gem
 module RailsForge
-  VERSION = "2.1.0"
+  VERSION = "2.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: railsforge
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - RailsForge Contributors