hephaestus 0.8.12.1 → 0.8.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89c0585bf79ff89a4a35d183a6bdec69ec180effa6c5254aec22467093efeefa
-  data.tar.gz: 0aefd45fc0dd8549a845f49b510ba9ec7fbe991c85af3f7c9e65e79ed613c9ca
+  metadata.gz: f10ca0de88c450f5e8febca532d785bb3e0b9ae1392e84a89e5bc69822936bf4
+  data.tar.gz: 5558246e1b43416722c74d86f35527b39894834524bb863c9cc7380233b661c5
 SHA512:
-  metadata.gz: 1dcf277f2074215cbf3b207d99534f5bdcf2fd6deb9ed62d6c10e3c87680da8184a30a7e5cfce6ce58e05df6173fb1d808e1fc48edb45f4f1ee4627af2bf2054
-  data.tar.gz: 96c5fbb95236e5fe15fd538742c89010e6d9a581b2cfbf3ce70677b7412a1a48301c8f58a68521b7f0b0d45a79f253ca0f5eb31f2475049584d322c491b6214a
+  metadata.gz: c38a22b9ac3409157e42f26aea6b82ea3b488c984b43e18918c8d4cf12aee16ec446fad81aa0d04cecad9ad5676130e4cc0990605d8502f2131af37e3d44d152
+  data.tar.gz: 04aa1224bad239a6f7ef662d1f00a61ffb0a560ab882472e7afcad07f820600f7f3e6f2aa70ef639338abfa5264f6544b99e096f75f0b4922c79425a77598ed9

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+# [v0.8.13] - 17-12-2024
+## What's Changed
+* Move content to clio by @gjtorikian in https://github.com/yettoapp/hephaestus/pull/99
+* Remove outro, point to Clio by @gjtorikian in https://github.com/yettoapp/hephaestus/pull/100
+
+
+**Full Changelog**: https://github.com/yettoapp/hephaestus/compare/v0.8.12.2...v0.8.13
+# [v0.8.12.2] - 17-12-2024
+## What's Changed
+* Fixups by @gjtorikian in https://github.com/yettoapp/hephaestus/pull/97
+
+
+**Full Changelog**: https://github.com/yettoapp/hephaestus/compare/v0.8.12.1...v0.8.12.2
 # [v0.8.12.1] - 16-12-2024
 ## What's Changed
 * general updates by @gjtorikian in https://github.com/yettoapp/hephaestus/pull/95

data/README.md

@@ -26,187 +26,13 @@ Where `app` represents the name of the platform you'd like to interact with, lik
 If you're working on updating/testing this gem locally, you may also try:
 
 ```
-rm -rf plug-app && DEBUG=1 bundle exec bin/hephaestus plug-app
+rm -rf plug-app && DEBUG=1 bundle exec hephaestus/bin/hephaestus plug-app
 ```
 
 This way you can wipe the dir and quickly iterate on new changes.
 
 If you're having trouble connecting to the Internet, you can set `HEPHAESTUS_NO_EXTERNAL=1`.
 
-## Building upon the base
-
-Most of the files which Hephaestus creates for you shouldn't need much modification. The information below is part-informative, part-guidelines on how to extend the generated code for your specific plug.
-
-### Controllers
-
-#### `ApplicationController`
-
-Your application controller inherits from `Hephaestus::ApplicationController`, and handles the basics of request/response cycles. Two common callbacks to add here are:
-
-- `before_action :set_request_span_context`, which lets you add data to the `OpenTelemetry` trace before a request occurs
-- `after_action :set_response_span_context`, similarly, lets you add to the trace after the response is sent
-
-For examples on how to integrate with these, check out `plug-email`.
-
-#### `SettingsController`
-
-Typically, your settings inherit directly from Hephaestus. We'll discuss more about how this works in `routes.rb`. Either way, you'll define two files:
-
-- `app/views/settings/new.json.jbuilder`
-- `app/views/settings/edit.json.jbuilder`
-
-Define the settings UI in these files. See `plug-email` for an example of a settings page with no customizations.
-
-However, for multi-step plugs, it's common to expect customized steps. If you'd like to extend the settings controller, create a file with one of two methods:
-
-- `new`
-- `edit`
-
-You only need to define these methods if you're actually overriding the action—often, this only means `edit`. If you do define methods in this controller, remember to add `before_action :ensure_json_request` at the top. For examples on settings pages which have _some_ customization, see `plug-github` and `plug-linear`. For an example of a totally custom settings page, see `plug-zendesk`.
-
-#### `AppController`
-
-The logic to communicate with your platform sits in `AppController`. Every plug is unique, so the requirements for your platform varies!
-
-At a minimum, though, you should place all the logic which authenticates requests in the `Authable` concern. See `plug-github` and `plug-linear` for practical examples.
-
-#### `YettoController`
-
-Place the logic which receives webhooks from Yetto in the `YettoController`. This controller must `include Hephaestus::ValidatesFromYetto`, and must define `before_action :from_yetto?`. Beyond that, you can respond to events as they come in, and fire jobs to perform the actions your platform needs to integrate with Yetto.
-
-### Jobs
-
-Jobs are at the heart of plugs, because they perform time-sensitive work asynchronously. Since Hephaestus already creates an `ApplicationJob` which inherits from `Hephaestus::ApplicationJob`, there isn't much else you need to do, other than define your jobs.
-
-Whenever you need to integrate with Yetto, just pass the appropriate arguments to `Hephaestus::UpdateYettoJob`.
-
-The bulk of your plug logic should exist within these jobs. Keep the controllers as place to authenticate incoming requests and respond with appropriate status codes.
-
-### Constants
-
-Place any and all constants in the file called `lib/constants.rb`.
-
-Note that Hepheastus provides several convenience methods and constants for you. These are:
-
-- `plug_shortname`: the downcased version of the plug (e.g., `Slack => slack`, `GitHub => github`)
-- `plug_name`: The proper name of the plug (e.g., `Slack`, `GitHub`)
-- `plug_url`: The plug's URL (e.g., `email{.plugs.yetto.app,.plugs.yetto.dev,.ngrok.io}`)
-
-### Application Configuration
-
-The typical Rails' environment configs (`config/environments/{development.rb,test.rb,production.rb}`) are managed by Hephaestus. However, any plug can define their own environment files as well. These are added after Hephaestus' default configuration.
-
-The `test.rb` file in `plug-email` provides an example of this.
-
-#### Upgrading Rails
-
-Upgrading Rails always introduces breaking changes, even between minor releases. To ensure that a plug still works after a Rails upgrade, first, add
-
-```ruby
-rails "x"
-```
-
-to your plug's Gemfile (where `"x"` is the new Rails version.) Note that this means plugs can run Rails versions independently of what Hephaestus provides (although variance is not recommended, it can help during the upgrade process).
-
-Next, call `rails app:update:configs`. You can pretty much ignore every changed file, except the one that starts with `new_framework_defaults_`. Use these values to slowly reintroduce the new configuration changes, as described in [the Rails documentation](https://guides.rubyonrails.org/v8.0/upgrading_ruby_on_rails.html#configure-framework-defaults).
-
-### Integrating the Plug with the Engine
-
-There are certain times where the child application needs to "inject" data into Hephaestus. These are typically customizations that are unique to the plug. Place these customizations in `config/application.rb`, inside of an `initializer :engines_blank_point do` block.
-
-At a minimum, you'll need to define your plug's API version, and the version of the Yetto API it's communicating with:
-
-```ruby
-initializer :engines_blank_point do
-  config.yetto_api_version = "2023-03-06"
-  config.plug_api_version = "2023-03-06"
-end
-```
-
-You can also define several other customizations:
-
-- `config.tracing_body_filters`: use this to scrub out any sensitive data coming in from your platform, to prevent it from leaking in our metrics aggregator. See the override in `plug-email` for an example. The default is to simply log everything (after running it through [Rails' `ParameterFilter`](https://api.rubyonrails.org/v7.1/classes/ActiveSupport/ParameterFilter.html), of course), which may not be a good idea!
-- `config.enhance_update_yetto_job`: use this to include any plug-specific logic which needs to occur as part of issuing calls to the Yetto API
-
-For an example of both these customizations, see `plug-email`.
-
-There's also middleware you can use to protect any endpoint with an OpenAPI schema. To do so, add:
-
-```ruby
-require "hephaestus/middleware/openapi_validation"
-config.middleware.use(Hephaestus::Middleware::OpenapiValidation, match_path: "/app/2023-03-06/path/", limit_methods_to: ["POST"], spec: Rails.root.join("lib/schemas/path/2023-03-06/openapi.json"))
-```
-
-In this example, any `POST` to `match_path` is protected by the OpenAPI `spec` provided.
-
-### Services
-
-Place any HTTP communication necessary to communicate with your platform in this directory. All other code should which communicates to your plug should rely on methods defined in this file.
-
-See any of the plugs for an example of how to define this interaction, particularly with `httpsensible`.
-
-### Routes
-
-If you do not have any custom actions to perform in the settings controller, define your settings pages as:
-
-```ruby
-# you must always include this line when referring to `hephaestus_settings`
-HephaestusSettingsController = Hephaestus::SettingsController
-
-get "/api/#{Rails.application.config.plug_api_version}/settings", to: "hephaestus_settings#new"
-get "/api/#{Rails.application.config.plug_api_version}/settings/:organization_id/:inbox_id/:plug_installation_id/edit", to: "hephaestus_settings#edit"
-```
-
-Otherwise, be sure to refer to `hephaestus_settings` only for any default settings related actions:
-
-```ruby
-# you must always include this line when referring to `hephaestus_settings`
-HephaestusSettingsController = Hephaestus::SettingsController
-
-get "/api/#{Rails.application.config.plug_api_version}/settings", to: "hephaestus_settings#new"
-get "/api/#{Rails.application.config.plug_api_version}/settings/:organization_id/:inbox_id/:plug_installation_id/edit", to: "settings#edit"
-```
-
-Otherwise, you can add any other routes your plug needs to `config/routes.rb`.
-
-### Launching the server
-
-First, you'll note that you have a `script/ngrok` file, which launches an ngrok server at `https://${hostname}-plug-app.ngrok.io`, which maps locally to `http://localhost:6661`. Setting up ngrok can be essential when testing the platform locally for the first time. (Keep in mind that you still need to run `script/server` to actually start the local server—this is just to help facilitate communication with the platform.)
-
-### Setting up routes
-
-You should probably open up config/routes.rb to make modifications to any incoming (from the platform) or outgoing (for Yetto) HTTP flows.
-
-### Defining settings
-
-Next, you'll want to open `app/views/settings/new.json.jbuilder` and modify the JSON structure of the Settings form page users will see when they first install the plug. Note that this adheres to a strict schema.
-
-### Accepting events
-
-After a user submits a plug installation on the Yetto side, it'll send a POST payload to `/api/:version/:event/:record_type`--for example, `/api/2023-03-06/after/plug_installation`. Open up the `yetto_controller.rb` file and decide what happens next!
-
-### Creating services
-
-Any code which communicates with the third party should be placed in the `app/services` directory. A generic HTTP service is included.
-
-### Writing tests
-
-In addition to writing tests for your plug interacting with its platform, many of your tests will also need to cover your plug's interaction with Yetto.
-
-Writing these tests well comes with time; it's not an easy thing to cover in a pithy paragraph. Regardless, here's a bit of hopefully helpful advice.
-
-Be sure to tests requests before _and_ after they occur. Typically, this takes the form of a `stub_request` and `assert_requested`. Similarly, be sure to:
-
-- `include Hephaestus::Webmocks::SlackWebmock` whenever a plug action is expected to error out to Slack
-- `include Hephaestus::Webmocks::YettoWebmock` whenever a plug needs to issue a request to Yetto
-
-Use `include Hephaestus::API::TestHelpers` whenever you need to write a test which either
-
-- match `"/#{plug_shortname}` routes (by issuing calls to `plug`). These are routes which your external server is calling into.
-- match `/api` routes (by issuing calls to `api`). These are routes which Yetto is calling into.
-
-For examples on when and how to use these methods, see `plug-github`.
-
 ## Acknowledgements
 
 The template generation for this project was heavily based on [thoughtbot/suspenders](https://github.com/thoughtbot/suspenders).

data/bin/hephaestus

@@ -67,44 +67,34 @@ if ENV.fetch("HEPHAESTUS_NO_EXTERNAL", "0") != "1"
   end
 end
 
-puts Rainbow("Looking good! Proceeding...").blue
-
-path = ARGV.first
-if File.exist?(path)
-  puts Rainbow("\nError: The directory #{path} already exists.").red
-  exit 1
-end
-
-unless path.start_with?("plug-")
-  puts Rainbow("\nError: The directory name must start with 'plug-'").red
-  exit 1
-end
-
-if path.split("-").length < 2
-  puts Rainbow("\nError: The directory name must start with 'plug-'").red
-  exit 1
-end
+puts Rainbow("You're on the latest version of Hephaestus! Proceeding...").blue
 
 ENGINE_ROOT = File.expand_path("..", __dir__)
 ENGINE_PATH = File.expand_path("../lib/hephaestus/engine", __dir__)
 APP_PATH = File.expand_path("../test/dummy/config/application", __dir__)
 
 # Set up gems listed in the Gemfile.
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
-require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+# ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
+# require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
 
 require "rails/all"
 require "hephaestus"
 
 templates_root = File.expand_path(File.join("..", "templates"), File.dirname(__FILE__))
 Hephaestus::AppGenerator.source_root(templates_root)
-Hephaestus::AppGenerator.source_paths << Rails::Generators::AppGenerator.source_root << templates_root
-
-ARGV.push("--minimal")
-ARGV.push("--no-skip-active-job")
-ARGV.push("--skip-asset-pipeline")
-ARGV.push("--skip-active-record")
-ARGV.push("--skip-docker")
-ARGV.push("--skip_bundle")
+
+# Since we're hijacking Rails' generation process,
+# we *do not* want any of Rails' generators to interfere.
+# Rails provides its own list of generators,
+# and then attaches Hephaestus' generators to that list;
+# so, we'll remove any generators that come before Hephaestus' generators.
+config = Hephaestus::AppGenerator.all_commands
+
+delete_keys = true
+config.keys.each do |key|
+  break if key == "hephaestus_generator"
+
+  config.delete(key) if delete_keys
+end
 
 Hephaestus::AppGenerator.start

data/lib/hephaestus/engine.rb

@@ -16,7 +16,8 @@ module Hephaestus
     when "production", "staging"
       ENV["GIT_SHA"] || ""
     when "development"
-      %x(git rev-parse HEAD)
+      result = %x(git rev-parse HEAD 2>&1)
+      $CHILD_STATUS == 0 ? result : "deadbeef" # check if the child process exited cleanly.
     when "test"
       "deadbeef"
     end.chomp

data/lib/hephaestus/generators/app_generator.rb

@@ -4,11 +4,16 @@
 require "rails/generators"
 require "rails/generators/rails/app/app_generator"
 require "tempfile"
+require "bundler"
 
+require "hephaestus/actions"
 require "hephaestus/app_name"
 module Hephaestus
   class AppGenerator < Rails::Generators::AppGenerator
     include Hephaestus::AppName
+    include Hephaestus::Actions
+
+    attr_reader :result_dir
 
     hide!
 
@@ -24,16 +29,29 @@ module Hephaestus
       group: :hephaestus,
       desc: "Show this help message and quit"
 
-    def finish_template
-      invoke(:hephaestus_initialize)
-      # super
-    end
-
-    def hephaestus_initialize
+    # This method name is important as everything before it is added by
+    # Rails::Generators::AppGenerator; this is our true entrypoint.
+    def hephaestus_generator
       say(set_color("Invoking Hephaestus customizations...", :cyan))
 
-      invoke(:init_git)
-      invoke(:customize_gemfile)
+      path = ARGV.first
+      if File.exist?(path)
+        raise(Rainbow("\nError: The directory #{path} already exists.").red.to_s)
+      end
+
+      unless path.start_with?("plug-")
+        raise(Rainbow("\nError: The directory name must start with 'plug-'").red.to_s)
+      end
+
+      if path.split("-").length < 2
+        raise(Rainbow("\nError: The directory name must start with 'plug-'").red.to_s)
+      end
+
+      @destination_stack << @app_path
+
+      @result_dir = @destination_stack.join(File::SEPARATOR)
+
+      invoke(:copy_basics)
 
       invoke(:copy_github_actions)
       invoke(:copy_vscode_settings)
@@ -44,28 +62,20 @@ module Hephaestus
       invoke(:setup_test_environment)
 
       invoke(:configure_app)
-      invoke(:leftovers)
-    end
-
-    def init_git
-      run("git remote add origin https://github.com/yettoapp/#{app_name}.git")
-      run("git branch -m production")
+      invoke(:finalize)
+      invoke(:first_commit)
+      invoke(:outro)
     end
 
-    def customize_gemfile
-      say(set_color("Customizing Gemfile...", :cyan))
-      template("Gemfile", "Gemfile", force: true)
-      # FIXME: unsure why, but when the generators are called, Rails expects Gemfiles in these locations?
-      copy_file("Gemfile", File.join(Hephaestus::AppGenerator.source_root, "Gemfile"))
-      copy_file("Gemfile", File.join(Hephaestus::AppGenerator.source_root, "..", "Gemfile"))
-      replace_in_files(Hephaestus::AppGenerator.source_root, %|ruby File.read(".ruby-version").strip|, %|ruby "#{Hephaestus::RUBY_VERSION}"|)
+    def copy_basics
+      capture_stdout do
+        directory("root", ".")
 
-      unless ENV.fetch("HEPHAESTUS_NO_EXTERNAL", "0") == "1"
-        capture_stdout do
-          run("BUNDLE_GEMFILE=\"#{destination_root}/Gemfile\" bundle install", abort_on_failure: false)
-          run("BUNDLE_GEMFILE=\"#{destination_root}/Gemfile\" bundle update")
-          run("BUNDLE_GEMFILE=\"#{destination_root}/Gemfile\" bundle lock --add-platform x86_64-linux")
+        Dir.glob(File.join(destination_root, "hephaestus_*")).each do |file|
+          File.rename(file, file.gsub("hephaestus_", "."))
         end
+
+        copy_file("root/hephaestus_env.sample", ".env")
       end
     end
 
@@ -87,145 +97,161 @@ module Hephaestus
 
     def setup_development_environment
       say(set_color("Setting up the development environment...", :cyan))
-      build(:setup_dev_environment)
+
       capture_stdout do
-        build(:copy_setup_scripts)
+        copy_file("config/environments/blank.rb", "config/environments/development.rb", force: true)
+
+        directory(Hephaestus.source_path("script"), "script")
+
+        chmod_dir("script")
       end
     end
 
     def setup_staging_environment
       say(set_color("Setting up the staging environment...", :cyan))
-      build(:setup_staging_environment)
+
       capture_stdout do
+        copy_file("config/environments/blank.rb", "config/environments/staging.rb", force: true)
       end
     end
 
     def setup_production_environment
       say(set_color("Setting up the production environment...", :cyan))
-      build(:setup_production_environment)
+
       capture_stdout do
+        copy_file("config/environments/blank.rb", "config/environments/production.rb", force: true)
       end
     end
 
     def setup_test_environment
       say(set_color("Setting up the test environment...", :cyan))
-      build(:setup_test_environment)
+
+      capture_stdout do
+        copy_file("config/environments/blank.rb", "config/environments/test.rb", force: true)
+      end
     end
 
     def configure_app
       say(set_color("Configuring app...", :cyan))
 
       capture_stdout do
-        remove_dir("bin")
-        remove_dir("app/helpers")
-        remove_dir("app/models")
-        remove_dir("app/views/layouts")
-        remove_dir("lib/assets")
-        remove_file("lib/tasks/.keep")
-      end
+        # This must be here, rather than a generator, because generators are run in a Rails environment,
+        # and the bootup process requires the fake PEM key file to be present.
+        # we do this to specify the template source, otherwise the generator wants to use its own `test` dir
+        source = File.join(Hephaestus::AppGenerator.source_root, "test")
+        directory(source, "test", force: true)
+
+        # This must be here, rather than a generator, because generators are run in a Rails environment,
+        # and the OpenAPI middleware, which is loaded when the app boots, requires the schema files to be present.
+        directory("lib/schemas/api/2023-03-06", "lib/schemas/api/2023-03-06")
 
-      # This must be here, rather than a generator, because generators are run in a Rails environment,
-      # and the bootup process requires the fake PEM key file to be present.
-      # we do this to specify the template source, otherwise the generator wants to use its own `test` dir
-      source = File.join(Hephaestus::AppGenerator.source_root, "test")
-      directory(source, "test", force: true)
+        # we do this to specify the template source, otherwise the generator wants to use Rails own `bin` dir
+        source = File.join(Hephaestus::Engine.root, "templates", "bin")
+        directory(source, "bin", force: true)
+        chmod_dir("bin")
 
-      # This must be here, rather than a generator, because generators are run in a Rails environment,
-      # and the OpenAPI middleware, which is loaded when the app boots, requires the schema files to be present.
-      capture_stdout do
-        directory("lib/schemas/api/2023-03-06", "lib/schemas/api/2023-03-06")
-      end
+        # we do this to specify the template source, otherwise the generator wants to use Rails' own dir
+        ["controllers", "jobs", "services", "views"].each do |dir|
+          source = File.join(Hephaestus::Engine.root, "templates", "app", dir)
+          directory(source, "app/#{dir}", force: true)
+        end
 
-      # we do this to specify the template source, otherwise the generator wants to use Rails own `bin` dir
-      source = File.join(Hephaestus::Engine.root, "templates", "bin")
-      directory(source, "bin", force: true)
+        directory("db", "db")
 
-      say(set_color("\n*** All these upcoming `HEAD` errors are okay to ignore! ***\n", :cyan))
+        directory("vendor/fly", "vendor/fly")
 
-      capture_stdout do
-        generate("hephaestus:core")
+        directory("lib/tasks", "lib/tasks")
 
-        generate("hephaestus:db")
-        generate("hephaestus:deployment")
-        generate("hephaestus:lib")
+        remove_file("config/credentials.yml.enc")
 
         # keep this at the end
-        generate("hephaestus:config")
+        directory("config", "config", force: true, exclude_pattern: /blank.rb/)
       end
     end
 
-    # NOTE: this function name is important as it matches
-    # a Rails function of the same name (that performs work
-    # that we don't want to do). Think of this as the final step in the process
-    # started by `finish_template`.
-    def leftovers
-      build(:replace_generic_variables)
+    # Think of this as the final step in the process
+    # started by `hephaestus_generator`. All the relevant commands are run in the context of the
+    # new app directory.
+    def finalize
+      File.rename(File.join(destination_root, "app", "controllers", "app_controller.rb"), File.join(destination_root, "app", "controllers", "#{plug_name}_controller.rb"))
+      File.rename(File.join(destination_root, "app", "services", "app_service.rb"), File.join(destination_root, "app", "services", "#{plug_name}_service.rb"))
+      File.rename(File.join(destination_root, "test", "controllers", "app_controller_test.rb"), File.join(destination_root, "test", "controllers", "#{plug_name}_controller_test.rb"))
+      File.rename(File.join(destination_root, "test", "support", "webmocks", "app_webmock.rb"), File.join(destination_root, "test", "support", "webmocks", "#{plug_name}_webmock.rb"))
 
-      say(set_color("Generating `hephaestus:license`...", :cyan))
-      capture_stdout do
-        generate("hephaestus:license")
-      end
+      replace_in_file(File.join("lib", "schemas", "api", "2023-03-06", "openapi.json"), %r{paths/app.json}, "paths/#{plug_name}.json")
+      File.rename(File.join(destination_root, "lib", "schemas", "api", "2023-03-06", "paths", "app.json"), File.join(destination_root, "lib", "schemas", "api", "2023-03-06", "paths", "#{plug_name}.json"))
 
-      say(set_color("Generating `hephaestus:rubocop`...", :cyan))
-      capture_stdout do
-        generate("hephaestus:rubocop")
-      end
+      Dir.chdir(shell.base.result_dir) do
+        unless ENV.fetch("HEPHAESTUS_NO_EXTERNAL", "0") == "1"
+          say(set_color("Installing gems...", :cyan))
+          capture_stdout do
+            run("bundle install", abort_on_failure: false)
+            run("bundle update")
+            run("bundle lock --add-platform x86_64-linux")
+          end
+        end
 
-      # say(set_color("Generating `hephaestus:sorbet`...", :cyan))
-      # capture_stdout do
-      #   generate("hephaestus:sorbet")
-      # end
+        result = nil
+        say(set_color("Generating `hephaestus:license`...", :cyan))
+        Bundler.with_unbundled_env do
+          capture_stdout do
+            capture_stderr do
+              result = run("script/licenses --update", quiet: true, abort_on_failure: false)
+            end
+          end
+        end
 
-      replace_in_file(File.join("lib", "schemas", "api", "2023-03-06", "openapi.json"), %r{app/paths.json}, "#{plug_name}/paths.json")
-      File.rename(File.join(destination_root, "lib", "schemas", "api", "2023-03-06", "paths", "app.json"), File.join(destination_root, "lib", "schemas", "api", "2023-03-06", "paths", "#{plug_name}.json"))
+        unless result
+          say(set_color("Error generating licenses. When Hephaestus finishes executing, run `script/licenses --update`.", :red))
+          sleep(3)
+        end
 
-      say(set_color("Creating first commit...", :cyan))
-      capture_stdout do
-        invoke(:commit)
-      end
+        # say(set_color("Generating `hephaestus:sorbet`...", :cyan))
+        #   Bundler.with_unbundled_env do
+        #     run("bundle exec tapioca init")
+        #     run("bundle exec tapioca require")
+        #     run("script/sorbet --update")
+        #   end
+
+        say(set_color("Generating `hephaestus:rubocop`...", :cyan))
+        Bundler.with_unbundled_env do
+          capture_stdout do
+            capture_stderr do
+              result = run("bundle exec rubocop -A", abort_on_failure: false)
+            end
+          end
+        end
 
-      invoke(:outro)
+        unless result
+          say(set_color("Could not run Rubocop. When Hephaestus finishes executing, run `bundle exec rubocop -A`.", :red))
+          sleep(3)
+        end
+      end
     end
 
-    def commit
-      run("git add .")
-      run("git commit -m 'Initial commit'", capture: true)
+    def first_commit
+      say(set_color("Creating first commit...", :cyan))
+
+      Dir.chdir(shell.base.result_dir) do
+        capture_stdout do
+          run("git init")
+          run("git remote add origin https://github.com/yettoapp/#{app_name}.git")
+          run("git branch -m production")
+
+          run("git add .")
+          run("git commit -m 'Initial commit'", capture: true)
+        end
+      end
     end
 
     def outro
       say(<<~OUTPUT)
 
-        #{set_color("Congratulations!", :green)} You just made a Yetto plug.
-
-        You'll need to `cd #{ARGV.first}` and run the following commands--I can't do it for you!
-
-        * `bin/rails credentials:edit --environment development`
-
-        #{set_color("WAIT!", :red)} After running this command, note that Rails credited a file called development.key in the config/credentials directory.
-        Store this in 1Password, then change the .env file to use this value. Generate keys for staging/production, too:
-
-        * `bin/rails credentials:edit --environment staging`
-          `bin/rails credentials:edit --environment production`
+        #{set_color("Congratulations! You just made a Yetto plug.", :green)}
 
-        Store this in 1Password too; you don't need the .env file for staging/production.
+        You'll need to `cd #{shell.base.result_dir}` and run some more commands--I can't do it for you!
 
-        For `YETTO_SIGNING_SECRET` and `YETTO_PLUG_ID`, you'll need to generate those values yourself.
-
-        Then, try running `bin/rails c` to ensure that everything was set up correctly.
-        Running `rake test` is also a good idea.
-
-        #{set_color("Also, after pushing to GitHub:", :yellow)}
-
-        * Set `settings/branches` to protect `production`
-          * ✅ Require status checks to pass before merging
-          * 🖊️ Status checks that are required: `ruby / test_without_services`, `docker / test-build`, `ruby / brakeman`, `ruby / bundle-audit`.
-
-            You can only set those 👆 after you've opened the first PR on GitHub. Crazy, I know!!
-            But, doing so is *essential* for automerge to function properly.
-
-        * In `/settings`:
-          * ✅ Allow auto-merge
-          * ✅ Automatically delete head branches
+        Check out the appropriate documentation on Clio for more information: engineering/plugs/building.md
       OUTPUT
     end
 
@@ -245,13 +271,46 @@ module Hephaestus
       !options[:skip_active_record]
     end
 
-    private def capture_stdout
-      out = StringIO.new
-      $stdout = out
+    private def capture_stdout(&block)
+      capture_stream("stdout", &block)
+    end
+
+    private def capture_stderr(&block)
+      capture_stream("stderr", &block)
+    end
+
+    private def capture_stream(stream)
+      captured_stream = Tempfile.new(stream)
+      stream_io = eval("$#{stream}", binding, __FILE__, __LINE__) # rubocop:disable Security/Eval
+      origin_stream = stream_io.dup
+      stream_io.reopen(captured_stream)
+
       yield
-      out.string
-    ensure
-      $stdout = STDOUT
+
+      stream_io.rewind
+      captured_stream.read
+
+      unless captured_stream.nil?
+        captured_stream.close
+        captured_stream.unlink
+      end
+      stream_io.reopen(origin_stream) unless stream_io.nil?
+    end
+
+    private def chmod_dir(dir)
+      Dir.glob(File.join(destination_root, dir, "**", "*")).each do |file|
+        next if File.directory?(file)
+
+        # Rails adds this
+        if file == ".keep"
+          remove_file(file)
+          next
+        end
+
+        # this is because we might have *.tt templates, which aren't executable,
+        # so we gotta re-execute-em all
+        chmod(file, 0o755)
+      end
     end
   end
 end

data/lib/hephaestus/generators/base.rb

@@ -32,14 +32,6 @@ module Hephaestus
 
       private
 
-      def app_name
-        Rails.app_class.module_parent_name.demodulize.underscore.dasherize
-      end
-
-      def short_app_name
-        app_name.sub(/plug-/i, "")
-      end
-
       def empty_directory_with_keep_file(destination)
         empty_directory(destination, {})
         keep_file(destination)

data/lib/hephaestus/version.rb

@@ -2,7 +2,7 @@
 # frozen_string_literal: true
 
 module Hephaestus
-  VERSION = "0.8.12.1"
+  VERSION = "0.8.13"
   RAILS_VERSION = ">= 8.0"
   RUBY_VERSION = File
     .read("#{File.dirname(__FILE__)}/../../.ruby-version")

data/lib/hephaestus.rb

@@ -8,24 +8,17 @@ def debugging?
 end
 
 require "debug" if debugging?
+require "amazing_print" if debugging?
 
 require "hephaestus/version"
 require "hephaestus/engine"
 
 require "hephaestus/generators/app_generator"
-require "hephaestus/generators/config_generator"
-require "hephaestus/generators/core_generator"
-require "hephaestus/generators/db_generator"
-require "hephaestus/generators/deployment_generator"
-require "hephaestus/generators/lib_generator"
-require "hephaestus/generators/license_generator"
-require "hephaestus/generators/rubocop_generator"
-require "hephaestus/generators/sorbet_generator"
 
 require "hephaestus/actions"
 require "hephaestus/app_name"
+
 require "hephaestus/actions/strip_comments_action"
-require "hephaestus/app_builder"
 
 module Hephaestus
   class << self

data/templates/bin/bundle

@@ -41,7 +41,7 @@ m = Module.new do
 
   def gemfile
     gemfile = ENV["BUNDLE_GEMFILE"]
-    return gemfile if gemfile.present?
+    return gemfile if gemfile && !gemfile.empty? # rubocop:disable Rails/Present
 
     File.expand_path("../Gemfile", __dir__)
   end

data/templates/{Gemfile → root/Gemfile}

@@ -13,10 +13,6 @@ gem "hephaestus", "~> 0.8"
 
 # !!! TODO: put your platform's dependencies here !!!
 
-# the one and only
-gem "octokit", "~> 9.1"
-gem "faraday-retry", "~> 2.2"
-
 group :development, :test do
   # better debug output with `ap`
   gem "amazing_print"

data/templates/root/compose.yml

@@ -0,0 +1,5 @@
+services:
+  redis-db:
+    image: redis:7-bookworm
+    ports:
+      - "6401:6401"

data/templates/root/hephaestus_dockerignore

@@ -0,0 +1,43 @@
+# See https://docs.docker.com/engine/reference/builder/#dockerignore-file for more about ignoring files.
+
+# Ignore git directory.
+/.git/
+
+# Ignore bundler config.
+/.bundle
+
+# Ignore all environment files (except templates).
+/.env*
+!/.env*.erb
+
+# Ignore all default key files.
+/config/master.key
+/config/credentials/*.key
+
+# Ignore all logfiles and tempfiles.
+/log/*
+/tmp/*
+!/log/.keep
+!/tmp/.keep
+
+# Ignore pidfiles, but keep the directory.
+/tmp/pids/*
+!/tmp/pids/.keep
+
+# Ignore storage (uploaded files in development and any SQLite databases).
+/storage/*
+!/storage/.keep
+/tmp/storage/*
+!/tmp/storage/.keep
+
+# Ignore assets.
+/node_modules/
+/app/assets/builds/*
+!/app/assets/builds/.keep
+/public/assets
+
+# Use the one in the base Dockerfile
+.ruby-version
+
+security-results.json
+coverage/

data/templates/root/hephaestus_gitattributes

@@ -0,0 +1,5 @@
+# See https://git-scm.com/docs/gitattributes for more about git attribute files.
+
+
+# Mark any vendored files as having been vendored.
+vendor/* linguist-vendored

data/templates/root/hephaestus_licensed.yml

@@ -0,0 +1,56 @@
+cache_path: vendor/.licenses
+
+allowed:
+  - apache-2.0
+  - bsd-2-clause
+  - bsd-3-clause
+  - isc
+  - mit
+  - cc0-1.0
+  - unlicense
+
+ignored:
+  bundler:
+    - base64 # BSD-2-Clause ("This file is released under the same license as ruby.")
+    - benchmark # BSD-2-Clause
+    - bigdecimal # BSD-2-Clause ("This file is released under the same license as ruby.")
+    - bundler-audit # GPL-3.0; but also, only used in CI/test
+    - drb # BSD-2-Clause ("This file is released under the same license as ruby.")
+    - io-console # BSD-2-Clause
+    - logger # BSD-2-Clause
+    - mutex_m # BSD-2-Clause ("This file is released under the same license as ruby.")
+    - reline # BSD-2-Clause ("This file is released under the same license as ruby.")
+    - rdoc # BSD-2-Clause ("This file is released under the same license as ruby.")
+    - ruby2_keywords # BSD-2-Clause; ignored because of custom LICENSE text
+    - securerandom # BSD-2-Clause ("This file is released under the same license as ruby.")
+    - sidekiq # LGPL-3.0; ignored because of custom LICENSE text
+    - stringio # BSD-2-Clause ("This file is released under the same license as ruby.")
+    - uri # BSD-2-Clause
+
+reviewed:
+  bundler:
+    - activerecord # MIT
+    - brakeman # BRAKEMAN PUBLIC USE LICENSE
+    - bundler # MIT
+    - concurrent-ruby # MIT
+    - date # BSD-2-Clause
+    - dry-core # MIT
+    - dry-transformer # MIT
+    - exponential-backoff # MIT
+    - faraday-net_http # MIT
+    - json # BSD-2-Clause
+    - jwt # MIT
+    - net-http # BSD-2-Clause
+    - net-imap # BSD-2-Clause
+    - net-pop # BSD-2-Clause
+    - net-protocol # BSD-2-Clause
+    - net-smtp # BSD-2-Clause
+    - nio4r # MIT
+    - parser # MIT
+    - pg # BSD-2-Clause
+    - racc # BSD-2-Clause
+    - timeout # BSD-2-Clause
+    - unf # BSD-2-Clause
+    - websocket-driver # Apache-2.0
+    - websocket-extensions # Apache-2.0
+

data/templates/root/hephaestus_rubocop.yml

@@ -0,0 +1,5 @@
+inherit_gem:
+  rubocop-standard:
+    - config/default.yml
+    - config/minitest.yml
+    - config/rails.yml

data/templates/root/hephaestus_ruby-version

@@ -0,0 +1 @@
+3.3.6

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hephaestus
 version: !ruby/object:Gem::Version
-  version: 0.8.12.1
+  version: 0.8.13
 platform: ruby
 authors:
 - Garen Torikian
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-12-16 00:00:00.000000000 Z
+date: 2024-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bootsnap
@@ -427,19 +427,10 @@ files:
 - lib/hephaestus.rb
 - lib/hephaestus/actions.rb
 - lib/hephaestus/actions/strip_comments_action.rb
-- lib/hephaestus/app_builder.rb
 - lib/hephaestus/app_name.rb
 - lib/hephaestus/engine.rb
 - lib/hephaestus/generators/app_generator.rb
 - lib/hephaestus/generators/base.rb
-- lib/hephaestus/generators/config_generator.rb
-- lib/hephaestus/generators/core_generator.rb
-- lib/hephaestus/generators/db_generator.rb
-- lib/hephaestus/generators/deployment_generator.rb
-- lib/hephaestus/generators/lib_generator.rb
-- lib/hephaestus/generators/license_generator.rb
-- lib/hephaestus/generators/rubocop_generator.rb
-- lib/hephaestus/generators/sorbet_generator.rb
 - lib/hephaestus/http.rb
 - lib/hephaestus/middleware.rb
 - lib/hephaestus/middleware/malformed_request.rb
@@ -454,11 +445,6 @@ files:
 - lib/hephaestus/version.rb
 - lib/tasks/hephaestus_tasks.rake
 - lib/tasks/rubocop.rake
-- lib/version.rb
-- templates/Dockerfile
-- templates/Gemfile
-- templates/Procfile
-- templates/README.md.erb
 - templates/app/controllers/app_controller.rb.tt
 - templates/app/controllers/application_controller.rb
 - templates/app/controllers/concerns/authable.rb.tt
@@ -479,7 +465,6 @@ files:
 - templates/bin/rake
 - templates/bin/setup
 - templates/bin/tapioca
-- templates/config.ru
 - templates/config/application.rb.tt
 - templates/config/boot.rb
 - templates/config/environment.rb
@@ -491,7 +476,6 @@ files:
 - templates/config/routes.rb.tt
 - templates/db/queue_schema.rb
 - templates/db/schema.rb
-- templates/hephaestus_env.sample
 - templates/hephaestus_github/dependabot.yml
 - templates/hephaestus_github/workflows/automerge.yml
 - templates/hephaestus_github/workflows/deploy.yml
@@ -501,7 +485,6 @@ files:
 - templates/hephaestus_github/workflows/sorbet.yml
 - templates/hephaestus_github/workflows/test.yml.tt
 - templates/hephaestus_github/workflows/updater.yml
-- templates/hephaestus_gitignore
 - templates/hephaestus_vscode/extensions.json
 - templates/hephaestus_vscode/launch.json
 - templates/hephaestus_vscode/settings.json
@@ -524,6 +507,19 @@ files:
 - templates/lib/schemas/api/2023-03-06/paths/yetto/message_created.json
 - templates/lib/schemas/api/2023-03-06/paths/yetto/plug_installation_created.json
 - templates/lib/tasks/test_tasks.rake
+- templates/root/Dockerfile
+- templates/root/Gemfile
+- templates/root/Procfile
+- templates/root/README.md.tt
+- templates/root/compose.yml
+- templates/root/config.ru
+- templates/root/hephaestus_dockerignore
+- templates/root/hephaestus_env.sample
+- templates/root/hephaestus_gitattributes
+- templates/root/hephaestus_gitignore
+- templates/root/hephaestus_licensed.yml
+- templates/root/hephaestus_rubocop.yml
+- templates/root/hephaestus_ruby-version
 - templates/script/ci
 - templates/script/docker-build-prod.tt
 - templates/script/docker-run.tt

data/lib/hephaestus/app_builder.rb

@@ -1,79 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require "forwardable"
-
-module Hephaestus
-  class AppBuilder < ::Rails::AppBuilder
-    include Hephaestus::Actions
-
-    extend Forwardable
-
-    def readme
-      template("README.md.erb", "README.md")
-    end
-
-    def gitignore
-      copy_file("hephaestus_gitignore", ".gitignore")
-    end
-
-    def setup_dev_environment
-      copy_file("config/environments/blank.rb", "config/environments/development.rb", force: true)
-    end
-
-    def copy_setup_scripts
-      directory(Hephaestus.source_path("script"), "script")
-      Dir.glob("script/**/*").each do |file|
-        next if File.directory?(file)
-
-        # Rails adds this
-        if file == ".keep"
-          remove_file(file)
-          next
-        end
-
-        # this is because we might have *.tt templates, which aren't executable,
-        # so we gotta re-execute-em all
-        chmod(file, 0o755)
-      end
-    end
-
-    def setup_staging_environment
-      copy_file("config/environments/blank.rb", "config/environments/staging.rb", force: true)
-    end
-
-    def setup_production_environment
-      copy_file("config/environments/blank.rb", "config/environments/production.rb", force: true)
-    end
-
-    def setup_test_environment
-      copy_file("config/environments/blank.rb", "config/environments/test.rb", force: true)
-    end
-
-    def ruby_version
-      create_file(".ruby-version", "#{Hephaestus::RUBY_VERSION}\n")
-    end
-
-    def replace_generic_variables
-      say(set_color("Replacing generic file names...", :cyan))
-
-      File.rename(File.join(destination_root, "app", "controllers", "app_controller.rb"), File.join(destination_root, "app", "controllers", "#{plug_name}_controller.rb"))
-      File.rename(File.join(destination_root, "app", "services", "app_service.rb"), File.join(destination_root, "app", "services", "#{plug_name}_service.rb"))
-      File.rename(File.join(destination_root, "test", "controllers", "app_controller_test.rb"), File.join(destination_root, "test", "controllers", "#{plug_name}_controller_test.rb"))
-      File.rename(File.join(destination_root, "test", "support", "webmocks", "app_webmock.rb"), File.join(destination_root, "test", "support", "webmocks", "#{plug_name}_webmock.rb"))
-
-      replace_in_file(File.join("lib", "schemas", "api", "2023-03-06", "openapi.json"), %r{app/paths.json}, "#{plug_name}/paths.json")
-      File.rename(File.join(destination_root, "lib", "schemas", "api", "2023-03-06", "paths", "app.json"), File.join(destination_root, "lib", "schemas", "api", "2023-03-06", "paths", "#{plug_name}.json"))
-    end
-
-    private
-
-    def root_path
-      @root_path ||= Pathname(__dir__).join("..", "..").expand_path
-    end
-
-    def development_env?
-      root_path.join("hephaestus.gemspec").exist?
-    end
-  end
-end

data/lib/hephaestus/generators/config_generator.rb

@@ -1,18 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Hephaestus
-  class ConfigGenerator < Generators::Base
-    include Hephaestus::AppName
-
-    def config_application
-      directory("config", "config", force: true, exclude_pattern: /blank.rb/)
-    end
-
-    def credentials
-      remove_file("config/credentials.yml.enc")
-    end
-  end
-end

data/lib/hephaestus/generators/core_generator.rb

@@ -1,38 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-# require_relative "base"
-
-module Hephaestus
-  class CoreGenerator < Generators::Base
-    include Hephaestus::AppName
-
-    def gemfile
-      # we do this to specify the template source, otherwise the generator wants to use Rails own `controllers` dir
-      source = File.join(Hephaestus::Engine.root, "templates", "Gemfile")
-      copy_file(source, "Gemfile", force: true)
-    end
-
-    def controllers
-      # we do this to specify the template source, otherwise the generator wants to use Rails own `controllers` dir
-      source = File.join(Hephaestus::Engine.root, "templates", "app", "controllers")
-      directory(source, "app/controllers", force: true)
-    end
-
-    def jobs
-      # we do this to specify the template source, otherwise the generator wants to use Rails own `jobs` dir
-      source = File.join(Hephaestus::Engine.root, "templates", "app", "jobs")
-      directory(source, "app/jobs", force: true)
-    end
-
-    def services
-      source = File.join(Hephaestus::Engine.root, "templates", "app", "services")
-      directory(source, "app/services", force: true)
-    end
-
-    def views
-      source = File.join(Hephaestus::Engine.root, "templates", "app", "views")
-      directory(source, "app/views", force: true)
-    end
-  end
-end

data/lib/hephaestus/generators/db_generator.rb

@@ -1,12 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Hephaestus
-  class DbGenerator < Generators::Base
-    def database
-      directory("db", "db")
-    end
-  end
-end

data/lib/hephaestus/generators/deployment_generator.rb

@@ -1,25 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Hephaestus
-  class DeploymentGenerator < Generators::Base
-    def procfile
-      copy_file("Procfile", "Procfile")
-    end
-
-    def dotenv
-      copy_file("hephaestus_env.sample", ".env")
-      copy_file("hephaestus_env.sample", ".env.sample")
-    end
-
-    def docker
-      copy_file("Dockerfile", "Dockerfile")
-    end
-
-    def fly
-      directory("vendor/fly", "vendor/fly")
-    end
-  end
-end

data/lib/hephaestus/generators/lib_generator.rb

@@ -1,12 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Hephaestus
-  class LibGenerator < Generators::Base
-    def lib_tasks
-      directory("lib/tasks", "lib/tasks")
-    end
-  end
-end

data/lib/hephaestus/generators/license_generator.rb

@@ -1,19 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Hephaestus
-  class LicenseGenerator < Generators::Base
-    def licensed
-      copy_file(".licensed.yml", ".licensed.yml")
-    end
-
-    def generate_licenses
-      unless run("script/licenses --update", abort_on_failure: false)
-        say(set_color("Error generating licenses. When this is all over, run `script/licenses --update`.", :red))
-        sleep(3)
-      end
-    end
-  end
-end

data/lib/hephaestus/generators/rubocop_generator.rb

@@ -1,18 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Hephaestus
-  class RubocopGenerator < Generators::Base
-    def rubocop
-      copy_file(".rubocop.yml", ".rubocop.yml", force: true)
-    end
-
-    def lint
-      Bundler.with_unbundled_env do
-        run("bundle exec rubocop -A", abort_on_failure: false)
-      end
-    end
-  end
-end

data/lib/hephaestus/generators/sorbet_generator.rb

@@ -1,17 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Hephaestus
-  class SorbetGenerator < Generators::Base
-    def sorbet
-      copy_file("sorbet/custom.rbi", "sorbet/custom.rbi")
-      Bundler.with_unbundled_env do
-        run("bundle exec tapioca init")
-        run("bundle exec tapioca require")
-        run("script/sorbet --update")
-      end
-    end
-  end
-end

data/lib/version.rb

@@ -1,6 +0,0 @@
-# typed: false
-# frozen_string_literal: true
-
-module Hephaestus
-  VERSION = "0.1.0"
-end