markdown_exec 1.3.0 → 1.3.2

data/bin/tab_completion.sh.erb

@@ -30,6 +30,7 @@ _mde() {
     if [[ ${prev} == -* ]] ; then
       case $prev in
         <% svhs.each do |svh|
+
           svn = svh[:long_name]
           if svn && svh[:arg_name]
             svn = '--' + svh[:long_name]
@@ -43,6 +44,21 @@ _mde() {
               <%= svn + ') COMPREPLY="' + svh[:compreply] + '"; return 0 ;;' %>
             <% end
           end
+
+          svn = svh[:short_name]
+          if svn && svh[:arg_name]
+            svn = '-' + svh[:short_name]
+            if svh[:compreply] == false
+              # nothing
+            elsif svh[:compreply].nil? %>
+              <%= svn + ') __filedirs_all; return 0 ;;' %>
+            <% elsif svh[:compreply].empty?
+              # nothing
+            else %>
+              <%= svn + ') COMPREPLY="' + svh[:compreply] + '"; return 0 ;;' %>
+            <% end
+          end
+
         end %>
       esac
     fi
@@ -65,11 +81,18 @@ _mde() {
   if [[ -z ${cur} ]] ; then
     case $prev in
       <% svhs.each do |svh|
+
         svn = svh[:long_name]
         if svn && svh[:arg_name]
           svn = '--' + svh[:long_name] %>
           <%= svn + ') COMPREPLY=".' + svh[:arg_name] + '."; return 0 ;;' %>
         <% end
+
+        svn = svh[:short_name]
+        if svn && svh[:arg_name]
+          svn = '-' + svh[:short_name] %>
+          <%= svn + ') COMPREPLY=".' + svh[:arg_name] + '."; return 0 ;;' %>
+        <% end
       end %>
     esac
   fi

data/lib/cli.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+# utility functions to provide CLI
+#
+module CLI
+  # skip :reek:UtilityFunction
+  def value_for_cli(value)
+    case value.class.to_s
+    when 'String'
+      Shellwords.escape value
+    when 'FalseClass', 'TrueClass'
+      value ? '1' : '0'
+    else
+      Shellwords.escape value.to_s
+    end
+  end
+end

data/lib/env.rb

@@ -10,17 +10,21 @@ module Env
   # :reek:NilCheck
   # :reek:UtilityFunction
   def env_bool(name, default: false)
-    return default if name.nil? || (val = ENV[name]).nil?
+    return default if name.nil? || (val = ENV.fetch(name, nil)).nil?
     return false if val.empty? || val == '0'
 
     true
   end
 
+  def env_bool_false(name)
+    !(val = (name && ENV.fetch(name, nil))).nil? && !(val.empty? || val == '0')
+  end
+
   # skip :reek:DataClump
   # skip :reek:NilCheck
   # skip :reek:UtilityFunction
   def env_int(name, default: 0)
-    return default if name.nil? || (val = ENV[name]).nil?
+    return default if name.nil? || (val = ENV.fetch(name, nil)).nil?
     return default if val.empty?
 
     val.to_i
@@ -30,7 +34,7 @@ module Env
   # skip :reek:NilCheck
   # skip :reek:UtilityFunction
   def env_str(name, default: '')
-    return default if name.nil? || (val = ENV[name]).nil?
+    return default if name.nil? || (val = ENV.fetch(name, nil)).nil?
 
     val || default
   end

data/lib/env_opts.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+require_relative 'tap'
+
+include Tap #; tap_config
+
+# define options with initial values
+# option to read value from environmnt variables
+# option to cast input values
+# value priority: default < environment < argument
+#
+class EnvOpts
+  attr_reader :opts, :values
+
+  def initialize(opts_raw = {}, argv = ARGV)
+    @opts = {}
+    @values = {}
+    add_options(opts_raw)
+    # parse(argv, &block) if block_given?
+    block_given? ? parse(argv, &block) : parse(argv)
+
+    self # rubocop:disable Lint/Void
+  end
+
+  # add options to menu
+  # calculate help text
+  #
+  def add_options(opts_raw)
+    return self if opts_raw.nil?
+
+    rows = opts_raw.map do |key, opt_raw|
+      key2 = key_name_to_option_name(key)
+
+      # set_per_options(key2, opt_raw)
+      @opts[key2] = (opt_raw ||= {})
+      set_key_value_as_cast key2, EnvOpts.optdefault(opt_raw)
+
+      set_key_value_per_environment_as_cast(key2, opt_raw)
+
+      [
+        [20, '-', "--#{key}"],
+        [16, '-', @opts[key2][:env].present? ? option_name_to_environment_name(key2, @opts[key2]) : ''],
+        # [24, '-', get_environment_value_from_option(key2, @opts[key2])],
+        [24, '-', @opts[key2][:default]],
+        [6, '-', if (fixed = opt_raw.fetch(:fixed, nil)).nil?
+                   ":#{option_cast(@opts[key2])}"
+                 else
+                   fixed.to_s
+                 end]
+      ]
+    end.tap_yaml 'rows'
+
+    max_widths = rows.reduce([0, 0, 0, 0]) do |memo, (c0, c1, c2, c3)|
+      [
+        [memo[0], c0[2].to_s.length].max,
+        [memo[1], c1[2].to_s.length].max,
+        [memo[2], c2[2].to_s.length].max,
+        [memo[3], c3[2].to_s.length].max
+      ]
+    end.tap_inspect 'max_widths'
+
+    @values['help'] = rows.map do |(c0, c1, c2, c3)|
+      [format("%#{c0[1]}#{max_widths[0]}s", c0[2]),
+       format("%#{c1[1]}#{max_widths[1]}s", c1[2]),
+       format("%#{c2[1]}#{max_widths[2]}s", c2[2]),
+       format("%#{c3[1]}#{max_widths[3]}s", c3[2])]
+    end.map do |row|
+      row.join('  ')
+    end.join("\n")
+    @opts.tap_inspect '@opts'
+    @values.tap_inspect '@values'
+
+    self
+  end
+
+  # accept :d or :default option
+  #
+  def self.optdefault(opt_raw)
+    return opt_raw[:d] unless opt_raw[:d].nil?
+
+    opt_raw[:default]
+  end
+
+  def output_help
+    puts @values['help']
+  end
+
+  # process arguments as mostly pairs of option name and value
+  #
+  def parse(argv = ARGV)
+    return self if argv.nil? || !(argv&.count || 0).positive?
+
+    args_ind = 0
+    while args_ind < argv.count
+      args_consumed = 0
+      arg = argv.fetch(args_ind, '') #.tap_inspect 'argument', source: 'EnvOpts'
+      if arg.start_with? '--'
+        opt_name = arg[2..-1] #.tap_inspect 'opt_name', source: 'EnvOpts'
+        args_consumed = consume_arguments(opt_name, argv.fetch(args_ind + 1, nil))
+      end
+
+      if args_consumed.zero?
+        if arg == '--help'
+          output_help
+          exit
+        elsif block_given?
+          yield 'NAO', [arg]
+          args_consumed = 1
+        else
+          warn "Invalid argument: #{arg.inspect} in #{argv.inspect}"
+          exit 1
+        end
+      end
+
+      args_ind += args_consumed
+    end
+    @opts.tap_inspect '@opts'
+    @values.tap_inspect '@values'
+
+    self
+  end
+
+  # set option current values per environment values
+  #
+  def set_keys_value_per_environment_as_cast(opts_raw)
+    return self if opts_raw.nil?
+
+    opts_raw.each do |key, opt_raw|
+      set_key_value_per_environment_as_cast(key_name_to_option_name(key), opt_raw)
+    end
+    @opts.tap_inspect '@opts'
+
+    self
+  end
+
+  private
+
+  # convert key name or symbol to an option name
+  #
+  def key_name_to_option_name(key)
+    (key.is_a?(Symbol) ? symbol_name_to_option_name(key) : key) #.tap_inspect
+  end
+
+  # get cast of environment variable
+  #
+  def option_cast(opt_raw)
+    (opt_raw[:cast].present? ? opt_raw[:cast].to_s : 'to_s').tap_inspect
+  end
+
+  # update value for named option
+  # return number of arguments used
+  #
+  def consume_arguments(opt_name, value)
+    return 0 if (opt_raw = @opts.fetch(opt_name, nil)).nil?
+
+    return 0 unless opt_raw.fetch(:option, true)
+
+    if !(fixed = opt_raw.fetch(:fixed, nil)).nil?
+      set_key_value_as_cast(opt_name, fixed)
+      1
+    elsif value.nil?
+      0
+    else
+      set_key_value_as_cast(opt_name, value)
+      2
+    end
+  end
+
+  # option names use hyphens
+  #
+  def method_name_to_option_name(name)
+    name.to_s.gsub('_', '-') #.tap_inspect
+  end
+
+  # read and write options using the option name as a method
+  #
+  def method_missing(method_name, *args)
+    method_name.tap_inspect 'method_name'
+    if method_name.to_s.end_with?('=')
+      value = args.first
+      name = method_name_to_option_name(method_name.to_s[0..-2])
+      set_key_value_as_cast(name, value)
+    else
+      @values[method_name_to_option_name(method_name)]
+    end.tap_inspect "ref #{method_name}", source: 'EnvOpts'
+  end
+
+  # option name to environment name
+  # if true or empty, compute from option name
+  #
+  def option_name_to_environment_name(opt_name, opt_raw)
+    case env_name = opt_raw.fetch(:env, '')
+    when true, ''
+      "#{@values['env-prefix']}#{opt_name.upcase.gsub('-', '_')}"
+    else
+      env_name
+    end.tap_inspect
+  end
+
+  # get environment value from option
+  #
+  def get_environment_value_from_option(opt_name, opt_raw)
+    ENV.fetch(option_name_to_environment_name(opt_name, opt_raw), nil).tap_inspect
+  end
+
+  # option names are available as methods
+  #
+  def respond_to_missing?(method_name, include_private = false)
+    (@opts.keys.include?(method_name_to_option_name(method_name)) || super)
+  end
+
+  def set_key_value_as_cast(key, value)
+    [key, value].tap_inspect 'key, value'
+    opt = @opts[key]
+    set_key_value_raw(key, (opt[:cast] ? value.send(opt[:cast]) : value))
+  end
+
+  # set key value_per environment as cast
+  #
+  def set_key_value_per_environment_as_cast(key, opt_raw)
+    key.tap_inspect 'key'
+    opt_raw.tap_inspect 'opt_raw'
+    return if opt_raw[:env].nil?
+
+    value = get_environment_value_from_option(key, opt_raw).tap_inspect 'value'
+    set_key_value_as_cast(key, opt_raw[:cast] ? value.send(opt_raw[:cast]) : value) unless value.nil?
+  end
+
+  # set key value (raw)
+  #
+  def set_key_value_raw(key, value)
+    [key, value].tap_inspect 'key, value'
+    @values[key] = value
+  end
+
+  # symbol name to option name
+  # option names use hyphens
+  #
+  def symbol_name_to_option_name(name)
+    name.to_s.gsub('_', '-') #.tap_inspect
+  end
+end

data/lib/environment_opt_parse.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+require 'optparse'
+require 'yaml'
+
+require_relative 'object_present'
+
+# add Hash.sym_keys
+#
+class Hash
+  unless defined?(sym_keys)
+    def sym_keys
+      transform_keys(&:to_sym)
+      # map do |key, value|
+      #   [key.to_sym, value]
+      # end.to_h
+    end
+  end
+end
+
+# parse application configuration from command-line options and environment variables
+#
+class EnvironmentOptParse
+  attr_reader :options, :remainder
+
+  # utility functions to create menu
+  #
+  module Menu
+    def menu_all(menu_data, lambdas, config)
+      config.tap_yaml 'config'
+      input_option_values, remainder, = menu_parse(add_proc(menu_data, lambdas))
+      # options = menu_default_option_values(menu_data).merge input_option_values
+      # options = (menu_default_option_values(menu_data)).merge(input_option_values).tap_yaml 'options1'
+      options = menu_default_option_values(menu_data).merge(config).merge(input_option_values) #.tap_yaml 'options2'
+      # options = menu_data.map do |menu_item|
+      #   menu_item.tap_inspect 'menu_item'
+      #   mion = menu_item[:opt_name]&.to_sym.tap_inspect 'mion'
+      #   omion = config[mion].tap_inspect 'omion'
+      #   unless omion.nil?
+      #     menu_item[:default] = omion
+      #   end
+      #   menu_item
+      # end,
+
+      [options, remainder]
+    end
+
+    def add_proc(menu_data, lambdas)
+      menu_data.each do |menu_item|
+        menu_item.tap_yaml 'menu_item'
+        procname = menu_item[:procname]
+        next if procname.nil?
+
+        menu_item[:proccode] = lambdas.fetch(procname.to_sym, menu_item[:procname])
+      end.tap_yaml
+    end
+
+    def menu_default_option_values(menu_data)
+      menu_data.map do |item|
+        item_default = item[:default]
+        next if item_default.nil?
+        next unless item[:opt_name].present?
+
+        [item[:opt_name].to_sym, item_default]
+      end.compact.to_h
+    end
+
+    def menu_help(menu_data)
+      options = {}
+      option_parser = OptionParser.new do |opts|
+        opts.banner = [
+          "#{APP_NAME} - #{APP_DESC} (#{VERSION})",
+          "Usage: #{File.basename($PROGRAM_NAME)} [options]"
+        ].join("\n")
+
+        menu_data.each do |item|
+          menu_option_append opts, options, item
+        end
+      end
+
+      option_parser.help
+    end
+
+    def menu_option_append(opts, options, item)
+      return unless item[:long_name].present? || item[:short_name].present?
+
+      mmoo = [
+        # long name
+        if item[:long_name].present?
+          "--#{item[:long_name]}#{item[:arg_name].present? ? " #{item[:arg_name]}" : ''}"
+        end,
+
+        # short name
+        item[:short_name].present? ? "-#{item[:short_name]}" : nil,
+
+        # description and default
+        [item[:description],
+         item[:default].present? ? "[#{value_for_menu item[:default]}]" : nil].compact.join('  '),
+
+        # apply proccode, if present, to value
+        # save value to options hash if option is named
+        #
+        lambda { |value|
+          (item[:proccode] ? item[:proccode].call(value) : value).tap do |converted|
+            opt_name = item[:opt_name]
+            next if opt_name.nil?
+
+            options[opt_name.to_sym] = converted if item[:opt_name]
+          end
+        }
+      ].compact
+      opts.on(*mmoo)
+    end
+
+    def menu_parse(menu_options)
+      options = {}
+      option_parser = OptionParser.new do |opts|
+        menu_options.each do |item|
+          item[:opt_name] = item[:opt_name]&.to_sym
+          menu_option_append opts, options, item
+        end
+      end
+      option_parser.load # filename defaults to basename of the program without suffix in a directory ~/.options
+      option_parser.environment # env defaults to the basename of the program.
+      remainder = option_parser.parse!
+
+      [options, remainder, option_parser.help]
+    end
+
+    # skip :reek:UtilityFunction
+    def value_for_menu(value)
+      case value.class.to_s
+      when 'String'
+        value
+      when 'FalseClass', 'TrueClass'
+        value ? '1' : '0'
+      else
+        value.to_s
+      end
+    end
+  end
+
+  include Menu
+
+  def initialize(menu: {}, lambdas: nil, options: nil, version: nil)
+    @menu = if menu.class.to_s == 'String'
+              filetext = File.read(menu).tap_yaml 'filetext'
+              fileyaml = YAML.load(filetext)
+              fileyaml.map(&:sym_keys)
+            else
+              menu
+            end.tap_yaml '@menu'
+    @lambdas = lambdas
+    @version = version || '0.1'
+    # @options = {}
+    @options = if options.class.to_s == 'String'
+                 YAML.safe_load(File.read(options)).sym_keys.tap_yaml '@options'
+               else
+                 {}
+               end #.tap_yaml '@options'
+
+    parse!
+  end
+
+  def parse!
+    @options, @remainder = menu_all(
+      @menu,
+      # @menu.map do |menu_item|
+      #   menu_item.tap_inspect 'menu_item'
+      #   mion = menu_item[:opt_name]&.to_sym.tap_inspect 'mion'
+      #   omion = @options[mion].tap_inspect 'omion'
+      #   unless omion.nil?
+      #     @options[menu_item[:default]] = omion
+      #   end
+      #   menu_item
+      # end,
+      {
+        debug: ->(value) { tap_config value: value },
+
+        # stdout_configuration: lambda { |_| self.options.tap_puts 'eop' },
+        # stdout_configuration: (lambda { |options|
+        #   lambda { |v| options.tap_puts 'eop_l' }
+        # }).call(@options),
+
+        stdout_defaults: ->(_) { menu_default_option_values(@menu).to_yaml.tap_puts },
+        stdout_help: lambda { |_|
+                       menu_help(@menu).tap_puts
+                       exit
+                     },
+        val_as_bool: ->(value) { value.class.to_s == 'String' ? (value.chomp != '0') : value },
+        val_as_int: ->(value) { value.to_i },
+        val_as_str: ->(value) { value.to_s },
+        version: lambda { |_|
+                   @version.tap_puts
+                   exit
+                 }
+      }.merge(@lambdas || {}),
+      @options
+    )
+    @options #.tap_yaml '@options'
+  end
+end

data/lib/markdown_exec/version.rb

@@ -7,5 +7,5 @@ module MarkdownExec
   BIN_NAME = 'mde'
   GEM_NAME = 'markdown_exec'
   TAP_DEBUG = 'MDE_DEBUG'
-  VERSION = '1.3.0'
+  VERSION = '1.3.2'
 end