hephaestus 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 371b5a8acd1794fe2317f9f6e6c94de073e3790198d3f9f5871b149df137602e
+  data.tar.gz: ba0f8d0dfe79c043782610058fcebbe74f8c05d2c3edc472200841b769aeaf6a
+SHA512:
+  metadata.gz: a3b51205a5048ca0c67d5121fa477bb3b5053125968c0c31dd04386f5b224016e3a02dd08f5fcd74390b87f0dccbb253304e13f6c8da0f79584b137aa988231d
+  data.tar.gz: 1d59384fc58c249d0b964a1dbe0d26a3c29109febaebd2ba12f9cea745c34d889fe674a992bfb42611c6a27b9b5fef6226b827399d65c7a75e128367684c2bce

data/.ruby-version

@@ -0,0 +1 @@
+3.1.1

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## [v0.0.1](https://github.com/yettoapp/hephaestus/tree/v0.0.1) (2023-02-28)
+
+[Full Changelog](https://github.com/yettoapp/hephaestus/compare/b33ebb8ab3188b8689b10d4649d3f29ea7ca1f2a...v0.0.1)
+
+**Merged pull requests:**
+
+- Add a Rails application template for plugs [\#1](https://github.com/yettoapp/hephaestus/pull/1) ([gjtorikian](https://github.com/gjtorikian))
+
+
+
+\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,19 @@
+# Hephaestus
+
+A plug template for Yetto.
+
+## Usage
+
+```
+rails new plug-app --api -m hephaestus/template.rb
+```
+
+If you're working on updating this locally, you'll also probably want:
+
+```
+rm -rf plug-app && DEBUG=1 rails new plug-app --api -m hephaestus/template.rb
+```
+
+## Acknowledgements
+
+This project was heavily based on [thoughtbot/suspenders](https://github.com/thoughtbot/suspenders).

data/bin/hephaestus

@@ -0,0 +1,55 @@
+#!/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 "Hephaestus error: Unable to find Rails version #{rails_version}"
+    end
+  else
+    require "hephaestus/version"
+
+    spec = Gem::Specification.find_by_name("rails", Hephaestus::RAILS_VERSION)
+
+    activate_rails_version.call(spec.version.to_s)
+  end
+end
+
+require "hephaestus"
+
+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 Hephaestus::VERSION
+  exit 0
+end
+
+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-active-record")
+Hephaestus::AppGenerator.start

data/lib/hephaestus/actions/strip_comments_action.rb

@@ -0,0 +1,263 @@
+# typed: false
+# frozen_string_literal: true
+
+require "parser/current"
+
+module Hephaestus
+  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
+        class << self
+          def beginning_of_line_pos(expr, initial_pos)
+            skip_before(expr, initial_pos) { |char| char == "\n" }
+          end
+
+          def skip_before(expr, initial_pos, &block)
+            skip_until(expr, initial_pos, -1, &block)
+          end
+
+          def 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
+      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
+        class << self
+          def call(source, parser)
+            buffer = Parser::Source::Buffer.new(nil, source: source)
+            ast = parser.parse(buffer)
+
+            LeadingNewlineStripRewriter.new.rewrite(buffer, ast).lstrip
+          end
+        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/hephaestus/actions.rb

@@ -0,0 +1,116 @@
+# typed: false
+# frozen_string_literal: true
+
+module Hephaestus
+  module Actions
+    def replace_in_file(relative_path, find, replace)
+      path = File.join(destination_root, relative_path)
+      contents = File.read(path)
+      contents.gsub!(find, replace)
+      File.write(path, contents)
+    end
+
+    def replace_in_files(relative_path, find, replace)
+      Dir.glob("#{relative_path}/**/*").each do |path|
+        next if File.directory?(path)
+
+        path = Pathname.new(path).relative_path_from(relative_path).to_s
+        replace_in_file(path, find, replace)
+      end
+    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)
+        File.write(destination_file, JSON.pretty_generate(new_json))
+      end
+
+      def destination_file
+        File.join(destination_root, file)
+      end
+
+      def existing_json
+        JSON.parse(File.read(destination_file), symbolize_names: true)
+      rescue Errno::ENOENT
+        {}
+      end
+
+      def hash_unmerge(hash, subhash)
+        subhash.reduce(hash) do |acc, (k, v)|
+          if hash.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/hephaestus/app_builder.rb

@@ -0,0 +1,168 @@
+# 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 gemfile
+      template("Gemfile.erb", "Gemfile")
+    end
+
+    def raise_on_delivery_errors
+      replace_in_file(
+        "config/environments/development.rb",
+        "raise_delivery_errors = false",
+        "raise_delivery_errors = true",
+      )
+    end
+
+    def copy_setup_scripts
+      source = File.join(Hephaestus::AppGenerator.source_root, "script")
+      directory(source, "script")
+      Dir.glob("script/**/*").each do |file|
+        next if File.directory?(file)
+
+        chmod(file, 0o755)
+      end
+    end
+
+    def configure_dev_hosting
+      config = <<~EOD
+        # Let dev server run on GitHub Codespaces
+        config.hosts << /[a-z0-9-]+.githubpreview.dev/
+
+        # Let dev server run on ngrok domains
+        config.hosts << /[a-z0-9-]+.ngrok.io/
+      EOD
+
+      configure_environment("development", config)
+    end
+
+    def setup_asset_host
+      config = <<~EOD
+        config.public_file_server.headers = {
+            "Cache-Control" => "public, max-age=31557600",
+          }
+      EOD
+
+      configure_environment("production", config)
+    end
+
+    def setup_background_worker
+      config = <<~EOD
+        # Use a real queuing backend for Active Job (and separate queues per environment).
+        config.active_job.queue_adapter = :sidekiq
+      EOD
+      configure_environment("production", config)
+      configure_environment("staging", config)
+    end
+
+    def setup_slack_logger
+      config = <<~EOD
+        config.after_initialize do
+          Rails.logger.extend(ActiveSupport::Logger.broadcast(SlackWebhookLogger.logger))
+        end
+      EOD
+      configure_environment("production", config)
+      configure_environment("staging", config)
+      configure_environment("test", config)
+    end
+
+    def setup_staging_environment
+      FileUtils.cp(File.join(destination_root, "config/environments/production.rb"), File.join(destination_root, "config/environments/staging.rb"))
+    end
+
+    def replace_gemfile
+      template("Gemfile.erb", "Gemfile", force: true) do |content|
+        if development_env?
+          content.gsub(/gem .hephaestus./) { |s| %(#{s}, path: "#{root_path}") }
+        else
+          content
+        end
+      end
+    end
+
+    def ruby_version
+      create_file(".ruby-version", "#{Hephaestus::RUBY_VERSION}\n")
+    end
+
+    def configure_time_formats
+      replace_in_file("config/application.rb", /# config.time_zone = .*/, "config.time_zone = \"UTC\"")
+    end
+
+    def create_github_repo(repo_name)
+      run("gh repo create #{repo_name}")
+    end
+
+    def remove_config_comment_lines
+      config_files = [
+        "application.rb",
+        "environment.rb",
+        "environments/development.rb",
+        "environments/production.rb",
+        "environments/test.rb",
+      ]
+
+      config_files.each do |config_file|
+        path = Pathname(destination_root).join("config", config_file)
+        source = Actions::StripCommentsAction.call(path.read)
+
+        path.write(source)
+      end
+    end
+
+    def remove_routes_comment_lines
+      replace_in_file(
+        "config/routes.rb",
+        /Rails\.application\.routes\.draw do.*end/m,
+        "Rails.application.routes.draw do\nend",
+      )
+    end
+
+    def setup_test_environment
+      remove_dir("test")
+      source = File.join(Hephaestus::AppGenerator.source_root, "test")
+      directory(source, "test")
+    end
+
+    def replace_generic_variables
+      replace_in_files(destination_root, "${APP}", app_name.titlecase)
+      replace_in_files(destination_root, "PlugApp", app_name.underscore.camelcase)
+      replace_in_files(destination_root, "plug-app", app_name.dasherize)
+      replace_in_files(destination_root, "PLUG_APP", app_name.underscore.upcase)
+      replace_in_files(destination_root, "plug_app", app_name.underscore)
+    end
+
+    private
+
+    def root_path
+      @root_path ||= Pathname(__dir__).join("..", "..").expand_path
+    end
+
+    def development_env?
+      root_path.join("hephaestus.gemspec").exist?
+    end
+
+    def raise_on_missing_translations_in(environment)
+      config = "config.i18n.raise_on_missing_translations = true"
+
+      uncomment_lines("config/environments/#{environment}.rb", config)
+    end
+
+    def heroku_adapter
+      @heroku_adapter ||= Adapters::Heroku.new(self)
+    end
+  end
+end

data/lib/hephaestus/exit_on_failure.rb

@@ -0,0 +1,22 @@
+# typed: false
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "English"
+
+module Hephaestus
+  module ExitOnFailure
+    extend ActiveSupport::Concern
+
+    # def bundle_command(*args)
+    #   run("bundle", args)
+    #   exit(false) if $CHILD_STATUS.exitstatus.nonzero?
+    # end
+
+    module ClassMethods
+      def exit_on_failure?
+        true
+      end
+    end
+  end
+end