lhj-tools 0.1.4 → 0.1.8

data/lib/lhj/tree/tree.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative 'node'
+require_relative 'directory_renderer'
+require_relative 'number_renderer'
+require_relative 'hash_walker'
+require_relative 'path_walker'
+
+module Lhj
+  class Tree
+    # @api public
+    def self.[](data)
+      new(data)
+    end
+
+    # The list of nodes in this tree.
+    attr_reader :nodes
+
+    # Create a Tree
+    #
+    # @param [String,Dir,Hash] data
+    #
+    # @api public
+    def initialize(data = nil, options = {}, &block)
+      @data   = data ? data.dup.freeze : nil
+      @walker = select_walker.new(options)
+      @nodes  = []
+
+      if @data
+        @walker.traverse(data)
+        @nodes = @walker.nodes
+      end
+
+      @nodes_stack = []
+
+      instance_eval(&block) if block_given?
+
+      freeze
+    end
+
+    # Add node to this tree.
+    #
+    # @param [Symbol,String] name
+    #   the name for the node
+    #
+    # @param [Node, LeafNode] type
+    #   the type of node to add
+    #
+    # @example
+    #   TTY::Tree.new do
+    #     node '...' do
+    #       node '...'
+    #     end
+    #   end
+    #
+    # @api public
+    def node(name, type = Node, &block)
+      parent = @nodes_stack.empty? ? Node::ROOT : @nodes_stack.last
+      level = [0, @nodes_stack.size - 1].max
+      prefix = ':pipe' * level
+      if parent.class == LeafNode
+        prefix = ':space' * level
+      end
+      node = type.new(name, parent.full_path, prefix, @nodes_stack.size)
+      @nodes << node
+
+      return unless block_given?
+
+      @nodes_stack << node
+      if block.arity.zero?
+        instance_eval(&block)
+      else
+        instance_eval(&(->(*_args) { block[node] }))
+      end
+      @nodes_stack.pop
+    end
+
+    # Add leaf node
+    #
+    # @api public
+    def leaf(name, &block)
+      node(name, LeafNode, &block)
+    end
+
+    # @api public
+    def render(options = {})
+      as = options.delete(:as) || :dir
+      renderer = select_renderer(as).new(nodes, options)
+      renderer.render
+    end
+
+    private
+
+    # @api private
+    def select_walker
+      if @data.is_a?(Hash) || @data.nil?
+        HashWalker
+      else
+        @data ||= Dir.pwd
+        PathWalker
+      end
+    end
+
+    def select_renderer(as)
+      case as
+      when :dir, :directory then DirectoryRenderer
+      when :num, :number then NumberRenderer
+      end
+    end
+  end
+end
+

data/lib/lhj/ui/errors/lhj_common_error.rb

@@ -0,0 +1,19 @@
+require_relative 'lhj_exception'
+
+module Lhj
+  class Interface
+    # Super class for exception types that we do not want to record
+    # explicitly as crashes or user errors
+    class LhjCommonException < LhjException; end
+
+    # Raised when there is a build failure in xcodebuild
+    class LhjBuildFailure < LhjCommonException; end
+
+    # Raised when a test fails when being run by tools such as scan or snapshot
+    class LhjTestFailure < LhjCommonException; end
+
+    # Raise this type of exception when a failure caused by a third party
+    # dependency (i.e. xcodebuild, gradle, slather) happens.
+    class LhjDependencyCausedException < LhjCommonException; end
+  end
+end

data/lib/lhj/ui/errors/lhj_crash.rb

@@ -0,0 +1,11 @@
+require_relative 'lhj_exception'
+
+module Lhj
+  class Interface
+    class LhjCrash < LhjException
+      def prefix
+        '[LHJ_CRASH]'
+      end
+    end
+  end
+end

data/lib/lhj/ui/errors/lhj_error.rb

@@ -0,0 +1,25 @@
+require_relative 'lhj_exception'
+
+module Lhj
+  class Interface
+    class LhjError < LhjException
+      attr_reader :show_github_issues
+      attr_reader :error_info
+
+      def initialize(show_github_issues: false, error_info: nil)
+        @show_github_issues = show_github_issues
+        @error_info = error_info
+      end
+
+      def prefix
+        '[USER_ERROR]'
+      end
+    end
+  end
+end
+
+class Exception
+  # def fastlane_should_report_metrics?
+  #   return false
+  # end
+end

data/lib/lhj/ui/errors/lhj_exception.rb

@@ -0,0 +1,19 @@
+module Lhj
+  class Interface
+    class LhjException < StandardError
+      def prefix
+        '[LHJ_EXCEPTION]'
+      end
+
+      def caused_by_calling_ui_method?(method_name: nil)
+        return false if backtrace.nil? || backtrace[0].nil? || method_name.nil?
+        first_frame = backtrace[0]
+        if first_frame.include?(method_name) && first_frame.include?('interface.rb')
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/lhj/ui/errors/lhj_shell_error.rb

@@ -0,0 +1,11 @@
+require_relative 'lhj_exception'
+
+module Lhj
+  class Interface
+    class LhjShellError < LhjException
+      def prefix
+        '[SHELL_ERROR]'
+      end
+    end
+  end
+end

data/lib/lhj/ui/errors.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/errors/*.rb"].each { |f| require_relative f }

data/lib/lhj/ui/implementations/shell.rb

@@ -0,0 +1,148 @@
+require_relative '../interface'
+
+module Lhj
+  # Shell is the terminal output of things
+  # For documentation for each of the methods open `interface.rb`
+  class Shell < Interface
+
+    def log
+      return @log if @log
+
+      $stdout.sync = true
+
+      # if !ENV.key?('DEBUG')
+      #   $stdout.puts("Logging disabled while running tests. Force them by setting the DEBUG environment variable")
+      #   @log ||= Logger.new(nil) # don't show any logs when running tests
+      # else
+        @log ||= Logger.new($stdout)
+      # end
+
+      @log.formatter = proc do |severity, datetime, progname, msg|
+        "#{format_string(datetime, severity)}#{msg}\n"
+      end
+
+      @log
+    end
+
+    def format_string(datetime = Time.now, severity = "")
+        return "[#{datetime.strftime('%H:%M:%S')}]: "
+    end
+
+    #####################################################
+    # @!group Messaging: show text to the user
+    #####################################################
+
+    def error(message)
+      log.error(message.to_s.red)
+    end
+
+    def important(message)
+      log.warn(message.to_s.yellow)
+    end
+
+    def success(message)
+      log.info(message.to_s.green)
+    end
+
+    def message(message)
+      log.info(message.to_s)
+    end
+
+    def deprecated(message)
+      log.error(message.to_s.deprecated)
+    end
+
+    def command(message)
+      log.info("$ #{message}".cyan)
+    end
+
+    def command_output(message)
+      actual = (encode_as_utf_8_if_possible(message).split("\r").last || "") # as clearing the line will remove the `>` and the time stamp
+      actual.split("\n").each do |msg|
+        prefix = msg.include?("▸") ? "" : "▸ "
+        log.info(prefix + "" + msg.magenta)
+      end
+    end
+
+    def verbose(message)
+      log.debug(message.to_s)
+    end
+
+    def header(message)
+      success(message)
+    end
+
+    def content_error(content, error_line)
+      error_line = error_line.to_i
+      return unless error_line > 0
+
+      contents = content.split(/\r?\n/).map(&:chomp)
+
+      start_line = error_line - 2 < 1 ? 1 : error_line - 2
+      end_line = error_line + 2 < contents.length ? error_line + 2 : contents.length
+
+      Range.new(start_line, end_line).each do |line|
+        str = line == error_line ? " => " : "    "
+        str << line.to_s.rjust(Math.log10(end_line) + 1)
+        str << ":\t#{contents[line - 1]}"
+        error(str)
+      end
+    end
+
+    #####################################################
+    # @!group Errors: Inputs
+    #####################################################
+
+    def interactive?
+      interactive = true
+      interactive = false if $stdout.isatty == false
+      interactive = false if Helper.ci?
+      return interactive
+    end
+
+    def input(message)
+      verify_interactive!(message)
+      ask("#{format_string}#{message.to_s.yellow}").to_s.strip
+    end
+
+    def confirm(message)
+      verify_interactive!(message)
+      agree("#{format_string}#{message.to_s.yellow} (y/n)", true)
+    end
+
+    def select(message, options)
+      verify_interactive!(message)
+
+      important(message)
+      choose(*options)
+    end
+
+    def password(message)
+      verify_interactive!(message)
+
+      ask("#{format_string}#{message.to_s.yellow}") do |q|
+        q.whitespace = :chomp
+        q.echo = "*"
+      end
+    end
+
+    private
+
+    def encode_as_utf_8_if_possible(message)
+      return message if message.valid_encoding?
+
+      # genstrings outputs UTF-16, so we should try to use this encoding if it turns out to be valid
+      test_message = message.dup
+      return message.encode(Encoding::UTF_8, Encoding::UTF_16) if test_message.force_encoding(Encoding::UTF_16).valid_encoding?
+
+      # replace any invalid with empty string
+      message.encode(Encoding::UTF_8, invalid: :replace)
+    end
+
+    def verify_interactive!(message)
+      return if interactive?
+      important(message)
+      crash!("Could not retrieve response as fastlane runs in non-interactive mode")
+    end
+  end
+end

data/lib/lhj/ui/interface.rb

@@ -0,0 +1,205 @@
+require_relative 'errors'
+
+module Lhj
+  # Abstract super class
+  class Interface
+    #####################################################
+    # @!group Messaging: show text to the user
+    #####################################################
+
+    # Level Error: Can be used to show additional error
+    #   information before actually raising an exception
+    #   or can be used to just show an error from which
+    #   fastlane can recover (much magic)
+    #
+    #   By default those messages are shown in red
+    def error(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Important: Can be used to show warnings to the user
+    #   not necessarily negative, but something the user should
+    #   be aware of.
+    #
+    #   By default those messages are shown in yellow
+    def important(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Success: Show that something was successful
+    #
+    #   By default those messages are shown in green
+    def success(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Message: Show a neutral message to the user
+    #
+    #   By default those messages shown in white/black
+    def message(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Deprecated: Show that a particular function is deprecated
+    #
+    #   By default those messages shown in strong blue
+    def deprecated(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Command: Print out a terminal command that is being
+    #   executed.
+    #
+    #   By default those messages shown in cyan
+    def command(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Command Output: Print the output of a command with
+    #   this method
+    #
+    #   By default those messages shown in magenta
+    def command_output(_message)
+      not_implemented(__method__)
+    end
+
+    # Level Verbose: Print out additional information for the
+    #   users that are interested. Will only be printed when
+    #   FastlaneCore::Globals.verbose? = true
+    #
+    #   By default those messages are shown in white
+    def verbose(_message)
+      not_implemented(__method__)
+    end
+
+    # Print a header = a text in a box
+    #   use this if this message is really important
+    def header(_message)
+      not_implemented(__method__)
+    end
+
+    # Print lines of content around specific line where
+    #   failed to parse.
+    #
+    #   This message will be shown as error
+    def content_error(content, error_line)
+      not_implemented(__method__)
+    end
+
+    #####################################################
+    # @!group Errors: Inputs
+    #####################################################
+
+    # Is is possible to ask the user questions?
+    def interactive?
+      not_implemented(__method__)
+    end
+
+    # get a standard text input (single line)
+    def input(_message)
+      not_implemented(__method__)
+    end
+
+    # A simple yes or no question
+    def confirm(_message)
+      not_implemented(__method__)
+    end
+
+    # Let the user select one out of x items
+    # return value is the value of the option the user chose
+    def select(_message, _options)
+      not_implemented(__method__)
+    end
+
+    # Password input for the user, text field shouldn't show
+    # plain text
+    def password(_message)
+      not_implemented(__method__)
+    end
+
+    #####################################################
+    # @!group Abort helper methods
+    #####################################################
+
+    # Pass an exception to this method to exit the program
+    #   using the given exception
+    # Use this method instead of user_error! if this error is
+    # unexpected, e.g. an invalid server response that shouldn't happen
+    def crash!(exception)
+      raise LhjCrash.new, exception.to_s
+    end
+
+    # Use this method to exit the program because of an user error
+    #   e.g. app doesn't exist on the given Developer Account
+    #        or invalid user credentials
+    #        or scan tests fail
+    # This will show the error message, but doesn't show the full
+    #   stack trace
+    # Basically this should be used when you actively catch the error
+    # and want to show a nice error message to the user
+    def user_error!(error_message, options = {})
+      raise LhjError.new(show_github_issues: options[:show_github_issues], error_info: options[:error_info]), error_message.to_s
+    end
+
+    # Use this method to exit the program because of a shell command
+    # failure -- the command returned a non-zero response. This does
+    # not specify the nature of the error. The error might be from a
+    # programming error, a user error, or an expected  error because
+    # the user of the Fastfile doesn't have their environment set up
+    # properly. Because of this, when these errors occur, it means
+    # that the caller of the shell command did not adequate error
+    # handling and the caller error handling should be improved.
+    def shell_error!(error_message, options = {})
+      raise LhjShellError.new(options), error_message.to_s
+    end
+
+    # Use this method to exit the program because of a build failure
+    # that's caused by the source code of the user. Example for this
+    # is that gym will fail when the code doesn't compile or because
+    # settings for the project are incorrect.
+    # By using this method we'll have more accurate results about
+    # fastlane failures
+    def build_failure!(error_message, options = {})
+      raise LhjBuildFailure.new(options), error_message.to_s
+    end
+
+    # Use this method to exit the program because of a test failure
+    # that's caused by the source code of the user. Example for this
+    # is that scan will fail when the tests fail.
+    # By using this method we'll have more accurate results about
+    # fastlane failures
+    def test_failure!(error_message)
+      raise LhjTestFailure.new, error_message
+    end
+
+    # Use this method to exit the program because of terminal state
+    # that is neither the fault of fastlane, nor a problem with the
+    # user's input. Using this method instead of user_error! will
+    # avoid tracking this outcome as a fastlane failure.
+    #
+    #   e.g. tests ran successfully, but no screenshots were found
+    #
+    # This will show the message, but hide the full stack trace.
+    def abort_with_message!(message)
+      raise LhjCommonException.new, message
+    end
+
+    #####################################################
+    # @!group Helpers
+    #####################################################
+    def not_implemented(method_name)
+      require_relative 'ui'
+      UI.user_error!("Current UI '#{self}' doesn't support method '#{method_name}'")
+    end
+
+    def to_s
+      self.class.name.split('::').last
+    end
+  end
+end
+
+class String
+  def deprecated
+    self.bold.blue
+  end
+end

data/lib/lhj/ui/ui.rb

@@ -0,0 +1,26 @@
+module Lhj
+  class UI
+    class << self
+      attr_accessor(:ui_object)
+
+      def ui_object
+        require_relative 'implementations/shell'
+        @ui_object ||= Shell.new
+      end
+
+      def method_missing(method_sym, *args, &_block)
+        # not using `responds` because we don't care about methods like .to_s and so on
+        require_relative 'interface'
+        interface_methods = Lhj::Interface.instance_methods - Object.instance_methods
+        UI.user_error!("Unknown method '#{method_sym}', supported #{interface_methods}") unless interface_methods.include?(method_sym)
+
+        self.ui_object.send(method_sym, *args)
+      end
+    end
+  end
+end
+
+# Import all available implementations
+Dir[File.dirname(__FILE__) + '/implementations/*.rb'].each do |file|
+  require_relative file
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhj-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.8
 platform: ruby
 authors:
 - lihaijian
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-20 00:00:00.000000000 Z
+date: 2022-01-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: claide
@@ -118,6 +118,60 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: tty-spinner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: excon
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.71.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.71.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 - !ruby/object:Gem::Dependency
   name: faraday-cookie_jar
   requirement: !ruby/object:Gem::Requirement
@@ -218,8 +272,13 @@ extra_rdoc_files: []
 files:
 - README.md
 - bin/lhj
+- lib/lhj/action/sh_helper.rb
 - lib/lhj/command.rb
+- lib/lhj/command/config.rb
+- lib/lhj/command/config/info.rb
+- lib/lhj/command/file_path.rb
 - lib/lhj/command/head_import.rb
+- lib/lhj/command/http.rb
 - lib/lhj/command/init.rb
 - lib/lhj/command/local/fetch.rb
 - lib/lhj/command/local/filter.rb
@@ -233,6 +292,7 @@ files:
 - lib/lhj/command/refactor_rename.rb
 - lib/lhj/command/rename_image.rb
 - lib/lhj/command/reverse_import.rb
+- lib/lhj/command/sync_pod_repo.rb
 - lib/lhj/command/template.rb
 - lib/lhj/command/trans.rb
 - lib/lhj/command/view.rb
@@ -244,6 +304,21 @@ files:
 - lib/lhj/helper/trans_helper.rb
 - lib/lhj/tools.rb
 - lib/lhj/tools/version.rb
+- lib/lhj/tree/directory_renderer.rb
+- lib/lhj/tree/hash_walker.rb
+- lib/lhj/tree/node.rb
+- lib/lhj/tree/number_renderer.rb
+- lib/lhj/tree/path_walker.rb
+- lib/lhj/tree/tree.rb
+- lib/lhj/ui/errors.rb
+- lib/lhj/ui/errors/lhj_common_error.rb
+- lib/lhj/ui/errors/lhj_crash.rb
+- lib/lhj/ui/errors/lhj_error.rb
+- lib/lhj/ui/errors/lhj_exception.rb
+- lib/lhj/ui/errors/lhj_shell_error.rb
+- lib/lhj/ui/implementations/shell.rb
+- lib/lhj/ui/interface.rb
+- lib/lhj/ui/ui.rb
 homepage:
 licenses:
 - MIT