@shopify/cli-kit 3.69.4 → 3.71.0

package/assets/cli-ruby/ext/javy/javy.rb

@@ -1,204 +0,0 @@
-require "open-uri"
-require "zlib"
-require "open3"
-require "digest/sha2"
-
-module Javy
-  ROOT = __dir__
-  BIN_FOLDER = File.join(ShopifyCLI.cache_dir, "javy", "bin")
-  HASH_FOLDER = File.join(ROOT, "hashes")
-  VERSION = File.read(File.join(ROOT, "version")).strip
-  TARGET = File.join(BIN_FOLDER, "javy-#{VERSION}")
-
-  class << self
-    def install
-      ShopifyCLI::Result
-        .wrap { Installer.call(target: target, platform: platform, version: VERSION) }
-        .call
-    end
-
-    def build(source:, dest: nil)
-      optional_args = []
-      optional_args += ["-o", dest] unless dest.nil?
-
-      ShopifyCLI::Result
-        .wrap { ensure_installed }
-        .call
-        .then { exec(source, *optional_args) }
-    end
-
-    private
-
-    def exec(*args, **kwargs)
-      out_and_err, stat = CLI::Kit::System.capture2e(target, *args, **kwargs)
-      raise ExecutionError, out_and_err unless stat.success?
-      true
-    end
-
-    def platform
-      Platform.new
-    end
-
-    def target
-      platform.format_executable_path(TARGET)
-    end
-
-    def ensure_installed
-      delete_outdated_installations
-      install.unwrap { |e| raise e } unless Installer.installed?(target: target)
-      true
-    end
-
-    def delete_outdated_installations
-      installed_binaries
-        .reject { |v| v == target }
-        .each { |file| File.delete(file) }
-    end
-
-    def installed_binaries
-      Dir[File.join(BIN_FOLDER, "javy-*")]
-    end
-
-    module Installer
-      def self.call(target:, platform:, version:)
-        asset = Asset.new(
-          platform: platform,
-          version: version,
-          owner: "Shopify",
-          repository: "javy",
-          basename: "javy"
-        )
-
-        downloaded = asset.download(target: target)
-        raise InstallationError.asset_not_found(platform: platform, version: version, url: asset.url) unless downloaded
-
-        true
-      end
-
-      def self.installed?(target:)
-        File.executable?(target)
-      end
-    end
-  end
-
-  class Error < RuntimeError; end
-  class ExecutionError < Error; end
-
-  class InstallationError < Error
-    def self.cpu_unsupported
-      new("Javy is not supported on this CPU")
-    end
-
-    def self.asset_not_found(platform:, version:, url:)
-      new(format(
-        "Unable to download javy %{version} for %{os} (%{cpu}) at %{url}",
-        version: version,
-        os: platform.os,
-        cpu: platform.cpu,
-        url: url
-      ))
-    end
-
-    def self.invalid_binary
-      new("Invalid Javy binary downloaded.")
-    end
-  end
-
-  Asset = Struct.new(:platform, :version, :owner, :repository, :basename, keyword_init: true) do
-    def download(target:)
-      FileUtils.mkdir_p(BIN_FOLDER)
-
-      source_file = url.open
-      validate_sha!(source_file)
-      source_file.seek(0)
-
-      Dir.chdir(File.dirname(target)) do
-        File.open(File.basename(target), "wb") do |target_file|
-          decompress(source_file, target_file)
-        end
-
-        File.chmod(0755, target)
-      end
-
-      true
-    rescue OpenURI::HTTPError
-      false
-    end
-
-    def url
-      URI.parse(format(
-        "https://github.com/%{owner}/%{repository}/releases/download/%{version}/%{filename}",
-        owner: owner,
-        repository: repository,
-        version: version,
-        filename: filename
-      ))
-    end
-
-    def filename
-      format(
-        "%{basename}-%{cpu}-%{os}-%{version}.gz",
-        basename: basename,
-        cpu: platform.cpu,
-        os: platform.os,
-        version: version
-      )
-    end
-
-    private
-
-    def decompress(source, target)
-      zlib = Zlib::GzipReader.new(source)
-      target << zlib.read
-    ensure
-      zlib.close
-    end
-
-    def validate_sha!(source)
-      generated_hash = Digest::SHA256.hexdigest(source.read).strip
-      expected_hash = File.read(File.join(HASH_FOLDER, "#{filename}.sha256")).strip
-      raise InstallationError.invalid_binary unless generated_hash == expected_hash
-    end
-  end
-
-  Platform = Struct.new(:ruby_platform) do
-    def initialize(ruby_platform = RUBY_PLATFORM)
-      super(ruby_platform)
-    end
-
-    def to_s
-      format("%{cpu}-%{os}", cpu: cpu, os: os)
-    end
-
-    def os
-      case ruby_platform
-      when /linux/
-        "linux"
-      when /darwin/
-        "macos"
-      else
-        "windows"
-      end
-    end
-
-    def cpu
-      case ruby_platform
-      when /x64/, /x86_64/
-        "x86_64"
-      when /arm/
-        "arm"
-      else
-        raise InstallationError.cpu_unsupported
-      end
-    end
-
-    def format_executable_path(path)
-      case os
-      when "windows"
-        File.extname(path) != ".exe" ? path + ".exe" : path
-      else
-        path
-      end
-    end
-  end
-end

package/assets/cli-ruby/ext/javy/version

@@ -1 +0,0 @@
-v0.3.0

package/assets/cli-ruby/ext/shopify-extensions/extconf.rb

@@ -1,21 +0,0 @@
-require_relative "./shopify_extensions"
-
-installation_dir = ENV.fetch("SHOPIFY_CLI_EXTENSIONS_INSTALLATION_DIR", __dir__)
-
-File.write(File.expand_path("Makefile", installation_dir), <<~MAKEFILE)
-  .PHONY: clean
-
-  clean: ;
-
-  install: ;
-MAKEFILE
-
-begin
-  ShopifyExtensions.install(
-    target: File.expand_path("shopify-extensions", installation_dir)
-  )
-rescue ShopifyExtensions::InstallationError => error
-  STDERR.puts(error.message)
-rescue => error
-  STDERR.puts("Unable to install shopify-extensions: #{error}")
-end

package/assets/cli-ruby/ext/shopify-extensions/shopify_extensions.rb

@@ -1,152 +0,0 @@
-require "rbconfig"
-require "open-uri"
-require "zlib"
-require "open3"
-
-module ShopifyExtensions
-  def self.install(**args)
-    Install.call(**args)
-  end
-
-  class Install
-    def self.call(platform: Platform.new, **args)
-      new.call(platform: platform, **args)
-    end
-
-    def self.version
-      File.read(File.expand_path("../version", __FILE__)).strip
-    end
-
-    def call(platform:, version: self.class.version, target:)
-      target = platform.format_path(target.to_s)
-
-      asset = Asset.new(
-        platform: platform,
-        version: version,
-        owner: "Shopify",
-        repository: "shopify-cli-extensions",
-        basename: "shopify-extensions"
-      )
-      downloaded = asset.download(target: target)
-      raise InstallationError.asset_not_found(platform: platform, version: version) unless downloaded
-
-      raise InstallationError.installation_failed unless verify(target, version: version)
-    end
-
-    private
-
-    def fetch_release_details_for(version:)
-      JSON.parse(URI.parse(release_url_for(version: version)).open.read).yield_self(&Release)
-    rescue OpenURI::HTTPError
-      nil
-    end
-
-    def verify(target, version:)
-      return false unless File.executable?(target)
-      installed_server_version, exit_code = Open3.capture2(target, "version")
-      return false unless exit_code == 0
-      return false unless installed_server_version.strip == version.strip
-      true
-    end
-  end
-
-  class InstallationError < RuntimeError
-    def self.installation_failed
-      new("Failed to install shopify-extensions properly")
-    end
-
-    def self.asset_not_found(platform:, version:)
-      new(format(
-        "Unable to download shopify-extensions %{version} for %{os} (%{cpu})",
-        version: version,
-        os: platform.os,
-        cpu: platform.cpu
-      ))
-    end
-  end
-
-  Asset = Struct.new(:platform, :version, :owner, :repository, :basename, keyword_init: true) do
-    def download(target:)
-      Dir.chdir(File.dirname(target)) do
-        File.open(File.basename(target), "wb") do |target_file|
-          decompress(url.open, target_file)
-        end
-        File.chmod(0755, target)
-      end
-
-      true
-    rescue OpenURI::HTTPError
-      false
-    end
-
-    def url
-      URI.parse(format(
-        "https://github.com/%{owner}/%{repository}/releases/download/%{version}/%{filename}",
-        owner: owner,
-        repository: repository,
-        version: version,
-        filename: filename
-      ))
-    end
-
-    def filename
-      format(
-        "%{basename}-%{os}-%{cpu}.%{extension}",
-        basename: basename,
-        os: platform.os,
-        cpu: platform.cpu,
-        extension: platform.os == "windows" ? "exe.gz" : "gz"
-      )
-    end
-
-    private
-
-    def decompress(source, target)
-      zlib = Zlib::GzipReader.new(source)
-      target << zlib.read
-    ensure
-      zlib.close
-    end
-  end
-
-  Platform = Struct.new(:ruby_config) do
-    def initialize(ruby_config = RbConfig::CONFIG)
-      super(ruby_config)
-    end
-
-    def format_path(path)
-      case os
-      when "windows"
-        File.extname(path) != ".exe" ? path + ".exe" : path
-      else
-        path
-      end
-    end
-
-    def to_s
-      format("%{os}-%{cpu}", os: os, cpu: cpu)
-    end
-
-    def os
-      case ruby_config.fetch("host_os")
-      when /linux/
-        "linux"
-      when /darwin/
-        "darwin"
-      else
-        "windows"
-      end
-    end
-
-    def cpu
-      case ruby_config.fetch("host_cpu")
-      when /arm.*64/
-        "arm64"
-      when /64/
-        "amd64"
-      else
-        "386"
-      end
-    end
-  end
-end

package/assets/cli-ruby/ext/shopify-extensions/version

@@ -1 +0,0 @@
-v0.12.0

package/assets/cli-ruby/features/support/assertions.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "minitest/spec"
-require "minitest/assertions"
-
-class MinitestWorld
-  include Minitest::Assertions
-  attr_accessor :assertions
-
-  def initialize
-    self.assertions = 0
-  end
-end
-
-World do
-  MinitestWorld.new
-end

package/assets/cli-ruby/features/support/cli.rb

@@ -1,7 +0,0 @@
-module CLI
-  def self.version
-    version_file_path = File.expand_path("../../lib/shopify_cli/version.rb", __dir__)
-    version_file_content = File.read(version_file_path)
-    version_file_content.match(/VERSION\s+=\s+"(?<version>[0-9]+\.[0-9]+\.[0-9]+)"/)[:version].chomp
-  end
-end

package/assets/cli-ruby/features/support/process.rb

@@ -1,27 +0,0 @@
-require "open3"
-require_relative "../../utilities/utilities"
-
-module Process
-  class ProcessError < StandardError
-    attr_reader :exit_status, :stderr
-    def initialize(exit_status:, stderr:)
-      @exit_status = exit_status
-      @stderr = stderr
-      super
-    end
-
-    def to_s
-      stderr
-    end
-  end
-
-  def self.run(*args, cwd: nil)
-    cwd ||= Dir.pwd
-    _, err, stat = Open3.capture3(*args, chdir: cwd)
-    raise ProcessError.new(exit_status: stat.exitstatus, stderr: err) unless stat.success?
-  end
-
-  def self.shopify_executable_path
-    File.expand_path("../../bin/shopify", __dir__)
-  end
-end

package/assets/cli-ruby/features/support/requires.rb

@@ -1,3 +0,0 @@
-require_relative "../../utilities/utilities"
-require "byebug"
-require "fileutils"

package/assets/cli-ruby/lib/docgen/class_template.md.erb

@@ -1,81 +0,0 @@
-<%= comment %>
-<% if constants.any? -%>
-- [Constants](#constants)
-<%- end -%>
-<%- if attributes.any? -%>
-- [Attributes](#attributes)
-<%- end -%>
-<%- if class_methods.any? -%>
-- [Class Methods](#class-methods)
-<%- class_methods.each do |method| -%>
-  - [<%= method.title %>](#<%= method.title.gsub("?", "") %>)
-<%- end -%>
-<%- end -%>
-<%- if instance_methods.any? -%>
-- [Instance Methods](#instance-methods)
-<%- instance_methods.each do |method| -%>
-  - [<%= method.title %>](#<%= method.title.gsub("?", "") %>)
-<%- end -%>
-<%- end -%>
-<%- if included.any? -%>
-- [Includes](#includes)
-<%- end -%>
-<%- if extended.any? -%>
-- [Extends](#extends)
-<%- end -%>
-<%- if constants.any? %>
-## Constants
-<%- constants.each do |const| -%>
-- `<%= const.title %>` <%= const.comment %>
-<%- end -%>
-<%- end -%>
-<%- if attributes.any? %>
-## Attributes
-<%- attributes.each do |attr| -%>
-- `<%= attr.title %>` <%= attr.comment %>
-<%- end -%>
-<%- end -%>
-<%- if class_methods.any? %>
-## Class Methods
-<% class_methods.each do |method| %>
-### <%= method.title %>
-`<%= method.signature %>`
-<%= method.comment %>
-<details><summary>see source</summary><p>
-
-```ruby
-<%= method.source_code %>
-```
-</p></details>
-
----
-<%- end -%>
-<%- end -%>
-<%- if instance_methods.any? %>
-## Instance Methods
-<% instance_methods.each do |method| %>
-### <%= method.title %>
-`<%= method.signature %>`
-<%= method.comment %>
-<details><summary>see source</summary><p>
-
-```ruby
-<%= method.source_code %>
-```
-</p></details>
-
----
-<%- end -%>
-<%- end -%>
-<%- if included.any? %>
-## Includes
-<% included.each do |incld| %>
-- <%= incld.title %>
-<%- end -%>
-<%- end -%>
-<%- if extended.any? %>
-## Extends
-<% extended.each do |incld| %>
-- <%= incld.title %>
-<%- end -%>
-<%- end -%>

package/assets/cli-ruby/lib/docgen/index_template.md.erb

@@ -1,5 +0,0 @@
-The Shopify CLI has a set of core APIs that simplify the process of extending its functionality.
-
-<%- classes.each do |method| -%>
-- [<%= method.title %>](https://github.com/Shopify/shopify-cli/wiki/<%= method.filename %>)
-<%- end -%>

package/assets/cli-ruby/lib/docgen/markdown.rb

@@ -1,101 +0,0 @@
-require "rdoc/rdoc"
-require "erb"
-
-module RDoc
-  module Generator
-    class Markdown
-      ::RDoc::RDoc.add_generator(self)
-
-      DocClass = Struct.new(
-        :title, :kind, :comment, :class_methods, :instance_methods, :attributes,
-        :constants, :extended, :included, :filename,
-        keyword_init: true,
-      )
-      ClassMember = Struct.new(:title, :comment, :signature, :source_code, keyword_init: true)
-
-      def initialize(store, options)
-        @options = options
-        @store = store
-        @converter = ::RDoc::Markup::ToMarkdown.new
-      end
-
-      def generate
-        render(build_classes)
-      end
-
-      private
-
-      def render(data)
-        class_template_path = File.join(File.dirname(__FILE__), "class_template.md.erb")
-        class_renderer = ERB.new(File.read(class_template_path), nil, "-")
-        data.each do |cls|
-          File.write("#{cls.filename}.md", class_renderer.result(cls.instance_eval { binding }))
-        end
-        index_template_path = File.join(File.dirname(__FILE__), "index_template.md.erb")
-        index_renderer = ERB.new(File.read(index_template_path), nil, "-")
-        File.write("Core-APIs.md", index_renderer.result(OpenStruct.new(classes: data).instance_eval { binding }))
-      end
-
-      def build_classes
-        classes = @store.all_classes_and_modules.map do |klass|
-          is_class = @store.all_modules.find { |m| m.full_name == klass.full_name }.nil?
-          kind = is_class ? :class : :module
-          DocClass.new(
-            filename: "#{kind}-#{klass.full_name}",
-            title: klass.full_name,
-            kind: kind,
-            comment: @converter.convert(klass.comment.parse),
-            constants: build_members(klass.constants),
-            class_methods: build_members(klass.method_list.select { |m| m.type == "class" }),
-            instance_methods: build_members(klass.method_list.select { |m| m.type == "instance" }),
-            attributes: build_members(klass.attributes),
-            extended: build_members(klass.extends),
-            included: build_members(klass.includes),
-          )
-        end
-
-        # Remove nondescript items
-        classes.reject do |klass|
-          klass.comment.empty? && klass.constants.empty? &&
-            klass.class_methods.empty? && klass.instance_methods.empty? &&
-            klass.attributes.empty? && klass.extended.empty? &&
-            klass.included.empty?
-        end
-      end
-
-      def build_members(member_list)
-        member_list.map do |m|
-          ClassMember.new(
-            title:     m.name,
-            comment:   @converter.convert(m.comment.parse),
-            signature: m.respond_to?(:arglists) ? m.arglists : "",
-            source_code: source(m),
-          )
-        end
-      end
-
-      # Just extracts sourcecode from html formatting/highlighting into a text
-      # blob so that markdown can format it with a codeblock
-      def source(m)
-        return "" unless m.respond_to?(:token_stream)
-        # each line, get the text
-        src = (m.token_stream || []).map do |t|
-          next unless t
-          CGI.escapeHTML(t[:text])
-        end.join
-        # dedent the source
-        indent = src.length
-        lines = src.lines.to_a
-        lines.shift if src =~ /\A.*#\ *File/i # remove '# File' comment
-        lines.each do |line|
-          next unless line =~ /^ *(?=\S)/
-          n = Regexp.last_match(0).length
-          indent = n if n < indent
-          break if n == 0
-        end
-        src.gsub!(/^#{' ' * indent}/, "") if indent > 0
-        src
-      end
-    end
-  end
-end