@shopify/cli-kit 3.69.3 → 3.70.0

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

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-require "shopify_cli"
-
-module ShopifyCLI
-  ##
-  # ShopifyCLI::Project captures the current project that the user is working on.
-  # This class can be used to fetch and save project environment as well as the
-  # project config `.shopify-cli.yml`.
-  #
-  class Project
-    include SmartProperties
-
-    class << self
-      ##
-      # will get an instance of the project that the user is currently operating
-      # on. This is used for access to project resources.
-      #
-      # #### Parameters
-      #
-      # * `force_reload` - whether to force a reload of the project files
-      #
-      # #### Returns
-      #
-      # * `project` - a Project instance if the user is currently in the project.
-      #
-      # #### Raises
-      #
-      # * `ShopifyCLI::Abort` - If the cli is not currently in a project directory
-      #   then this will be raised with a message implying that the user is not in
-      #   a project directory.
-      #
-      # #### Example
-      #
-      #   project = ShopifyCLI::Project.current
-      #
-      def current(force_reload: false)
-        clear if force_reload
-        at(Dir.pwd)
-      end
-
-      ##
-      # will return true if the command line is currently within a project
-      #
-      # #### Returns
-      #
-      # * `has_current?` - boolean, true if there is a current project
-      #
-      def has_current?
-        !directory(Dir.pwd).nil?
-      end
-
-      ##
-      # will fetch the project type of the current project. This is mostly used
-      # for internal project type loading, you should not normally need this.
-      #
-      # #### Returns
-      #
-      # * `type` - a symbol of the name of the project type identifier. i.e. [rails, node]
-      #   This will be nil if the user is not in a current project.
-      #
-      # #### Example
-      #
-      #   type = ShopifyCLI::Project.current_project_type
-      #
-      def current_project_type
-        return unless has_current?
-        current.config["project_type"].to_sym
-      end
-
-      ##
-      # writes out the `.shopify-cli.yml` file. You should use this when creating
-      # a project type so that the rest of your project type commands will load
-      # in this project, in the future.
-      #
-      # #### Parameters
-      #
-      # * `ctx` - the current running context of your command
-      # * `project_type` - a string or symbol of your project type name
-      # * `organization_id` - the id of the partner organization that the app is owned by. Used for metrics
-      # * `identifiers` - an optional hash of other app identifiers
-      #
-      # #### Example
-      #
-      #   ShopifyCLI::Project.write(
-      #     @ctx,
-      #     project_type: "node",
-      #     organization_id: form_data.organization_id,
-      #   )
-      #
-      def write(ctx, project_type:, organization_id:, **identifiers)
-        require "yaml" # takes 20ms, so deferred as late as possible.
-        content = Hash[{ project_type: project_type, organization_id: organization_id.to_i }
-          .merge(identifiers)
-          .collect { |k, v| [k.to_s, v] }]
-        content["shopify_organization"] = true if Shopifolk.acting_as_shopify_organization?
-
-        ctx.write(".shopify-cli.yml", YAML.dump(content))
-        clear
-      end
-
-      def project_name
-        File.basename(current.directory)
-      end
-
-      def clear
-        @at = nil
-        @dir = nil
-      end
-
-      def at(dir)
-        proj_dir = directory(dir)
-        if !proj_dir && !ShopifyCLI::Environment.run_as_subprocess?
-          raise(ShopifyCLI::Abort, Context.message("core.project.error.not_in_project"))
-        end
-        @at ||= Hash.new { |h, k| h[k] = new(directory: k) }
-        @at[proj_dir]
-      end
-
-      private
-
-      def directory(dir)
-        @dir ||= Hash.new { |h, k| h[k] = Utilities.directory(".shopify-cli.yml", k) }
-        @dir[dir]
-      end
-    end
-
-    property :directory # :nodoc:
-    property :env # :nodoc:
-
-    ##
-    # will read, parse and return the envfile for the project
-    #
-    # #### Returns
-    #
-    # * `env` - An instance of a ShopifyCLI::Resources::EnvFile
-    #
-    # #### Example
-    #
-    #   ShopifyCLI::Project.current.env
-    #
-    def env
-      @env ||= begin
-                 Resources::EnvFile.read(directory)
-               rescue Errno::ENOENT
-                 nil
-               end
-    end
-
-    ##
-    # will read, parse and return the .shopify-cli.yml for the project
-    #
-    # #### Returns
-    #
-    # * `config` - A hash of configuration
-    #
-    # #### Raises
-    #
-    # * `ShopifyCLI::Abort` - If the yml is invalid or poorly formatted
-    # * `ShopifyCLI::Abort` - If the yml file does not exist
-    #
-    # #### Example
-    #
-    #   ShopifyCLI::Project.current.config
-    #
-    def config
-      @config ||= begin
-        config = load_yaml_file(".shopify-cli.yml")
-        unless config.is_a?(Hash)
-          raise ShopifyCLI::Abort, Context.message("core.yaml.error.not_hash", ".shopify-cli.yml")
-        end
-
-        # The app_type key was deprecated in favour of project_type, so replace it
-        if config.key?("app_type")
-          config["project_type"] = config["app_type"]
-          config.delete("app_type")
-        end
-
-        config
-      end
-    end
-
-    private
-
-    def load_yaml_file(relative_path)
-      f = File.join(directory, relative_path)
-      require "yaml" # takes 20ms, so deferred as late as possible.
-      begin
-        YAML.load_file(f)
-      rescue Psych::SyntaxError => e
-        raise(ShopifyCLI::Abort, Context.message("core.yaml.error.invalid", relative_path, e.message))
-      # rescue Errno::EACCES => e
-      # TODO
-      #   Dev::Helpers::EaccesHandler.diagnose_and_raise(f, e, mode: :read)
-      rescue Errno::ENOENT
-        raise ShopifyCLI::Abort, Context.message("core.yaml.error.not_found", f)
-      end
-    end
-  end
-end

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

@@ -1,66 +0,0 @@
-module ShopifyCLI
-  class ProjectType
-    extend Feature::Set
-
-    class << self
-      attr_accessor :project_type,
-        :project_name,
-        :project_load_shallow
-
-      def repository
-        @repository ||= []
-      end
-      alias_method :all_loaded, :repository
-
-      def inherited(klass)
-        super
-        repository << klass
-        klass.project_type = @current_type
-        klass.project_load_shallow = @shallow_load
-      end
-
-      def load_type(current_type, shallow = false)
-        filepath = File.join(ShopifyCLI::ROOT, "lib", "project_types", current_type.to_s, "cli.rb")
-        return unless File.exist?(filepath)
-        @shallow_load = shallow
-        @current_type = current_type
-        load(filepath)
-        @current_type = nil
-        @shallow_load = false
-        for_app_type(current_type)
-      end
-
-      def load_all
-        Dir.glob(File.join(ShopifyCLI::ROOT, "lib", "project_types", "*", "cli.rb")).map do |filepath|
-          load_type(filepath.split(File::Separator)[-2].to_sym, true)
-        end
-      end
-
-      def for_app_type(type)
-        repository.find { |k| k.project_type.to_s == type.to_s }
-      end
-
-      def project_filepath(path)
-        File.join(ShopifyCLI::PROJECT_TYPES_DIR, project_type.to_s, path)
-      end
-
-      def title(name)
-        @project_name = name
-      end
-
-      def register_task(task, name)
-        return if project_load_shallow
-        ShopifyCLI::Tasks.register(task, name)
-      end
-
-      def register_messages(messages)
-        # Make sure we don't attempt to register a file more than once as that will fail
-        @registered_message_files ||= {}
-        return if @registered_message_files.key?(@project_type)
-        @registered_message_files[@project_type] = true
-
-        Context.load_messages(messages)
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-module ShopifyCLI
-  module ReportingConfigurationController
-    def self.enable_reporting(enabled)
-      ShopifyCLI::Config.set(
-        Constants::Config::Sections::Analytics::NAME,
-        Constants::Config::Sections::Analytics::Fields::ENABLED,
-        enabled
-      )
-    end
-
-    def self.reporting_prompted?
-      ShopifyCLI::Config.get_section(Constants::Config::Sections::Analytics::NAME).key?(
-        Constants::Config::Sections::Analytics::Fields::ENABLED
-      )
-    end
-
-    def self.reporting_enabled?
-      ShopifyCLI::Config.get_bool(
-        Constants::Config::Sections::Analytics::NAME,
-        Constants::Config::Sections::Analytics::Fields::ENABLED,
-        default: false
-      )
-    end
-
-    def self.check_or_prompt_report_automatically(*)
-      false
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-##
-# `ResolveConstant` implements constant resolution. It is implemented as a
-# `MethodObject` and therefore returns a result object. By default, constants
-# are resolved relative to `Kernal`, but the top-level namespace is
-# configurable:
-#
-#    ShopifyCLI::Resolve.call(:object).value # => Object
-#    ShopifyCLI::Resolve.call('minitest/test').value # => MiniTest::Test
-#    ShopifyCLI::Resolve.call(:test, namespace: MiniTest) # => MiniTest::Test
-#
-module ShopifyCLI
-  class ResolveConstant
-    include ShopifyCLI::MethodObject
-    property! :namespace, accepts: ->(ns) { ns.respond_to?(:const_get) }, default: -> { Kernel }
-
-    def call(name)
-      name
-        .to_s
-        .split(%r{/|:{2}})
-        .map { |const_name| const_name.split(/[_-]/).map(&:capitalize).join("") }
-        .join("::")
-        .yield_self { |const_name| namespace.const_get(const_name) }
-    end
-  end
-end

package/assets/cli-ruby/lib/shopify_cli/resources/env_file.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-module ShopifyCLI
-  module Resources
-    class EnvFile
-      include SmartProperties
-      FILENAME = ".env"
-      KEY_MAP = {
-        "SHOPIFY_API_KEY" => :api_key,
-        "SHOPIFY_API_SECRET" => :secret,
-        "SHOP" => :shop,
-        "SCOPES" => :scopes,
-        "HOST" => :host,
-      }
-
-      class << self
-        def path(directory)
-          File.join(directory, FILENAME)
-        end
-
-        def read(_directory = Dir.pwd, overrides: {})
-          input = parse_external_env(overrides: overrides)
-          new(input)
-        end
-
-        def from_hash(hash)
-          new(env_input(hash))
-        end
-
-        def parse(directory)
-          File.read(path(directory))
-            .gsub("\r\n", "\n").split("\n").each_with_object({}) do |line, output|
-            match = /\A(#*\s*[A-Za-z_0-9]+)\s*=\s*(.*)\z/.match(line)
-            if match
-              key = match[1]
-              output[key] = case match[2]
-              # Remove single quotes
-              when /\A'(.*)'\z/ then match[2]
-              # Remove double quotes and unescape string preserving newline characters
-              when /\A"(.*)"\z/ then match[2].gsub('\n', "\n").gsub(/\\(.)/, '\1')
-              else match[2]
-              end
-            end
-            output
-          end
-        end
-
-        def parse_external_env(directory = Dir.pwd, overrides: {})
-          env_input(parse(directory), overrides: overrides)
-        end
-
-        def env_input(parsed_source, overrides: {})
-          env_details = {}
-          extra = {}
-          parsed_source.merge(overrides).each do |key, value|
-            if KEY_MAP[key]
-              env_details[KEY_MAP[key]] = value
-            else
-              extra[key] = value
-            end
-          end
-          env_details[:extra] = extra
-          env_details
-        end
-      end
-
-      property :api_key, required: true
-      property :secret
-      property :shop
-      property :scopes
-      property :host
-      property :extra, default: -> { {} }
-
-      def to_h
-        out = {}
-        KEY_MAP.each do |key, value|
-          out[key] = send(value).to_s if send(value)
-        end
-        extra.each do |key, value|
-          out[key] = value.to_s
-        end
-        out
-      end
-
-      def write(ctx)
-        spin_group = CLI::UI::SpinGroup.new
-        spin_group.add(ctx.message("core.env_file.saving_header", FILENAME)) do |spinner|
-          output = []
-          KEY_MAP.each do |key, value|
-            output << "#{key}=#{send(value)}" if send(value)
-          end
-          extra.each do |key, value|
-            output << "#{key}=#{value}"
-          end
-          ctx.print_task(ctx.message("core.env_file.saving", FILENAME))
-          ctx.write(FILENAME, output.join("\n") + "\n")
-          spinner.update_title(ctx.message("core.env_file.saved", FILENAME))
-        end
-        spin_group.wait
-      end
-
-      def update(ctx, field, value)
-        self[field] = value
-        write(ctx)
-      end
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-module ShopifyCLI
-  module Resources
-    autoload :EnvFile, "shopify_cli/resources/env_file"
-  end
-end