shopify-cli 0.9.0

data/vendor/deps/cli-ui/lib/cli/ui/terminal.rb

@@ -0,0 +1,36 @@
+require 'cli/ui'
+require 'io/console'
+
+module CLI
+  module UI
+    module Terminal
+      DEFAULT_WIDTH = 80
+      DEFAULT_HEIGHT = 24
+
+      # Returns the width of the terminal, if possible
+      # Otherwise will return 80
+      #
+      def self.width
+        if console = IO.respond_to?(:console) && IO.console
+          width = console.winsize[1]
+          width.zero? ? DEFAULT_WIDTH : width
+        else
+          DEFAULT_WIDTH
+        end
+      rescue Errno::EIO
+        DEFAULT_WIDTH
+      end
+
+      def self.height
+        if console = IO.respond_to?(:console) && IO.console
+          height = console.winsize[0]
+          height.zero? ? DEFAULT_HEIGHT : height
+        else
+          DEFAULT_HEIGHT
+        end
+      rescue Errno::EIO
+        DEFAULT_HEIGHT
+      end
+    end
+  end
+end

data/vendor/deps/cli-ui/lib/cli/ui/truncater.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'cli/ui'
+
+module CLI
+  module UI
+    # Truncater truncates a string to a provided printable width.
+    module Truncater
+      PARSE_ROOT = :root
+      PARSE_ANSI = :ansi
+      PARSE_ESC  = :esc
+      PARSE_ZWJ  = :zwj
+
+      ESC                 = 0x1b
+      LEFT_SQUARE_BRACKET = 0x5b
+      ZWJ                 = 0x200d # emojipedia.org/emoji-zwj-sequences
+      SEMICOLON           = 0x3b
+
+      # EMOJI_RANGE in particular is super inaccurate. This is best-effort.
+      # If you need this to be more accurate, we'll almost certainly accept a
+      # PR improving it.
+      EMOJI_RANGE    = 0x1f300..0x1f5ff
+      NUMERIC_RANGE  = 0x30..0x39
+      LC_ALPHA_RANGE = 0x40..0x5a
+      UC_ALPHA_RANGE = 0x60..0x71
+
+      TRUNCATED = "\x1b[0m…"
+
+      class << self
+        def call(text, printing_width)
+          return text if text.size <= printing_width
+
+          width            = 0
+          mode             = PARSE_ROOT
+          truncation_index = nil
+
+          codepoints = text.codepoints
+          codepoints.each.with_index do |cp, index|
+            case mode
+            when PARSE_ROOT
+              case cp
+              when ESC # non-printable, followed by some more non-printables.
+                mode = PARSE_ESC
+              when ZWJ # non-printable, followed by another non-printable.
+                mode = PARSE_ZWJ
+              else
+                width += width(cp)
+                if width >= printing_width
+                  truncation_index ||= index
+                  # it looks like we could break here but we still want the
+                  # width calculation for the rest of the characters.
+                end
+              end
+            when PARSE_ESC
+              case cp
+              when LEFT_SQUARE_BRACKET
+                mode = PARSE_ANSI
+              else
+                mode = PARSE_ROOT
+              end
+            when PARSE_ANSI
+              # ANSI escape codes preeeetty much have the format of:
+              # \x1b[0-9;]+[A-Za-z]
+              case cp
+              when NUMERIC_RANGE, SEMICOLON
+              when LC_ALPHA_RANGE, UC_ALPHA_RANGE
+                mode = PARSE_ROOT
+              else
+                # unexpected. let's just go back to the root state I guess?
+                mode = PARSE_ROOT
+              end
+            when PARSE_ZWJ
+              # consume any character and consider it as having no width
+              # width(x+ZWJ+y) = width(x).
+              mode = PARSE_ROOT
+            end
+          end
+
+          # Without the `width <= printing_width` check, we truncate
+          # "foo\x1b[0m" for a width of 3, but it should not be truncated.
+          # It's specifically for the case where we decided "Yes, this is the
+          # point at which we'd have to add a truncation!" but it's actually
+          # the end of the string.
+          return text if !truncation_index || width <= printing_width
+
+          codepoints[0...truncation_index].pack("U*") + TRUNCATED
+        end
+
+        private
+
+        def width(printable_codepoint)
+          case printable_codepoint
+          when EMOJI_RANGE
+            2
+          else
+            1
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/deps/cli-ui/lib/cli/ui/version.rb

@@ -0,0 +1,5 @@
+module CLI
+  module UI
+    VERSION = "1.3.0"
+  end
+end

data/vendor/deps/smart_properties/REVISION

@@ -0,0 +1 @@
+691028e47d022a29405b7f0ccc8683c9d062c502

data/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'

data/vendor/deps/smart_properties/lib/smart_properties/errors.rb

@@ -0,0 +1,114 @@
+module SmartProperties
+  class Error < ::ArgumentError; end
+  class ConfigurationError < Error; end
+
+  class AssignmentError < Error
+    attr_accessor :sender
+    attr_accessor :property
+
+    def initialize(sender, property, message)
+      @sender = sender
+      @property = property
+      super(message)
+    end
+  end
+
+  class ConstructorArgumentForwardingError < Error
+    def initialize(positional_arguments, keyword_arguments)
+      argument_description = [
+        generate_description("positional", positional_arguments.count),
+        generate_description("keyword", keyword_arguments.count)
+      ].compact
+
+      arguments = positional_arguments + keyword_arguments.map { |name, value| "#{name}: #{value}" }
+
+      super "Forwarding the following %s failed: %s" % [
+        argument_description.join(" and "),
+        arguments.join(", ")
+      ]
+    end
+
+    private
+
+    def generate_description(argument_type, argument_number)
+      case argument_number
+      when 0
+        nil
+      when 1
+        "#{argument_type} argument"
+      else
+        "#{argument_number} #{argument_type} arguments"
+      end
+    end
+  end
+
+  class MissingValueError < AssignmentError
+    def initialize(sender, property)
+      super(
+        sender,
+        property,
+        "%s requires the property %s to be set" % [
+          sender.class.name,
+          property.name
+        ]
+      )
+    end
+
+    def to_hash
+      Hash[property.name, "must be set"]
+    end
+  end
+
+  class InvalidValueError < AssignmentError
+    attr_accessor :value
+
+    def initialize(sender, property, value)
+      @value = value
+
+      super(
+        sender,
+        property,
+        "%s does not accept %s as value for the property %s. Only accepts: %s" % [
+          sender.class.name,
+          value.inspect,
+          property.name,
+          accepter_message(sender, property)
+        ]
+      )
+    end
+
+    def to_hash
+      Hash[property.name, "does not accept %s as value" % value.inspect]
+    end
+
+    private
+
+    def accepter_message(sender, property)
+      accepter = property.accepter
+      if accepter.is_a?(Proc)
+        return "Values passing lambda defined in #{accepter.source_location.join(' at line ')}"
+      end
+      accepter
+    end
+  end
+
+  class InitializationError < Error
+    attr_accessor :sender
+    attr_accessor :properties
+
+    def initialize(sender, properties)
+      @sender = sender
+      @properties = properties
+      super(
+        "%s requires the following properties to be set: %s" % [
+          sender.class.name,
+          properties.map(&:name).sort.join(', ')
+        ]
+      )
+    end
+
+    def to_hash
+      properties.each_with_object({}) { |property, errors| errors[property.name] = "must be set" }
+    end
+  end
+end

data/vendor/deps/smart_properties/lib/smart_properties/property.rb

@@ -0,0 +1,162 @@
+module SmartProperties
+  class Property
+    MODULE_REFERENCE = :"@_smart_properties_method_scope"
+
+    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 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
+    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