prompter-ruby 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 62d43dac53307b79d18f84fcf1c40fd88dbf19a5c337b9e914c13fa010b73dbe
-  data.tar.gz: 7e2c23ca40c7178b0821bf105bd4389a33b2f293ca4ae76551b762262b17e9d2
+  metadata.gz: c21c7bea53b34f25eed8b9b186c5212d23033bd2600110125c85210b91052e85
+  data.tar.gz: f0f14bfcf7d30ad14d02d93e475d1a1d002aa548df5328002579fba950043089
 SHA512:
-  metadata.gz: 630c8c261d232440ac6335e0d479a8933b9e2c8f57379d63a5a94da0af59aabc9cabd1c32e549b07663c14902d8f70dcf3d9cc211832900a6b6f81b61f4e3ff6
-  data.tar.gz: 170c646d22cd2e94a1f63772f1772660acd4f33e9cc0215ba5432d29766df0560c9be3114b904cdf1b3c8116fe30226adacb7318a8f95cf749b4265a7da71f89
+  metadata.gz: 3ac3b64c564a9aafe1859ad333147318f46d6d9e0194760bcd78528fe0e737fe78bc45c3b2a917d54131f24d256bc6a9d619631d0a2c58304de6d6871577cb72
+  data.tar.gz: c0e98a881337ab38b3806ffe199a9be57d7632d6bb1a0f1dc85dbbcc3685f8d74ba5e5ce1b51e09fdd2c2d960e476f51218f1182852b2f29114320c636704d6c

data/README.md

@@ -1,11 +1,11 @@
 # prompter-ruby
 
-Prompt template engine for Ruby with variables, conditionals, loops, and versioning.
+Prompt template engine for Ruby. Render dynamic prompts with variables, conditionals, and loops.
 
 ## Installation
 
 ```ruby
-gem "prompter-ruby", "~> 0.1"
+gem "prompter-ruby"
 ```
 
 ## Usage
@@ -13,25 +13,39 @@ gem "prompter-ruby", "~> 0.1"
 ```ruby
 require "prompter_ruby"
 
-result = PrompterRuby.render("Hello {{name}}!", name: "World")
+# Basic variable interpolation
+template = PrompterRuby::Template.new("Hello, {{name}}!")
+template.render(name: "World")  # => "Hello, World!"
 
-template = PrompterRuby::Template.new(<<~PROMPT)
-  You are {{bot_name}}.
-  {% if context %}Context: {{context}}{% endif %}
-  {% for rule in rules %}- {{rule}}
+# Conditionals and loops
+source = <<~TMPL
+  You are a {{role}} assistant.
+  {% if context %}Use this context: {{context}}{% endif %}
+  {% for item in items %}
+  - {{item}}
   {% endfor %}
-PROMPT
+TMPL
+template = PrompterRuby::Template.new(source)
+template.render(role: "helpful", items: ["A", "B", "C"])
 
-result = template.render(
-  bot_name: "Max",
-  context: "Some info",
-  rules: ["Be concise", "Be helpful"]
-)
+# Strict mode (raise on undefined variables)
+template.render({ name: "World" }, strict: true)
 
-library = PrompterRuby::Library.new("./prompts/")
-template = library.get("rag_answer", version: "v2")
+# Validation
+template.valid?      # => true/false
+template.validate!   # raises ParseError if invalid
 ```
 
+## Features
+
+- `{{variable}}` interpolation with nested key access
+- `{% if %}` / `{% else %}` / `{% endif %}` conditionals
+- `{% for x in items %}` / `{% endfor %}` loops
+- Strict mode raises `UndefinedVariableError` for missing variables
+- ParseError with line numbers for unclosed blocks
+- Template validation (`valid?`, `validate!`)
+- Whitespace trimming for tag-only lines
+
 ## License
 
 MIT

data/lib/prompter_ruby/filters.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "json"
+
+module PrompterRuby
+  module Filters
+    REGISTRY = {
+      "upcase" => ->(v, _) { v.to_s.upcase },
+      "downcase" => ->(v, _) { v.to_s.downcase },
+      "capitalize" => ->(v, _) { v.to_s.capitalize },
+      "strip" => ->(v, _) { v.to_s.strip },
+      "reverse" => ->(v, _) { v.respond_to?(:reverse) ? v.reverse : v.to_s.reverse },
+      "size" => ->(v, _) { v.respond_to?(:size) ? v.size : v.to_s.size },
+      "first" => ->(v, _) { v.respond_to?(:first) ? v.first : v },
+      "last" => ->(v, _) { v.respond_to?(:last) ? v.last : v },
+      "json" => ->(v, _) { JSON.generate(v) },
+      "escape" => ->(v, _) { escape_html(v.to_s) },
+      "truncate" => ->(v, arg) { n = (arg || 100).to_i; v.to_s.length > n ? v.to_s[0...n] + "..." : v.to_s },
+      "join" => ->(v, arg) { v.respond_to?(:join) ? v.join(arg || ", ") : v.to_s },
+      "default" => ->(v, arg) { (v.nil? || (v.respond_to?(:empty?) && v.empty?)) ? arg : v },
+      "replace" => ->(v, arg) { parts = arg.to_s.split(",", 2).map(&:strip); v.to_s.gsub(parts[0].to_s, parts[1].to_s) }
+    }.freeze
+
+    def self.apply(value, filter_chain)
+      filter_chain.each do |name, arg|
+        filter = REGISTRY[name]
+        raise RenderError, "Unknown filter: '#{name}'" unless filter
+        value = filter.call(value, arg)
+      end
+      value
+    end
+
+    def self.parse(expression)
+      parts = expression.split("|")
+      var_name = parts.shift.strip
+      filters = parts.map do |f|
+        f = f.strip
+        if f.include?(":")
+          name, arg = f.split(":", 2)
+          [name.strip, arg.strip.delete("'\"")]
+        else
+          [f, nil]
+        end
+      end
+      [var_name, filters]
+    end
+
+    def self.escape_html(str)
+      str.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;").gsub('"', "&quot;").gsub("'", "&#39;")
+    end
+  end
+end

data/lib/prompter_ruby/nodes/comment_node.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PrompterRuby
+  module Nodes
+    class CommentNode
+      def initialize(text)
+        @text = text
+      end
+
+      def render(_context)
+        ""
+      end
+    end
+  end
+end

data/lib/prompter_ruby/nodes/if_node.rb

@@ -3,36 +3,91 @@
 module PrompterRuby
   module Nodes
     class IfNode
-      def initialize(condition, true_nodes, false_nodes = [])
+      COMPARISON_OPS = %w[== != >= <= > <].freeze
+
+      def initialize(condition, true_nodes, false_nodes = [], elsif_branches: [])
         @condition = condition.strip
         @true_nodes = true_nodes
         @false_nodes = false_nodes
+        @elsif_branches = elsif_branches  # Array of [condition, nodes]
       end
 
       def render(context)
-        if evaluate_condition(context)
+        if evaluate_condition(@condition, context)
           @true_nodes.map { |n| n.render(context) }.join
         else
+          @elsif_branches.each do |cond, nodes|
+            if evaluate_condition(cond, context)
+              return nodes.map { |n| n.render(context) }.join
+            end
+          end
           @false_nodes.map { |n| n.render(context) }.join
         end
       end
 
       private
 
-      def evaluate_condition(context)
-        negate = false
-        condition = @condition
+      def evaluate_condition(condition, context)
+        # Boolean operators (and/or)
+        if condition.include?(" and ")
+          parts = condition.split(" and ", 2)
+          return evaluate_condition(parts[0].strip, context) && evaluate_condition(parts[1].strip, context)
+        end
+        if condition.include?(" or ")
+          parts = condition.split(" or ", 2)
+          return evaluate_condition(parts[0].strip, context) || evaluate_condition(parts[1].strip, context)
+        end
 
+        negate = false
         if condition.start_with?("not ")
           negate = true
           condition = condition.sub("not ", "").strip
         end
 
+        # Comparison operators
+        COMPARISON_OPS.each do |op|
+          if condition.include?(" #{op} ")
+            left, right = condition.split(" #{op} ", 2).map(&:strip)
+            left_val = resolve_or_literal(left, context)
+            right_val = resolve_or_literal(right, context)
+            result = compare(left_val, right_val, op)
+            return negate ? !result : result
+          end
+        end
+
         value = resolve_value(condition, context)
         result = truthy?(value)
         negate ? !result : result
       end
 
+      def compare(a, b, op)
+        case op
+        when "==" then a == b
+        when "!=" then a != b
+        when ">" then a.to_f > b.to_f
+        when ">=" then a.to_f >= b.to_f
+        when "<" then a.to_f < b.to_f
+        when "<=" then a.to_f <= b.to_f
+        else false
+        end
+      end
+
+      def resolve_or_literal(expr, context)
+        # String literal
+        if expr.match?(/\A['"](.*)['"]/)
+          return expr[1..-2]
+        end
+        # Numeric literal
+        if expr.match?(/\A-?\d+(\.\d+)?\z/)
+          return expr.include?(".") ? expr.to_f : expr.to_i
+        end
+        # Boolean
+        return true if expr == "true"
+        return false if expr == "false"
+        # Variable
+        resolve_value(expr, context)
+      end
+
       def resolve_value(name, context)
         parts = name.split(".")
         value = context

data/lib/prompter_ruby/nodes/raw_node.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module PrompterRuby
+  module Nodes
+    class RawNode
+      def initialize(text)
+        @text = text
+      end
+
+      def render(_context)
+        @text
+      end
+    end
+  end
+end

data/lib/prompter_ruby/nodes/set_node.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module PrompterRuby
+  module Nodes
+    class SetNode
+      def initialize(name, value_expr)
+        @name = name.strip
+        @value_expr = value_expr.strip
+      end
+
+      def render(context)
+        value = evaluate(@value_expr, context)
+        context[@name.to_sym] = value
+        ""
+      end
+
+      private
+
+      def evaluate(expr, context)
+        # String literal
+        if expr.match?(/\A["'](.*)["']\z/)
+          return expr[1..-2]
+        end
+
+        # Numeric
+        if expr.match?(/\A-?\d+(\.\d+)?\z/)
+          return expr.include?(".") ? expr.to_f : expr.to_i
+        end
+
+        # Boolean
+        return true if expr == "true"
+        return false if expr == "false"
+
+        # Variable reference
+        resolve(expr, context)
+      end
+
+      def resolve(name, context)
+        parts = name.split(".")
+        value = context
+        parts.each do |part|
+          if value.is_a?(Hash)
+            key = value.key?(part.to_sym) ? part.to_sym : part
+            value = value[key]
+          else
+            return nil
+          end
+        end
+        value
+      end
+    end
+  end
+end

data/lib/prompter_ruby/nodes/variable_node.rb

@@ -6,23 +6,28 @@ module PrompterRuby
       attr_reader :name
 
       def initialize(name)
-        @name = name.strip
+        @raw = name.strip
+        @var_name, @filters = Filters.parse(@raw)
       end
 
       def render(context)
         value = resolve(context)
 
         if value.nil? && context[:__strict__]
-          raise UndefinedVariableError, "Undefined variable: '#{@name}'"
+          raise UndefinedVariableError, "Undefined variable: '#{@var_name}'"
         end
 
-        value.to_s
+        if @filters.any?
+          Filters.apply(value, @filters).to_s
+        else
+          value.to_s
+        end
       end
 
       private
 
       def resolve(context)
-        parts = @name.split(".")
+        parts = @var_name.split(".")
         value = context
 
         parts.each do |part|

data/lib/prompter_ruby/parser.rb

@@ -4,6 +4,7 @@ module PrompterRuby
   class Parser
     VARIABLE_PATTERN = /\{\{(.*?)\}\}/
     TAG_PATTERN = /\{%(.*?)%\}/
+    COMMENT_PATTERN = /\{#(.*?)#\}/m
 
     def parse(source)
       tokens = tokenize(source)
@@ -21,6 +22,7 @@ module PrompterRuby
       while scanner.length > 0
         var_match = scanner.match(VARIABLE_PATTERN)
         tag_match = scanner.match(TAG_PATTERN)
+        comment_match = scanner.match(COMMENT_PATTERN)
 
         next_match = nil
         next_pos = scanner.length
@@ -35,6 +37,11 @@ module PrompterRuby
           next_pos = tag_match.begin(0)
         end
 
+        if comment_match && comment_match.begin(0) < next_pos
+          next_match = :comment
+          next_pos = comment_match.begin(0)
+        end
+
         if next_pos > 0
           tokens << [:text, scanner[0...next_pos], line_number(source, offset)]
         end
@@ -48,6 +55,10 @@ module PrompterRuby
           tokens << [:tag, tag_match[1].strip, line_number(source, offset + tag_match.begin(0))]
           offset += tag_match.end(0)
           scanner = scanner[tag_match.end(0)..]
+        when :comment
+          tokens << [:comment, comment_match[1].strip, line_number(source, offset + comment_match.begin(0))]
+          offset += comment_match.end(0)
+          scanner = scanner[comment_match.end(0)..]
         else
           break
         end
@@ -144,6 +155,9 @@ module PrompterRuby
         when :text
           nodes << Nodes::TextNode.new(value)
           index += 1
+        when :comment
+          nodes << Nodes::CommentNode.new(value)
+          index += 1
         when :variable
           nodes << Nodes::VariableNode.new(value)
           index += 1
@@ -164,7 +178,23 @@ module PrompterRuby
 
             index = index + 1 + end_index
 
+            # Handle elsif/else chains
+            elsif_branches = []
             false_nodes = []
+
+            while tokens[index] && tokens[index][1]&.start_with?("elsif ")
+              elsif_cond = tokens[index][1].sub("elsif ", "").strip
+              elsif_line = tokens[index][2]
+              result = parse_nodes(tokens[(index + 1)..], stop_tags: ["elsif", "else", "endif"], open_tag: "elsif", open_line: elsif_line)
+              if result.is_a?(Array) && result.length == 2
+                elsif_nodes, end_index = result
+              else
+                raise ParseError, "Unclosed 'elsif' block starting at line #{elsif_line}"
+              end
+              elsif_branches << [elsif_cond, elsif_nodes]
+              index = index + 1 + end_index
+            end
+
             if tokens[index] && tokens[index][1]&.start_with?("else")
               else_line = tokens[index][2]
               result = parse_nodes(tokens[(index + 1)..], stop_tags: ["endif"], open_tag: "else", open_line: else_line)
@@ -185,7 +215,7 @@ module PrompterRuby
 
             index += 1
 
-            nodes << Nodes::IfNode.new(condition, true_nodes, false_nodes)
+            nodes << Nodes::IfNode.new(condition, true_nodes, false_nodes, elsif_branches: elsif_branches)
           elsif value.start_with?("for ")
             match = value.match(/for\s+(\w+)\s+in\s+(\S+)/)
             raise ParseError, "Invalid for syntax: #{value}" unless match
@@ -209,6 +239,30 @@ module PrompterRuby
             index = index + 1 + end_index + 1
 
             nodes << Nodes::ForNode.new(item_name, collection_name, body_nodes)
+          elsif value == "raw"
+            # Collect raw tokens until endraw, reconstructing original syntax
+            raw_text = ""
+            index += 1
+            while index < tokens.length
+              type_r, value_r, = tokens[index]
+              if type_r == :tag && value_r == "endraw"
+                index += 1
+                break
+              end
+              case type_r
+              when :text, :text_skip then raw_text += value_r
+              when :variable then raw_text += "{{#{value_r}}}"
+              when :tag then raw_text += "{%#{value_r}%}"
+              when :comment then raw_text += "{##{value_r}#}"
+              end
+              index += 1
+            end
+            nodes << Nodes::RawNode.new(raw_text)
+          elsif value.start_with?("set ")
+            match = value.match(/set\s+(\w+)\s*=\s*(.+)/)
+            raise ParseError, "Invalid set syntax: #{value}" unless match
+            nodes << Nodes::SetNode.new(match[1], match[2])
+            index += 1
           else
             nodes << Nodes::TextNode.new("{%#{value}%}")
             index += 1

data/lib/prompter_ruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PrompterRuby
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/lib/prompter_ruby.rb

@@ -2,10 +2,14 @@
 
 require_relative "prompter_ruby/version"
 require_relative "prompter_ruby/errors"
+require_relative "prompter_ruby/filters"
 require_relative "prompter_ruby/nodes/text_node"
 require_relative "prompter_ruby/nodes/variable_node"
 require_relative "prompter_ruby/nodes/if_node"
 require_relative "prompter_ruby/nodes/for_node"
+require_relative "prompter_ruby/nodes/comment_node"
+require_relative "prompter_ruby/nodes/raw_node"
+require_relative "prompter_ruby/nodes/set_node"
 require_relative "prompter_ruby/parser"
 require_relative "prompter_ruby/template"
 require_relative "prompter_ruby/library"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prompter-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Johannes Dwi Cahyo
@@ -51,9 +51,13 @@ files:
 - Rakefile
 - lib/prompter_ruby.rb
 - lib/prompter_ruby/errors.rb
+- lib/prompter_ruby/filters.rb
 - lib/prompter_ruby/library.rb
+- lib/prompter_ruby/nodes/comment_node.rb
 - lib/prompter_ruby/nodes/for_node.rb
 - lib/prompter_ruby/nodes/if_node.rb
+- lib/prompter_ruby/nodes/raw_node.rb
+- lib/prompter_ruby/nodes/set_node.rb
 - lib/prompter_ruby/nodes/text_node.rb
 - lib/prompter_ruby/nodes/variable_node.rb
 - lib/prompter_ruby/parser.rb