markdown_exec 3.0.5 → 3.0.7

data/docs/ux-blocks-init-act.md

@@ -0,0 +1,100 @@
+# UX Block Init and Act Keys
+
+The `init` and `act` keys determine which other key is read for processing during initialization and activation respectively.
+
+## Algorithm
+
+1. **Init Phase** (when document is loaded) per FCB.init_source:
+   - If `init` is `false`: No initialization occurs
+   - If `init` is a string: That string becomes the initial value
+   - If `init` is `:allow`: First value from `allow` list is used
+   - If `init` is `:echo`: Value from `echo` key is evaluated and returned
+   - If `init` is `:exec`: Command from `exec` key is executed and stdout is returned
+   - If `init` is not present: Defaults to first available in order:
+     - `:allow` if `allow` exists
+     - `:default` if `default` exists
+     - `:echo` if `echo` exists
+     - `:exec` if `exec` exists
+     - `false` if none of the above exist
+
+2. **Act Phase** (when block is activated) per FCB.act_source:
+   - If `act` is `false`: Block cannot be activated
+   - If `act` is `:allow`: User selects from `allow` list
+   - If `act` is `:echo`: Value from `echo` key is evaluated and returned
+   - If `act` is `:edit`: User is prompted for input
+   - If `act` is `:exec`: Command from `exec` key is executed and stdout is returned
+   - If `act` is not present: Defaults to:
+     - If `init` is `false`:
+       - First available in order: `:allow`, `:echo`, `:edit`, `:exec`
+     - Otherwise:
+       - `:allow` if `allow` exists
+       - `:edit` if `allow` does not exist
+
+## Examples
+
+### Echo on Init, Exec on Act
+```ux
+name: DEPLOY_CONFIG
+init: :echo
+echo: "Deploying ${VERSION} to ${ENVIRONMENT}"
+act: :exec
+exec: "deploy.sh ${ENVIRONMENT} ${VERSION}"
+```
+Behavior:
+- On init: Evaluates echo string "Deploying ${VERSION} to ${ENVIRONMENT}"
+- On act: Executes deploy.sh with environment and version parameters
+
+### Allow on Init, Edit on Act
+```ux
+name: ENVIRONMENT
+init: :allow
+allow:
+  - development
+  - staging
+  - production
+act: :edit
+prompt: Select environment
+```
+Behavior:
+- On init: Uses first allowed value (development)
+- On act: Prompts user to select from allowed values
+
+### Exec on Init, Echo on Act
+```ux
+name: CURRENT_DIR
+init: :exec
+exec: basename $(pwd)
+act: :echo
+echo: "Current directory: ${CURRENT_DIR}"
+```
+Behavior:
+- On init: Executes basename command on current directory
+- On act: Evaluates echo string with current directory value
+
+### Allow on Both
+```ux
+name: API_KEY
+init: :allow
+allow:
+  - ${PROD_API_KEY}
+  - ${STAGING_API_KEY}
+  - ${DEV_API_KEY}
+act: :allow
+require:
+  - ENVIRONMENT
+```
+Behavior:
+- On init: Uses first allowed API key
+- On act: Shows menu of allowed API keys for selection
+
+### Echo on Both
+```ux
+name: SHELL_VERSION
+init: :echo
+echo: $SHELL
+act: :echo
+echo: "Using shell: ${SHELL_VERSION}"
+```
+Behavior:
+- On init: Gets shell value from environment
+- On act: Evaluates echo string with current shell value 

data/lib/command_result.rb

@@ -32,6 +32,18 @@ class CommandResult
     exit_status.zero?
   end
 
+  # def new_lines
+  #   value = @attributes[:new_lines]
+  #   ww caller.deref[0..4], value    
+  #   value
+  # end
+
+  # # trap assignment to new_lines
+  # def new_lines=(value)
+  #   ww caller.deref[0..4], value    
+  #   @attributes[:new_lines] = value
+  # end
+
   def method_missing(name, *args)
     key = name.to_s.chomp('=').to_sym
 

data/lib/command_result_alternatives.rb

@@ -0,0 +1,233 @@
+#!/usr/bin/env -S bundle exec ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+# Alternative implementations of CommandResult that provide the same specs
+
+# Option 1: Using OpenStruct as base with method overrides
+require 'ostruct'
+
+class CommandResultOpenStruct < OpenStruct
+  def initialize(**attributes)
+    # Set defaults
+    defaults = { exit_status: 0, stdout: '' }
+    super(defaults.merge(attributes))
+  end
+
+  def failure?
+    !success?
+  end
+
+  def success?
+    exit_status.zero?
+  end
+
+  # Intercept specific setter
+  def new_lines=(value)
+    warn caller.deref[0..4], value
+    super(value)
+  end
+end
+
+# Option 2: Using instance variables with define_method
+class CommandResultInstanceVars
+  def initialize(**attributes)
+    @exit_status = 0
+    @stdout = ''
+    
+    attributes.each do |name, value|
+      instance_variable_set("@#{name}", value)
+      
+      # Define getter and setter methods dynamically
+      self.class.define_method(name) do
+        instance_variable_get("@#{name}")
+      end
+      
+      self.class.define_method("#{name}=") do |val|
+        instance_variable_set("@#{name}", val)
+      end
+    end
+  end
+
+  def failure?
+    !success?
+  end
+
+  def success?
+    exit_status.zero?
+  end
+
+  # Intercept specific setter
+  def new_lines=(value)
+    warn caller.deref[0..4], value
+    @new_lines = value
+  end
+
+  def method_missing(name, *args)
+    if name.to_s.end_with?('=')
+      # Setter
+      attr_name = name.to_s.chomp('=')
+      instance_variable_set("@#{attr_name}", args.first)
+      
+      # Define methods for future use
+      self.class.define_method(attr_name) do
+        instance_variable_get("@#{attr_name}")
+      end
+      
+      self.class.define_method(name) do |val|
+        instance_variable_set("@#{attr_name}", val)
+      end
+    else
+      # Getter
+      if instance_variable_defined?("@#{name}")
+        instance_variable_get("@#{name}")
+      else
+        super
+      end
+    end
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    attr_name = name.to_s.chomp('=').to_sym
+    instance_variable_defined?("@#{attr_name}") || super
+  end
+end
+
+# Option 3: Using Struct with dynamic extension
+class CommandResultStruct
+  def self.new(**attributes)
+    # Create a Struct class with the given attributes plus defaults
+    defaults = { exit_status: 0, stdout: '' }
+    all_attrs = defaults.merge(attributes)
+    
+    struct_class = Struct.new(*all_attrs.keys, keyword_init: true) do
+      def failure?
+        !success?
+      end
+
+      def success?
+        exit_status.zero?
+      end
+
+      # Intercept specific setter
+      def new_lines=(value)
+        warn caller.deref[0..4], value
+        super(value)
+      end
+      
+      # Add dynamic attribute support
+      def method_missing(name, *args)
+        if name.to_s.end_with?('=')
+          # Add new attribute dynamically by recreating struct
+          attr_name = name.to_s.chomp('=').to_sym
+          current_attrs = to_h
+          current_attrs[attr_name] = args.first
+          
+          # This is a limitation - we can't easily add new fields to existing Struct
+          # So this approach has constraints
+          super
+        else
+          super
+        end
+      end
+    end
+    
+    struct_class.new(**all_attrs)
+  end
+end
+
+# Option 4: Using SimpleDelegator with Hash
+require 'delegate'
+
+class CommandResultDelegator < SimpleDelegator
+  def initialize(**attributes)
+    defaults = { exit_status: 0, stdout: '' }
+    @hash = defaults.merge(attributes)
+    super(@hash)
+  end
+
+  def failure?
+    !success?
+  end
+
+  def success?
+    self[:exit_status].zero?
+  end
+
+  # Intercept specific setter
+  def new_lines=(value)
+    warn caller.deref[0..4], value
+    self[:new_lines] = value
+  end
+
+  def method_missing(name, *args)
+    key = name.to_s.chomp('=').to_sym
+
+    if name.to_s.end_with?('=') # setter
+      self[key] = args.first
+    elsif key?(key) # getter
+      self[key]
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    key = name.to_s.chomp('=').to_sym
+    key?(key) || super
+  end
+end
+
+# Option 5: Using refinements for cleaner method_missing
+module AttributeAccess
+  refine Hash do
+    def method_missing(name, *args)
+      key = name.to_s.chomp('=').to_sym
+
+      if name.to_s.end_with?('=') # setter
+        self[key] = args.first
+      elsif key?(key) # getter
+        self[key]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      key = name.to_s.chomp('=').to_sym
+      key?(key) || super
+    end
+  end
+end
+
+class CommandResultRefined
+  using AttributeAccess
+  
+  def initialize(**attributes)
+    @attributes = { exit_status: 0, stdout: '' }.merge(attributes)
+    @attributes.extend(AttributeAccess::Hash)
+  end
+
+  def failure?
+    !success?
+  end
+
+  def success?
+    @attributes.exit_status.zero?
+  end
+
+  # Intercept specific setter
+  def new_lines=(value)
+    warn caller.deref[0..4], value
+    @attributes.new_lines = value
+  end
+
+  def method_missing(name, *args)
+    @attributes.send(name, *args)
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    @attributes.respond_to?(name, include_private)
+  end
+end 

data/lib/env_interface.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+require_relative 'ww'
+
+# A class that provides an interface to ENV variables with customizable getters and setters
+class EnvInterface
+  class << self
+    # Get an environment variable with optional transformation
+    # @param key [String] The environment variable name
+    # @param default [Object] Default value if the variable is not set
+    # @param transform [Proc] Optional transformation to apply to the value
+    # @return [Object] The environment variable value
+    def get(key, default: nil, transform: nil)
+ww key, \
+      value = ENV[key]
+      return default if value.nil?
+
+      transform ? transform.call(value) : value
+    end
+
+    # Set an environment variable with optional transformation
+    # @param key [String] The environment variable name
+    # @param value [Object] The value to set
+    # @param transform [Proc] Optional transformation to apply before setting
+    # @return [String] The set value
+    def set(key, value, transform: nil)
+ww key, caller.deref[0..3], value
+      transformed_value = transform ? transform.call(value) : value
+      ENV[key] = transformed_value.to_s
+    end
+
+    # Check if an environment variable exists
+    # @param key [String] The environment variable name
+    # @return [Boolean] true if the variable exists
+    def exists?(key)
+      ENV.key?(key)
+    end
+
+    # Delete an environment variable
+    # @param key [String] The environment variable name
+    # @return [String] The deleted value
+    def delete(key)
+      ENV.delete(key)
+    end
+
+    # Get all environment variables
+    # @return [Hash] All environment variables
+    def all
+      ENV.to_h
+    end
+
+    # Clear all environment variables
+    # @return [void]
+    def clear
+      ENV.clear
+    end
+  end
+end