@shopify/cli-kit 3.38.0 → 3.40.0

package/assets/cli-ruby/vendor/deps/smart_properties/lib/smart_properties/property.rb

@@ -0,0 +1,168 @@
+module SmartProperties
+  class Property
+    MODULE_REFERENCE = :"@_smart_properties_method_scope"
+    ALLOWED_DEFAULT_CLASSES = [Proc, Numeric, String, Range, TrueClass, FalseClass, NilClass, Symbol, Module].freeze
+
+    attr_reader :name
+    attr_reader :converter
+    attr_reader :accepter
+    attr_reader :reader
+    attr_reader :instance_variable_name
+    attr_reader :writable
+
+    def self.define(scope, name, options = {})
+      new(name, options).tap { |p| p.define(scope) }
+    end
+
+    def initialize(name, attrs = {})
+      attrs = attrs.dup
+
+      @name      = name.to_sym
+      @default   = attrs.delete(:default)
+      @converter = attrs.delete(:converts)
+      @accepter  = attrs.delete(:accepts)
+      @required  = attrs.delete(:required)
+      @reader    = attrs.delete(:reader)
+      @writable  = attrs.delete(:writable)
+      @reader    ||= @name
+
+      @instance_variable_name = :"@#{name}"
+
+      unless ALLOWED_DEFAULT_CLASSES.any? { |cls| @default.is_a?(cls) }
+        raise ConfigurationError, "Default attribute value #{@default.inspect} cannot be specified as literal, "\
+          "use the syntax `default: -> { ... }` instead."
+      end
+
+      unless attrs.empty?
+        raise ConfigurationError, "SmartProperties do not support the following configuration options: #{attrs.keys.map { |m| m.to_s }.sort.join(', ')}."
+      end
+    end
+
+    def required?(scope)
+      @required.kind_of?(Proc) ? scope.instance_exec(&@required) : !!@required
+    end
+
+    def optional?(scope)
+      !required?(scope)
+    end
+
+    def missing?(scope)
+      required?(scope) && !present?(scope)
+    end
+
+    def present?(scope)
+      !null_object?(get(scope))
+    end
+
+    def writable?
+      return true if @writable.nil?
+      @writable
+    end
+
+    def convert(scope, value)
+      return value unless converter
+      return value if null_object?(value)
+
+      case converter
+      when Symbol
+        converter.to_proc.call(value)
+      else
+        scope.instance_exec(value, &converter)
+      end
+    end
+
+    def default(scope)
+      @default.kind_of?(Proc) ? scope.instance_exec(&@default) : @default.dup
+    end
+
+    def accepts?(value, scope)
+      return true unless accepter
+      return true if null_object?(value)
+
+      if accepter.respond_to?(:to_proc)
+        !!scope.instance_exec(value, &accepter)
+      else
+        Array(accepter).any? { |accepter| accepter === value }
+      end
+    end
+
+    def prepare(scope, value)
+      required = required?(scope)
+      raise MissingValueError.new(scope, self) if required && null_object?(value)
+      value = convert(scope, value)
+      raise MissingValueError.new(scope, self) if required && null_object?(value)
+      raise InvalidValueError.new(scope, self, value) unless accepts?(value, scope)
+      value
+    end
+
+    def define(klass)
+      property = self
+
+      scope =
+        if klass.instance_variable_defined?(MODULE_REFERENCE)
+          klass.instance_variable_get(MODULE_REFERENCE)
+        else
+          m = Module.new
+          klass.send(:include, m)
+          klass.instance_variable_set(MODULE_REFERENCE, m)
+          m
+        end
+
+      scope.send(:define_method, reader) do
+        property.get(self)
+      end
+
+      if writable?
+        scope.send(:define_method, :"#{name}=") do |value|
+          property.set(self, value)
+        end
+      end
+    end
+
+    def set(scope, value)
+      scope.instance_variable_set(instance_variable_name, prepare(scope, value))
+    end
+
+    def set_default(scope)
+      return false if present?(scope)
+
+      default_value = default(scope)
+      return false if null_object?(default_value)
+
+      set(scope, default_value)
+      true
+    end
+
+    def get(scope)
+      return nil unless scope.instance_variable_defined?(instance_variable_name)
+      scope.instance_variable_get(instance_variable_name)
+    end
+
+    def to_h
+      {
+        accepter: @accepter,
+        converter: @converter,
+        default: @default,
+        instance_variable_name: @instance_variable_name,
+        name: @name,
+        reader: @reader,
+        required: @required
+      }
+    end
+
+    private
+
+    def null_object?(object)
+      object.nil?
+    rescue NoMethodError => error
+      # BasicObject does not respond to #nil? by default, so we need to double
+      # check if somebody implemented it and it fails internally or if the
+      # error occured because the method is actually not present. In the former
+      # case, we want to raise the exception because there is something wrong
+      # with the implementation of object#nil?. In the latter case we treat the
+      # object as truthy because we don't know better.
+      raise error if (class << object; self; end).public_instance_methods.include?(:nil?)
+      false
+    end
+  end
+end

package/assets/cli-ruby/vendor/deps/smart_properties/lib/smart_properties/property_collection.rb

@@ -0,0 +1,83 @@
+module SmartProperties
+  class PropertyCollection
+    include Enumerable
+
+    attr_reader :parent
+
+    def self.for(scope)
+      parent = scope.ancestors[1..-1].find do |ancestor|
+        ancestor.ancestors.include?(SmartProperties) &&
+          ancestor != scope &&
+          ancestor != SmartProperties
+      end
+
+      if parent.nil?
+        new
+      else
+        parent.properties.register(collection = new)
+        collection
+      end
+    end
+
+    def initialize
+      @collection = {}
+      @collection_with_parent_collection = {}
+      @children = []
+    end
+
+    def []=(name, value)
+      name = name.to_s
+      collection[name] = value
+      collection_with_parent_collection[name] = value
+      notify_children
+      value
+    end
+
+    def [](name)
+      collection_with_parent_collection[name.to_s]
+    end
+
+    def key?(name)
+      collection_with_parent_collection.key?(name.to_s)
+    end
+
+    def keys
+      collection_with_parent_collection.keys.map(&:to_sym)
+    end
+
+    def values
+      collection_with_parent_collection.values
+    end
+
+    def each(&block)
+      return to_enum(:each) if block.nil?
+      collection_with_parent_collection.each { |name, value| block.call([name.to_sym, value]) }
+    end
+
+    def to_hash
+      Hash[each.to_a]
+    end
+
+    def register(child)
+      children.push(child)
+      child.refresh(collection_with_parent_collection)
+      nil
+    end
+
+    protected
+
+    attr_accessor :children
+    attr_accessor :collection
+    attr_accessor :collection_with_parent_collection
+
+    def notify_children
+      @children.each { |child| child.refresh(collection_with_parent_collection) }
+    end
+
+    def refresh(parent_collection)
+      @collection_with_parent_collection = parent_collection.merge(collection)
+      notify_children
+      nil
+    end
+  end
+end

package/assets/cli-ruby/vendor/deps/smart_properties/lib/smart_properties/validations/ancestor.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module SmartProperties
+  module Validations
+    class Ancestor
+      include SmartProperties
+
+      property! :type, accepts: ->(type) { type.is_a?(Class) }
+
+      def validate(klass)
+        klass.is_a?(Class) && klass < type
+      end
+
+      def to_proc
+        validator = self
+        ->(klass) { validator.validate(klass) }
+      end
+
+      def to_s
+        "subclasses of #{type.to_s}"
+      end
+
+      class << self
+        alias_method :must_be, :new
+      end
+    end
+  end
+end

package/assets/cli-ruby/vendor/deps/smart_properties/lib/smart_properties/validations.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module SmartProperties
+  module Validations
+  end
+end
+
+require_relative 'validations/ancestor'

package/assets/cli-ruby/vendor/deps/smart_properties/lib/smart_properties/version.rb

@@ -0,0 +1,3 @@
+module SmartProperties
+  VERSION = "1.15.0"
+end

package/assets/cli-ruby/vendor/deps/smart_properties/lib/smart_properties.rb

@@ -0,0 +1,174 @@
+##
+# {SmartProperties} can be used to easily build more full-fledged accessors
+# for standard Ruby classes. In contrast to regular accessors,
+# {SmartProperties} support validation and conversion of input data, as well
+# as, the specification of default values. Additionally, individual
+# {SmartProperties} can be marked as required. This causes the runtime to
+# throw an +ArgumentError+ whenever a required property has not been
+# specified.
+#
+# In order to use {SmartProperties}, simply include the {SmartProperties}
+# module and use the {ClassMethods#property} method to define properties.
+#
+# @see ClassMethods#property
+#   More information on how to configure properties
+#
+# @example Definition of a property that makes use of all {SmartProperties} features.
+#
+#  property :language_code, :accepts => [:de, :en],
+#                           :converts => :to_sym,
+#                           :default  => :de,
+#                           :required => true
+#
+module SmartProperties
+  module ClassMethods
+    ##
+    # Returns a class's smart properties. This includes the properties that
+    # have been defined in the parent classes.
+    #
+    # @return [Hash<String, Property>] A map of property names to property instances.
+    #
+    def properties
+      @_smart_properties ||= PropertyCollection.for(self)
+    end
+
+    ##
+    # Defines a new property from a name and a set of options. This results
+    # results in creating an accessor that has additional features:
+    #
+    # 1. Validation of input data by specifiying the +:accepts+ option:
+    #    If you use a class as value for this option, the setter will check
+    #    if the value it is about to assign is of this type. If you use an
+    #    array, the setter will check if the value it is about to assign is
+    #    included in this array. Finally, if you specify a block, it will
+    #    invoke the block with the value it is about to assign and check if
+    #    the block returns a thruthy value, meaning anything but +false+ and
+    #    +nil+.
+    #
+    # 2. Conversion of input data by specifiying the +:converts+ option:
+    #    If you use provide a symbol as value for this option, the setter will
+    #    invoke this method on the object it is about to assign and take the
+    #    result of this call instead. If you provide a block, it will invoke
+    #    the block with the value it is about to assign and take the result
+    #    of the block instead.
+    #
+    # 3. Providing a default value by specifiying the +:default+ option.
+    #
+    # 4. Forcing a property to be present by setting the +:required+ option
+    #    to true.
+    #
+    #
+    # @param [Symbol] name the name of the property
+    #
+    # @param [Hash] options the list of options used to configure the property
+    # @option options [Array, Class, Proc] :accepts
+    #   specifies how the validation is done
+    # @option options [Proc, Symbol] :converts
+    #   specifies how the conversion is done
+    # @option options :default
+    #   specifies the default value of the property
+    # @option options [true, false] :required
+    #   specifies whether or not this property is required
+    #
+    # @return [Property] The defined property.
+    #
+    # @example Definition of a property that makes use of all {SmartProperties} features.
+    #
+    #  property :language_code, :accepts => [:de, :en],
+    #                           :converts => :to_sym,
+    #                           :default  => :de,
+    #                           :required => true
+    #
+    def property(name, options = {})
+      properties[name] = Property.define(self, name, options)
+    end
+    protected :property
+
+    def property!(name, options = {})
+      options[:required] = true
+      property(name, options)
+    end
+    protected :property!
+  end
+
+  class << self
+    private
+
+    ##
+    # Extends the class, which this module is included in, with a property
+    # method to define properties.
+    #
+    # @param [Class] base the class this module is included in
+    #
+    def included(base)
+      base.extend(ClassMethods)
+    end
+  end
+
+  ##
+  # Implements a key-value enabled constructor that acts as default
+  # constructor for all {SmartProperties}-enabled classes. Positional arguments
+  # or keyword arguments that do not correspond to a property are forwarded to
+  # the super class constructor.
+  #
+  # @param [Hash] attrs the set of attributes that is used for initialization
+  #
+  # @raise [SmartProperties::ConstructorArgumentForwardingError] when unknown arguments were supplied that could not be processed by the super class initializer either.
+  # @raise [SmartProperties::InitializationError] when incorrect values were supplied or required values weren't been supplied.
+  #
+  def initialize(*args, &block)
+    attrs = args.last.is_a?(Hash) ? args.pop.dup : {}
+    properties = self.class.properties
+
+    # Track missing properties
+    missing_properties = []
+
+    # Set values
+    properties.each do |name, property|
+      if attrs.key?(name)
+        property.set(self, attrs.delete(name))
+      elsif attrs.key?(name.to_s)
+        property.set(self, attrs.delete(name.to_s))
+      else
+        missing_properties.push(property)
+      end
+    end
+
+    # Call the super constructor and forward unprocessed arguments
+    begin
+      attrs.empty? ? super(*args) : super(*args.dup.push(attrs))
+    rescue ArgumentError
+      raise SmartProperties::ConstructorArgumentForwardingError.new(args, attrs)
+    end
+
+    # Execute configuration block
+    block.call(self) if block
+
+    # Set default values for missing properties
+    missing_properties.delete_if { |property| property.set_default(self) }
+
+    # Recheck - cannot be done while assigning default values because
+    # one property might depend on the default value of another property
+    missing_properties.delete_if { |property| property.present?(self) || property.optional?(self) }
+
+    raise SmartProperties::InitializationError.new(self, missing_properties) unless missing_properties.empty?
+  end
+
+  def [](name)
+    return if name.nil?
+    name = name.to_sym
+    reader = self.class.properties[name].reader
+    public_send(reader) if self.class.properties.key?(name)
+  end
+
+  def []=(name, value)
+    return if name.nil?
+    public_send(:"#{name.to_sym}=", value) if self.class.properties.key?(name)
+  end
+end
+
+require_relative 'smart_properties/property_collection'
+require_relative 'smart_properties/property'
+require_relative 'smart_properties/errors'
+require_relative 'smart_properties/version'
+require_relative 'smart_properties/validations'

package/assets/cli-ruby/vendor/deps/webrick/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

package/assets/cli-ruby/vendor/deps/webrick/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

package/assets/cli-ruby/vendor/deps/webrick/README.md

@@ -0,0 +1,61 @@
+# Webrick
+
+WEBrick is an HTTP server toolkit that can be configured as an HTTPS server, a proxy server, and a virtual-host server.
+
+WEBrick features complete logging of both server operations and HTTP access.
+
+WEBrick supports both basic and digest authentication in addition to algorithms not in RFC 2617.
+
+A WEBrick server can be composed of multiple WEBrick servers or servlets to provide differing behavior on a per-host or per-path basis. WEBrick includes servlets for handling CGI scripts, ERB pages, Ruby blocks and directory listings.
+
+WEBrick also includes tools for daemonizing a process and starting a process at a higher privilege level and dropping permissions.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'webrick'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install webrick
+
+## Usage
+
+To create a new WEBrick::HTTPServer that will listen to connections on port 8000 and serve documents from the current user's public_html folder:
+
+```ruby
+require 'webrick'
+
+root = File.expand_path '~/public_html'
+server = WEBrick::HTTPServer.new :Port => 8000, :DocumentRoot => root
+```
+
+To run the server you will need to provide a suitable shutdown hook as
+starting the server blocks the current thread:
+
+```ruby
+trap 'INT' do server.shutdown end
+
+server.start
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and Patch are welcome on https://bugs.ruby-lang.org/.
+
+## License
+
+The gem is available as open source under the terms of the [2-Clause BSD License](https://opensource.org/licenses/BSD-2-Clause).

package/assets/cli-ruby/vendor/deps/webrick/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test" << "test/lib"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
+task :default => :test