shopify-cli 0.9.0

data/vendor/deps/cli-kit/lib/cli/kit/util.rb

@@ -0,0 +1,189 @@
+module CLI
+  module Kit
+    module Util
+      class << self
+        def snake_case(camel_case, seperator = "_")
+          camel_case.to_s # MyCoolThing::MyAPIModule
+            .gsub(/::/, '/') # MyCoolThing/MyAPIModule
+            .gsub(/([A-Z]+)([A-Z][a-z])/, "\\1#{seperator}\\2") # MyCoolThing::MyAPI_Module
+            .gsub(/([a-z\d])([A-Z])/, "\\1#{seperator}\\2") # My_Cool_Thing::My_API_Module
+            .downcase # my_cool_thing/my_api_module
+        end
+
+        def dash_case(camel_case)
+          snake_case(camel_case, '-')
+        end
+
+        # The following methods is taken from activesupport
+        # All credit for this method goes to the original authors.
+        # https://github.com/rails/rails/blob/d66e7835bea9505f7003e5038aa19b6ea95ceea1/activesupport/lib/active_support/core_ext/string/strip.rb
+        #
+        # Copyright (c) 2005-2018 David Heinemeier Hansson
+        #
+        # Permission is hereby granted, free of charge, to any person obtaining
+        # a copy of this software and associated documentation files (the
+        # "Software"), to deal in the Software without restriction, including
+        # without limitation the rights to use, copy, modify, merge, publish,
+        # distribute, sublicense, and/or sell copies of the Software, and to
+        # permit persons to whom the Software is furnished to do so, subject to
+        # the following conditions:
+        #
+        # The above copyright notice and this permission notice shall be
+        # included in all copies or substantial portions of the Software.
+        #
+        # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+        # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+        # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+        # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+        # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+        # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+        # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+        #
+        # Strips indentation by removing the amount of leading whitespace in the least indented
+        # non-empty line in the whole string
+        #
+        def strip_heredoc(str)
+          str.gsub(/^#{str.scan(/^[ \t]*(?=\S)/).min}/, "".freeze)
+        end
+
+        # Joins an array with commas and "and", using the Oxford comma.
+        def english_join(array)
+          return "" if array.nil?
+          return array.join(" and ") if array.length < 3
+
+          "#{array[0..-2].join(', ')}, and #{array[-1]}"
+        end
+
+        # Execute a block within the context of a variable enviroment
+        #
+        def with_environment(environment, value)
+          return yield unless environment
+
+          old_env = ENV[environment]
+          begin
+            ENV[environment] = value
+            yield
+          ensure
+            old_env ? ENV[environment] = old_env : ENV.delete(environment)
+          end
+        end
+
+        # Converts an integer representing bytes into a human readable format
+        #
+        def to_filesize(bytes, precision: 2, space: false)
+          to_si_scale(bytes, 'B', precision: precision, space: space, factor: 1024)
+        end
+
+        # Converts a number to a human readable format on the SI scale
+        #
+        def to_si_scale(number, unit = '', factor: 1000, precision: 2, space: false)
+          raise ArgumentError, "factor should only be 1000 or 1024" unless [1000, 1024].include?(factor)
+
+          small_scale = %w(m µ n p f a z y)
+          big_scale = %w(k M G T P E Z Y)
+          negative = number < 0
+          number = number.abs.to_f
+
+          if number == 0 || number.between?(1, factor)
+            prefix = ""
+            scale = 0
+          else
+            scale = Math.log(number, factor).floor
+            if number < 1
+              index = [-scale - 1, small_scale.length].min
+              scale = -(index + 1)
+              prefix = small_scale[index]
+            else
+              index = [scale - 1, big_scale.length].min
+              scale = index + 1
+              prefix = big_scale[index]
+            end
+          end
+
+          divider = (factor**scale)
+          fnum = (number / divider).round(precision)
+
+          # Trim useless decimal
+          fnum = fnum.to_i if (fnum.to_i.to_f * divider) == number
+
+          fnum = -fnum if negative
+          prefix = " " + prefix if space
+
+          "#{fnum}#{prefix}#{unit}"
+        end
+
+        # Dir.chdir, when invoked in block form, complains when we call chdir
+        # again recursively. There's no apparent good reason for this, so we
+        # simply implement our own block form of Dir.chdir here.
+        def with_dir(dir)
+          prev = Dir.pwd
+          Dir.chdir(dir)
+          yield
+        ensure
+          Dir.chdir(prev)
+        end
+
+        def with_tmp_dir
+          require 'fileutils'
+          dir = Dir.mktmpdir
+          with_dir(dir) do
+            yield(dir)
+          end
+        ensure
+          FileUtils.remove_entry(dir)
+        end
+
+        # Standard way of checking for CI / Tests
+        def testing?
+          ci? || ENV['TEST']
+        end
+
+        # Set only in IntegrationTest#session; indicates that the process was
+        # called by `session.execute` from an IntegrationTest subclass.
+        def integration_test_session?
+          ENV['INTEGRATION_TEST_SESSION']
+        end
+
+        # Standard way of checking for CI
+        def ci?
+          ENV['CI']
+        end
+
+        # Must call retry_after on the result in order to execute the block
+        #
+        # Example usage:
+        #
+        # CLI::Kit::Util.begin do
+        #   might_raise_if_costly_prep_not_done()
+        # end.retry_after(ExpectedError) do
+        #   costly_prep()
+        # end
+        def begin(&block_that_might_raise)
+          Retrier.new(block_that_might_raise)
+        end
+      end
+
+      class Retrier
+        def initialize(block_that_might_raise)
+          @block_that_might_raise = block_that_might_raise
+        end
+
+        def retry_after(exception = StandardError, retries: 1, &before_retry)
+          @block_that_might_raise.call
+        rescue exception => e
+          raise if (retries -= 1) < 0
+          if before_retry
+            if before_retry.arity == 0
+              yield
+            else
+              yield e
+            end
+          end
+          retry
+        end
+      end
+
+      private_constant :Retrier
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module CLI
+  module Kit
+    VERSION = "3.3.0"
+  end
+end

data/vendor/deps/cli-ui/REVISION

@@ -0,0 +1 @@
+35e1b188f19b2ba0ab85bbf48ab983b1f72a361b

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

@@ -0,0 +1,187 @@
+module CLI
+  module UI
+    autoload :ANSI,               'cli/ui/ansi'
+    autoload :Glyph,              'cli/ui/glyph'
+    autoload :Color,              'cli/ui/color'
+    autoload :Box,                'cli/ui/box'
+    autoload :Frame,              'cli/ui/frame'
+    autoload :Progress,           'cli/ui/progress'
+    autoload :Prompt,             'cli/ui/prompt'
+    autoload :Terminal,           'cli/ui/terminal'
+    autoload :Truncater,          'cli/ui/truncater'
+    autoload :Formatter,          'cli/ui/formatter'
+    autoload :Spinner,            'cli/ui/spinner'
+
+    # Convenience accessor to +CLI::UI::Spinner::SpinGroup+
+    SpinGroup = Spinner::SpinGroup
+
+    # Glyph resolution using +CLI::UI::Glyph.lookup+
+    # Look at the method signature for +Glyph.lookup+ for more details
+    #
+    # ==== Attributes
+    #
+    # * +handle+ - handle of the glyph to resolve
+    #
+    def self.glyph(handle)
+      CLI::UI::Glyph.lookup(handle)
+    end
+
+    # Color resolution using +CLI::UI::Color.lookup+
+    # Will lookup using +Color.lookup+ if a symbol, otherwise we assume it is a valid color and return it
+    #
+    # ==== Attributes
+    #
+    # * +input+ - color to resolve
+    #
+    def self.resolve_color(input)
+      case input
+      when Symbol
+        CLI::UI::Color.lookup(input)
+      else
+        input
+      end
+    end
+
+    # Conviencence Method for +CLI::UI::Prompt.confirm+
+    #
+    # ==== Attributes
+    #
+    # * +question+ - question to confirm
+    #
+    def self.confirm(question, **kwargs)
+      CLI::UI::Prompt.confirm(question, **kwargs)
+    end
+
+    # Conviencence Method for +CLI::UI::Prompt.ask+
+    #
+    # ==== Attributes
+    #
+    # * +question+ - question to ask
+    # * +kwargs+ - arugments for +Prompt.ask+
+    #
+    def self.ask(question, **kwargs)
+      CLI::UI::Prompt.ask(question, **kwargs)
+    end
+
+    # Conviencence Method to resolve text using +CLI::UI::Formatter.format+
+    # Check +CLI::UI::Formatter::SGR_MAP+ for available formatting options
+    #
+    # ==== Attributes
+    #
+    # * +input+ - input to format
+    # * +truncate_to+ - number of characters to truncate the string to (or nil)
+    #
+    def self.resolve_text(input, truncate_to: nil)
+      return input if input.nil?
+      formatted = CLI::UI::Formatter.new(input).format
+      return formatted unless truncate_to
+      return CLI::UI::Truncater.call(formatted, truncate_to)
+    end
+
+    # Conviencence Method to format text using +CLI::UI::Formatter.format+
+    # Check +CLI::UI::Formatter::SGR_MAP+ for available formatting options
+    #
+    # https://user-images.githubusercontent.com/3074765/33799827-6d0721a2-dd01-11e7-9ab5-c3d455264afe.png
+    # https://user-images.githubusercontent.com/3074765/33799847-9ec03fd0-dd01-11e7-93f7-5f5cc540e61e.png
+    #
+    # ==== Attributes
+    #
+    # * +input+ - input to format
+    #
+    # ==== Options
+    #
+    # * +enable_color+ - should color be used? default to true unless output is redirected.
+    #
+    def self.fmt(input, enable_color: enable_color?)
+      CLI::UI::Formatter.new(input).format(enable_color: enable_color)
+    end
+
+    # Conviencence Method for +CLI::UI::Frame.open+
+    #
+    # ==== Attributes
+    #
+    # * +args+ - arguments for +Frame.open+
+    # * +block+ - block for +Frame.open+
+    #
+    def self.frame(*args, &block)
+      CLI::UI::Frame.open(*args, &block)
+    end
+
+    # Conviencence Method for +CLI::UI::Spinner.spin+
+    #
+    # ==== Attributes
+    #
+    # * +args+ - arguments for +Spinner.open+
+    # * +block+ - block for +Spinner.open+
+    #
+    def self.spinner(*args, &block)
+      CLI::UI::Spinner.spin(*args, &block)
+    end
+
+    # Conviencence Method to override frame color using +CLI::UI::Frame.with_frame_color+
+    #
+    # ==== Attributes
+    #
+    # * +color+ - color to override to
+    # * +block+ - block for +Frame.with_frame_color_override+
+    #
+    def self.with_frame_color(color, &block)
+      CLI::UI::Frame.with_frame_color_override(color, &block)
+    end
+
+    # Duplicate output to a file path
+    #
+    # ==== Attributes
+    #
+    # * +path+ - path to duplicate output to
+    #
+    def self.log_output_to(path)
+      if CLI::UI::StdoutRouter.duplicate_output_to
+        raise "multiple logs not allowed"
+      end
+      CLI::UI::StdoutRouter.duplicate_output_to = File.open(path, 'w')
+      yield
+    ensure
+      if file_descriptor = CLI::UI::StdoutRouter.duplicate_output_to
+        file_descriptor.close
+        CLI::UI::StdoutRouter.duplicate_output_to = nil
+      end
+    end
+
+    # Disable all framing within a block
+    #
+    # ==== Attributes
+    #
+    # * +block+ - block in which to disable frames
+    #
+    def self.raw
+      prev = Thread.current[:no_cliui_frame_inset]
+      Thread.current[:no_cliui_frame_inset] = true
+      yield
+    ensure
+      Thread.current[:no_cliui_frame_inset] = prev
+    end
+
+    # Check whether colour is enabled in Formatter output. By default, colour
+    # is enabled when STDOUT is a TTY; that is, when output has not been
+    # redirected to another program or to a file.
+    #
+    def self.enable_color?
+      @enable_color
+    end
+
+    # Turn colour output in Formatter on or off.
+    #
+    # ==== Attributes
+    #
+    # * +bool+ - true or false; enable or disable colour.
+    #
+    def self.enable_color=(bool)
+      @enable_color = !!bool
+    end
+
+    self.enable_color = $stdout.tty?
+  end
+end
+
+require 'cli/ui/stdout_router'

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

@@ -0,0 +1,153 @@
+require 'cli/ui'
+
+module CLI
+  module UI
+    module ANSI
+      ESC = "\x1b"
+
+      # ANSI escape sequences (like \x1b[31m) have zero width.
+      # when calculating the padding width, we must exclude them.
+      # This also implements a basic version of utf8 character width calculation like
+      # we could get for real from something like utf8proc.
+      #
+      def self.printing_width(str)
+        zwj = false
+        strip_codes(str).codepoints.reduce(0) do |acc, cp|
+          if zwj
+            zwj = false
+            next acc
+          end
+          case cp
+          when 0x200d # zero-width joiner
+            zwj = true
+            acc
+          else
+            acc + 1
+          end
+        end
+      end
+
+      # Strips ANSI codes from a str
+      #
+      # ==== Attributes
+      #
+      # - +str+ - The string from which to strip codes
+      #
+      def self.strip_codes(str)
+        str.gsub(/\x1b\[[\d;]+[A-z]|\r/, '')
+      end
+
+      # Returns an ANSI control sequence
+      #
+      # ==== Attributes
+      #
+      # - +args+ - Argument to pass to the ANSI control sequence
+      # - +cmd+ - ANSI control sequence Command
+      #
+      def self.control(args, cmd)
+        ESC + "[" + args + cmd
+      end
+
+      # https://en.wikipedia.org/wiki/ANSI_escape_code#graphics
+      def self.sgr(params)
+        control(params.to_s, 'm')
+      end
+
+      # Cursor Movement
+
+      # Move the cursor up n lines
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of lines by which to move the cursor up
+      #
+      def self.cursor_up(n = 1)
+        return '' if n.zero?
+        control(n.to_s, 'A')
+      end
+
+      # Move the cursor down n lines
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of lines by which to move the cursor down
+      #
+      def self.cursor_down(n = 1)
+        return '' if n.zero?
+        control(n.to_s, 'B')
+      end
+
+      # Move the cursor forward n columns
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of columns by which to move the cursor forward
+      #
+      def self.cursor_forward(n = 1)
+        return '' if n.zero?
+        control(n.to_s, 'C')
+      end
+
+      # Move the cursor back n columns
+      #
+      # ==== Attributes
+      #
+      # * +n+ - number of columns by which to move the cursor back
+      #
+      def self.cursor_back(n = 1)
+        return '' if n.zero?
+        control(n.to_s, 'D')
+      end
+
+      # Move the cursor to a specific column
+      #
+      # ==== Attributes
+      #
+      # * +n+ - The column to move to
+      #
+      def self.cursor_horizontal_absolute(n = 1)
+        control(n.to_s, 'G')
+      end
+
+      # Show the cursor
+      #
+      def self.show_cursor
+        control('', "?25h")
+      end
+
+      # Hide the cursor
+      #
+      def self.hide_cursor
+        control('', "?25l")
+      end
+
+      # Save the cursor position
+      #
+      def self.cursor_save
+        control('', 's')
+      end
+
+      # Restore the saved cursor position
+      #
+      def self.cursor_restore
+        control('', 'u')
+      end
+
+      # Move to the next line
+      #
+      def self.next_line
+        cursor_down + control('1', 'G')
+      end
+
+      # Move to the previous line
+      #
+      def self.previous_line
+        cursor_up + control('1', 'G')
+      end
+
+      def self.clear_to_end_of_line
+        control('', 'K')
+      end
+    end
+  end
+end