suspenders 1.54.1 → 1.56.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1c3a5fd298d2c49ceed3d4b3c79d99590aae75259c0f4ec6f06bd6f244336d3
-  data.tar.gz: c880d208a127a68da87b63a33da39fade1abf8e6c6d6b754806771be68e23e03
+  metadata.gz: 683a61a7377c93edb0f396688cd578f338bcdc5de7ffb28276165e1bb81edcc4
+  data.tar.gz: c5a8d3b44cd4c8f9277b0f7d4c223b034b4ae93d050830c3f8755eef1766814e
 SHA512:
-  metadata.gz: 35d40b50ca80e2248efe6cc0c5ac5b87eff319aa6638e9293bafbb798081a1143b7a2d0e5907261bf68ceece79f482471c0762782a6d4cfebc69b0871fe8ea28
-  data.tar.gz: d02195af5d9673603233ce092cae10b4a2e2cf49697d8129c808a378d743d008f9046787b53ec050ec9a4450433fb063a7fbc4308fb5c16efc17d3ed73de291a
+  metadata.gz: 7646058fca03e48da09e9a3a26ec4ca21f9e07a51ff2394f548b231c1b50d78ea514c27589473039ed9cb86e9fddb6614ca00bad68dbe19800590f56e6124c46
+  data.tar.gz: 67cffd8fa9c7fe841ec6595545bb200b38f500baef0036b9bf29be8c7950b59fb27ed8f2094933fd9d8b00760981a516bd17f6d5e83765290d0ba74fac44c73f

data/.ruby-version

@@ -1 +1 @@
-2.6.6
+2.7.4

data/CONTRIBUTING.md

@@ -48,7 +48,7 @@ All new contributions must be within the generator framework, as described in
 
 ## Versions
 
-To update the Ruby version, change `.ruby-version` and `.travis.yml`.
+To update the Ruby version, change `.ruby-version`.
 
 If you see this error while running tests:
 

data/NEWS.md

@@ -1,4 +1,41 @@
-Unreleased
+1.56.1 (July 17, 2022)
+
+Fixes a critical error with the previous release
+
+* Run database migrations as the last step of bin/suspenders
+* Fix bundler error on bin/suspenders script
+
+1.56.0 (July 4, 2022)
+
+Maintenance release
+
+* Fixed: Make Suspenders fail if running with an unsupported Rails version
+* Added: Update default configuration to use request specs
+* Added: Add missing Errno::ECONNREFUSED to HTTP_ERRORS
+* Fixed: Drop use of git in gemspec
+* Fixed: Enforce bundler >= 2.1.0
+* Fixed: Make suspenders abort when something goes wrong
+* Fixed: Reliability and aesthetics of the config files comment stripper
+* Fixed: ActionMailer asset host in the production configuration
+* Added: Configure the oj gem (fast JSON parsing) when generating a new application
+* Fixed: Improve error message of the match_contents matcher
+* Fixed: Convert generator tests to unit tests thus speeding up the test suite
+* Removed: Preloader generator / spring
+* Added: Pull in DATABASE_URL env var explicitly in database.yml
+* Removed: Travis CI configuration
+* Upgraded: Ruby to version 2.7.4
+* Added: A GitHub Action for CI
+* Fixed: Run bin/suspenders in both CLI and tests against a fixed Rails version
+
+1.55.1 (September 11, 2020)
+
+* Fixed: Missing newline in generated development config
+
+1.55.0 (July 15, 2020)
+
+* Changed: lint generator to install standard instead of RuboCop
+* Changed: profile generator and timeout generator to write to `.sample.env`
+  instead of `.env`
 
 1.54.1 (June 30, 2020)
 

data/README.md

@@ -1,4 +1,7 @@
-# Suspenders [![Build Status](https://secure.travis-ci.org/thoughtbot/suspenders.svg?branch=master)](http://travis-ci.org/thoughtbot/suspenders) [![Reviewed by Hound](https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg)](https://houndci.com)
+# Suspenders
+
+[![Build Status](https://github.com/thoughtbot/suspenders/actions/workflows/main.yml/badge.svg?branch=master)](https://github.com/thoughtbot/suspenders/actions)
+[![Reviewed by Hound](https://img.shields.io/badge/Reviewed_by-Hound-8E64B0.svg)](https://houndci.com)
 
 Suspenders is the base Rails application used at
 [thoughtbot](https://thoughtbot.com/).
@@ -64,8 +67,6 @@ And development gems like:
   unused eager loading
 * [Bundler Audit](https://github.com/rubysec/bundler-audit) for scanning the
   Gemfile for insecure dependencies based on published CVEs
-* [Spring](https://github.com/rails/spring) for fast Rails actions via
-  pre-loading
 * [Web Console](https://github.com/rails/web-console) for better debugging via
   in-browser IRB consoles.
 
@@ -155,21 +156,13 @@ bypass this with the `--skip-git` option:
 You can optionally create a GitHub repository for the suspended Rails app. It
 requires that you have [Hub](https://github.com/github/hub) on your system:
 
-    curl https://hub.github.com/standalone -sLo ~/bin/hub && chmod +x ~/bin/hub
+    brew install hub # macOS, for other systems see https://github.com/github/hub#installation
     suspenders app --github organization/project
 
 This has the same effect as running:
 
     hub create organization/project
 
-## Spring
-
-Suspenders uses [spring](https://github.com/rails/spring) by default.
-It makes Rails applications load faster, but it might introduce confusing issues
-around stale code not being refreshed.
-If you think your application is running old code, run `spring stop`.
-And if you'd rather not use spring, add `DISABLE_SPRING=1` to your login file.
-
 ## Dependencies
 
 Suspenders requires the latest version of Ruby.

data/bin/suspenders

@@ -4,14 +4,41 @@ require 'pathname'
 source_path = (Pathname.new(__FILE__).dirname + '../lib').expand_path
 $LOAD_PATH << source_path
 
-require 'suspenders'
+activate_rails_version = ->(rails_version) do
+  rails_bin_path = Gem.activate_bin_path("railties", "rails", rails_version)
+  rails_path = File.expand_path("../..", rails_bin_path)
+  $LOAD_PATH.unshift(rails_path)
+end
+
+if str = ARGV.first
+  str = str.b[/\A_(.*)_\z/, 1]
+
+  if str && Gem::Version.correct?(str)
+    rails_version = str
+    ARGV.shift
+
+    begin
+      activate_rails_version.call(rails_version)
+    rescue Gem::GemNotFoundException
+      abort "Suspenders error: Unable to find Rails version #{rails_version}"
+    end
+  else
+    require "suspenders/version"
+
+    spec = Gem::Specification.find_by_name("rails", Suspenders::RAILS_VERSION)
+
+    activate_rails_version.call(spec.version.to_s)
+  end
+end
+
+require "suspenders"
 
 if ARGV.empty?
   puts "Please provide a path for the new application"
   puts
   puts "See --help for more info"
   exit 0
-elsif ['-v', '--version'].include? ARGV[0]
+elsif ["-v", "--version"].include? ARGV[0]
   puts Suspenders::VERSION
   exit 0
 end

data/lib/suspenders/actions/strip_comments_action.rb

@@ -0,0 +1,254 @@
+require "parser/current"
+
+module Suspenders
+  module Actions
+    class StripCommentsAction
+      class << self
+        def call(source)
+          parser = Parser::CurrentRuby.new
+
+          source
+            .then { |s| strip_comments(s, parser) }
+            .then { |s| strip_trailing_whitespace(s) }
+            .then { |s| strip_dup_newlines(s) }
+            .then { |s| strip_leading_scope_newlines(s, parser) }
+        end
+
+        private
+
+        def strip_comments(source, parser)
+          StripComments.call(source, parser.reset)
+        end
+
+        def strip_trailing_whitespace(source)
+          source.gsub(/[[:blank:]]+$/, "")
+        end
+
+        def strip_dup_newlines(source)
+          source.gsub(/\n{2,}/, "\n\n")
+        end
+
+        def strip_leading_scope_newlines(source, parser)
+          StripLeadingScopeNewlines.call(source, parser.reset)
+        end
+      end
+
+      # Strips full-line and inline comments from a buffer but does
+      # not remove whitespaces or newlines after the fact. Example
+      # input:
+      #
+      #     MyGem.application.configure do |config|
+      #       # Full-line comment
+      #       config.option1 = :value # Inline comment
+      #     end
+      #
+      # The output is:
+      #
+      #     MyGem.application.configure do |config|
+      #
+      #       config.option1 = :value
+      #     end
+      class StripComments
+        class << self
+          def call(source, parser)
+            buffer = Parser::Source::Buffer.new(nil, source: source)
+            rewriter = Parser::Source::TreeRewriter.new(buffer)
+
+            _, comments = parser.parse_with_comments(buffer)
+
+            comments.each do |comment|
+              strip_comment(comment, buffer, rewriter)
+            end
+
+            rewriter.process
+          end
+
+          private
+
+          def strip_comment(comment, buffer, rewriter)
+            expr = comment.location.expression
+
+            if full_line_comment?(expr)
+              expr = full_line_comment_expr(expr, buffer)
+            end
+
+            rewriter.remove(expr)
+          end
+
+          def full_line_comment_expr(expr, buffer)
+            pos = BackwardStringScanner.beginning_of_line_pos(expr, expr.begin_pos)
+
+            Parser::Source::Range.new(buffer, pos, expr.end_pos + 1)
+          end
+
+          def full_line_comment?(expr)
+            expr.source == expr.source_line.lstrip
+          end
+        end
+      end
+
+      # A tiny, non-stateful backward string scanner somewhat inspired
+      # by Ruby's StringScanner. Ruby's StringScanner is unable to
+      # seek backward on a string.
+      class BackwardStringScanner
+        def self.beginning_of_line_pos(expr, initial_pos)
+          skip_before(expr, initial_pos) { |char| char == "\n" }
+        end
+
+        def self.skip_before(expr, initial_pos, &block)
+          skip_until(expr, initial_pos, -1, &block)
+        end
+
+        def self.skip_until(expr, initial_pos, lookup_inc = 0)
+          pos = initial_pos
+
+          loop do
+            break if pos.zero?
+            char = expr.source_buffer.source[pos + lookup_inc]
+            break if yield(char)
+            pos -= 1
+          end
+
+          pos
+        end
+      end
+
+      # The intent of this class is purely aesthetic: remove leading
+      # newlines inside of code scopes like blocks and begin/end.
+      # Example input:
+      #
+      #     module MyGem
+      #
+      #       MyGem.application.configure do |config|
+      #
+      #         config.option1 = true
+      #
+      #         config.option2 = false
+      #       end
+      #     end
+      #
+      # The output is:
+      #
+      #     module MyGem
+      #       MyGem.application.configure do |config|
+      #         config.option1 = true
+      #
+      #         config.option2 = false
+      #       end
+      #     end
+      class StripLeadingScopeNewlines
+        def self.call(source, parser)
+          buffer = Parser::Source::Buffer.new(nil, source: source)
+          ast = parser.parse(buffer)
+
+          LeadingNewlineStripRewriter.new.rewrite(buffer, ast).lstrip
+        end
+
+        class LeadingNewlineStripRewriter < Parser::TreeRewriter
+          def on_module(node)
+            strip_newline_before(node.children[1])
+            strip_newline_after(node.children.last)
+
+            super
+          end
+
+          def on_class(node)
+            strip_newline_before(node.children[2])
+            strip_newline_after(node.children.last)
+
+            super
+          end
+
+          def on_begin(node)
+            handle_begin(node)
+
+            super
+          end
+
+          def on_kwbegin(node)
+            strip_newline_before(node.children[0])
+            strip_newline_after(node.children.last)
+
+            handle_begin(node)
+
+            super
+          end
+
+          def on_block(node)
+            strip_newline_before(node.children[2])
+            strip_newline_after(node.children.last)
+
+            super
+          end
+
+          private
+
+          def handle_begin(node)
+            strip_blank_lines_between_setter_calls(node.children)
+
+            node.children.each do |child_node|
+              send("on_#{child_node.type}", child_node)
+            end
+          end
+
+          def strip_blank_lines_between_setter_calls(children)
+            pairs = children.each_cons(2).to_a
+
+            pairs.each do |(node_before, node_after)|
+              if setter_call?(node_before) && setter_call?(node_after)
+                strip_newline_before(node_after)
+              end
+            end
+          end
+
+          def setter_call?(node)
+            node.children[1].to_s.end_with?("=")
+          end
+
+          def strip_newline_before(node)
+            return if node.nil?
+
+            expr = node.location.expression
+            end_pos = find_end_pos(expr, expr.begin_pos)
+            begin_pos = find_begin_pos(expr, end_pos)
+
+            strip_source_range(expr, begin_pos, end_pos)
+          end
+
+          def strip_newline_after(node)
+            return if node.nil?
+
+            expr = node.location.expression
+            source = expr.source_buffer.source
+
+            if source[expr.end_pos + 1] == "\n"
+              strip_source_range(expr, expr.end_pos, expr.end_pos + 1)
+            end
+          end
+
+          def find_end_pos(expr, begin_pos)
+            BackwardStringScanner.skip_until(expr, begin_pos) do |char|
+              char == "\n"
+            end
+          end
+
+          def find_begin_pos(expr, end_pos)
+            BackwardStringScanner.skip_before(expr, end_pos) do |char|
+              char != "\n" && char != " "
+            end
+          end
+
+          def strip_source_range(expr, begin_pos, end_pos)
+            remove(
+              Parser::Source::Range.new(
+                expr.source_buffer,
+                begin_pos,
+                end_pos
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/suspenders/actions.rb

@@ -6,7 +6,7 @@ module Suspenders
       unless contents.gsub!(find, replace)
         raise "#{find.inspect} not found in #{relative_path}"
       end
-      File.open(path, "w") { |file| file.write(contents) }
+      File.write(path, contents)
     end
 
     def action_mailer_host(rails_env, host)

data/lib/suspenders/adapters/heroku.rb

@@ -7,8 +7,8 @@ module Suspenders
 
       def set_heroku_remotes
         remotes = <<~SHELL
-          #{command_to_join_heroku_app('staging')}
-          #{command_to_join_heroku_app('production')}
+          #{command_to_join_heroku_app("staging")}
+          #{command_to_join_heroku_app("production")}
 
           git config heroku.remote staging
         SHELL
@@ -29,28 +29,28 @@ module Suspenders
       end
 
       def set_heroku_rails_secrets
-        %w(staging production).each do |environment|
+        %w[staging production].each do |environment|
           run_toolbelt_command(
             "config:add SECRET_KEY_BASE=#{generate_secret}",
-            environment,
+            environment
           )
         end
       end
 
       def set_heroku_honeybadger_env
-        %w(staging production).each do |environment|
+        %w[staging production].each do |environment|
           run_toolbelt_command(
             "config:add HONEYBADGER_ENV=#{environment}",
-            environment,
+            environment
           )
         end
       end
 
       def set_heroku_backup_schedule
-        %w(staging production).each do |environment|
+        %w[staging production].each do |environment|
           run_toolbelt_command(
             "pg:backups:schedule DATABASE_URL --at '10:00 UTC'",
-            environment,
+            environment
           )
         end
       end
@@ -65,34 +65,34 @@ module Suspenders
         run_toolbelt_command(
           "pipelines:create #{heroku_app_name} \
             -a #{heroku_app_name}-staging --stage staging",
-          "staging",
+          "staging"
         )
 
         run_toolbelt_command(
           "pipelines:add #{heroku_app_name} \
             -a #{heroku_app_name}-production --stage production",
-          "production",
+          "production"
         )
       end
 
       def set_heroku_application_host
-        %w(staging production).each do |environment|
+        %w[staging production].each do |environment|
           run_toolbelt_command(
             "config:add APPLICATION_HOST=#{heroku_app_name}-#{environment}.herokuapp.com",
-            environment,
+            environment
           )
         end
       end
 
       def set_heroku_buildpacks
-        %w(staging production).each do |environment|
+        %w[staging production].each do |environment|
           run_toolbelt_command(
             "buildpacks:add --index 1 heroku/nodejs",
-            environment,
+            environment
           )
           run_toolbelt_command(
             "buildpacks:add --index 2 heroku/ruby",
-            environment,
+            environment
           )
         end
       end
@@ -128,7 +128,7 @@ module Suspenders
 
       def run_toolbelt_command(command, environment)
         app_builder.run(
-          "heroku #{command} --remote #{environment}",
+          "heroku #{command} --remote #{environment}"
         )
       end
     end