prompt_manager 0.5.8 → 1.0.0

data/lib/prompt_manager/directive_processor.rb

@@ -1,47 +0,0 @@
-# lib/prompt_manager/directive_processor.rb
-
-# This is an example of a directive processor class.
-# It only supports the //include directive which is also
-# aliased as //import.
-
-module PromptManager
-  class DirectiveProcessor
-    EXCLUDED_METHODS = %w[ run initialize ]
-
-    def initialize
-      @prefix_size    = PromptManager::Prompt::DIRECTIVE_SIGNAL.size
-      @included_files = []
-    end
-
-    def run(directives)
-      return {} if directives.nil? || directives.empty?
-      directives.each do |key, _|
-        sans_prefix = key[@prefix_size..]
-        args        = sans_prefix.split(' ')
-        method_name = args.shift
-
-        if EXCLUDED_METHODS.include?(method_name)
-          directives[key] = "Error: #{method_name} is not a valid directive: #{key}"
-        elsif respond_to?(method_name)
-          directives[key] =  send(method_name, *args)
-        else
-          directives[key] = "Error: Unknown directive '#{key}'"
-        end
-      end
-      directives
-    end
-
-    def include(file_path)
-      if  File.exist?(file_path) &&
-          File.readable?(file_path) &&
-          !@included_files.include?(file_path)
-        content = File.read(file_path)
-        @included_files << file_path
-        content
-      else
-        "Error: File '#{file_path}' not accessible"
-      end
-    end
-    alias_method :import, :include
-  end
-end

data/lib/prompt_manager/prompt.rb

@@ -1,195 +0,0 @@
-# prompt_manager/lib/prompt_manager/prompt.rb
-
-require_relative "directive_processor"
-
-class PromptManager::Prompt
-  COMMENT_SIGNAL          = '#'   # lines beginning with this are a comment
-  DIRECTIVE_SIGNAL        = '//'  # Like the old IBM JCL
-  DEFAULT_PARAMETER_REGEX = /(\[[A-Z _|]+\])/
-  @parameter_regex        = DEFAULT_PARAMETER_REGEX
-
-  ##############################################
-  ## Public class methods
-
-  class << self
-    attr_accessor :storage_adapter, :parameter_regex
-
-    def get(id:)
-      storage_adapter.get(id: id)  # Return the hash directly from storage
-    end
-
-    def create(id:, text: "", parameters: {})
-      storage_adapter.save(
-        id:         id,
-        text:       text,
-        parameters: parameters
-      )
-
-      ::PromptManager::Prompt.new(id: id, context: [], directives_processor: PromptManager::DirectiveProcessor.new)
-    end
-
-    def find(id:)
-      ::PromptManager::Prompt.new(id: id, context: [], directives_processor: PromptManager::DirectiveProcessor.new)
-    end
-
-    def destroy(id:)
-      prompt = find(id: id)
-      prompt.delete
-    end
-
-    def search(for_what)
-      storage_adapter.search(for_what)
-    end
-
-    def method_missing(method_name, *args, &block)
-      if storage_adapter.respond_to?(method_name)
-        storage_adapter.send(method_name, *args, &block)
-      else
-        super
-      end
-    end
-
-    def respond_to_missing?(method_name, include_private = false)
-      storage_adapter.respond_to?(method_name, include_private) || super
-    end
-  end
-
-  ##############################################
-  ## Public Instance Methods
-
-  attr_accessor :id,           # String name for the prompt
-                :text,         # String, full text of the prompt
-                :parameters    # Hash, Key and Value are Strings
-
-
-  def initialize(
-      id:       nil,    # A String name for the prompt
-      context:  [],     # TODO: Array of Strings or Pathname?
-      directives_processor: PromptManager::DirectiveProcessor.new,
-      external_binding:     binding,
-      erb_flag:             false,    # replace $ENVAR and ${ENVAR} when true
-      envar_flag:           false     # process ERB against the external_binding when true
-    )
-
-    @id  = id
-    @directives_processor = directives_processor
-
-    validate_arguments(@id)
-
-    @record           = db.get(id: id)
-    @text             = @record[:text]        || ""
-    @parameters       = @record[:parameters]  || {}
-    @directives       = {}
-    @external_binding = external_binding
-    @erb_flag         = erb_flag
-    @envar_flag       = envar_flag
-  end
-
-  def validate_arguments(prompt_id, prompts_db=db)
-    raise ArgumentError, 'id cannot be blank'           if prompt_id.nil? || prompt_id.strip.empty?
-    raise(ArgumentError, 'storage_adapter is not set')  if prompts_db.nil?
-  end
-
-  def to_s
-    processed_text = remove_comments
-    processed_text = substitute_values(processed_text, @parameters)
-    processed_text = substitute_env_vars(processed_text)
-    processed_text = process_directives(processed_text)
-    process_erb(processed_text)
-  end
-
-  def save
-    db.save(
-      id:         id,
-      text:       text,       # Save the original text
-      parameters: parameters
-    )
-  end
-
-  def delete = db.delete(id: id)
-
-
-  ######################################
-  private
-
-  def db = self.class.storage_adapter
-
-
-  def remove_comments
-    lines = @text.gsub(/<!--.*?-->/m, '').lines(chomp: true)
-    markdown_block_depth = 0
-    filtered_lines = []
-    end_index = lines.index("__END__") || lines.size
-
-    lines[0...end_index].each do |line|
-      trimmed_line = line.strip
-
-      if trimmed_line.start_with?('```')
-        if trimmed_line == '```markdown'
-          markdown_block_depth += 1
-        elsif markdown_block_depth > 0
-          markdown_block_depth -= 1
-        end
-      end
-
-      if markdown_block_depth > 0 || !trimmed_line.start_with?(COMMENT_SIGNAL)
-        filtered_lines << line
-      end
-    end
-
-    filtered_lines.join("\n")
-  end
-
-
-
-
-  def substitute_values(input_text, values_hash)
-    if values_hash.is_a?(Hash) && !values_hash.empty?
-      values_hash.each do |key, value|
-        value = value.last if value.is_a?(Array)
-        input_text = input_text.gsub(key, value.nil? ? '' : value)
-      end
-    end
-    input_text
-  end
-
-  def erb?      = @erb_flag
-  def envar?    = @envar_flag
-
-  def substitute_env_vars(input_text)
-    return input_text unless envar?
-
-    # First, handle shell command substitution $(command)
-    input_text = input_text.gsub(/\$\(([^\)]+)\)/) do |match|
-      cmd = $1.strip
-      begin
-        # Execute the shell command and capture its output
-        result = `#{cmd}`.chomp
-        result.empty? ? match : result
-      rescue => e
-        # If command execution fails, log the error and keep the original text
-        warn "Shell command execution failed: #{e.message}"
-        match
-      end
-    end
-
-    # Then handle environment variables as before
-    input_text.gsub(/\$(\w+)|\$\{(\w+)\}/) do |match|
-      env_var = $1 || $2
-      ENV[env_var] || match
-    end
-  end
-
-  def process_directives(input_text)
-    directive_lines = input_text.split("\n").select { |line| line.strip.start_with?(DIRECTIVE_SIGNAL) }
-    @directives = directive_lines.each_with_object({}) { |line, hash| hash[line.strip] = "" }
-    @directives = @directives_processor.run(@directives)
-    substitute_values(input_text, @directives)
-  end
-
-  def process_erb(input_text)
-    return input_text unless erb?
-
-    ERB.new(input_text).result(@external_binding)
-  end
-end

data/lib/prompt_manager/storage/active_record_adapter.rb

@@ -1,157 +0,0 @@
-# prompt_manager/lib/prompt_manager/storage/active_record_adapter.rb
-
-# This class acts as an adapter for interacting with an ActiveRecord model
-require 'active_record'
-# to manage storage operations for PromptManager::Prompt instances. It defines
-# methods that allow for saving, searching, retrieving by ID, and deleting
-# prompts.
-#
-# To use this adapter, you must configure it with an ActiveRecord model and
-# the column names for ID, text content, and parameters. The adapter will
-# handle serialization and deserialization of parameters.
-#
-# This adapter is used by PromptManager::Prompt as its storage backend, enabling CRUD operations on persistent prompt data.
-
-class PromptManager::Storage::ActiveRecordAdapter
-  
-  class << self
-    # Configure the ActiveRecord model and column mappings
-    attr_accessor :model,
-                  :id_column,
-                  :text_column,
-                  :parameters_column
-
-    # Configure the adapter with the required settings
-    # Must be called with a block before using the adapter
-    def config
-      if block_given?
-        yield self
-        validate_configuration
-      else
-        raise ArgumentError, "No block given to config"
-      end
-      
-      self
-    end
-
-    # Validate that all required configuration is present and valid
-    def validate_configuration
-      validate_model
-      validate_columns
-    end
-
-    # Ensure the provided model is a valid ActiveRecord model
-    def validate_model
-      raise ArgumentError, "AR Model not set" unless model
-      raise ArgumentError, "AR Model is not an ActiveRecord model" unless model < ActiveRecord::Base
-    end
-
-    # Verify that all required columns exist in the model
-    def validate_columns
-      columns = model.column_names # Array of Strings
-      [id_column, text_column, parameters_column].each do |column|
-        raise ArgumentError, "#{column} is not a valid column for model #{model}" unless columns.include?(column.to_s)
-      end
-    end
-
-    # Delegate unknown methods to the ActiveRecord model
-    def method_missing(method_name, *args, &block)
-      if model.respond_to?(method_name)
-        model.send(method_name, *args, &block)
-      else
-        super
-      end
-    end
-
-    # Support respond_to? for delegated methods
-    def respond_to_missing?(method_name, include_private = false)
-      model.respond_to?(method_name, include_private) || super
-    end
-  end
-  
-
-  ##############################################
-  # The ActiveRecord object representing the current prompt
-  attr_accessor :record
-
-  # Accessor methods to avoid repeated self.class prefixes
-  def model             = self.class.model
-  def id_column         = self.class.id_column
-  def text_column       = self.class.text_column
-  def parameters_column = self.class.parameters_column
-
-  # Initialize the adapter and validate configuration
-  def initialize
-    self.class.send(:validate_configuration) # send gets around private designations of a method
-    @record = model.first
-  end
-
-  # Retrieve a prompt by its ID
-  # Returns a hash with id, text, and parameters
-  def get(id:)
-    @record = model.find_by(id_column => id)
-    raise ArgumentError, "Prompt not found with id: #{id}" unless @record
-
-    # Handle case where parameters might be stored as a JSON string
-    # instead of a native Hash
-    parameters = @record[parameters_column]
-
-    if parameters.is_a? String
-      parameters = JSON.parse parameters
-    end
-
-    {
-      id:         id,
-      text:       @record[text_column],
-      parameters: parameters
-    }
-  end
-
-  # Save a prompt with the given ID, text, and parameters
-  # Creates a new record if one doesn't exist, otherwise updates existing record
-  def save(id:, text: "", parameters: {})
-    @record = model.find_or_initialize_by(id_column => id) 
-
-    @record[text_column] = text
-    @record[parameters_column] = parameters
-    @record.save!
-  end
-
-  # Delete a prompt with the given ID
-  def delete(id:)
-    @record = model.find_by(id_column => id)
-    @record&.destroy
-  end
-
-  # Return an array of all prompt IDs
-  def list(*)
-    model.all.pluck(id_column)
-  end
-
-  # Search for prompts containing the given text
-  # Returns an array of matching prompt IDs
-  def search(for_what)
-    model.where("#{text_column} LIKE ?", "%#{for_what}%").pluck(id_column)
-  end
-
-  ##############################################
-  private
-
-  # Delegate unknown methods to the current record
-  def method_missing(method_name, *args, &block)
-    if @record && @record.respond_to?(method_name)
-      @record.send(method_name, *args, &block)
-    elsif model.respond_to?(method_name)
-      model.send(method_name, *args, &block)
-    else
-      super
-    end
-  end
-
-  # Support respond_to? for delegated methods
-  def respond_to_missing?(method_name, include_private = false)
-    (model.respond_to?(method_name, include_private) ||
-     (@record && @record.respond_to?(method_name, include_private)) ||
-     super)
-  end
-end