cl-magic 0.4.0 → 1.2.0

data/lib/cl/magic/cl-dk

@@ -10,101 +10,18 @@ require 'cl/magic/common/common_options.rb'
 require 'cl/magic/common/logging.rb'
 require 'cl/magic/common/parse_and_pick.rb'
 
-@logger = get_logger()
-
-#
-# Util Methods
-#
-
-def get_base_compose_hash()
-  cmd = "cd #{@working_dir} && docker compose config 2> /dev/null"
-  return YAML.load(`#{cmd}`)
-end
-
-def get_save_parts_filepath()
-  return File.join(@working_dir, ".cl-dk-parts.yml")
-end
+require_relative 'dk/help_printer'
+require_relative 'dk/yaml_arg_munger'
+require_relative 'dk/world_settings'
+require_relative 'dk/parts_merger'
 
-def get_base_compose_parts_and_make_hashes()
-  compose_hash = get_base_compose_hash()
-  dk_parts_hash = {}
-  dk_make_hash = {}
-  if compose_hash
-    compose_hash = merge_world_files(compose_hash, show_help=ARGV.include?("--help"))
-    dk_parts_hash = compose_hash['x-dk-parts'] ? compose_hash.delete('x-dk-parts') : {}
-    dk_make_hash = compose_hash['x-dk-make'] ? compose_hash.delete('x-dk-make') : {}
-  end
-  return compose_hash, dk_parts_hash, dk_make_hash
-end
-
-# world
-
-def get_repo_basename()
-  command = "cd #{@working_dir} && basename $(git remote get-url origin 2> /dev/null) .git"
-  repo_basename = TTY::Command.new(:printer => :null).run(command).out.gsub('.git', '').strip.chomp
-  if repo_basename==".git" or repo_basename==""
-    return File.basename(@working_dir)
-  end
-  return repo_basename
-end
-
-def get_world_settings_filepath()
-  return File.join(".cl-dk-world.yml")
-end
-
-def get_world_settings_hash()
-  filepath = get_world_settings_filepath()
-  return File.exist?(filepath) ? YAML.load_file(filepath) : {}
-end
-
-def get_world_path_from_settings()
-  world_settings = get_world_settings_hash()
-  if world_settings.key?(:world_path) and world_settings.key?(:context)
-    return File.join(world_settings[:world_path], world_settings[:context])
-  end
-  return ""
-end
-
-def save_world_settings(world_settings_hash)
-  filepath = get_world_settings_filepath()
-  tempfile = File.new(filepath, 'w')
-  tempfile.write(world_settings_hash.to_yaml)
-  tempfile.close
-end
-
-def get_world_project_path()
-  repo_basename = get_repo_basename()
-  world_path = get_world_path_from_settings()
-  return File.join(world_path, repo_basename) if world_path and repo_basename
-  return nil
-end
+@logger = get_logger()
 
 #
 # Help Methods
 #
 
-def print_dk_help_line(key, help)
-  if $stdout.isatty
-    if help.nil?
-      @logger.puts("#{key.ljust(15, ' ')} ???no help???")
-    else
-      key = key.ljust(15, ' ')
-      help_parts = help.split(";")
-
-      # first line
-      @logger.puts(key, help_parts.shift)
-
-      # following lines
-      padding = "".ljust(15, ' ')
-      help_parts.each do |p|
-        @logger.puts(padding, p)
-      end
-      @logger.puts("") if help.end_with?(";")
-    end
-  end
-end
-
-def print_dk_help(dk_parts_hash, dk_make_hash, args)
+def try_print_dk_help(dk_parts_hash, dk_make_hash, args)
   no_args = args.empty?()
   asked_for_help = args.include?('--help')
   has_dk_commands = dk_parts_hash.keys.any?
@@ -115,15 +32,9 @@ def print_dk_help(dk_parts_hash, dk_make_hash, args)
     puts ""
     puts "Run docker compose while munging yamls in sophisticated ways."
     puts ""
-    if get_repo_basename
-      puts "PROJ INFO"
-      puts " - Repo basename:       #{get_repo_basename}"
-      puts " - World filepath:      #{get_world_project_path()}"
-      puts ""
-    end
     puts "PROJ PARTS"
     dk_parts_hash.keys.each do |key|
-      print_dk_help_line(key, dk_parts_hash[key].fetch('help'))
+      @help_printer.print_dk_help_line(key, dk_parts_hash[key].fetch('help'))
     end
     puts ""
     puts "YML TOKENS"
@@ -133,208 +44,10 @@ def print_dk_help(dk_parts_hash, dk_make_hash, args)
     puts "  - <dk-project-path>   absolute filepath to world/project directory"
     puts "  - <dk-working-path>   absolute filepath to location dk command was run from"
     puts ""
-    puts "ADDITIONAL TURNKEY COMMANDS"
-    puts " - dk set-world         sets the location of the world directory"
-    puts " - dk make              turnkey commands for a project"
-    puts " - dk set-parts        save parts so they are automatically applied to commands"
-    puts ""
     puts "-------------------------"
   end
 end
 
-def print_make_help(dk_parts_hash, dk_make_hash)
-  if $stdout.isatty
-    puts ""
-    puts "Usage: dk [DK_PARTS] make COMMAND"
-    puts ""
-    puts "Make commands designed to make your developer experience more turnkey"
-    puts ""
-    puts "Parts:"
-    dk_parts_hash.keys.each do |key|
-      print_dk_help_line(key, dk_parts_hash[key].fetch('help'))
-    end
-    puts ""
-    puts "Commands:"
-    dk_make_hash.keys.each do |key|
-      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 print_set_world_help()
-  puts ""
-  puts "Usage: dk set-world PATH"
-  puts ""
-  puts "Set the folder that contains dk-world configuration"
-  puts ""
-end
-
-def print_set_parts_help()
-  compose_hash, dk_parts_hash, dk_make_hash = get_base_compose_parts_and_make_hashes()
-
-  # print help
-  puts ""
-  puts "Usage: dk [DK_PARTS] set-parts"
-  puts ""
-  puts "Set parts for a project and apply to every 'dk' command"
-  puts ""
-  if dk_parts_hash.keys.any?
-    puts "Parts:"
-    dk_parts_hash.keys.each do |key|
-      print_dk_help_line(key, dk_parts_hash[key].fetch('help'))
-    end
-    puts ""
-  end
-end
-
-#
-# Yaml Merging
-#
-
-class ::Hash
-  def dk_merge(second)
-    merger = proc { |_, v1, v2|
-      if Hash === v1 && Hash === v2
-        v1.merge(v2, &merger)
-      else
-        if Array === v1 && Array === v2
-          if v2.first=="<dk-replace>"
-            v2[1..-1] # everything but the first item
-          else
-            v1 | v2 # union arrays
-          end
-        else
-          if [:undefined, nil, :nil].include?(v2)
-            v1
-          else
-            v2
-          end
-        end
-      end
-    }
-    merge(second.to_h, &merger)
-  end
-  def dk_reject!(&blk)
-    self.each do |k, v|
-      v.dk_reject!(&blk)  if v.is_a?(Hash)
-      self.delete(k)  if blk.call(k, v)
-    end
-  end
-end
-
-def dk_merge_and_remove(compose_hash, yml_hash)
-  # remove help & merge
-  clean_yml = yml_hash.clone
-  clean_yml.delete('help')
-  return compose_hash.dk_merge(clean_yml).dk_reject! { |k, v| v=='<dk-remove>' }
-end
-
-def merge_world_files(compose_hash, show_help=false)
-  dk_proj_path = get_world_project_path()
-  if dk_proj_path
-    print_dk_help_line("dk-project-path", "#{dk_proj_path}") if show_help and $stdout.isatty
-
-    Dir.glob("#{dk_proj_path}/*.yml").sort.each do |filepath|
-      print_dk_help_line("dk-world", "#{filepath}") if show_help and $stdout.isatty
-
-      # read file and replace
-      contents = File.read(filepath)
-      contents.gsub!('<dk-world-path>', get_world_path_from_settings())
-      contents.gsub!('<dk-project-path>', dk_proj_path)
-      contents.gsub!('<dk-working-path>', @working_dir)
-
-      # yml merge
-      yml_hash = YAML.load(contents)
-      compose_hash = dk_merge_and_remove(compose_hash, yml_hash)
-    end
-  end
-  return compose_hash
-end
-
-def get_saved_parts(dk_parts_hash)
-  saved_part_keys = []
-  filepath = get_save_parts_filepath()
-
-  # merge
-  if File.exist?(filepath)
-    saved_parts = YAML.load_file(filepath)
-    saved_parts.each do |potential_part_key|
-      dk_part = dk_parts_hash.fetch(potential_part_key, nil) # yml detail
-      if dk_part
-        saved_part_keys << potential_part_key
-      else
-        @logger.error "invalid saved part: #{potential_part_key}"
-        exit 1
-      end
-    end
-  end
-  return saved_part_keys
-end
-
-def merge_parts_save_and_prep_args(compose_hash, dk_parts_hash, dk_make_hash, saved_part_keys)
-  tempfile = File.new(File.join(@working_dir, ".cl-dk.yml"), 'w')
-  args = ARGV.clone
-
-  # dk help
-  print_dk_help(dk_parts_hash, dk_make_hash, args)
-
-  def print_and_merge_part(part_key, dk_part, compose_hash)
-
-    # print
-    if $stdout.isatty
-      help_str = dk_part.fetch('help')
-      print_dk_help_line("#{part_key}", "#{help_str ? '- ' + help_str : ''}") if dk_part.keys.any?
-    end
-    # merge
-    return dk_merge_and_remove(compose_hash, dk_part)
-  end
-
-  # saved parts
-  saved_part_keys.each do |potential_part_key|
-    dk_part = dk_parts_hash.fetch(potential_part_key, nil) # yml detail
-    compose_hash = print_and_merge_part(potential_part_key, dk_part, compose_hash) if dk_part
-  end
-
-  # arg parts
-  selected_part_keys = []
-  while true
-    potential_part_key = args.first
-    dk_part = dk_parts_hash.fetch(potential_part_key, nil) # yml detail
-    if dk_part
-
-      # unless already applied
-      unless saved_part_keys.include?(potential_part_key)
-        compose_hash = print_and_merge_part(potential_part_key, dk_part, compose_hash)
-      end
-      selected_part_keys << potential_part_key
-      args.shift # remove part arg
-    else
-      break
-    end
-  end
-  @logger.puts "" if $stdout.isatty     # tailing line break
-  tempfile.write(compose_hash.to_yaml)  # write it to the tempfile
-
-  # clone args
-  args = args.clone
-
-  # remove existing '-f' flag, if needed
-  file_flag_index = args.index('-f')
-  if file_flag_index==0
-    args.delete_at(file_flag_index)
-    args.delete_at(file_flag_index)
-  end
-  args.unshift('-f', tempfile.path) # add new '-f' flag
-
-  tempfile.close
-  return args, selected_part_keys
-end
-
 #
 # Run: DK
 #
@@ -345,147 +58,29 @@ def run_dk(compose_args)
 end
 
 #
-# Run: SET WORLD
+# Features
 #
 
-def run_dk_set_world()
-  world_settings = get_world_settings_hash()
+def do_work()
 
-  # world path
-  world_path = ARGV[1]
-  if world_path.nil?
-    print_set_world_help
-    exit
-  else
-    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
-  end
+  # 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)
 
-  if TTY::Prompt.new.yes?("Set world to: #{world_path}?")
-    world_settings[:world_path] = world_path
-    save_world_settings(world_settings)
-    run_dk_set_context()
+  # world files
+  compose_hash, dk_parts_hash, dk_make_hash = @yaml_arg_munger.get_base_compose_parts_and_make_hashes()
+  if compose_hash
+    try_print_dk_help(dk_parts_hash, dk_make_hash, ARGV.clone)
+    compose_hash, selected_parts, shifted_args = @parts_merger.merge_parts(compose_hash, dk_parts_hash, ARGV.clone)
+    final_args = @yaml_arg_munger.save_yaml_and_adjust_args(compose_hash, shifted_args)
+    run_dk(final_args)
   else
-    exit
-  end
-
-end
-
-def run_dk_set_context()
-  world_settings = get_world_settings_hash()
-  unless world_settings[:world_path] and File.directory?(world_settings[:world_path])
-    @logger.error "no world path set."
+    @logger.error "no docker configuration found"
     exit 1
   end
 
-  # read folder from world path (aka. context)
-  all_dir = Dir.chdir(world_settings[: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[:context] = selected_dir
-  save_world_settings(world_settings)
-
-  @logger.puts "world set!"
-  exit
-end
-
-#
-# Run: SET PARTS
-#
-
-def run_dk_set_parts()
-  parts = ARGV[1..]
-  filepath = get_save_parts_filepath()
-  if parts.any?
-    tempfile = File.new(filepath, 'w')
-    tempfile.write(ARGV[1..].to_yaml) # write it to the tempfile
-    tempfile.close
-  else
-    if File.exist?(filepath)
-      File.delete(filepath)
-      @logger.info "parts cleared"
-    else
-      print_set_parts_help()
-    end
-  end
-  exit
-end
-
-#
-# Run: MAKE
-#
-
-def run_dk_make(compose_args, dk_make_hash, dk_parts_hash, selected_part_keys)
-  # print help?
-  no_make_command = (compose_args.count == 3)
-  if no_make_command
-    print_make_help(dk_parts_hash, dk_make_hash)
-  else
-
-    #
-    # supports running multiple commands in a row
-    # ex. dk make down up
-    #
-
-    make_commands = compose_args[3..]
-    make_commands.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 make_commands.length == i+1
-          all_commands.pop
-        else
-          nil
-        end
-
-        # run background commands
-        all_commands.each do |c|
-          cmd = prep_make_command(c, selected_part_keys)
-          `#{cmd}`  # run in sub-process
-        end
-
-        # run last command in foreground
-        if last_cmd
-          cmd = prep_make_command(last_cmd, selected_part_keys)
-          exec(cmd)
-        end
-      end
-    end
-
-  end
-end
-
-def prep_make_command(c, selected_part_keys)
-  c = interpolate_parts_into_command(c, selected_part_keys)
-
-  # logging
-  @logger.puts "" if $stdout.isatty
-  @logger.wait(c)
-  cmd = "cd #{@working_dir} && #{c}"
-end
-
-def interpolate_parts_into_command(cmd, selected_part_keys)
-  if selected_part_keys.any?
-    parts = selected_part_keys.join(' ')
-    return cmd.gsub("cl dk", "cl dk #{parts}")
-  end
-  return cmd
 end
 
 #
@@ -494,32 +89,4 @@ end
 
 @working_dir = ENV['CL_WORKING_DIR'] # passed through cl-magic to here
 
-# SET commands first
-case ARGV.first
-when "set-world"
-  run_dk_set_world()
-when "set-context"
-  run_dk_set_context()
-when "set-parts"
-  run_dk_set_parts()
-else
-  compose_hash, dk_parts_hash, dk_make_hash = get_base_compose_parts_and_make_hashes()
-  if compose_hash
-
-    # parts & args
-    saved_part_keys = get_saved_parts(dk_parts_hash)
-    compose_args, selected_part_keys = merge_parts_save_and_prep_args(compose_hash, dk_parts_hash, dk_make_hash, saved_part_keys)
-
-    # sub-command
-    case compose_args[2]
-    when "make"
-      all_part_keys = selected_part_keys + saved_part_keys
-      run_dk_make(compose_args, dk_make_hash, dk_parts_hash, all_part_keys)
-    else
-      run_dk(compose_args)
-    end
-  else
-    @logger.error "no docker configuration found"
-    exit 1
-  end
-end
+do_work()

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

@@ -0,0 +1,174 @@
+#!/usr/bin/env ruby
+# cli for your compose projects
+require 'optparse'
+require 'optparse/subcommand'
+
+require 'cl/magic/common/common_options.rb'
+require 'cl/magic/common/logging.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 print_make_help(dk_parts_hash, dk_make_hash)
+  if $stdout.isatty
+    puts ""
+    puts "Usage: dk make [DK_PARTS] COMMAND"
+    puts ""
+    puts "Make commands designed to make your developer experience more turnkey"
+    puts ""
+    puts "Parts:"
+    dk_parts_hash.keys.each do |key|
+      @help_printer.print_dk_help_line(key, dk_parts_hash[key].fetch('help'))
+    end
+    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, dk_parts_hash, selected_parts)
+
+  # print help?
+  no_make_command = (final_args.count == 2)
+  if no_make_command
+    print_make_help(dk_parts_hash, dk_make_hash)
+  else
+
+    #
+    # supports running multiple commands in a row
+    # ex. dk make down up
+    #
+
+    make_commands = final_args[2..]
+    make_commands.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 make_commands.length == i+1
+          all_commands.pop
+        else
+          nil
+        end
+
+        # run background commands
+        all_commands.each do |c|
+          cmd = prep_make_command(c, selected_parts)
+          `#{cmd}`  # run in sub-process
+        end
+
+        # run last command in foreground
+        if last_cmd
+          cmd = prep_make_command(last_cmd, selected_parts)
+          exec(cmd)
+        end
+      end
+    end
+
+  end
+end
+
+def prep_make_command(c, selected_parts)
+  # logging
+  @logger.puts "" if $stdout.isatty
+  @logger.wait(c.gsub("cl dk", "dk"))
+
+  # run command
+  c = interpolate_parts_into_command(c, selected_parts)
+  cmd = "cd #{@working_dir} && #{c}"
+end
+
+def interpolate_parts_into_command(cmd, selected_parts)
+  cmd = "cl #{cmd}" if cmd.start_with?("dk")
+
+  # subcommands: don't need interpolated parts
+  ['parts', 'make', 'make-world', 'world'].each do |subcommand|
+    return cmd if cmd.start_with?("cl dk #{subcommand}")
+  end
+
+  if selected_parts.any?
+    parts = selected_parts.join(' ')
+    if cmd.include? "cl dk make"
+      return cmd.gsub("cl dk make", "cl dk make #{parts}")
+    else
+      return cmd.gsub("cl dk", "cl dk #{parts}")
+    end
+  end
+  return cmd
+end
+
+#
+# Features
+#
+
+def do_work()
+
+  # 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
+    compose_hash, selected_parts, shifted_args = @parts_merger.merge_parts(compose_hash, dk_parts_hash, ARGV.clone)
+    final_args = @yaml_arg_munger.save_yaml_and_adjust_args(compose_hash, shifted_args)
+    run_dk_make(final_args, dk_make_hash, dk_parts_hash, selected_parts)
+  else
+    @logger.error "no docker configuration found"
+    exit 1
+  end
+
+end
+
+#
+# Options
+#
+
+options = {}
+global_banner = <<DOC
+
+ Cli for your compose projects
+
+ 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)
+
+do_work()