MuranoCLI 3.2.0.beta.1 → 3.2.0.beta.5

data/lib/MrMurano/commands/token.rb

@@ -24,7 +24,12 @@ def args_parse_user_host_pair(args)
   [username, host]
 end
 
-def args_opts_parse_token!(args, options)
+def args_sole_token_maybe(args)
+  return unless args.length == 1
+  args.shift if MrMurano::HttpAuthed.instance.token_looks_legit(args[0])
+end
+
+def args_opts_parse_token_maybe(args, options, must: false)
   n_specified = 0
   token = args.shift
   n_specified += 1 unless token.nil?
@@ -43,10 +48,9 @@ def args_opts_parse_token!(args, options)
   if n_specified > 1
     MrMurano::Verbose.error(%(Please specify only one token, --token, or --from-env))
     exit 1
-  elsif n_specified == 0
-    token = ask('Token: ')
   end
-  if token.to_s.empty?
+  token = nil if token.to_s.empty?
+  if must && token.nil?
     MrMurano::Verbose.error(%(Please specify a token!))
     unless ENV['MURANO_TOKEN'].to_s.empty?
       MrMurano::Verbose.warning(
@@ -58,6 +62,20 @@ def args_opts_parse_token!(args, options)
   token
 end
 
+def args_opts_parse_token(args, options)
+  args_opts_parse_token_maybe(args, options, must: false)
+end
+
+def args_opts_parse_token!(args, options)
+  args_opts_parse_token_maybe(args, options, must: true)
+end
+
+def cmd_option_token_options(c)
+  # We cannot use --token, because it's already a global_option.
+  c.option '--value TOKEN', String, %(The token to use)
+  c.option '--from-env', %(Use token in MURANO_TOKEN)
+end
+
 command :token do |c|
   c.syntax = %(murano token)
   c.summary = %(About token commands)
@@ -164,20 +182,20 @@ end
 alias_command 'token fetch', 'token get'
 
 command 'token set' do |c|
-  c.syntax = %(murano token set [<username>] [<host>] [<token>])
+  c.syntax = %(murano token set [[[<username>] [<host>] [<token>]] | [<token>]])
   c.summary = %(Set token for username and host)
   c.description = %(
     Set token for username and host.
   ).strip
-  # We cannot use --token, because it's already a global_option.
-  c.option '--value TOKEN', String, %(The token to use)
-  c.option '--from-env', %(Use token in MURANO_TOKEN)
+  cmd_option_token_options(c)
   c.project_not_required = true
 
   c.action do |args, options|
     c.verify_arg_count!(args, 3)
+    # If there's just one arg, might be the token (otherwise it's the username).
+    token = args_sole_token_maybe(args)
     username, host = args_parse_user_host_pair(args)
-    token = args_opts_parse_token!(args, options)
+    token = args_opts_parse_token!(args, options) if token.nil?
     token_file = MrMurano::Tokens.new
     token_file.load
     token_file.set(host, username, token)
@@ -186,24 +204,51 @@ command 'token set' do |c|
 end
 
 command 'token delete' do |c|
-  c.syntax = %(murano token delete [<username>] [<host>])
+  c.syntax = %(murano token delete [[[<username>] [<host>]] | [<token>]])
   c.summary = %(Invalidate and delete token for username and host)
   c.description = %(
     Invalidate and delete token for username and host.
   ).strip
   c.option '--no-invalidate', %(Do not also invalidate token on server)
+  cmd_option_token_options(c)
   c.project_not_required = true
 
+  # Note: We confirm deleting passwords, but not throwaway tokens.
   c.action do |args, options|
     c.verify_arg_count!(args, 2)
-    # We confirm deleting passwords, but not throwaway tokens.
-    username, host = args_parse_user_host_pair(args)
+    clear_cache = false
+    # If there's just one arg, might be the token (otherwise it's the username).
+    token = args_sole_token_maybe(args)
+    if token.nil?
+      n_args = args.length
+      # First see if the user specified a username and/or host.
+      username, host = args_parse_user_host_pair(args)
+      # See if the user used --value or --from-env.
+      alt_token = args_opts_parse_token(args, options)
+      # If the user specified a user or host, they should not specify the
+      # token (user and host are used to lookup in the tokens file).
+      if !alt_token.nil?
+        if n_args > 0
+          MrMurano::Verbose.error %(
+            Please specify either token, or user and host, but not both
+          ).strip
+          break
+        end
+        token = alt_token
+      else
+        token = MrMurano::HttpAuthed.instance.token_from_file(host, username)
+        clear_cache = true
+      end
+    end
+    if token.nil?
+      MrMurano::Verbose.warning %(No token specified or none found for user)
+      break
+    end
     # We can create an authless instance, which won't ask user for
     # login creds, because the delete command does not need creds.
     acc = MrMurano::Account.new(authless: true)
-    token = MrMurano::HttpAuthed.instance.token_from_file(host, username)
     acc.invalidate_token(token) unless options.no_invalidate
-    MrMurano::HttpAuthed.instance.token_remove(host, username)
+    MrMurano::HttpAuthed.instance.token_remove(host, username) if clear_cache
   end
 end
 

data/lib/MrMurano/commands/usage.rb

@@ -7,6 +7,7 @@
 
 require 'MrMurano/ReCommander'
 require 'MrMurano/Solution'
+require 'MrMurano/commands/solution_picker'
 
 command :usage do |c|
   c.syntax = %(murano usage)

data/lib/MrMurano/commands.rb

@@ -17,6 +17,7 @@ require 'MrMurano/commands/content'
 require 'MrMurano/commands/cors'
 require 'MrMurano/commands/devices'
 require 'MrMurano/commands/domain'
+require 'MrMurano/commands/element'
 require 'MrMurano/commands/exchange'
 require 'MrMurano/commands/globals'
 require 'MrMurano/commands/keystore'
@@ -28,6 +29,7 @@ require 'MrMurano/commands/mock'
 require 'MrMurano/commands/postgresql'
 require 'MrMurano/commands/password'
 require 'MrMurano/commands/settings'
+require 'MrMurano/commands/service'
 require 'MrMurano/commands/show'
 require 'MrMurano/commands/solution'
 require 'MrMurano/commands/status'

data/lib/MrMurano/hash.rb

@@ -42,6 +42,97 @@ class Hash
     end
     self
   end
+
+  # h = { :a => { :b => { :c => 1, :d => 2 }, :e => 3 }, :f => 4 }
+  # flat_hash(h) #=> {[:a, :b, :c]=>1, [:a, :b, :d]=>2, [:a, :e]=>3, [:f]=>4}
+  def self.flat_hash(hash, long_key=[], flat={})
+    return flat.update(long_key => hash) unless hash.is_a? Hash
+    hash.each { |key, val| flat_hash(val, long_key + [key], flat) }
+    flat
+  end
+
+  # Get all hash and nested hash keys.
+  def self.nested_keys(obj)
+    obj.each_with_object([]) do |(key, val), keys|
+      keys << key
+      keys.concat(nested_keys(val)) if val.is_a? Hash
+    end
+  end
+
+  # deep_symbolize_keys is from rails:
+  #
+  #   https://github.com/rails/rails/blob/f213e926892020f9ab6c8974612c59e2ba959253/
+  #     activesupport/lib/active_support/core_ext/hash/keys.rb
+
+  # Returns a new hash with all keys converted by the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  #
+  #  hash = { person: { name: 'Rob', age: '28' } }
+  #
+  #  hash.deep_transform_keys{ |key| key.to_s.upcase }
+  #  # => {"PERSON"=>{"NAME"=>"Rob", "AGE"=>"28"}}
+  def deep_transform_keys(&block)
+    _deep_transform_keys_in_object(self, &block)
+  end
+
+  # Destructively converts all keys by using the block operation.
+  # This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_transform_keys!(&block)
+    _deep_transform_keys_in_object!(self, &block)
+  end
+
+  # Returns a new hash with all keys converted to symbols, as long as
+  # they respond to +to_sym+. This includes the keys from the root hash
+  # and from all nested hashes and arrays.
+  #
+  #   hash = { 'person' => { 'name' => 'Rob', 'age' => '28' } }
+  #
+  #   hash.deep_symbolize_keys
+  #   # => {:person=>{:name=>"Rob", :age=>"28"}}
+  def deep_symbolize_keys
+    # rubocop:disable Style/RescueModifier
+    deep_transform_keys { |key| key.to_sym rescue key }
+  end
+
+  # Destructively converts all keys to symbols, as long as they respond
+  # to +to_sym+. This includes the keys from the root hash and from all
+  # nested hashes and arrays.
+  def deep_symbolize_keys!
+    deep_transform_keys! { |key| key.to_sym rescue key }
+  end
+
+  private
+
+  # support methods for deep transforming nested hashes and arrays
+  def _deep_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, value), result|
+        result[yield(key)] = _deep_transform_keys_in_object(value, &block)
+      end
+    when Array
+      object.map { |e| _deep_transform_keys_in_object(e, &block) }
+    else
+      object
+    end
+  end
+
+  def _deep_transform_keys_in_object!(object, &block)
+    case object
+    when Hash
+      object.keys.each do |key|
+        value = object.delete(key)
+        object[yield(key)] = _deep_transform_keys_in_object!(value, &block)
+      end
+      object
+    when Array
+      object.map! { |e| _deep_transform_keys_in_object!(e, &block) }
+    else
+      object
+    end
+  end
 end
 
 def ordered_hash(dict)

data/lib/MrMurano/http.rb

@@ -62,25 +62,72 @@ module MrMurano
           )
           ccmd << %(-F #{m[:name]}=@#{m[:filename]}) unless m.nil?
         else
-          ccmd << %(-d '#{request.body}')
+          req_body = request.body
+          unless $cfg['tool.show-password']
+            req_body = req_body.gsub(
+              /"password":(["'])(?:(?=(\\?))\2.)*?\1/, '"password":"<redacted>"'
+            )
+          end
+          ccmd << %(-d '#{req_body}')
+        end
+      end
+
+      MrMurano::Http.curldebug_log(ccmd.join(' '), stamp_it: true)
+    end
+
+    # (lb): Ideally, we'd refactor and these wouldn't be static class methods.
+    def self.curldebug_after(request, response)
+      @http_complete = [] unless defined? @http_complete
+      @http_complete.push([request, response])
+      return response unless $cfg['tool.curldebug'] && $cfg['tool.curlfancy']
+      MrMurano::Http.curldebug_elapsed
+      if response.nil?
+        formatted = '<nil>'
+      else
+        begin
+          formatted = "#{response.code} / #{response.body}"
+        rescue StandardError
+          formatted = response.to_s
         end
       end
-      MrMurano::Http.curldebug_log(ccmd.join(' '))
+      formatted = "Response: #{formatted}"
+      MrMurano::Http.curldebug_log(formatted)
+      response
+    end
+
+    def self.curldebug_elapsed
+      http_recv_at = Time.now
+      if !@http_sent_at.nil?
+        formatted = "ElapsedT: #{http_recv_at - @http_sent_at}"
+      else
+        formatted = 'ElapsedT: Overlapping command clobbered time.'
+        MrMurano::Verbose.warning(formatted) if $cfg['tool.debug']
+      end
+      MrMurano::Http.curldebug_log(formatted)
+      @http_sent_at = nil
     end
 
-    def self.curldebug_log(ccmd)
+    def self.curldebug_log(formatted, stamp_it: false)
       if $cfg.curlfile_f.nil?
-        MrMurano::Progress.instance.whirly_interject { puts ccmd }
+        MrMurano::Progress.instance.whirly_interject { puts formatted }
       else
-        $cfg.curlfile_f << ccmd + "\n\n"
+        $cfg.curlfile_f << formatted + "\n\n"
         $cfg.curlfile_f.flush
       end
+      return unless stamp_it
+      @http_outstanding = [] unless defined? @http_outstanding
+      @http_outstanding.push(formatted)
+      @http_sent_at = Time.now
     end
 
     def http
       uri = URI($cfg['net.protocol'] + '://' + $cfg['net.host'])
       if !defined?(@http) || @http.nil?
         @http = Net::HTTP.new(uri.host, uri.port)
+        # (lb): The HTTP timeouts default to 60 secs. But requests
+        # sometimes timeout, so experimenting with longer timeouts.
+        @http.open_timeout = 90 # default: 60
+        @http.read_timeout = 90 # default: 60
         @http.use_ssl = true if $cfg['net.protocol'] == 'https'
         begin
           @http.start
@@ -148,9 +195,11 @@ module MrMurano
     def workit(request)
       curldebug(request)
       if block_given?
-        yield request, http
+        response = yield request, http
+        MrMurano::Http.curldebug_after(request, response)
       else
         response = http.request(request)
+        MrMurano::Http.curldebug_after(request, response)
         case response
         when Net::HTTPSuccess
           workit_response(response)

data/lib/MrMurano/makePretty.rb

@@ -307,6 +307,53 @@ module MrMurano
     def self.body_prefix(options)
       options.indent && '  ' || ''
     end
+
+    def self.width_last_column(headers, elems)
+      return nil unless $stdout.tty?
+      # Calculate how much room (how many characters) are left for the
+      # description column.
+      width_taken = 0
+      # rubocop:disable Performance/FixedSize
+      #   "Do not compute the size of statically sized objects."
+      width_taken += '| '.length
+      # Calculate the width of each column except the last (:description).
+      headers[0..-2].each do |key|
+        elem_with_max = elems.max { |a, b| a.send(key).length <=> b.send(key).length }
+        width_taken += elem_with_max.send(key).length unless elem_with_max.nil?
+        width_taken += ' | '.length
+      end
+      width_taken += ' | '.length
+      term_width, _rows = HighLine::SystemExtensions.terminal_size
+      width_avail = term_width - width_taken
+      # MAGIC_NUMBER: Tweak/change this if you want. 20 char min feels
+      # about right: don't wrap if column would be narrow or negative.
+      return nil if width_avail < 20
+      width_avail
+    end
+
+    def self.split_text_on_whitespace(full, width_avail)
+      # The easiest method is to split at the width, and not on closest whitespace:
+      #   elem.meta[key].scan(/.{1,#{width_avail}}/).join("\n")
+      # We'll instead split on whitespace.
+      parts = []
+      split_posit = width_avail - 1
+      until full.empty?
+        # Split the description on a space before the max width.
+        part = full[0..split_posit]
+        full = full[(split_posit + 1)..-1] || ''
+        leftover = ''
+        part, _space, leftover = part.rpartition(' ') unless full.empty?
+        if part.empty?
+          part = leftover.to_s
+          leftover = ''
+        else
+          full = leftover.to_s + full
+          full = full
+        end
+        parts.push(part.strip)
+      end
+      parts.join("\n")
+    end
   end
 end
 

data/lib/MrMurano/optparse.rb

@@ -1559,58 +1559,73 @@ XXX
   def parse_in_order(argv = default_argv, setter = nil, &nonopt)  # :nodoc:
     opt, arg, val, rest = nil
     nonopt ||= proc {|a| throw :terminate, a}
+    end_of_options = false
+
     argv.unshift(arg) if arg = catch(:terminate) {
       while arg = argv.shift
-        case arg
-        # long option
-        when /\A--([^=]*)(?:=(.*))?/m
-          opt, rest = $1, $2
-          begin
-            sw, = complete(:long, opt, true)
-          rescue ParseError
-            raise $!.set_option(arg, true)
-          end
-          begin
-            opt, cb, val = sw.parse(rest, argv) {|*exc| raise(*exc)}
-            val = cb.call(val) if cb
-            setter.call(sw.switch_name, val) if setter
-          rescue ParseError
-            raise $!.set_option(arg, rest)
-          end
+        is_nonopt = end_of_options
+
+        if !end_of_options
+          case arg
+
+          # end of options
+          when '--'
+            end_of_options = true
+
+          # long option
+          when /\A--([^=]*)(?:=(.*))?/m
+            opt, rest = $1, $2
+            begin
+              sw, = complete(:long, opt, true)
+            rescue ParseError
+              raise $!.set_option(arg, true)
+            end
+            begin
+              opt, cb, val = sw.parse(rest, argv) {|*exc| raise(*exc)}
+              val = cb.call(val) if cb
+              setter.call(sw.switch_name, val) if setter
+            rescue ParseError
+              raise $!.set_option(arg, rest)
+            end
 
-        # short option
-        when /\A-(.)((=).*|.+)?/m
-          opt, has_arg, eq, val, rest = $1, $3, $3, $2, $2
-          begin
-            sw, = search(:short, opt)
-            unless sw
-              begin
-                sw, = complete(:short, opt)
-                # short option matched.
-                val = arg.sub(/\A-/, '')
-                has_arg = true
-              rescue InvalidOption
-                # if no short options match, try completion with long
-                # options.
-                sw, = complete(:long, opt)
-                eq ||= !rest
+          # short option
+          when /\A-(.)((=).*|.+)?/m
+            opt, has_arg, eq, val, rest = $1, $3, $3, $2, $2
+            begin
+              sw, = search(:short, opt)
+              unless sw
+                begin
+                  sw, = complete(:short, opt)
+                  # short option matched.
+                  val = arg.sub(/\A-/, '')
+                  has_arg = true
+                rescue InvalidOption
+                  # if no short options match, try completion with long
+                  # options.
+                  sw, = complete(:long, opt)
+                  eq ||= !rest
+                end
               end
+            rescue ParseError
+              raise $!.set_option(arg, true)
             end
-          rescue ParseError
-            raise $!.set_option(arg, true)
-          end
-          begin
-            opt, cb, val = sw.parse(val, argv) {|*exc| raise(*exc) if eq}
-            raise InvalidOption, arg if has_arg and !eq and arg == "-#{opt}"
-            argv.unshift(opt) if opt and (!rest or (opt = opt.sub(/\A-*/, '-')) != '-')
-            val = cb.call(val) if cb
-            setter.call(sw.switch_name, val) if setter
-          rescue ParseError
-            raise $!.set_option(arg, arg.length > 2)
+            begin
+              opt, cb, val = sw.parse(val, argv) {|*exc| raise(*exc) if eq}
+              raise InvalidOption, arg if has_arg and !eq and arg == "-#{opt}"
+              argv.unshift(opt) if opt and (!rest or (opt = opt.sub(/\A-*/, '-')) != '-')
+              val = cb.call(val) if cb
+              setter.call(sw.switch_name, val) if setter
+            rescue ParseError
+              raise $!.set_option(arg, arg.length > 2)
+            end
+
+          # non-option argument
+          else
+            is_nonopt = true
           end
+        end
 
-        # non-option argument
-        else
+        if is_nonopt
           catch(:prune) do
             visit(:each_option) do |sw0|
               sw = sw0

data/lib/MrMurano/variegated/TruthyFalsey.rb

@@ -0,0 +1,48 @@
+# Copyright © 2016-2017 Exosite LLC. All Rights Reserved
+# License: PROPRIETARY. See LICENSE.txt.
+# frozen_string_literal: true
+
+# vim:tw=0:ts=2:sw=2:et:ai
+# Unauthorized copying of this file is strictly prohibited.
+
+class TruthyFalsey
+  attr_reader :rejoinder
+
+  def initialize(rejoinder)
+    @rejoinder = rejoinder
+  end
+
+  TRUTHY_WORDS = %w[1 on t true y yes +].freeze
+
+  FALSEY_WORDS = ['0', 'off', 'f', 'false', 'n', 'no', '-', ''].freeze
+
+  def truthy?
+    TRUTHY_WORDS.include? @rejoinder.to_s.downcase
+  end
+
+  def falsey?
+    FALSEY_WORDS.include? @rejoinder.to_s.downcase
+  end
+
+  def self.coerce_if_boolean(value, reference)
+    # Ruby doesn't have a Boolean type, just TrueClass and FalseClass.
+    return value unless [true, false].include? reference
+    tfy = TruthyFalsey.new(value)
+    if tfy.truthy?
+      true
+    elsif tfy.falsey?
+      false
+    else
+      value
+    end
+  end
+
+  def self.coerce_boolean(value, reference, default: 'true')
+    if value.nil?
+      default
+    else
+      TruthyFalsey.coerce_if_boolean(value, reference)
+    end
+  end
+end
+

data/lib/MrMurano/variegated/ruby_dig.rb

@@ -0,0 +1,64 @@
+# Copyright © 2016-2017 Exosite LLC. All Rights Reserved
+# License: PROPRIETARY. See LICENSE.txt.
+# frozen_string_literal: true
+
+# vim:tw=0:ts=2:sw=2:et:ai
+# Unauthorized copying of this file is strictly prohibited.
+
+# The Safe Navigation Operator (&.) was introduced in Ruby 2.3.
+#
+# Here, we introduce a delegator that performs a similar dig operator,
+# but it wraps each child hash in a delegator, and it allows one to
+# safe-set a nested value.
+#
+# For more on the dig operator, see:
+#
+#   http://mitrev.net/ruby/2015/11/13/the-operator-in-ruby/
+
+# NOTE: (lb): Rather than deriving from the built-in SimpleDelegator class,
+# from the 'delegate' library, we use a third-party package, because
+# SimpleDelegator maps the class and is_a? methods to the delegator, i.e.,
+# some_delegator.is_a? Delegator == true. But we'd prefer that the delegator
+# map to the wrapped object, e.g., MyDelegator.new(Hash.new).class == Hash.
+
+# From:
+#   https://github.com/stevenharman/dumb_delegator
+require 'dumb_delegator'
+
+class HashDiggable < DumbDelegator
+  def initialize(obj=nil)
+    super(obj || {})
+  end
+
+  def a_diggable_hash?
+    true
+  end
+
+  def fill_safe(value, *path)
+    sub_hash = self
+    sub_hash = dig_safe(*path[0..-2]) if path.length > 1
+    sub_hash[path[-1]] = value
+  end
+
+  def dig_safe(key, *rest)
+    value = self[key]
+
+    if value.nil?
+      value = self[key] = ::HashDiggable.new
+    else
+      begin
+        value.a_diggable_hash?
+        # Okay!
+      rescue ::NoMethodError => _err
+        value = self[key] = ::HashDiggable.new(value) if value.is_a? ::Hash
+      end
+    end
+
+    if rest.empty?
+      value
+    else
+      value.dig_safe(*rest)
+    end
+  end
+end
+