cl-magic 0.4.0 → 1.2.1

data/lib/cl/magic/cl-dk-make-world

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+# cli for your world
+require 'yaml'
+require 'optparse'
+require 'optparse/subcommand'
+require 'tty-command'
+
+require 'cl/magic/common/common_options.rb'
+require 'cl/magic/common/logging.rb'
+
+require_relative 'dk/help_printer'
+require_relative 'dk/world_settings'
+
+@logger = get_logger()
+@cl_cmd_name = File.basename(__FILE__).split('-').join(' ')
+
+def print_make_help(dk_make_hash)
+  if $stdout.isatty
+    puts ""
+    puts "Usage: dk make-world COMMAND"
+    puts ""
+    puts "Make commands for your world"
+    puts ""
+    puts "Commands:"
+    dk_make_hash.keys.each do |key|
+      @help_printer.print_dk_help_line(key, dk_make_hash[key].fetch('help'))
+    end
+    puts ""
+  else
+    dk_make_hash.keys.each do |key|
+      puts key
+    end
+  end
+end
+
+def run_dk_make(final_args, dk_make_hash)
+
+  # print help?
+  if final_args.empty?
+    print_make_help(dk_make_hash)
+  else
+
+    #
+    # supports running multiple commands in a row
+    # ex. dk make down up
+    #
+
+    final_args.each_with_index do |key, i|
+
+      if not dk_make_hash.has_key?(key)
+        @logger.error "#{key} - command not found"
+        exit 1
+      else
+
+        all_commands = dk_make_hash[key]["commands"]
+
+        #
+        # all commands run in a subprocess except the last one, so
+        # the last command can run in the forground and be
+        # interactive (ex. dk make down up bash)
+        #
+
+        # construct last command
+        last_cmd = if final_args.length == i+1
+          all_commands.pop
+        else
+          nil
+        end
+
+        # run background commands
+        all_commands.each do |c|
+          cmd = prep_make_command(c)
+          puts `#{cmd}`  # run in sub-process
+        end
+
+        # run last command in foreground
+        if last_cmd
+          cmd = prep_make_command(last_cmd)
+          exec(cmd)
+        end
+      end
+    end
+
+  end
+end
+
+def prep_make_command(c)
+  # logging
+  @logger.puts "" if $stdout.isatty
+  @logger.wait(c.gsub("cl dk", "dk"))
+
+  # run command - from world path
+  cmd = "cd #{@world_path} && WORKING_DIR=#{@working_dir} #{c}"
+end
+
+#
+# Features
+#
+
+def do_work()
+
+  # world yaml
+  world_yaml_filepath = File.join(@world_path, "world.yml")
+  if File.exist?(world_yaml_filepath)
+
+    # read file, replace & yaml load
+    contents = File.read(world_yaml_filepath)
+    contents.gsub!('<dk-working-path>', @working_dir)
+    yml_hash = YAML.load(contents)
+
+    # run command
+    if yml_hash and yml_hash.key? "x-dk-make-world"
+      run_dk_make(ARGV, yml_hash["x-dk-make-world"])
+    else
+      @logger.puts ""
+      @logger.warn "no commands available"
+      @logger.info "#{world_yaml_filepath}"
+      @logger.puts ""
+    end
+  else
+    @logger.puts ""
+    @logger.warn "Current world context has no world.yml"
+    @logger.info "#{world_path}"
+    @logger.puts ""
+  end
+end
+
+#
+# Options
+#
+
+
+options = {}
+global_banner = <<DOC
+
+ Dk make world
+
+ Usage: #{@cl_cmd_name} [options]
+
+DOC
+
+
+global = OptionParser.new do |g|
+  g.banner = global_banner
+  add_help_and_verbose(g)
+end
+
+#
+# Run
+#
+
+@working_dir = ENV['CL_WORKING_DIR'] # passed through cl-magic to here
+
+global.parse(ARGV)
+
+# utils
+@world_settings = WorldSettings.new(@working_dir)
+@help_printer = HelpPrinter.new(@logger)
+
+# world path
+@world_path = @world_settings.get_world_path_from_settings()
+
+do_work()

data/lib/cl/magic/cl-dk-parts

@@ -0,0 +1,261 @@
+#!/usr/bin/env ruby
+# set, list and clear parts for a compose project
+require 'yaml'
+require 'optparse'
+require 'optparse/subcommand'
+require 'tty-command'
+
+require 'cl/magic/common/common_options.rb'
+require 'cl/magic/common/logging.rb'
+require 'cl/magic/common/parse_and_pick.rb'
+
+require_relative 'dk/help_printer'
+require_relative 'dk/yaml_arg_munger'
+require_relative 'dk/world_settings'
+require_relative 'dk/parts_merger'
+
+@logger = get_logger()
+@cl_cmd_name = File.basename(__FILE__).split('-').join(' ')
+
+def get_save_parts_filepath()
+  return File.join(@working_dir, ".cl-dk-parts.yml")
+end
+
+def yield_all_parts
+
+  # utils
+  @help_printer = HelpPrinter.new(@logger)
+  @world_settings = WorldSettings.new(@working_dir)
+  @yaml_arg_munger = YamlArgMunger.new(@working_dir, @world_settings)
+  @parts_merger = PartsMerger.new(@working_dir, @yaml_arg_munger, @help_printer, @logger)
+
+  # world files
+  compose_hash, dk_parts_hash, dk_make_hash = @yaml_arg_munger.get_base_compose_parts_and_make_hashes()
+  if compose_hash
+    yield dk_parts_hash
+  else
+    @logger.error "no docker configuration found"
+    exit 1
+  end
+end
+
+#
+# Features
+#
+
+def do_set(options)
+
+  yield_all_parts do |dk_parts_hash|
+    parts = ARGV[1..]
+
+    if parts.any? or options[:action] == :set
+
+      # validate parts
+      parts.each do |part|
+        unless dk_parts_hash.include? part
+          puts ""
+          @logger.error "invalid part: #{part}"
+          @logger.info "allowed parts: #{dk_parts_hash.keys.join(", ")}"
+          puts ""
+          exit 1
+        end
+      end
+
+      create_file_unless_exists(options)
+
+      # save parts
+      filepath = get_save_parts_filepath()
+      parts = ARGV[1..]
+      case options[:action]
+      when :set
+        unless parts.any?
+          options = dk_parts_hash.keys.collect {|k| [k.ljust(25, ' '), dk_parts_hash[k]['help'].rjust(25, ' ')]}
+          selected_parts = pick_multiple_result(options, "Which parts?", nil, false)
+          parts = selected_parts.collect {|o| o.first.strip}
+        end
+        File.open(filepath, 'w') { |file| file.write(parts.to_yaml) }
+        @logger.success "parts set"
+      when :add
+        data = YAML.load_file(filepath)
+        parts.each {|p| data << p}
+        File.open(filepath, 'w') { |file| file.write(data.uniq.to_yaml) }
+        @logger.success "parts added"
+      when :remove
+        data = YAML.load_file(filepath)
+        data.reject! { |p| parts.include?(p) }
+        File.open(filepath, 'w') { |file| file.write(data.to_yaml) }
+        @logger.success "parts removed"
+      end
+    else
+      @logger.warn "you didn't pass any parts to set"
+      exit 1
+    end
+    exit
+
+  end
+
+end
+
+def create_file_unless_exists(options)
+  filepath = get_save_parts_filepath()
+  unless File.exist?(filepath)
+    File.open(filepath, 'w') { |file| file.write([].to_yaml) }
+  end
+end
+
+def do_clear(options)
+  filepath = get_save_parts_filepath()
+  if File.exist?(filepath)
+    File.delete(filepath)
+    @logger.info "parts cleared"
+  end
+end
+
+def get_saved_parts()
+  filepath = get_save_parts_filepath()
+  return YAML.load_file(filepath) if File.exist?(filepath)
+  return []
+end
+
+def do_list_saved_parts(options)
+
+  is_tty = $stdout.isatty
+
+  yield_all_parts do |dk_parts_hash|
+
+    saved_parts = get_saved_parts()
+    if saved_parts.any?
+      puts "" if is_tty
+      dk_parts_hash.keys.each do |part|
+        if is_tty
+          part_desc = "#{part.ljust(27, ' ')} | #{dk_parts_hash[part]['help']}"
+          if saved_parts.include? part
+            puts "* #{part_desc}"
+          else
+            puts "  #{part_desc}"
+          end
+        else
+          puts part if saved_parts.include? part # terminal only
+        end
+      end
+      puts "" if is_tty
+    else
+      if is_tty
+        puts ""
+        @logger.info "no saved parts"
+        puts ""
+        dk_parts_hash.keys.each do |part|
+          puts "  #{part}"
+        end
+        puts ""
+      end
+    end
+  end
+end
+
+#
+# Options
+#
+
+options = {}
+global_banner = <<DOC
+
+ Dk parts
+
+ Usage: #{@cl_cmd_name} [options]
+
+DOC
+
+dk_parts_set_banner = <<DOC
+
+ Set parts
+
+ Usage: #{@cl_cmd_name} set [options]
+
+DOC
+
+dk_parts_add_banner = <<DOC
+
+ Add parts
+
+ Usage: #{@cl_cmd_name} set [options]
+
+DOC
+
+dk_parts_remove_banner = <<DOC
+
+ Remove parts
+
+ Usage: #{@cl_cmd_name} set [options]
+
+DOC
+
+dk_parts_clear_banner = <<DOC
+
+ Clear parts
+
+ Usage: #{@cl_cmd_name} set [options]
+
+DOC
+
+dk_parts_list_banner = <<DOC
+
+ List saved parts
+
+ Usage: #{@cl_cmd_name} set [options]
+
+DOC
+
+global = OptionParser.new do |g|
+  g.banner = global_banner
+  add_help_and_verbose(g)
+
+  g.subcommand 'set' do |s|
+    s.banner = dk_parts_set_banner
+    options[:action] = :set
+  end
+
+  g.subcommand 'add' do |s|
+    s.banner = dk_parts_set_banner
+    options[:action] = :add
+  end
+
+  g.subcommand 'remove' do |s|
+    s.banner = dk_parts_set_banner
+    options[:action] = :remove
+  end
+
+  g.subcommand 'clear' do |s|
+    s.banner = dk_parts_clear_banner
+    options[:action] = :clear
+  end
+
+  g.subcommand 'list' do |s|
+    s.banner = dk_parts_list_banner
+    options[:action] = :list
+  end
+
+end
+
+#
+# Run
+#
+
+@working_dir = ENV['CL_WORKING_DIR'] # passed through cl-magic to here
+
+global.parse(ARGV)
+
+case options[:action]
+when :set
+  do_set(options)
+when :add
+  do_set(options)
+when :remove
+  do_set(options)
+when :clear
+  do_clear(options)
+when :list
+  do_list_saved_parts(options)
+else
+  puts global.parse! %w[--help]
+end

data/lib/cl/magic/cl-dk-world

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+# set world and context for dk tool
+require 'yaml'
+require 'optparse'
+require 'optparse/subcommand'
+require 'tty-command'
+
+require 'cl/magic/common/common_options.rb'
+require 'cl/magic/common/parse_and_pick.rb'
+require 'cl/magic/common/logging.rb'
+
+require_relative 'dk/world_settings'
+
+@logger = get_logger()
+@cl_cmd_name = File.basename(__FILE__).split('-').join(' ')
+
+#
+# Features
+#
+
+def set(options, world_settings)
+  world_settings_hash = world_settings.get_world_settings_hash()
+
+  # world path
+  world_path = options[:world_path]
+
+  if world_path.start_with?("/") or world_path.start_with?("~")
+    world_path = File.expand_path(world_path)
+  else
+    world_path = File.expand_path(File.join(@working_dir, world_path))
+  end
+
+  if TTY::Prompt.new.yes?("Set world to: #{world_path}?")
+    world_settings_hash[:world_path] = world_path
+    world_settings.save_world_settings(world_settings_hash)
+    switch_context(world_settings)
+  else
+    exit
+  end
+
+end
+
+def switch_context(world_settings)
+  world_settings_hash = world_settings.get_world_settings_hash()
+  unless world_settings_hash[:world_path] and File.directory?(world_settings_hash[:world_path])
+    @logger.error "no world path set."
+    exit 1
+  end
+
+  # read folder from world path (aka. context)
+  all_dir = Dir.chdir(world_settings_hash[:world_path]) do
+    Dir.glob('*').select { |f| File.directory? f and f != "common" }
+  end
+  selected_dir = pick_single_result(all_dir.collect {|f| [f]}, "select context").first
+  world_settings_hash[:context] = selected_dir
+  world_settings.save_world_settings(world_settings_hash)
+
+  @logger.puts "world set!"
+  exit
+end
+
+#
+# Options
+#
+
+
+options = {}
+global_banner = <<DOC
+
+ Dk world
+
+ Usage: #{@cl_cmd_name} [options]
+
+DOC
+
+dk_world_set_banner = <<DOC
+
+ Set world
+
+ Usage: #{@cl_cmd_name} set [options]
+
+DOC
+
+dk_world_switch_context_banner = <<DOC
+
+ Set context
+
+ Usage: #{@cl_cmd_name} switch_context [options]
+
+DOC
+
+
+global = OptionParser.new do |g|
+  g.banner = global_banner
+  add_help_and_verbose(g)
+
+  g.subcommand 'set' do |s|
+    s.banner = dk_world_set_banner
+    options[:action] = :set
+
+    s.on("-p", "--path PATH", "path to world folder") do |v|
+      options[:world_path] = v
+    end
+  end
+
+  g.subcommand 'switch_context' do |s|
+    s.banner = dk_world_switch_context_banner
+    options[:action] = :switch_context
+  end
+
+end
+
+#
+# Run
+#
+
+@working_dir = ENV['CL_WORKING_DIR'] # passed through cl-magic to here
+
+global.parse(ARGV)
+
+world_settings = WorldSettings.new(@working_dir)
+
+case options[:action]
+when :set
+  if options[:world_path].nil?
+    @logger.error("missing --path")
+    exit 1
+  end
+
+  history_command = """#{@cl_cmd_name} world set \\
+  --path #{options[:world_path]}
+"""
+  write_history(history_command)
+
+  set(options, world_settings)
+when :switch_context
+  switch_context(world_settings)
+else
+  puts global.parse! %w[--help]
+end

data/lib/cl/magic/cl-jira-fetch

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# Fetch jira issues, status changelogs and save them to a file
+# Fetch jira issues by jql
 require 'optparse'
 require 'optparse/subcommand'
 require 'tty-command'
@@ -23,43 +23,25 @@ def do_work(options)
   break_at_one_page = false # when developing, set this to true
   jira = Jira.new options[:base_uri], options[:username], options[:token], break_at_one_page
 
-  puts ""
-  @logger.wait "fetch epics"
-  epic_ids, epics = jira.get_epic_ids(options[:project], options[:epic_wildcard])
-  @logger.success "#{epic_ids.count} epics"
-
-  puts ""
+  @logger.puts ""
   @logger.wait "fetch issues"
-  issues = jira.get_issues(options[:project], epic_ids)
-  @logger.success "#{issues.count} issues"
-
-  puts ""
-  @logger.wait "fetch & merge change logs"
-  issues = collect_status_changelogs(jira, issues, options)
-  @logger.success ""
-
-  puts ""
-  @logger.wait "saving file"
-  output_filepath = File.join(@working_dir, options[:output_filename])
-  File.open(output_filepath, 'w') do |file|
-    issues.each do |o|
-      file.puts(o.to_json)
-    end
-  end
+  issues = jira.run_jql_query(options[:jql])
+
+  @logger.puts ""
+  @logger.wait "fetch & merge comments"
+  issues = jira.collect_comments(jira, issues)
 
-  @logger.success " #{output_filepath}"
+  puts issues.to_json
 end
 
 #
 # Options
 #
 
-options = {
-  output_filename: "jira-fetch-#{Time.now.strftime("%Y%m%d%H%M%S")}.datafile"
-}
+options = {}
 global_banner = <<DOC
 
-Fetch jira issues, status changelogs and save them to a file
+Fetch jira issues and their comments
 
  Usage: #{@cl_cmd_name} [options]
 
@@ -81,18 +63,6 @@ global = OptionParser.new do |g|
     options[:token] = v
   end
 
-  g.on("-p", "--project KEY", "jira project to fetch from") do |v|
-    options[:project] = v
-  end
-
-  g.on("-w", "--epic-wildcard TEXT", "wildcard to filter the epics by") do |v|
-    options[:epic_wildcard] = v
-  end
-
-  g.on("-f", "--output-filename NAME", "the name of the output file (defaults to jira-fetch-timestamp.datafile)") do |v|
-    options[:output_filename] = v
-  end
-
 end
 
 #
@@ -100,7 +70,8 @@ end
 #
 
 @working_dir = ENV['CL_WORKING_DIR'] # passed through cl-magic to here
-global.parse(ARGV)
+global.parse!(ARGV)
+options[:jql] = ARGV.join(' ')
 
 # error on token right away
 if options[:token].nil?
@@ -111,17 +82,14 @@ end
 # prompt for missing options
 ask_and_store_option(options, :base_uri, "base_uri: ")
 ask_and_store_option(options, :username, "username: ")
-ask_and_store_option(options, :project, "project: ")
-ask_and_store_option(options, :epic_wildcard, "epic_wildcard: ")
-ask_and_store_option(options, :output_filename, "output_filename: ")
+ask_and_store_option(options, :jql, "jql: ")
 
 # display full command
 write_history("""#{@cl_cmd_name} \\
   --base-uri=#{options[:base_uri]} \\
   --username=#{options[:username]} \\
-  --project=#{options[:project]} \\
-  --epic-wildcard=#{options[:epic_wildcard]} \\
-  --token
+  --token REDACTED \\
+  -- #{options[:jql]}
 """)
 
 do_work(options)