markdown-run 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb82e5ea1c357a231ca30c1802c103456733e8a1d76256008dbf8d8af34f1703
-  data.tar.gz: c25a53287f14c41a184f46a436e1f08266c184c834c7272c6b936f75652a59b3
+  metadata.gz: 9fb74c59f4e26ed84c5733a6adc0707523cc9eae17797a12cf90a854618c11a3
+  data.tar.gz: 765069182cc8a77902e6e9676469f670a3cee84c1a5e888571d189e9d4d782bc
 SHA512:
-  metadata.gz: 153076de8074dfb3a5407380eeb0419980528f46714375ccca7aa05ed26d57fc10da029b790cd193c3076263bbf28ce8484833c7faeb7591c26c14b1923a499b
-  data.tar.gz: cd8ef15078084c0994f68face1f523328afed9557c9e5add38375a1c1a60e72ff8279803b63e6560b5a1748ef38e5128e01adf8909613d4d9fe446fd68fc6ae5
+  metadata.gz: 29ba3d6f47e39875804ffdeafde532149b10f5052b26fd1c333564531445a27789602140105e51371d98f198582bde1ee200a50ef8e6595a0e4c1d5656e97249
+  data.tar.gz: 89df023e98a32578dee678dde88f0922312aaf018893e11a263552386eaafa2bafea44984255e73a9dc9f8e5dfecc3955d5d3d8b8f1a47ed07dbdf9bad0eabcb

data/.rubocop.yml

@@ -1,8 +1,2 @@
-AllCops:
-  TargetRubyVersion: 3.0
-
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  EnforcedStyle: double_quotes
+inherit_gem:
+  rubocop-rails-omakase: rubocop.yml

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 ## [Unreleased]
 
+## [0.2.0] - 2025-05-14
+
+- Gemfile update
+
+## [0.1.1] - 2025-05-14
+
+- Added checks for missing dependencies
+
 ## [0.1.0] - 2025-05-13
 
 - Initial release

data/README.md

@@ -1,39 +1,28 @@
-# Markdown::Run
+[![Ruby](https://github.com/aurelienbottazini/markdown-run/actions/workflows/main.yml/badge.svg)](https://github.com/aurelienbottazini/markdown-run/actions/workflows/main.yml)
 
-TODO: Delete this and the text below, and describe your gem
+[![Gem Version](https://badge.fury.io/rb/markdown-run.svg)](https://badge.fury.io/rb/markdown-run)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/markdown/run`. To experiment with that code, run `bin/console` for an interactive prompt.
+# Markdown-run
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
-
-Install the gem and add to the application's Gemfile by executing:
-
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
-
-If bundler is not being used to manage dependencies, install the gem by executing:
-
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_IMMEDIATELY_AFTER_RELEASE_TO_RUBYGEMS_ORG
+`gem install markdown-run`
 
 ## Usage
 
-TODO: Write usage instructions here
+- Run specs `markdown-run`
+- Run on a markdown file `markdown-run your-filename`
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Just run the script with `./exe/markdown-run`
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/aurelienbottazini/markdown-run. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/aurelienbottazini/markdown-run/blob/main/CODE_OF_CONDUCT.md).
+Bug reports are welcome on GitHub at https://github.com/aurelienbottazini/markdown-run.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-## Code of Conduct
-
-Everyone interacting in the Markdown::Run project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/aurelienbottazini/markdown-run/blob/main/CODE_OF_CONDUCT.md).
+## [code of conduct](https://github.com/aurelienbottazini/markdown-run/blob/main/CODE_OF_CONDUCT.md).

data/exe/markdown-run

@@ -1,50 +1,74 @@
 #!/usr/bin/env ruby
 
-require 'tempfile'
-require 'open3'
-require 'fileutils'
+require "tempfile"
+require "open3"
+require "fileutils"
 
 # --- Language Execution Configuration ---
 JS_CONFIG = {
-  command: ->(_code_content, temp_file_path) { [ "bun #{temp_file_path}", {} ] },
-  temp_file_suffix: '.js',
+  command: ->(_code_content, temp_file_path) {
+    # Check if bun is available
+    bun_exists = system("command -v bun > /dev/null 2>&1")
+    if bun_exists
+      [ "bun #{temp_file_path}", {} ]
+    else
+      # Fallback to node if bun is not available
+      [ "node #{temp_file_path}", {} ]
+    end
+  },
+  temp_file_suffix: ".js",
   error_handling: :js_specific # For specific stderr appending on error
 }.freeze
 
 SQLITE_CONFIG = {
   command: ->(code_content, temp_file_path) { [ "sqlite3 #{temp_file_path}", { stdin_data: code_content } ] },
-  temp_file_suffix: '.db' # Temp file is the database
+  temp_file_suffix: ".db" # Temp file is the database
 }.freeze
 
 SUPPORTED_LANGUAGES = {
-  'psql' => {
-    command: ->(code_content, _temp_file_path) { [ "psql -A -t -X", { stdin_data: code_content } ] }
+  "psql" => {
+    command: ->(code_content, _temp_file_path) {
+      psql_exists = system("command -v psql > /dev/null 2>&1")
+      unless psql_exists
+        warn "Error: psql command not found. Please install PostgreSQL or ensure psql is in your PATH."
+        exit 1 # Abort the script
+      end
+      [ "psql -A -t -X", { stdin_data: code_content } ]
+    }
   },
-  'ruby' => {
-    command: ->(_code_content, temp_file_path) { [ "xmpfilter #{temp_file_path}", {} ] },
-    temp_file_suffix: '.rb',
-    result_block_type: 'ruby' # For special '```ruby RESULT' blocks
+  "ruby" => {
+    command: ->(_code_content, temp_file_path) {
+      xmpfilter_exists = system("command -v xmpfilter > /dev/null 2>&1")
+      unless xmpfilter_exists
+        warn "Error: xmpfilter command not found. Please install xmpfilter or ensure it is in your PATH."
+        exit 1 # Abort the script
+      end
+      [ "xmpfilter #{temp_file_path}", {} ]
+    },
+    temp_file_suffix: ".rb",
+    result_block_type: "ruby" # For special '```ruby RESULT' blocks
   },
-  'js' => JS_CONFIG,
-  'javascript' => JS_CONFIG, # Alias for js
-  'sqlite' => SQLITE_CONFIG,
-  'sqlite3' => SQLITE_CONFIG # Alias for sqlite
+  "js" => JS_CONFIG,
+  "javascript" => JS_CONFIG, # Alias for js
+  "sqlite" => SQLITE_CONFIG,
+  "sqlite3" => SQLITE_CONFIG # Alias for sqlite
 }.freeze
 
-LANGUAGE_REGEX_PART = SUPPORTED_LANGUAGES.keys.map { |lang| Regexp.escape(lang) }.join('|').freeze
-CODE_BLOCK_START_REGEX = /^```(#{LANGUAGE_REGEX_PART})$/i.freeze
+LANGUAGE_REGEX_PART = SUPPORTED_LANGUAGES.keys.map { |lang| Regexp.escape(lang) }.join("|").freeze
+CODE_BLOCK_START_REGEX = /^```(#{LANGUAGE_REGEX_PART})$/i
 # --- End Language Execution Configuration ---
 
 if ARGV.empty?
-  require 'bundler/inline'
+  require "bundler/inline"
   gemfile(true) do
-    source 'https://rubygems.org'
-    gem 'minitest' # You can specify a version like '~> 5.10' if needed
+    source "https://rubygems.org"
+    gem "minitest" # You can specify a version like '~> 5.10' if needed
+    gem "rcodetools"
   end
 
   puts "Running tests..."
-  require 'minitest/spec'
-  require 'minitest/autorun'
+  require "minitest/spec"
+  require "minitest/autorun"
 end
 
 # Script to process markdown files, execute code blocks based on language,
@@ -54,7 +78,9 @@ def execute_code_block(code_content, lang, temp_dir)
   result_output = ""
   stderr_output = ""
   exit_status = 0
-  captured_stdout, captured_stderr, captured_status_obj = nil, nil, nil
+  captured_stdout = nil
+  captured_stderr = nil
+  captured_status_obj = nil
 
   lang_key = lang.downcase # Normalize lang input for lookup
   lang_config = SUPPORTED_LANGUAGES[lang_key]
@@ -69,7 +95,7 @@ def execute_code_block(code_content, lang, temp_dir)
     # It returns [command_string, options_hash_for_open3]
 
     if temp_file_suffix # Needs a temporary file. Use lang_key as prefix.
-      Tempfile.create([lang_key, temp_file_suffix], temp_dir) do |temp_file|
+      Tempfile.create([ lang_key, temp_file_suffix ], temp_dir) do |temp_file|
         temp_file.write(code_content)
         temp_file.close
         # Pass temp_file.path. Lambda decides if it needs code_content directly.
@@ -108,9 +134,7 @@ def execute_code_block(code_content, lang, temp_dir)
     is_js_error_already_formatted = lang_config && lang_config[:error_handling] == :js_specific && result_output.include?("Stderr:")
     unless result_output.downcase.include?("error:") || is_js_error_already_formatted
       error_prefix = "Execution failed (status: #{exit_status})."
-      if stderr_output && !stderr_output.strip.empty?
-        error_prefix += " Stderr: #{stderr_output.strip}"
-      end
+      error_prefix += " Stderr: #{stderr_output.strip}" if stderr_output && !stderr_output.strip.empty?
       result_output = "#{error_prefix}\n#{result_output}"
     end
   end
@@ -148,7 +172,7 @@ def process_markdown_file_main(input_file_path)
           loop do
             block_line = file_enum.next
             output_lines << block_line
-            break if block_line.strip == '```'
+            break if block_line.strip == "```"
           end
         rescue StopIteration
           warn "Warning: End of file reached inside a '```ruby RESULT' block."
@@ -167,94 +191,92 @@ def process_markdown_file_main(input_file_path)
         output_lines << current_line
         next # Continue to the next line from the file
       end
-    else # We are in_code_block (current_block_lang is set, current_code_content is accumulating)
+    elsif current_line.strip == "```" # We are in_code_block (current_block_lang is set, current_code_content is accumulating)
       # Case 4: End of the current code block (```)
-      if current_line.strip == '```'
-        output_lines << current_line # The closing ``` of the code block
+      output_lines << current_line # The closing ``` of the code block
+
+      execute_this_block = true # Assume execution by default
+      lines_to_pass_through_if_skipped = [] # For blank line + RESULT header if skipping
+      blank_line_before_new_result = nil # If a blank line is consumed but block is still executed
 
-        execute_this_block = true # Assume execution by default
-        lines_to_pass_through_if_skipped = [] # For blank line + RESULT header if skipping
-        blank_line_before_new_result = nil # If a blank line is consumed but block is still executed
+      # Peek ahead logic
+      peek1 = nil
+      begin; peek1 = file_enum.peek; rescue StopIteration; end # If EOF, execute_this_block remains true
 
-        # Peek ahead logic
-        peek1 = nil
-        begin; peek1 = file_enum.peek; rescue StopIteration; end # If EOF, execute_this_block remains true
+      current_lang_config = SUPPORTED_LANGUAGES[current_block_lang] # Get config for the current block
+      is_ruby_style_result = current_lang_config && current_lang_config[:result_block_type] == "ruby"
 
-        current_lang_config = SUPPORTED_LANGUAGES[current_block_lang] # Get config for the current block
-        is_ruby_style_result = current_lang_config && current_lang_config[:result_block_type] == 'ruby'
+      expected_header_regex = is_ruby_style_result ? /^```ruby\s+RESULT$/i : /^```RESULT$/i
 
-        expected_header_regex = is_ruby_style_result ? /^```ruby\s+RESULT$/i : /^```RESULT$/i
+      if peek1 && peek1.match?(expected_header_regex)
+        execute_this_block = false
+        lines_to_pass_through_if_skipped << file_enum.next # Consume RESULT header
+      elsif peek1 && peek1.strip == "" # Blank line detected
+        consumed_blank_line = file_enum.next # Consume the blank line from enum
 
-        if peek1 && peek1.match?(expected_header_regex)
+        peek2 = nil
+        begin; peek2 = file_enum.peek; rescue StopIteration; end # EOF after blank line
+
+        if peek2 && peek2.match?(expected_header_regex)
           execute_this_block = false
+          lines_to_pass_through_if_skipped << consumed_blank_line # Add consumed blank line
           lines_to_pass_through_if_skipped << file_enum.next # Consume RESULT header
-        elsif peek1 && peek1.strip == "" # Blank line detected
-          consumed_blank_line = file_enum.next # Consume the blank line from enum
-
-          peek2 = nil
-          begin; peek2 = file_enum.peek; rescue StopIteration; end # EOF after blank line
-
-          if peek2 && peek2.match?(expected_header_regex)
-            execute_this_block = false
-            lines_to_pass_through_if_skipped << consumed_blank_line # Add consumed blank line
-            lines_to_pass_through_if_skipped << file_enum.next    # Consume RESULT header
-          else
-            # Blank line, but not followed by a RESULT header (or EOF after blank).
-            # We will execute the block. The consumed_blank_line should be outputted.
-            blank_line_before_new_result = consumed_blank_line
-            # execute_this_block remains true
-          end
+        else
+          # Blank line, but not followed by a RESULT header (or EOF after blank).
+          # We will execute the block. The consumed_blank_line should be outputted.
+          blank_line_before_new_result = consumed_blank_line
+          # execute_this_block remains true
         end
-        # If peek1 was nil (EOF) or something else not matching, execute_this_block remains true.
-
-        if execute_this_block
-          output_lines << blank_line_before_new_result if blank_line_before_new_result
-          if !current_code_content.strip.empty?
-            warn "Executing #{current_block_lang} code block..."
-            result_output = execute_code_block(current_code_content, current_block_lang, temp_dir)
-
-            output_lines << "\n" if blank_line_before_new_result.nil?
-            output_lines << (is_ruby_style_result ? "```ruby RESULT\n" : "```RESULT\n")
-            output_lines << result_output
-            output_lines << "\n" unless result_output.empty? || result_output.end_with?("\n")
-            output_lines << "```\n\n" # Ensures a blank line after the RESULT block
-          else
-            warn "Skipping empty code block for language '#{current_block_lang}'."
-          end
-        else # Do not execute; a RESULT block follows and was identified
-          lang_specific_result_type = is_ruby_style_result ? "```ruby RESULT" : "```RESULT"
-          warn "Found existing '#{lang_specific_result_type}' block for current #{current_block_lang} block, skipping execution."
-
-          output_lines.concat(lines_to_pass_through_if_skipped) # Add blank line (if any) and RESULT header
-
-          # Consume the rest of the RESULT block content until its closing ```
-          begin
-            loop do
-              result_block_line = file_enum.next
-              output_lines << result_block_line
-              break if result_block_line.strip == '```'
-            end
-          rescue StopIteration
-            warn "Warning: End of file reached inside a skipped 'RESULT' block."
-            break # Exit main loop
+      end
+      # If peek1 was nil (EOF) or something else not matching, execute_this_block remains true.
+
+      if execute_this_block
+        output_lines << blank_line_before_new_result if blank_line_before_new_result
+        if !current_code_content.strip.empty?
+          warn "Executing #{current_block_lang} code block..."
+          result_output = execute_code_block(current_code_content, current_block_lang, temp_dir)
+
+          output_lines << "\n" if blank_line_before_new_result.nil?
+          output_lines << (is_ruby_style_result ? "```ruby RESULT\n" : "```RESULT\n")
+          output_lines << result_output
+          output_lines << "\n" unless result_output.empty? || result_output.end_with?("\n")
+          output_lines << "```\n\n" # Ensures a blank line after the RESULT block
+        else
+          warn "Skipping empty code block for language '#{current_block_lang}'."
+        end
+      else # Do not execute; a RESULT block follows and was identified
+        lang_specific_result_type = is_ruby_style_result ? "```ruby RESULT" : "```RESULT"
+        warn "Found existing '#{lang_specific_result_type}' block for current #{current_block_lang} block, skipping execution."
+
+        output_lines.concat(lines_to_pass_through_if_skipped) # Add blank line (if any) and RESULT header
+
+        # Consume the rest of the RESULT block content until its closing ```
+        begin
+          loop do
+            result_block_line = file_enum.next
+            output_lines << result_block_line
+            break if result_block_line.strip == "```"
           end
+        rescue StopIteration
+          warn "Warning: End of file reached inside a skipped 'RESULT' block."
+          break # Exit main loop
         end
+      end
 
-        in_code_block = false
-        current_code_content = "" # Reset for next block
-        next # Continue to the next line from the file
+      in_code_block = false
+      current_code_content = "" # Reset for next block
+      next
       # Case 5: Line inside an active code block
-      else
-        current_code_content += current_line
-        output_lines << current_line # This line is part of the original code block being recorded
-        next # Continue to the next line from the file
-      end
+    else
+      current_code_content += current_line
+      output_lines << current_line # This line is part of the original code block being recorded
+      next # Continue to the next line from the file
     end
   end # loop
 
   # Write the modified content back to the input file
-  Tempfile.create([ 'md_exec_out_', File.extname(input_file_path) ], temp_dir) do |temp_output_file|
-    temp_output_file.write(output_lines.join(''))
+  Tempfile.create([ "md_exec_out_", File.extname(input_file_path) ], temp_dir) do |temp_output_file|
+    temp_output_file.write(output_lines.join(""))
     temp_output_file.close
     begin
       FileUtils.mv(temp_output_file.path, input_file_path)
@@ -295,6 +317,8 @@ class TestMarkdownExec < Minitest::Test
   end
 
   def test_psql_block_execution
+    skip "Skipping test_psql_block_execution on GitHub CI" if ENV['CI']
+
     md_content = <<~MARKDOWN
       ```psql
       SELECT 'hello psql test';
@@ -364,6 +388,4 @@ class TestMarkdownExec < Minitest::Test
   end
 end
 
-unless ARGV.empty?
-  process_markdown_file_main(ARGV[0])
-end
+process_markdown_file_main(ARGV[0]) unless ARGV.empty?

data/lib/markdown/run/version.rb

@@ -2,6 +2,6 @@
 
 module Markdown
   module Run
-    VERSION = "0.1.0"
+    VERSION = "0.1.2"
   end
 end

metadata

@@ -1,17 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: markdown-run
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Aurélien Bottazini
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-05-13 00:00:00.000000000 Z
-dependencies: []
-description: Run code blocks in Markdown files. Store output in a code block following
-  the original code block.
+date: 2025-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rcodetools
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Run code blocks in Markdown files for Ruby, JavaScript, sqlite and psql.
+  Insert execution results next to the original code blocks.
 email:
 - 32635+aurelienbottazini@users.noreply.github.com
 executables:
@@ -24,16 +38,13 @@ files:
 - CODE_OF_CONDUCT.md
 - LICENSE.txt
 - README.md
-- Rakefile
 - exe/markdown-run
-- lib/markdown/run.rb
 - lib/markdown/run/version.rb
-- sig/markdown/run.rbs
-homepage: https://github.com/aurelienbottazini/markdown-run
+homepage: https://rubygems.org/gems/markdown-run
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/aurelienbottazini/markdown-run
+  homepage_uri: https://rubygems.org/gems/markdown-run
   source_code_uri: https://github.com/aurelienbottazini/markdown-run
   changelog_uri: https://github.com/aurelienbottazini/markdown-run/blob/main/CHANGELOG.md
 post_install_message:

data/Rakefile

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-require "minitest/test_task"
-
-Minitest::TestTask.create
-
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
-task default: %i[test rubocop]

data/lib/markdown/run.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "run/version"
-
-module Markdown
-  module Run
-    class Error < StandardError; end
-    # Your code goes here...
-  end
-end

data/sig/markdown/run.rbs

@@ -1,6 +0,0 @@
-module Markdown
-  module Run
-    VERSION: String
-    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
-  end
-end