@shopify/cli-kit 3.45.0 → 3.46.0-pre.0

package/assets/cli-ruby/lib/shopify_cli/php_deps.rb

@@ -1,102 +0,0 @@
-require "shopify_cli"
-
-module ShopifyCLI
-  ##
-  # ShopifyCLI::PHPDeps ensures that all PHP dependencies are installed for projects.
-  #
-  class PHPDeps
-    include SmartProperties
-
-    property! :ctx, accepts: ShopifyCLI::Context
-
-    ##
-    # Proxy to instance method ShopifyCLI::PHPDeps.new.install.
-    #
-    # #### Parameters
-    # - `ctx`: running context from your command
-    # - `verbose`: whether to run the installation tools in verbose mode
-    #
-    # #### Example
-    #
-    #   ShopifyCLI::PHPDeps.install(ctx)
-    #
-    def self.install(ctx, verbose = false)
-      new(ctx: ctx).install(verbose)
-    end
-
-    ##
-    # Installs all of a project's PHP dependencies using Composer.
-    #
-    # #### Parameters
-    # - `verbose`: whether to run the installation tools in verbose mode
-    #
-    # #### Example
-    #
-    #   # context is the running context for the command
-    #   ShopifyCLI::PHPDeps.new(context).install(true)
-    #
-    def install(verbose = false)
-      title = ctx.message("core.php_deps.installing")
-      success = ctx.message("core.php_deps.installed")
-      failure = ctx.message("core.php_deps.error.install_error")
-
-      CLI::UI::Frame.open(title, success_text: success, failure_text: failure) do
-        composer(verbose)
-      end
-    end
-
-    private
-
-    def composer(verbose = false)
-      cmd = %w(composer install)
-      cmd << "--quiet" unless verbose
-
-      run_install_command(cmd)
-    end
-
-    def run_install_command(cmd)
-      deps = parse_dependencies
-      errors = nil
-
-      spinner_title = ctx.message("core.php_deps.installing")
-      success = CLI::UI::Spinner.spin(spinner_title, auto_debrief: false) do |spinner|
-        _out, errors, status = CLI::Kit::System.capture3(*cmd, env: @ctx.env, chdir: ctx.root)
-        update_spinner_title_and_status(spinner, status, deps)
-      end
-
-      errors.lines.each { |e| ctx.puts e } unless success || errors.nil?
-
-      ctx.abort(ctx.message("core.php_deps.error.install", "Composer")) unless success
-      success
-    end
-
-    def update_spinner_title_and_status(spinner, status, deps)
-      if status.success?
-        spinner.update_title(ctx.message("core.php_deps.installed_count", deps.size))
-      else
-        spinner.update_title(ctx.message("core.php_deps.error.install_spinner_error", deps.size))
-        CLI::UI::Spinner::TASK_FAILED
-      end
-    end
-
-    def parse_dependencies
-      composer_json = File.join(ctx.root, "composer.json")
-      pkg =
-        begin
-          JSON.parse(File.read(composer_json))
-        rescue Errno::ENOENT, Errno::ENOTDIR
-          ctx.abort(ctx.message("core.php_deps.error.missing_package", composer_json))
-        end
-
-      %w(require require-dev).map do |key|
-        pkg.fetch(key, []).keys
-      end.flatten
-    rescue JSON::ParserError
-      ctx.puts(
-        ctx.message("core.php_deps.error.invalid_package", File.read(File.join(path, "composer.json"))),
-        error: true
-      )
-      raise ShopifyCLI::AbortSilent
-    end
-  end
-end

package/assets/cli-ruby/lib/shopify_cli/process_supervision.rb

@@ -1,228 +0,0 @@
-require "fileutils"
-
-module ShopifyCLI
-  ##
-  # ProcessSupervision wraps a running process spawned by `exec` and keeps track
-  # if its `pid` and keeps a log file for it as well
-  class ProcessSupervision
-    # a string or a symbol to identify this process by
-    attr_reader :identifier
-    # process ID for the running process
-    attr_accessor :pid
-    # starttime of the process
-    attr_reader :time
-    # filepath to the pidfile for this process
-    attr_reader :pid_path
-    # filepath to the logfile for this process
-    attr_reader :log_path
-
-    class << self
-      def run_dir
-        # is the directory where the pid and logfile are kept
-        File.join(ShopifyCLI.cache_dir, "sv")
-      end
-
-      ##
-      # Will find and create a new instance of ProcessSupervision for a running process
-      # if it is currently running. It will return nil if the process is not running.
-      #
-      # #### Parameters
-      #
-      # * `identifier` - a string or a symbol that a process was started with
-      #
-      # #### Returns
-      #
-      # * `process` - ProcessSupervision instance if the process is running this
-      #   will be nil if the process is not running.
-      #
-      def for_ident(identifier)
-        pid, time = File.read(File.join(ShopifyCLI::ProcessSupervision.run_dir, "#{identifier}.pid")).split(":")
-        new(identifier, pid: Integer(pid), time: time)
-      rescue Errno::ENOENT
-        nil
-      end
-
-      ##
-      # will fork and spawn a new process that is separate from the current process.
-      # This process will keep running beyond the command running so be careful!
-      #
-      # #### Parameters
-      #
-      # * `identifier` - a string or symbol to identify the new process by.
-      # * `args` - a command to run, either a string or array of strings
-      # * `force_spawn` - whether we want the child process to be a spawn and not a fork, so it is terminated along with
-      #                   the parent
-      #
-      # #### Returns
-      #
-      # * `process` - ProcessSupervision instance if the process is running, this
-      #   will be nil if the process did not start.
-      #
-      def start(identifier, args, force_spawn: false)
-        return for_ident(identifier) if running?(identifier)
-
-        # Some systems don't support forking process without extra gems, so we resort to spawning a new child process -
-        # that means that it dies along with the original process if it is interrupted. If possible, we fork the process
-        # so that it doesn't have to be restarted on every run.
-        if Process.respond_to?(:fork) && !force_spawn
-          fork do
-            pid_file = new(identifier, pid: Process.pid)
-            pid_file.write
-            STDOUT.reopen(pid_file.log_path, "w")
-            STDERR.reopen(pid_file.log_path, "w")
-            STDIN.reopen("/dev/null", "r")
-            Process.setsid
-            exec(*args)
-          end
-        else
-          pid_file = new(identifier)
-
-          # Make sure the file exists and is empty, otherwise Windows fails
-          File.open(pid_file.log_path, "w") {}
-          pid = Process.spawn(
-            *args,
-            out: pid_file.log_path,
-            err: pid_file.log_path,
-            in: Context.new.windows? ? "nul" : "/dev/null",
-          )
-          pid_file.pid = pid
-          pid_file.write
-
-          Process.detach(pid)
-        end
-
-        sleep(0.1)
-        for_ident(identifier)
-      end
-
-      ##
-      # will attempt to shutdown a running process
-      #
-      # #### Parameters
-      #
-      # * `identifier` - a string or symbol to identify the new process by.
-      #
-      # #### Returns
-      #
-      # * `stopped` - [true, false]
-      #
-      def stop(identifier)
-        process = for_ident(identifier)
-        return false unless process
-        process.stop
-      end
-
-      ##
-      # will help identify if your process is still running in the background.
-      #
-      # #### Parameters
-      #
-      # * `identifier` - a string or symbol to identify the new process by.
-      #
-      # #### Returns
-      #
-      # * `running` - [true, false]
-      #
-      def running?(identifier)
-        process = for_ident(identifier)
-        return false unless process
-        process.alive?
-      end
-    end
-
-    def initialize(identifier, pid: nil, time: Time.now.strftime("%s")) # :nodoc:
-      @identifier = identifier
-      @pid = pid
-      @time = time
-      FileUtils.mkdir_p(ShopifyCLI::ProcessSupervision.run_dir)
-      @pid_path = File.join(ShopifyCLI::ProcessSupervision.run_dir, "#{identifier}.pid")
-      @log_path = File.join(ShopifyCLI::ProcessSupervision.run_dir, "#{identifier}.log")
-    end
-
-    ##
-    # will attempt to shutdown a running process
-    #
-    # #### Parameters
-    #
-    # * `ctx` - the context of this command
-    #
-    # #### Returns
-    #
-    # * `stopped` - [true, false]
-    #
-    def stop
-      kill_proc
-      unlink
-      true
-    rescue
-      false
-    end
-
-    ##
-    # will help identify if your process is still running in the background.
-    #
-    # #### Returns
-    #
-    # * `alive` - [true, false]
-    #
-    def alive?
-      stat(pid)
-    end
-
-    ##
-    # persists the pidfile
-    #
-    def write
-      FileUtils.mkdir_p(File.dirname(pid_path))
-      File.write(pid_path, "#{pid}:#{time}")
-    end
-
-    private
-
-    def unlink
-      File.unlink(pid_path)
-      File.unlink(log_path)
-      nil
-    rescue Errno::ENOENT
-      nil
-    end
-
-    def kill_proc
-      if Context.new.windows?
-        kill(pid)
-      else
-        kill(-pid) # process group
-      end
-    rescue Errno::ESRCH
-      begin
-        kill(pid)
-      rescue Errno::ESRCH # The process group does not exist, try the pid itself
-        # Race condition, process died in the middle
-      end
-    end
-
-    def kill(id)
-      ctx = Context.new
-
-      # Windows does not handle SIGTERM, go straight to SIGKILL
-      unless ctx.windows?
-        Process.kill("TERM", id)
-        50.times do
-          sleep(0.1)
-          break unless stat(id)
-        end
-      end
-      Process.kill("KILL", id) if stat(id)
-      sleep(0.1) if ctx.windows? # Give Windows a second to actually close the process
-    end
-
-    def stat(id)
-      Process.kill(0, id) # signal 0 checks if pid is alive
-      true
-    rescue Errno::EPERM
-      true
-    rescue Errno::ESRCH
-      false
-    end
-  end
-end

package/assets/cli-ruby/lib/shopify_cli/project_commands.rb

@@ -1,16 +0,0 @@
-module ShopifyCLI
-  class ProjectCommand < Command
-    def call(*)
-      @ctx.puts(self.class.help)
-    end
-
-    def self.help
-      project_type = name.split("::")[0].downcase
-      ShopifyCLI::Context.message(
-        "#{project_type}.help",
-        ShopifyCLI::TOOL_NAME,
-        subcommand_registry.command_names.join(" | ")
-      )
-    end
-  end
-end

package/assets/cli-ruby/lib/shopify_cli/release.rb

@@ -1,197 +0,0 @@
-require "net/http"
-require "fileutils"
-require "shopify_cli/sed"
-require "shopify_cli/changelog"
-require "octokit"
-
-module ShopifyCLI
-  class Release
-    def initialize(new_version, github_access_token)
-      @new_version = new_version
-      @github = Octokit::Client.new(access_token: github_access_token)
-    end
-
-    def prepare!
-      ensure_updated_main
-      create_release_branch
-      update_changelog
-      update_versions_in_files
-      commit_packaging
-      pr = create_pr
-      system("open #{pr["html_url"]}")
-    end
-
-    def package!
-      ensure_updated_main
-      ensure_correct_gem_version
-      Rake::Task["package"].invoke
-      update_homebrew
-      create_github_release
-    end
-
-    private
-
-    attr_reader :new_version, :github
-
-    def ensure_updated_main
-      # We can't be sure what is the correct action to take if changes have been
-      # made but not committed. Ensure the user handles the situation before
-      # moving on.
-      unless %x(git status --porcelain).empty?
-        raise <<~MESSAGE
-          Uncommitted changes have been made to the repository.
-          Please make sure `git status` does not show any changes before continuing.
-        MESSAGE
-      end
-      system_or_fail("git checkout main", "check out main branch")
-      unless system("git pull")
-        raise "git pull failed, cannot be sure there aren't new commits!"
-      end
-    end
-
-    def create_release_branch
-      puts "Checking out release branch"
-      system_or_fail("git checkout -b #{release_branch_name}", "check out release branch")
-    end
-
-    def update_changelog
-      if release_notes("Unreleased").empty?
-        puts "No unreleased CHANGELOG updates found!"
-      else
-        puts "Updating CHANGELOG"
-        changelog.update_version!(new_version)
-      end
-    end
-
-    def update_versions_in_files
-      version_file = File.join(ShopifyCLI::ROOT, "lib/shopify_cli/version.rb")
-      puts "Updating version.rb"
-      ShopifyCLI::Sed.new.replace_inline(version_file, ShopifyCLI::VERSION, new_version)
-      gemfile_lock = File.join(ShopifyCLI::ROOT, "Gemfile.lock")
-      puts "Updating Gemfile.lock"
-      ShopifyCLI::Sed.new.replace_inline(
-        gemfile_lock,
-        "shopify-cli (#{ShopifyCLI::VERSION})",
-        "shopify-cli (#{new_version})",
-      )
-    end
-
-    def commit_packaging
-      puts "Committing"
-      system_or_fail("git commit -am 'Packaging for release v#{new_version}'", "commit")
-      system_or_fail("git push -u origin #{release_branch_name}", "push branch")
-    end
-
-    def create_pr
-      repo = "Shopify/shopify-cli"
-      github.create_pull_request(
-        repo,
-        "main",
-        release_branch_name,
-        "Packaging for release v#{new_version}",
-        release_notes(new_version)
-      ).tap { |results| puts "Created #{repo} PR ##{results["number"]}" }
-    end
-
-    def ensure_correct_gem_version
-      response = Net::HTTP.get(URI("https://rubygems.org/api/v1/versions/shopify-cli/latest.json"))
-      latest_version = JSON.parse(response)["version"]
-      unless latest_version == new_version
-        raise "Attempted to update to #{new_version}, but latest on RubyGems is #{latest_version}"
-      end
-    end
-
-    def update_homebrew
-      ensure_updated_homebrew_repo
-      update_homebrew_repo
-      pr = create_homebrew_pr
-      system("open #{pr["html_url"]}")
-    end
-
-    def ensure_updated_homebrew_repo
-      unless File.exist?(homebrew_path)
-        system_or_fail("/opt/dev/bin/dev clone homebrew-shopify", "clone homebrew-shopify repo")
-      end
-
-      Dir.chdir(homebrew_path) do
-        system_or_fail("git checkout master && git pull", "pull latest homebrew-shopify")
-        system_or_fail("git checkout -b #{homebrew_release_branch}", "check out homebrew branch")
-      end
-    end
-
-    def update_homebrew_repo
-      source_file = File.join(package_dir, "shopify-cli@2.rb")
-      FileUtils.copy(source_file, homebrew_path)
-      Dir.chdir(homebrew_path) do
-        system_or_fail("git commit -am '#{homebrew_update_message}'", "commit homebrew update")
-        system_or_fail("git push -u origin #{homebrew_release_branch}", "push homebrew branch")
-      end
-    end
-
-    def create_homebrew_pr
-      repo = "Shopify/homebrew-shopify"
-      github.create_pull_request(
-        repo,
-        "master",
-        homebrew_release_branch,
-        homebrew_update_message,
-        homebrew_release_notes
-      ).tap { |results| puts "Created #{repo} PR ##{results["number"]}" }
-    end
-
-    def create_github_release
-      release = github.create_release(
-        "Shopify/shopify-cli",
-        "v#{new_version}",
-        {
-          name: "Version #{new_version}",
-          body: release_notes(new_version),
-        }
-      )
-      %w(.deb -1.noarch.rpm).each do |suffix|
-        github.upload_asset(
-          release["url"],
-          File.join(package_dir, "shopify-cli-#{new_version}#{suffix}")
-        )
-      end
-      system("open #{release["html_url"]}")
-    end
-
-    def homebrew_path
-      @homebrew_path ||= %x(/opt/dev/bin/dev project-path homebrew-shopify).chomp
-    end
-
-    def homebrew_update_message
-      @homebrew_update_message ||= "Update Shopify CLI to #{new_version}"
-    end
-
-    def package_dir
-      @package_dir ||= File.join(ShopifyCLI::ROOT, "packaging", "builds", new_version)
-    end
-
-    def homebrew_release_branch
-      "release_#{new_version.split(".").join("_")}_of_shopify-cli"
-    end
-
-    def homebrew_release_notes
-      "I'm releasing a new version of the Shopify CLI, " \
-        "[#{new_version}](https://github.com/Shopify/shopify-cli/releases/tag/v#{new_version})"
-    end
-
-    def release_branch_name
-      @release_branch_name ||= "release_#{new_version.split(".").join("_")}"
-    end
-
-    def release_notes(version)
-      changelog.release_notes(version)
-    end
-
-    def system_or_fail(command, action)
-      raise "Failed to #{action}!" unless system(command)
-    end
-
-    def changelog
-      @changelog ||= ShopifyCLI::Changelog.new
-    end
-  end
-end

package/assets/cli-ruby/lib/shopify_cli/sed.rb

@@ -1,19 +0,0 @@
-module ShopifyCLI
-  class Sed
-    class SedError < StandardError; end
-
-    def replace_inline(filename, pattern, output)
-      command =
-        case CLI::Kit::System.os
-        when :mac
-          "sed -i ''"
-        when :linux
-          "sed -i"
-        else
-          raise "Unrecognized system!"
-        end
-      success = system("#{command} 's/#{pattern}/#{output}/' #{filename}")
-      raise SedError unless success
-    end
-  end
-end

package/assets/cli-ruby/lib/shopify_cli/services/app/connect_service.rb

@@ -1,25 +0,0 @@
-module ShopifyCLI
-  module Services
-    module App
-      class ConnectService < BaseService
-        attr_reader :app_type, :project, :context
-
-        def initialize(app_type:, project:, context:)
-          @app_type = app_type
-          @project = project
-          @context = context
-          super()
-        end
-
-        def call
-          unless project&.env.nil?
-            context.puts(context.message("core.app.connect.production_warning"))
-          end
-
-          app = ShopifyCLI::Connect.new(context).default_connect(app_type.to_s)
-          context.done(context.message("core.app.connect.connected", app))
-        end
-      end
-    end
-  end
-end