markdown_exec 1.3.8 → 1.4

data/lib/method_sorter.rb

@@ -0,0 +1,76 @@
+require 'ripper'
+require 'parser/current'
+
+class MethodSorter
+  def initialize(file_path)
+    @file_path = file_path
+  end
+
+  def sort
+    file_contents = File.read(@file_path)
+
+    ast = Parser::CurrentRuby.parse(file_contents)
+
+    # Find the class node
+    class_node = ast.children.find { |node| node.type == :class }
+
+    method_nodes = []
+
+    # Look for method def nodes within each child node 
+    class_node.children.compact.each do |child|
+      if child.type == :begin
+        method_nodes += child.children.select {|n| n.type == :def}
+      end
+    end
+
+    # Sort and process method nodes
+    # class_node = ast.children.find { |node| node.type == :class }
+    # unless class_node
+    #   puts "No class node found in #{@file_path}"
+    #   return
+    # end
+
+    # method_nodes = class_node.children.compact.select { |node| 
+    #   node.type == :def
+    # }    
+
+    sorted_methods = method_nodes.sort_by{ |n| n.children[0].to_s }
+    ripper = Ripper.sexp(file_contents)
+    lines = ripper.each_with_index.map{|sexp, index| [sexp, index] }
+    
+    method_ranges = get_method_ranges(lines, method_nodes)
+    
+    result = replace_method_ranges(lines, method_ranges, sorted_methods)
+    
+    puts result.compact.select{|v|v.is_a? String}.join("\n")
+    # File.write(@file_path, result.join)
+  end
+
+  private
+  
+  def get_method_ranges(lines, method_nodes)
+    method_nodes.map do |method_node|
+      start_line = method_node.loc.line - 1
+      end_line = start_line
+      
+      while end_line < lines.size && lines[end_line][0] !~ /^end/
+        end_line += 1
+      end
+      
+      (start_line..end_line)
+    end
+  end
+  
+  def replace_method_ranges(lines, ranges, sorted_methods)
+    result = lines.dup
+    
+    ranges.each_with_index do |range, index|
+      result[range] = sorted_methods[index].loc.expression.source.split("\n") 
+    end
+    
+    result
+  end
+end
+
+sorter = MethodSorter.new(ARGV[0])
+sorter.sort

data/lib/sort_yaml_gpt4.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+def sort_yaml(input_yaml)
+  # Parse the input YAML
+  data = YAML.load(input_yaml)
+
+  # Ensure data is an array of hashes
+  unless data.is_a?(Array) && data.all? { |item| item.is_a?(Hash) }
+    raise ArgumentError, 'Input YAML must be an array of hashes.'
+  end
+
+  # Sort items by 'opt_name' values
+  sorted_data = data.sort_by do |item|
+    (item[:opt_name] || item[:long_name] || item[:short_name]).to_s
+  end
+
+  # Sort keys in each item
+  sorted_data.each do |item|
+    item.replace(item.sort.to_h)
+  end
+
+  # Convert the sorted data back to YAML and write to stdout
+  puts YAML.dump(sorted_data).gsub("\n-", "\n\n-")
+end
+
+# Read YAML from stdin
+input_yaml = $stdin.read
+
+# Call the function with input YAML
+sort_yaml(input_yaml)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdown_exec
 version: !ruby/object:Gem::Version
-  version: 1.3.8
+  version: '1.4'
 platform: ruby
 authors:
 - Fareed Stevenson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-20 00:00:00.000000000 Z
+date: 2023-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clipboard
@@ -91,6 +91,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".pryrc"
 - ".reek"
 - ".rubocop.yml"
 - CHANGELOG.md
@@ -105,28 +106,42 @@ files:
 - assets/output_of_execution.png
 - assets/select_a_block.png
 - assets/select_a_file.png
+- bin/bmde
+- bin/colorize_env_vars.sh
 - bin/console
 - bin/mde
 - bin/setup
 - bin/tab_completion.sh
 - bin/tab_completion.sh.erb
+- examples/duplicate_block.md
+- examples/import0.md
+- examples/import1.md
+- examples/include.md
+- examples/infile_config.md
+- examples/linked1.md
+- examples/linked2.md
+- examples/linked3.md
+- examples/opts.md
+- examples/pass-through.md
+- examples/plant.md
+- examples/port.md
+- examples/vars.md
+- examples/wrap.md
 - lib/block_label.rb
+- lib/block_types.rb
 - lib/cached_nested_file_reader.rb
 - lib/cli.rb
 - lib/colorize.rb
 - lib/env.rb
-- lib/env_opts.rb
 - lib/environment_opt_parse.rb
 - lib/fcb.rb
 - lib/filter.rb
-- lib/markdown_block_manager.rb
 - lib/markdown_exec.rb
 - lib/markdown_exec/version.rb
 - lib/mdoc.rb
 - lib/menu.src.yml
 - lib/menu.yml
-- lib/menu_options.rb
-- lib/menu_options.yml
+- lib/method_sorter.rb
 - lib/object_present.rb
 - lib/option_value.rb
 - lib/regexp.rb
@@ -134,6 +149,7 @@ files:
 - lib/saved_assets.rb
 - lib/saved_files_matcher.rb
 - lib/shared.rb
+- lib/sort_yaml_gpt4.rb
 - lib/tap.rb
 homepage: https://rubygems.org/gems/markdown_exec
 licenses:

data/lib/env_opts.rb

@@ -1,242 +0,0 @@
-# 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
-#
-# :reek:TooManyMethods
-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
-  #
-  # :reek:NestedIterators
-  def add_options(opts_raw)
-    return self if opts_raw.nil?
-
-    help_rows = opts_raw.map do |key, opt_raw|
-      opt_name = key_name_to_option_name(key)
-
-      # set_per_options(opt_name, opt_raw)
-      @opts[opt_name] = (opt_raw ||= {})
-      set_key_value_as_cast(opt_name, EnvOpts.optdefault(opt_raw))
-      set_key_value_per_environment_as_cast(opt_name, opt_raw)
-
-      [
-        [20, '-', "--#{opt_name}"],
-        [16, '-',
-         if @opts[opt_name][:env].present?
-           option_name_to_environment_name(opt_name, @opts[opt_name])
-         else
-           ''
-         end],
-        # [24, '-', get_environment_value_from_option(opt_name, @opts[opt_name])],
-        [24, '-', @opts[opt_name][:default]],
-        [6, '-', if (fixed = opt_raw.fetch(:fixed, nil)).nil?
-                   ":#{option_cast(@opts[opt_name])}"
-                 else
-                   fixed.to_s
-                 end]
-      ]
-    end
-
-    max_widths = help_rows.reduce([0, 0, 0, 0]) do |memo, vals|
-      vals.map.with_index do |val, ind|
-        [memo[ind], val[2].to_s.length].max
-      end
-    end
-
-    @values['help'] = help_rows.map do |row|
-      row.map.with_index do |cell, ind|
-        format("%#{cell[1]}#{max_widths[ind]}s", cell[2])
-      end.join('  ')
-    end.join("\n")
-
-    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, '')
-      if arg.start_with? '--'
-        opt_name = arg[2..-1]
-        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
-
-    self
-  end
-
-  # set option current values per environment values
-  #
-  def options_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
-
-    self
-  end
-
-  # symbol name to option name
-  # option names use hyphens
-  #
-  def self.symbol_name_to_option_name(name)
-    name.to_s.gsub('_', '-')
-  end
-
-  private
-
-  # convert key name or symbol to an option name
-  #
-  def key_name_to_option_name(key)
-    (key.is_a?(Symbol) ? EnvOpts.symbol_name_to_option_name(key) : key)
-  end
-
-  # get cast of environment variable
-  #
-  def option_cast(opt_raw)
-    (opt_raw[:cast].present? ? opt_raw[:cast].to_s : 'to_s')
-  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('_', '-')
-  end
-
-  # read and write options using the option name as a method
-  #
-  def method_missing(method_name, *args)
-    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
-  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
-  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)
-  end
-
-  # option names are available as methods
-  #
-  # :reek:BooleanParameter
-  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)
-    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)
-    return if opt_raw[:env].nil?
-
-    value = get_environment_value_from_option(key, opt_raw)
-
-    return unless value
-
-    set_key_value_as_cast(key,
-                          opt_raw[:cast] ? value.send(opt_raw[:cast]) : value)
-  end
-
-  # set key value (raw)
-  #
-  def set_key_value_raw(key, value)
-    @values[key] = value
-  end
-end

data/lib/markdown_block_manager.rb

@@ -1,64 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# encoding=utf-8
-
-require_relative 'filter'
-
-module MarkdownExec
-  ##
-  # MarkdownBlockManager represents an imported markdown document.
-  #
-  # It provides methods to extract and manipulate specific sections
-  # of the document, such as code blocks. It also supports recursion
-  # to fetch related or dependent blocks.
-  #
-  class MarkdownBlockManager
-    attr_reader :block_table
-
-    # initialize
-    #
-    # Initializes an instance of MarkdownBlockManager with the given block table.
-    #
-    # @param block_table [Array<Hash>] An array of hashes representing markdown blocks.
-    def initialize(block_table)
-      @block_table = block_table
-    end
-
-    # get_block
-    #
-    # Retrieves a code block by its name.
-    #
-    # @param name [String] The name of the code block to retrieve.
-    # @param default [Hash] The default value to return if the code block is not found.
-    # @return [Hash] The code block as a hash or the default value if not found.
-    def get_block(name, default = {})
-      @block_table.select { |block| block.fetch(:name, '') == name }.fetch(0, default)
-    end
-  end
-end
-
-if $PROGRAM_NAME == __FILE__
-  # require 'bundler/setup'
-  # Bundler.require(:default)
-
-  require 'minitest/autorun'
-
-  class MarkdownBlockManagerTest < Minitest::Test
-    def setup
-      @block_table = [
-        { name: 'block1', reqs: ['block2'], body: ['code1'] },
-        { name: 'block2', body: ['code2'] },
-        { name: 'block3', body: ['code3'] }
-      ]
-      @manager = MarkdownExec::MarkdownBlockManager.new(@block_table)
-    end
-
-    # Test the get_block method
-    def test_get_block
-      block = @manager.get_block('block2')
-      expected_block = { name: 'block2', body: ['code2'] }
-      assert_equal expected_block, block
-    end
-  end
-end