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

data/lib/MrMurano/commands/status.rb

@@ -9,6 +9,7 @@ require 'inflecto'
 require 'pathname'
 require 'MrMurano/verbosing'
 require 'MrMurano/SyncRoot'
+require 'MrMurano/commands/solution_picker'
 
 # Load options to control which things to sync
 def cmd_option_syncable_pickers(cmd)
@@ -44,212 +45,247 @@ def cmd_defaults_syncable_pickers(options)
   end
 end
 
-command :status do |c|
-  c.syntax = %(murano status [--options] [filters])
-  c.summary = %(Get the status of files)
-  c.description = %(
-Get the status of files.
+class StatusCmd
+  include MrMurano::Verbose
 
-Compares the local project against what is up in Murano, showing a summary
-of what things are new or changed.
+  STATUS_CMD_DESCRIPTION = %(
+The status command tells you the status of files
+================================================
 
-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.
+Compares the local project against what is up in Murano,
+showing a summary of what things are new or changed.
 
-The diff tool and options to it can be set with the config key 'diff.cmd'.
+With the --diff option, if an item has changes, the remote item and
+local item are passed to a diff tool and that output is displayed.
+
+  - The diff tool and options to it can be set with the config key 'diff.cmd'.
 
 Filters allow for selecting a subset of items to check based on patterns.
 
-File glob filters can be used to select local files. The glob is compared
-with the full file path.
+  - File glob filters can be used to select local files.
+    The glob is compared with the full file path.
 
 Each item type also supports specific filters. These always start with #.
-Endpoints can be selected with a "#<method>#<path glob>" pattern.
-  ).gsub(/^ +/, '').strip
-
-  # Add flag: --type [application|product|all].
-  cmd_add_solntype_pickers(c)
-
-  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
-        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
-      # NOTE: This path is the endpoint path.
-      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)
-      pretty_group_header(
-        ret[:toadd], 'Only on local machine', 'new locally', options.grouped
+  - E.g, Endpoints can be selected with a "#<method>#<path glob>" pattern.
+  ).strip
+
+  def command_status(cmd)
+    cmd.syntax = %(murano status [--options] [filters])
+    cmd.summary = %(Get the status of files)
+    cmd.description = STATUS_CMD_DESCRIPTION
+
+    # Add flag: --type [application|product|all].
+    cmd_add_solntype_pickers(cmd)
+
+    cmd.option '--all', 'Check everything'
+    cmd.option '--[no-]asdown', %(Report as if syncdown instead of syncup)
+    cmd.option '--[no-]asup', %(Report as if syncup instead of syncdown (default: true))
+    cmd.option '--[no-]diff', %(For modified items, show a diff)
+    cmd.option '--[no-]grouped', %(Group all adds, deletes, and mods together)
+    cmd.option '--[no-]show-all', %(List unchanged as well)
+    cmd.option '--[no-]show-type', %(Include type of item)
+    cmd_option_syncable_pickers(cmd)
+
+    cmd.example %(Show item statuses for dirty items:
+    #
+    # - Items that exist locally by not on the remote;
+    # - Items that exist remotely by not on the local;
+    # - Items that have differences between the local and remote sources
+), %(murano status)
+
+    cmd.example %(Show differences between local Services (event handlers)
+    # and those configured on the platform
+), %(murano diff -S)
+
+    cmd.example %(Show differences between local Endpoints and those configured
+    # on the platform but only files starting with "example",
+    # e.g., "endpoints/example1.lua", "endpoints/example-foo.lua", etc.
+    #
+    # NOTE: Use single quotes to prevent shell interpolation of the '*'.
+), %(murano diff -E 'endpoints/example*')
+
+    cmd.example %(Show status of specific files
+), %(murano status services/user.lua endpoints/example.lua)
+
+    cmd.action do |args, options|
+      # SKIP: cmd.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,
       )
-      ret[:toadd].each do |item|
-        interject " + #{item[:pp_type]}  #{highlight_chg(fmtr(item, options))}"
-        pretty_diff(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))}"
-        pretty_diff(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))}"
+      cmd_defaults_solntype_pickers(options)
+      cmd_defaults_syncable_pickers(options)
+
+      @grouped = { toadd: [], todel: [], tomod: [], unchg: [], skipd: [], clash: [] }
+
+      # 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
 
-      unless ret[:clash].empty?
-        pretty_group_header(
-          ret[:clash], 'Conflicting items', 'in conflict', options.grouped
-        )
-        ret[:clash].each do |item|
-          abbrev = $cfg['tool.ascii'] && 'x' || '✗'
-          interject " #{abbrev} #{item[:pp_type]}  #{highlight_del(fmtr(item, 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
 
-      return unless options.show_all
-      interject 'Unchanged:' if options.grouped
-      ret[:unchg].each { |item| interject "   #{item[:pp_type]}  #{fmtr(item, options)}" }
+      pretty(@grouped, options) if options.grouped
     end
+  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
+  def interject(msg)
+    MrMurano::Verbose.whirly_interject { say msg }
+  end
 
-    def pretty_diff(item, options)
-      return unless options.diff && $cfg['tool.verbose'] && !item[:diff].empty?
-      interject item[:diff]
+  def pretty(ret, options)
+    pretty_group_header(
+      ret[:toadd], 'Only on local machine', 'new locally', options.grouped
+    )
+    ret[:toadd].each do |item|
+      interject " + #{item[:pp_type]}  #{highlight_chg(item[:locus])}"
+      pretty_diff(item, options)
     end
 
-    def highlight_chg(msg)
-      Rainbow(msg).green.bright
+    pretty_group_header(
+      ret[:todel], 'Only on remote server', 'new remotely', options.grouped
+    )
+    ret[:todel].each do |item|
+      interject " - #{item[:pp_type]}  #{highlight_del(item[:locus])}"
+      pretty_diff(item, options)
     end
 
-    def highlight_del(msg)
-      Rainbow(msg).red.bright
+    pretty_group_header(
+      ret[:tomod], 'Items that differ', 'that differs', options.grouped
+    )
+    ret[:tomod].each do |item|
+      interject " M #{item[:pp_type]}  #{highlight_chg(item[:locus])}"
+      interject item[:diff] if options.diff
     end
 
-    @grouped = { toadd: [], todel: [], tomod: [], unchg: [], skipd: [], clash: [] }
-    def gmerge(ret, type, desc, options)
-      if options.grouped
-        out = @grouped
-      else
-        out = { toadd: [], todel: [], tomod: [], unchg: [], skipd: [], clash: [] }
+    # 2018-04-24: (lb): If one or the other solutions is not setup (app or prod)
+    # don't care, and don't indicate to user that missing soln's items are dirty.
+    # MAYBE: (lb): We can probably delete this comment. Keeping until more confident.
+    #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(item[:locus])}"
+    #  end
+    #end
+
+    unless ret[:clash].empty?
+      pretty_group_header(
+        ret[:clash], 'Conflicting items', 'in conflict', options.grouped
+      )
+      ret[:clash].each do |item|
+        abbrev = $cfg['tool.ascii'] && 'x' || '✗'
+        interject " #{abbrev} #{item[:pp_type]}  #{highlight_del(item[:locus])}"
       end
+    end
 
-      %i[toadd todel tomod unchg skipd clash].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
+    return unless options.show_all
+    interject 'Unchanged:' if options.grouped
+    ret[:unchg].each { |item| interject "   #{item[:pp_type]}  #{item[:locus]}" }
+  end
 
-      pretty(out, options) unless options.grouped
+  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
 
-    # *** Method code starts here ***
+  def pretty_diff(item, options)
+    return unless options.diff && $cfg['tool.verbose']
+    return unless !item[:diff].nil? && !item[:diff].empty?
+    interject item[:diff]
+  end
 
-    # 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
+  def highlight_chg(msg)
+    Rainbow(msg).green.bright
+  end
+
+  def highlight_del(msg)
+    Rainbow(msg).red.bright
+  end
+
+  def gmerge(ret, type, desc, options)
+    if options.grouped
+      out = @grouped
     else
-      raise('Unexpected code path.')
+      out = { toadd: [], todel: [], tomod: [], unchg: [], skipd: [], clash: [] }
     end
 
-    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)
+    %i[toadd todel tomod unchg skipd clash].each do |kind|
+      ret[kind].each do |item|
+        hitem = item.to_h
+        hitem[:pp_type] = type
+        hitem[:pp_desc] = desc
+        hitem[:locus] = item.location_friendly(show_type: options.show_type)
+        out[kind] << hitem
       end
     end
-    MrMurano::Verbose.whirly_stop
 
-    pretty(@grouped, options) if options.grouped
+    pretty(out, options) unless options.grouped
   end
+end # StatusCmd
+
+def wire_cmd_status
+  status_cmd = StatusCmd.new
+
+  command(:status) { |cmd| status_cmd.command_status(cmd) }
+  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',
+  )
 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'
+
+wire_cmd_status
 

data/lib/MrMurano/commands/sync.rb

@@ -7,13 +7,14 @@
 
 require 'MrMurano/verbosing'
 require 'MrMurano/SyncRoot'
+require 'MrMurano/commands/solution_picker'
 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})
-  c.option '--ignore-errors', %(Don't die on sync errors)
+def sync_add_options(cmd, locale)
+  cmd.option '--[no-]delete', %(Don't delete things from #{locale})
+  cmd.option '--[no-]create', %(Don't create things on #{locale})
+  cmd.option '--[no-]update', %(Don't update things on #{locale})
+  cmd.option '--ignore-errors', %(Don't die on sync errors)
 end
 
 def syncdown_files(options, args=nil)
@@ -28,26 +29,40 @@ def syncdown_files(options, args=nil)
   num_synced
 end
 
-command :syncdown do |c|
-  c.syntax = %(murano syncdown [--options] [filters])
-  c.summary = %(Sync project down from Murano)
-  c.description = %(
+command :syncdown do |cmd|
+  cmd.syntax = %(murano syncdown [--options] [filters])
+  cmd.summary = %(Sync project down from Murano)
+  cmd.description = %(
 Sync project down from Murano.
   ).strip
 
   # Add flag: --type [application|product|all].
-  cmd_add_solntype_pickers(c)
+  cmd_add_solntype_pickers(cmd)
 
-  c.option '--all', 'Sync everything'
-  cmd_option_syncable_pickers(c)
-  sync_add_options(c, 'local machine')
+  cmd.option '--all', 'Sync everything'
+  cmd_option_syncable_pickers(cmd)
+  sync_add_options(cmd, 'local machine')
 
-  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)
+  cmd.example %(Make local be like what is on the server
+), %(murano syncdown --all)
 
-  c.action do |args, options|
-    # SKIP: c.verify_arg_count!(args)
+  cmd.example %(Pull down new things, but don't delete or modify anything
+), %(murano syncdown --all --no-delete --no-update)
+
+  cmd.example %(Only pull down new static files
+), %(murano syncdown --assets --no-delete --no-update)
+
+  cmd.example %(Only pull down Endpoints whose filename starts with "example",
+    # e.g., "endpoints/example1.lua", "endpoints/example-foo.lua", etc.
+    #
+    # NOTE: Use single quotes to prevent shell interpolation of the '*'.
+), %(murano syncdown -E 'endpoints/example*')
+
+  cmd.example %(Only pull down specific files
+), %(murano syncdown services/user.lua endpoints/example.lua)
+
+  cmd.action do |args, options|
+    # SKIP: cmd.verify_arg_count!(args)
     options.default(delete: true, create: true, update: true)
     cmd_defaults_solntype_pickers(options)
     cmd_defaults_syncable_pickers(options)
@@ -60,36 +75,53 @@ 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.summary = %(Sync project up into Murano)
-  c.description = %(
+def syncup_files(options, args=nil)
+  MrMurano::SyncRoot.instance.each_filtered(options) 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
+
+command :syncup do |cmd|
+  cmd.syntax = %(murano syncup [--options] [filters])
+  cmd.summary = %(Sync project up into Murano)
+  cmd.description = %(
 Sync project up into Murano.
   ).strip
 
   # Add flag: --type [application|product|all].
-  cmd_add_solntype_pickers(c)
+  cmd_add_solntype_pickers(cmd)
+
+  cmd.option '--all', 'Sync everything'
+  cmd_option_syncable_pickers(cmd)
+  sync_add_options(cmd, 'server')
+
+  cmd.example %(Deploy project to server
+), %(murano syncup --all)
+
+  cmd.example %(Update static files
+), %(murano syncup --assets)
+
+  cmd.example %(Only add or modify static files
+), %(murano syncup --assets --no-delete)
 
-  c.option '--all', 'Sync everything'
-  cmd_option_syncable_pickers(c)
-  sync_add_options(c, 'server')
+  cmd.example %(Only update Endpoints whose filename starts with "example",
+    # e.g., "endpoints/example1.lua", "endpoints/example-foo.lua", etc.
+    #
+    # NOTE: Use single quotes to prevent shell interpolation of the '*'.
+), %(murano syncup -E 'endpoints/example*')
 
-  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)
+  cmd.example %(Only update specific files
+), %(murano syncup services/user.lua endpoints/example.lua)
 
-  c.action do |args, options|
-    # SKIP: c.verify_arg_count!(args)
+  cmd.action do |args, options|
+    # SKIP: cmd.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
+    syncup_files(options.__hash__, args)
   end
 end
 alias_command 'push', 'syncup', '--no-delete'