MuranoCLI 2.2.4 → 3.0.0

data/lib/MrMurano/commands/status.rb

@@ -1,102 +1,236 @@
+# Last Modified: 2017.08.18 /coding: utf-8
+# frozen_string_literal: true
 
-command :status do |c|
-  c.syntax = %{murano status [options] [filters]}
-  c.summary = %{Get the status of files}
-  c.description = %{Get the status of files
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
 
-  Compares the local project against what is up in Murano, returning a summary of
-  what things are new or changed.
+require 'inflecto'
+require 'MrMurano/verbosing'
+require 'MrMurano/SyncRoot'
 
-  When --diff is passed, for items that have changes, the remote item and local
-  item are passed to a diff tool and that output is included.
+# Load options to control which things to sync
+def cmd_option_syncable_pickers(cmd)
+  MrMurano::SyncRoot.instance.each_option do |short, long, desc|
+    cmd.option short, long, Inflecto.pluralize(desc)
+  end
+  MrMurano::SyncRoot.instance.each_alias_opt do |long, desc|
+    cmd.option long, Inflecto.pluralize(desc)
+  end
 
-  The diff tool and options to it can be set with the config key 'diff.cmd'.
+  cmd.option(
+    '--[no-]nesting',
+    %(Disable support for arranging Lua modules hierarchically)
+  ) do |nestation|
+    # This is only called if user specifies switch.
+    $cfg['modules.no-nesting'] = !nestation
+  end
+end
 
+def cmd_defaults_syncable_pickers(options)
+  # Weird. The options is a Commander::Command::Options object, but
+  # options.class says nil! Also, you cannot index properties or
+  # even options.send('opt'). But we can just twiddle the raw table.
+  table = options.__hash__
+  MrMurano::SyncRoot.instance.each_alias_sym do |pseudo, pseudo_sym, name, name_sym|
+    unless table[pseudo_sym].nil?
+      if table[name_sym].nil?
+        table[name_sym] = table[pseudo_sym]
+      elsif table[name_sym] != table[pseudo_sym]
+        MrMurano::Verbose.warning("Ignoring --#{pseudo} because --#{name} also specified")
+      end
+    end
+  end
+end
 
-  Filters allow for selecting a subset of items to check based on patterns.
+command :status do |c|
+  c.syntax = %(murano status [--options] [filters])
+  c.summary = %(Get the status of files)
+  c.description = %(
+Get the status of files.
 
-  File glob filters can be used to select local files.  The glob is compared with
-  the full file path.
+Compares the local project against what is up in Murano, showing a summary
+of what things are new or changed.
 
-  Each item type also supports specific filters. These always start with #.
-  Endpoints can be selected with a "#<method>#<path glob>" pattern.
+When --diff is passed, for items that have changes, the remote item and
+local item are passed to a diff tool and that output is included.
 
+The diff tool and options to it can be set with the config key 'diff.cmd'.
 
-  }.gsub(/^ +/,'')
-  c.option '--all', 'Check everything'
+Filters allow for selecting a subset of items to check based on patterns.
 
-  # Load options to control which things to status
-  MrMurano::SyncRoot.each_option do |s,l,d|
-    c.option s, l, d
-  end
+File glob filters can be used to select local files. The glob is compared
+with the full file path.
 
-  c.option '--[no-]asdown', %{Report as if syncdown instead of syncup}
-  c.option '--[no-]diff', %{For modified items, show a diff}
-  c.option '--[no-]grouped', %{Group all adds, deletes, and mods together}
-  c.option '--[no-]showall', %{List unchanged as well}
+Each item type also supports specific filters. These always start with #.
+Endpoints can be selected with a "#<method>#<path glob>" pattern.
+  ).gsub(/^ +/, '').strip
 
-  c.action do |args,options|
-    options.default :delete=>true, :create=>true, :update=>true, :diff=>false,
-      :grouped => true
+  # Add flag: --type [application|product|all].
+  cmd_add_solntype_pickers(c)
 
-    def fmtr(item)
-      if item.has_key? :local_path then
-        lp = item[:local_path].relative_path_from(Pathname.pwd()).to_s
-        if item.has_key?(:line) and item[:line] > 0 then
-          return "#{lp}:#{item[:line]}"
-        end
-        lp
+  c.option '--all', 'Check everything'
+  c.option '--[no-]asdown', %(Report as if syncdown instead of syncup)
+  c.option '--[no-]asup', %(Report as if syncup instead of syncdown (default: true))
+  c.option '--[no-]diff', %(For modified items, show a diff)
+  c.option '--[no-]grouped', %(Group all adds, deletes, and mods together)
+  c.option '--[no-]show-all', %(List unchanged as well)
+  c.option '--[no-]show-type', %(Include type of item)
+  cmd_option_syncable_pickers(c)
+
+  c.action do |args, options|
+    # SKIP: c.verify_arg_count!(args)
+    options.default(
+      all: nil,
+      asdown: nil,
+      asup: nil,
+      diff: false,
+      grouped: true,
+      show_all: false,
+      show_type: false,
+      # delete/create/update are not options the user can specify
+      # for status or diff commands; but the SyncUpDown class expects
+      # them.
+      delete: true,
+      create: true,
+      update: true,
+    )
+    cmd_defaults_solntype_pickers(options)
+    cmd_defaults_syncable_pickers(options)
+
+    def fmtr(item, options)
+      if item.key?(:local_path)
+        desc = item[:local_path].relative_path_from(Pathname.pwd).to_s
+        desc = "#{desc}:#{item[:line]}" if item.key?(:line) && item[:line] > 0
       else
-        item[:synckey]
+        desc = item[:synckey]
+      end
+      return desc unless options.show_type
+      unless item[:pp_desc].to_s.empty? || item[:pp_desc] == item[:synckey]
+        desc += " (#{item[:pp_desc]})"
       end
+      desc += " [#{item[:method]} #{item[:path]}]" if item[:method] && item[:path]
+      desc
     end
+
+    def interject(msg)
+      MrMurano::Verbose.whirly_interject { say msg }
+    end
+
     def pretty(ret, options)
-      say "Adding:" if options.grouped
-      ret[:toadd].each{|item| say " + #{item[:pp_type]}  #{fmtr(item)}"}
-      say "Deleteing:" if options.grouped
-      ret[:todel].each{|item| say " - #{item[:pp_type]}  #{fmtr(item)}"}
-      say "Changing:" if options.grouped
-      ret[:tomod].each{|item|
-        say " M #{item[:pp_type]}  #{fmtr(item)}"
-        say item[:diff] if options.diff
-      }
-      if options.showall then
-        say "Unchanged:" if options.grouped
-        ret[:unchg].each{|item| say "   #{item[:pp_type]}  #{fmtr(item)}"}
+      pretty_group_header(
+        ret[:toadd], 'Only on local machine', 'new locally', options.grouped
+      )
+      ret[:toadd].each do |item|
+        interject " + #{item[:pp_type]}  #{highlight_chg(fmtr(item, options))}"
+      end
+
+      pretty_group_header(
+        ret[:todel], 'Only on remote server', 'new remotely', options.grouped
+      )
+      ret[:todel].each do |item|
+        interject " - #{item[:pp_type]}  #{highlight_del(fmtr(item, options))}"
+      end
+
+      pretty_group_header(
+        ret[:tomod], 'Items that differ', 'that differs', options.grouped
+      )
+      ret[:tomod].each do |item|
+        interject " M #{item[:pp_type]}  #{highlight_chg(fmtr(item, options))}"
+        interject item[:diff] if options.diff
+      end
+
+      unless ret[:skipd].empty?
+        pretty_group_header(
+          ret[:skipd], 'Items without a solution', 'without a solution', options.grouped
+        )
+        ret[:skipd].each do |item|
+          interject " - #{item[:pp_type]}  #{highlight_del(fmtr(item, options))}"
+        end
+      end
+
+      return unless options.show_all
+      interject 'Unchanged:' if options.grouped
+      ret[:unchg].each { |item| interject "   #{item[:pp_type]}  #{fmtr(item, options)}" }
+    end
+
+    def pretty_group_header(group, header_any, header_empty, grouped)
+      return unless grouped
+      if !group.empty?
+        interject "#{header_any}:"
+      else
+        interject "Nothing #{header_empty}"
       end
     end
 
-    @grouped = {:toadd=>[],:todel=>[],:tomod=>[], :unchg=>[]}
-    def gmerge(ret, type, options)
-      if options.grouped then
+    def highlight_chg(msg)
+      Rainbow(msg).green.bright
+    end
+
+    def highlight_del(msg)
+      Rainbow(msg).red.bright
+    end
+
+    @grouped = { toadd: [], todel: [], tomod: [], unchg: [], skipd: [] }
+    def gmerge(ret, type, desc, options)
+      if options.grouped
         out = @grouped
       else
-        out = {:toadd=>[],:todel=>[],:tomod=>[], :unchg=>[]}
+        out = { toadd: [], todel: [], tomod: [], unchg: [], skipd: [] }
       end
 
-      [:toadd, :todel, :tomod, :unchg].each do |kind|
+      %i[toadd todel tomod unchg skipd].each do |kind|
         ret[kind].each do |item|
           item = item.to_h
           item[:pp_type] = type
+          item[:pp_desc] = desc
           out[kind] << item
         end
       end
 
-      unless options.grouped then
-        pretty(out, options)
+      pretty(out, options) unless options.grouped
+    end
+
+    # *** Method code starts here ***
+
+    # Check that user doesn't try to asdown and asup, or no-asdown and no-asup.
+    if options.asdown.nil? && options.asup.nil?
+      options.asdown = false
+      options.asup = true
+    elsif !options.asdown.nil? && !options.asup.nil?
+      unless options.asdown ^ options.asup
+        error('Please specify either --asdown or --asup, but not both!')
+        exit 1
       end
+    elsif options.asdown.nil?
+      options.asdown = !options.asup
+    elsif options.asup.nil?
+      options.asup = !options.asdown
+    else
+      raise('Unexpected code path.')
     end
 
-    MrMurano::SyncRoot.each_filtered(options.__hash__) do |name, type, klass|
-      sol = klass.new
-      ret = sol.status(options, args)
-      gmerge(ret, type, options)
+    MrMurano::SyncRoot.instance.each_filtered(options.__hash__) do |_name, type, klass, desc|
+      MrMurano::Verbose.whirly_msg "Fetching #{Inflecto.pluralize(desc)}..."
+      begin
+        syncable = klass.new
+      rescue MrMurano::ConfigError => err
+        MrMurano::Verbose.error "Could not fetch status for #{desc}: #{err}"
+      rescue StandardError => _err
+        raise
+      else
+        ret = syncable.status(options, args)
+        gmerge(ret, type, desc, options)
+      end
     end
+    MrMurano::Verbose.whirly_stop
 
     pretty(@grouped, options) if options.grouped
   end
 end
+alias_command 'diff', 'status', '--diff', '--no-grouped'
+alias_command 'diff application', 'status', '--diff', '--no-grouped', '--type', 'application'
+alias_command 'diff product', 'status', '--diff', '--no-grouped', '--type', 'product'
+alias_command 'application diff', 'status', '--diff', '--no-grouped', '--type', 'application'
+alias_command 'product diff', 'status', '--diff', '--no-grouped', '--type', 'product'
 
-alias_command :diff, :status, '--diff', '--no-grouped'
-
-#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/commands/sync.rb

@@ -1,60 +1,99 @@
+# Last Modified: 2017.08.16 /coding: utf-8
+# frozen_string_literal: true
 
-command :syncdown do |c|
-  c.syntax = %{murano syncdown [options] [filters]}
-  c.description = %{Sync project down from Murano}
-  c.option '--all', 'Sync everything'
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
+
+require 'MrMurano/verbosing'
+require 'MrMurano/SyncRoot'
+require 'MrMurano/commands/status'
+
+def sync_add_options(c, locale)
+  c.option '--[no-]delete', %(Don't delete things from #{locale})
+  c.option '--[no-]create', %(Don't create things on #{locale})
+  c.option '--[no-]update', %(Don't update things on #{locale})
+end
 
-  # Load options to control which things to sync
-  MrMurano::SyncRoot.each_option do |s,l,d|
-    c.option s, l, d
+def syncdown_files(options, args=nil)
+  args = [] if args.nil?
+  num_synced = 0
+  MrMurano::SyncRoot.instance.each_filtered(options) do |_name, _type, klass, desc|
+    MrMurano::Verbose.whirly_msg "Syncing #{Inflecto.pluralize(desc)}..."
+    sol = klass.new
+    num_synced += sol.syncdown(options, args)
   end
+  MrMurano::Verbose.whirly_stop
+  num_synced
+end
 
-  c.option '--[no-]delete', %{Don't delete things from server}
-  c.option '--[no-]create', %{Don't create things on server}
-  c.option '--[no-]update', %{Don't update things on server}
+command :syncdown do |c|
+  c.syntax = %(murano syncdown [--options] [filters])
+  c.summary = %(Sync project down from Murano)
+  c.description = %(
+Sync project down from Murano.
+  ).strip
 
-  c.example %{Make local be like what is on the server}, %{murano syncdown --all}
-  c.example %{Pull down new things, but don't delete or modify anything}, %{murano syncdown --all --no-delete --no-update}
-  c.example %{Only Pull new static files}, %{murano syncdown --files --no-delete --no-update}
+  # Add flag: --type [application|product|all].
+  cmd_add_solntype_pickers(c)
 
-  c.action do |args,options|
-    options.default :delete=>true, :create=>true, :update=>true
+  c.option '--all', 'Sync everything'
+  cmd_option_syncable_pickers(c)
+  sync_add_options(c, 'local machine')
 
-    MrMurano::SyncRoot.each_filtered(options.__hash__) do |name, type, klass|
-      sol = klass.new
-      sol.syncdown(options, args)
-    end
+  c.example %(Make local be like what is on the server), %(murano syncdown --all)
+  c.example %(Pull down new things, but don't delete or modify anything), %(murano syncdown --all --no-delete --no-update)
+  c.example %(Only Pull new static files), %(murano syncdown --files --no-delete --no-update)
+
+  c.action do |args, options|
+    # SKIP: c.verify_arg_count!(args)
+    options.default(delete: true, create: true, update: true)
+    cmd_defaults_solntype_pickers(options)
+    cmd_defaults_syncable_pickers(options)
+    syncdown_files(options.__hash__, args)
   end
 end
-alias_command :pull, :syncdown, '--no-delete'
+alias_command 'pull', 'syncdown', '--no-delete'
+alias_command 'pull application', 'syncdown', '--no-delete', '--type', 'application'
+alias_command 'pull product', 'syncdown', '--no-delete', '--type', 'product'
+alias_command 'application pull', 'syncdown', '--no-delete', '--type', 'application'
+alias_command 'product pull', 'syncdown', '--no-delete', '--type', 'product'
 
 command :syncup do |c|
-  c.syntax = %{murano syncup [options] [filters]}
-  c.description = %{Sync project up into Murano}
-  c.option '--all', 'Sync everything'
+  c.syntax = %(murano syncup [--options] [filters])
+  c.summary = %(Sync project up into Murano)
+  c.description = %(
+Sync project up into Murano.
+  ).strip
 
-  # Load options to control which things to sync
-  MrMurano::SyncRoot.each_option do |s,l,d|
-    c.option s, l, d
-  end
-
-  c.option '--[no-]delete', %{Don't delete things from server}
-  c.option '--[no-]create', %{Don't create things on server}
-  c.option '--[no-]update', %{Don't update things on server}
+  # Add flag: --type [application|product|all].
+  cmd_add_solntype_pickers(c)
 
-  c.example %{Deploy project to server}, %{murano syncup --all}
-  c.example %{Update static files}, %{murano syncup --files}
-  c.example %{Only add or modify static files}, %{murano syncup --files --no-delete}
+  c.option '--all', 'Sync everything'
+  cmd_option_syncable_pickers(c)
+  sync_add_options(c, 'server')
 
-  c.action do |args,options|
-    options.default :delete=>true, :create=>true, :update=>true
+  c.example %(Deploy project to server), %(murano syncup --all)
+  c.example %(Update static files), %(murano syncup --files)
+  c.example %(Only add or modify static files), %(murano syncup --files --no-delete)
 
-    MrMurano::SyncRoot.each_filtered(options.__hash__) do |name, type, klass|
+  c.action do |args, options|
+    # SKIP: c.verify_arg_count!(args)
+    options.default(delete: true, create: true, update: true)
+    cmd_defaults_solntype_pickers(options)
+    cmd_defaults_syncable_pickers(options)
+    #MrMurano::Verbose.whirly_start "Syncing solutions..."
+    MrMurano::SyncRoot.instance.each_filtered(options.__hash__) do |_name, _type, klass, desc|
+      MrMurano::Verbose.whirly_msg "Syncing #{Inflecto.pluralize(desc)}..."
       sol = klass.new
       sol.syncup(options, args)
     end
+    MrMurano::Verbose.whirly_stop
   end
 end
-alias_command :push, :syncup, '--no-delete'
+alias_command 'push', 'syncup', '--no-delete'
+alias_command 'push application', 'syncup', '--no-delete', '--type', 'application'
+alias_command 'push product', 'syncup', '--no-delete', '--type', 'product'
+alias_command 'application push', 'syncup', '--no-delete', '--type', 'application'
+alias_command 'product push', 'syncup', '--no-delete', '--type', 'product'
 
-#  vim: set ai et sw=2 ts=2 :

data/lib/MrMurano/commands/timeseries.rb

@@ -1,109 +1,127 @@
+# Last Modified: 2017.08.16 /coding: utf-8
+# frozen_string_literal: true
+
+# Copyright © 2016-2017 Exosite LLC.
+# License: MIT. See LICENSE.txt.
+#  vim:tw=0:ts=2:sw=2:et:ai
+
 require 'csv'
+require 'MrMurano/ReCommander'
 require 'MrMurano/Solution-ServiceConfig'
 
 module MrMurano
   class Timeseries < ServiceConfig
-    def initialize
+    def initialize(sid=nil)
+      # FIXME/2017-07-03: What soln types have timeseries?
+      @solntype = 'application.id'
       super
-      @serviceName = 'timeseries'
+      @service_name = 'timeseries'
     end
 
     def query(query)
-      call(:query, :post, {:q=>query})
+      call(:query, :post, q: query)
     end
 
     def write(writestr)
-      call(:write, :post, { :query=>writestr })
+      call(:write, :post, query: writestr)
     end
 
     def command(cmd)
-      call(:command, :post, { :q=>cmd})
+      call(:command, :post, q: cmd)
     end
-
   end
 end
 
 command :timeseries do |c|
-  c.syntax = %{murano timeseries}
-  c.summary = %{About Timeseries}
-  c.description = %{These commands are deprecated.
+  c.syntax = %(murano timeseries)
+  c.summary = %(About Timeseries)
+  c.description = %(
+These commands are deprecated.
 
 The timeseries sub-commands let you interact directly with the Timeseries
-instance in a solution.  This allows for easier debugging, being able to
-quickly try out different queries or write test data.}
+instance in a solution. This allows for easier debugging, being able to
+quickly try out different queries or write test data.
+  ).strip
 
-  c.action do |args, options|
+  c.action do |_args, _options|
     ::Commander::UI.enable_paging
     say MrMurano::SubCmdGroupHelp.new(c).get_help
   end
 end
 
 command 'timeseries query' do |c|
-  c.syntax = %{murano timeseries query <query string>}
-  c.summary = %{Query the timeseries database}
-  c.description = %{This command is deprecated.
+  c.syntax = %(murano timeseries query <query string>)
+  c.summary = %(Query the timeseries database)
+  c.description = %(
+This command is deprecated.
 
-Query the timeseries database}
-  c.option '-o', '--output FILE', %{Download to file instead of STDOUT}
-  c.option '--[no-]json', %{Display results as raw json}
-  c.option '--[no-]csv', %{Display results as CSV}
+Query the timeseries database.
+  ).strip
+  c.option '-o', '--output FILE', %(Download to file instead of STDOUT)
+  c.option '--[no-]json', %(Display results as raw json)
+  c.option '--[no-]csv', %(Display results as CSV)
 
-  c.action do |args,options|
-    options.defalts :json=>false, :csv=>false
+  c.action do |args, options|
+    # SKIP: c.verify_arg_count!(args)
+    options.defalts json: false, csv: false
     sol = MrMurano::Timeseries.new
     ret = sol.query args.join(' ')
 
     $cfg['tool.outformat'] = 'json' if options.json
     $cfg['tool.outformat'] = 'best csv' if options.csv
 
-    io=nil
-    if options.output then
-      io = File.open(options.output, 'w')
-    end
-
-    sol.outf(ret, io) do |dd, ios|
-      (ret[:results] or []).each do |res|
-        (res[:series] or []).each do |ser|
-          sol.tabularize({
-            :title=>ser[:name],
-            :headers=>ser[:columns],
-            :rows=>ser[:values]
-          }, ios)
+    io = File.open(options.output, 'w') if options.output
+    sol.outf(ret, io) do |_dd, ios|
+      (ret[:results] || []).each do |res|
+        (res[:series] || []).each do |ser|
+          sol.tabularize(
+            {
+              title: ser[:name],
+              headers: ser[:columns],
+              rows: ser[:values],
+            },
+            ios
+          )
         end
       end
     end
     io.close unless io.nil?
-
   end
 end
-alias_command :tsq, 'timeseries query'
+alias_command 'tsq', 'timeseries query'
 
 command 'timeseries write' do |c|
-  c.syntax = %{murano timeseries <write string>}
-  c.summary = %{Write data into the timeseries database}
-  c.description = %{This command is deprecated.
-
-Write data into the timeseries database}
-  c.option '--[no-]json', %{Display results as raw json}
-  c.action do |args,options|
-    options.defalts :json=>false
+  c.syntax = %(murano timeseries <write string>)
+  c.summary = %(Write data into the timeseries database)
+  c.description = %(
+This command is deprecated.
+
+Write data into the timeseries database.
+  ).strip
+  c.option '--[no-]json', %(Display results as raw json)
+  c.action do |args, options|
+    c.verify_arg_count!(args)
+    options.defalts(json: false)
     $cfg['tool.outformat'] = 'json' if options.json
     sol = MrMurano::Timeseries.new
     ret = sol.write args.join(' ')
     sol.outf ret
   end
 end
-alias_command :tsw, 'timeseries write'
+alias_command 'tsw', 'timeseries write'
 
 command 'timeseries command' do |c|
-  c.syntax = %{murano timeseries command <db command>}
-  c.summary = %{Execute a non-query command in the database}
-  c.description = %{This command is deprecated.
-
-Execute a non-query command in the database}
-  c.option '--[no-]json', %{Display results as raw json}
-  c.action do |args,options|
-    options.defalts :json=>false
+  c.syntax = %(murano timeseries command <db command>)
+  c.summary = %(Execute a non-query command in the database)
+  c.description = %(
+This command is deprecated.
+
+Execute a non-query command in the database.
+  ).strip
+  c.option '--[no-]json', %(Display results as raw json)
+  c.action do |args, options|
+    # SKIP: c.verify_arg_count!(args)
+    options.defalts(json: false)
     $cfg['tool.outformat'] = 'json' if options.json
     sol = MrMurano::Timeseries.new
     ret = sol.command args.join(' ')
@@ -111,5 +129,3 @@ Execute a non-query command in the database}
   end
 end
 
-
-#  vim: set ai et sw=2 ts=2 :