suspenders 20230113.0 → 20240516.0

data/RELEASING.md

@@ -1,18 +0,0 @@
-# Releasing
-
-1. Update `NEWS.md` to reflect the changes since last release.
-2. Update `lib/suspenders/version.rb` file accordingly.
-3. Commit changes. There shouldn't be code changes, and thus CI doesn't need to
-   run; you can add `[ci skip]` to the commit message.
-4. Tag the release: `git tag vVERSION -a -s`. The tag message should contain the
-   appropriate `NEWS.md` subsection.
-5. Push changes: `git push --tags`
-6. Build and publish to rubygems:
-   ```sh
-   gem build suspenders.gemspec
-   gem push suspenders-*.gem
-   ```
-7. Add a new GitHub release:
-   https://github.com/thoughtbot/suspenders/releases/new?tag=vVERSION
-8. Announce the new release, making sure to thank the contributors who helped
-   shape this version!

data/bin/suspenders

@@ -1,50 +0,0 @@
-#!/usr/bin/env ruby
-require 'pathname'
-
-source_path = (Pathname.new(__FILE__).dirname + '../lib').expand_path
-$LOAD_PATH << source_path
-
-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]
-  puts Suspenders::VERSION
-  exit 0
-end
-
-templates_root = File.expand_path(File.join("..", "templates"), File.dirname(__FILE__))
-Suspenders::AppGenerator.source_root templates_root
-Suspenders::AppGenerator.source_paths << Rails::Generators::AppGenerator.source_root << templates_root
-
-Suspenders::AppGenerator.start

data/docs/heroku_deploy.md

@@ -1,19 +0,0 @@
-# Deploying to Heroku
-
-## Setup
-
-Deploying to Heroku requires two additional steps:
-
-1. Set the following environment variables:
-
-- `ASSET_HOST`: `siteURL.herokuapp.com`
-- `APPLICATION_HOST`: `siteURL.herokuapp.com`
-- `SMTP_ADDRESS`: `smtp.example.com`
-- `SMTP_DOMAIN`: `example.com`
-- `SMTP_USERNAME`: `username`
-- `SMTP_PASSWORD`: `password`
-- `AUTO_MIGRATE_DB`: `true`
-
-## Execution
-
-- Use the `./bin/deploy` convention for deploying to Heroku

data/docs/rails_7.md

@@ -1,5 +0,0 @@
-# Rails 7
-
-To create a new Rails 7 app with Suspenders, you need to have `node >= 14.6`.
-
-After the app is created, run the server with `bin/dev`.

data/lib/suspenders/actions/strip_comments_action.rb

@@ -1,254 +0,0 @@
-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

@@ -1,106 +0,0 @@
-module Suspenders
-  module Actions
-    def replace_in_file(relative_path, find, replace)
-      path = File.join(destination_root, relative_path)
-      contents = IO.read(path)
-      unless contents.gsub!(find, replace)
-        raise "#{find.inspect} not found in #{relative_path}"
-      end
-      File.write(path, contents)
-    end
-
-    def action_mailer_host(rails_env, host)
-      config = "config.action_mailer.default_url_options = { host: #{host} }"
-      configure_environment(rails_env, config)
-    end
-
-    def action_mailer_asset_host(rails_env, host)
-      config = "config.action_mailer.asset_host = #{host}"
-      configure_environment(rails_env, config)
-    end
-
-    def configure_environment(rails_env, config)
-      inject_into_file(
-        "config/environments/#{rails_env}.rb",
-        "\n  #{config}",
-        before: "\nend"
-      )
-    end
-
-    def expand_json(file, data)
-      action ExpandJson.new(destination_root, file, data)
-    end
-
-    def gem(*args)
-      options = args.extract_options!
-      name, *versions = args
-
-      parts = [quote(name)]
-
-      if (versions = versions.any? ? versions : options.delete(:version))
-        versions = Array(versions)
-        versions.each do |version|
-          parts << quote(version)
-        end
-      end
-
-      parts << quote(options) unless options.empty?
-
-      str = []
-      str << indentation
-      str << "gem #{parts.join(", ")}"
-      append_file "Gemfile", %(\n#{str.join}\n), verbose: false
-    end
-
-    class ExpandJson
-      def initialize(destination_root, file, data)
-        @destination_root = destination_root
-        @file = file
-        @data = data
-      end
-
-      def invoke!
-        write_out { |existing_json| existing_json.deep_merge(data) }
-      end
-
-      def revoke!
-        write_out { |existing_json| hash_unmerge(existing_json, data) }
-      end
-
-      private
-
-      attr_reader :destination_root, :file, :data
-
-      def write_out
-        new_json = yield(existing_json)
-        IO.write(destination_file, JSON.pretty_generate(new_json))
-      end
-
-      def destination_file
-        File.join(destination_root, file)
-      end
-
-      def existing_json
-        JSON.parse(IO.read(destination_file), symbolize_names: true)
-      rescue Errno::ENOENT
-        {}
-      end
-
-      def hash_unmerge(hash, subhash)
-        subhash.reduce(hash) do |acc, (k, v)|
-          if hash.has_key?(k)
-            if v == hash[k]
-              acc.except(k)
-            elsif v.is_a?(Hash)
-              acc.merge(k => hash_unmerge(hash[k], v))
-            else
-              acc
-            end
-          else
-            acc
-          end
-        end
-      end
-    end
-  end
-end

data/lib/suspenders/adapters/heroku.rb

@@ -1,136 +0,0 @@
-module Suspenders
-  module Adapters
-    class Heroku
-      def initialize(app_builder)
-        @app_builder = app_builder
-      end
-
-      def set_heroku_remotes
-        remotes = <<~SHELL
-          #{command_to_join_heroku_app("staging")}
-          #{command_to_join_heroku_app("production")}
-
-          git config heroku.remote staging
-        SHELL
-
-        app_builder.append_file "bin/setup", remotes
-      end
-
-      def create_staging_heroku_app(flags)
-        app_name = heroku_app_name_for("staging")
-
-        run_toolbelt_command "create #{app_name} #{flags}", "staging"
-      end
-
-      def create_production_heroku_app(flags)
-        app_name = heroku_app_name_for("production")
-
-        run_toolbelt_command "create #{app_name} #{flags}", "production"
-      end
-
-      def set_heroku_rails_secrets
-        %w[staging production].each do |environment|
-          run_toolbelt_command(
-            "config:add SECRET_KEY_BASE=#{generate_secret}",
-            environment
-          )
-        end
-      end
-
-      def set_heroku_honeybadger_env
-        %w[staging production].each do |environment|
-          run_toolbelt_command(
-            "config:add HONEYBADGER_ENV=#{environment}",
-            environment
-          )
-        end
-      end
-
-      def set_heroku_backup_schedule
-        %w[staging production].each do |environment|
-          run_toolbelt_command(
-            "pg:backups:schedule DATABASE_URL --at '10:00 UTC'",
-            environment
-          )
-        end
-      end
-
-      def create_heroku_pipeline
-        pipelines_plugin = `heroku help | grep pipelines`
-        if pipelines_plugin.empty?
-          puts "You need heroku pipelines plugin. Run: brew upgrade heroku-toolbelt"
-          exit 1
-        end
-
-        run_toolbelt_command(
-          "pipelines:create #{heroku_app_name} \
-            -a #{heroku_app_name}-staging --stage staging",
-          "staging"
-        )
-
-        run_toolbelt_command(
-          "pipelines:add #{heroku_app_name} \
-            -a #{heroku_app_name}-production --stage production",
-          "production"
-        )
-      end
-
-      def set_heroku_application_host
-        %w[staging production].each do |environment|
-          run_toolbelt_command(
-            "config:add APPLICATION_HOST=#{heroku_app_name}-#{environment}.herokuapp.com",
-            environment
-          )
-        end
-      end
-
-      def set_heroku_buildpacks
-        %w[staging production].each do |environment|
-          run_toolbelt_command(
-            "buildpacks:add --index 1 heroku/nodejs",
-            environment
-          )
-          run_toolbelt_command(
-            "buildpacks:add --index 2 heroku/ruby",
-            environment
-          )
-        end
-      end
-
-      private
-
-      attr_reader :app_builder
-
-      def command_to_join_heroku_app(environment)
-        heroku_app_name = heroku_app_name_for(environment)
-        <<~SHELL
-
-          if heroku apps:info --app #{heroku_app_name} > /dev/null 2>&1; then
-            git remote add #{environment} git@heroku.com:#{heroku_app_name}.git || true
-            printf 'You are a collaborator on the "#{heroku_app_name}" Heroku app\n'
-          else
-            printf 'Ask for access to the "#{heroku_app_name}" Heroku app\n'
-          fi
-        SHELL
-      end
-
-      def heroku_app_name
-        app_builder.app_name.dasherize
-      end
-
-      def heroku_app_name_for(environment)
-        "#{heroku_app_name}-#{environment}"
-      end
-
-      def generate_secret
-        SecureRandom.hex(64)
-      end
-
-      def run_toolbelt_command(command, environment)
-        app_builder.run(
-          "heroku #{command} --remote #{environment}"
-        )
-      end
-    end
-  end
-end