braintrust 0.1.1 → 0.1.2

data/lib/braintrust/vendor/mustache/mustache.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+# Vendored from mustache gem v1.1.1
+# https://github.com/mustache/mustache
+# License: MIT
+# Modifications:
+#   - Namespaced under Braintrust::Vendor
+#   - Disabled HTML escaping (LLM prompts don't need HTML escaping)
+
+require_relative "enumerable"
+require_relative "template"
+require_relative "context"
+require_relative "settings"
+require_relative "utils"
+
+module Braintrust
+  module Vendor
+    # Mustache is the base class from which your Mustache subclasses
+    # should inherit (though it can be used on its own).
+    #
+    # The typical Mustache workflow is as follows:
+    #
+    # * Create a Mustache subclass: class Stats < Mustache
+    # * Create a template: stats.mustache
+    # * Instantiate an instance: view = Stats.new
+    # * Render that instance: view.render
+    #
+    # You can skip the instantiation by calling `Stats.render` directly.
+    class Mustache
+      # Initialize a new Mustache instance.
+      #
+      # @param [Hash] options An options hash
+      # @option options [String] template_path
+      # @option options [String] template_extension
+      # @option options [String] template_file
+      # @option options [String] template
+      # @option options [String] view_namespace
+      # @option options [String] view_path
+      def initialize(options = {})
+        @options = options
+
+        initialize_settings
+      end
+
+      # Instantiates an instance of this class and calls `render` with
+      # the passed args.
+      #
+      # @return A rendered String version of a template.
+      def self.render(*args)
+        new.render(*args)
+      end
+
+      # Parses our fancy pants template file and returns normal file with
+      # all special {{tags}} and {{#sections}}replaced{{/sections}}.
+      #
+      # @example Render view
+      #   @view.render("Hi {{thing}}!", :thing => :world)
+      #
+      # @example Set view template and then render
+      #   View.template = "Hi {{thing}}!"
+      #   @view = View.new
+      #   @view.render(:thing => :world)
+      #
+      # @param [String,Hash] data A String template or a Hash context.
+      #                           If a Hash is given, we'll try to figure
+      #                           out the template from the class.
+      # @param [Hash] ctx A Hash context if `data` is a String template.
+      # @return [String] Returns a rendered version of a template.
+      def render(data = template, ctx = {})
+        case data
+        when Hash
+          ctx = data
+        when Symbol
+          self.template_name = data
+        end
+
+        tpl = case data
+        when Hash
+          templateify(template)
+        when Symbol
+          templateify(template)
+        else
+          templateify(data)
+        end
+
+        return tpl.render(context) if ctx == {}
+
+        begin
+          context.push(ctx)
+          tpl.render(context)
+        ensure
+          context.pop
+        end
+      end
+
+      # Context accessors.
+      #
+      # @example Context accessors
+      #   view = Mustache.new
+      #   view[:name] = "Jon"
+      #   view.template = "Hi, {{name}}!"
+      #   view.render # => "Hi, Jon!"
+      def [](key)
+        context[key.to_sym]
+      end
+
+      def []=(key, value)
+        context[key.to_sym] = value
+      end
+
+      # A helper method which gives access to the context at a given time.
+      # Kind of a hack for now, but useful when you're in an iterating section
+      # and want access to the hash currently being iterated over.
+      def context
+        @context ||= Context.new(self)
+      end
+
+      # Given a file name and an optional context, attempts to load and
+      # render the file as a template.
+      def self.render_file(name, context = {})
+        render(partial(name), context)
+      end
+
+      # Given a file name and an optional context, attempts to load and
+      # render the file as a template.
+      def render_file(name, context = {})
+        self.class.render_file(name, context)
+      end
+
+      # Given a name, attempts to read a file and return the contents as a
+      # string. The file is not rendered, so it might contain
+      # {{mustaches}}.
+      #
+      # Call `render` if you need to process it.
+      def self.partial(name)
+        new.partial(name)
+      end
+
+      # Override this in your subclass if you want to do fun things like
+      # reading templates from a database. It will be rendered by the
+      # context, so all you need to do is return a string.
+      def partial(name)
+        path = "#{template_path}/#{name}.#{template_extension}"
+
+        begin
+          File.read(path)
+        rescue
+          raise if raise_on_context_miss?
+          ""
+        end
+      end
+
+      # BRAINTRUST MODIFICATION: No HTML escaping for LLM prompts.
+      # Original mustache uses CGI.escapeHTML which would turn
+      # characters like < > & " into HTML entities.
+      # For LLM prompts, we want the raw text without escaping.
+      #
+      # @param [Object] value Value to escape.
+      # @return [String] Unescaped content (just converted to string).
+      def escape(value)
+        value.to_s
+      end
+
+      # @deprecated Use {#escape} instead.
+      # Kept for compatibility but also does no escaping.
+      def escapeHTML(str)
+        str.to_s
+      end
+
+      # Has this instance or its class already compiled a template?
+      def compiled?
+        (@template && @template.is_a?(Template)) || self.class.compiled?
+      end
+
+      private
+
+      # When given a symbol or string representing a class, will try to produce an
+      # appropriate view class.
+      #
+      # @example
+      #   Mustache.view_namespace = Hurl::Views
+      #   Mustache.view_class(:Partial) # => Hurl::Views::Partial
+      def self.view_class(name)
+        name = classify(name.to_s)
+
+        # Emptiness begets emptiness.
+        return Mustache if name.to_s.empty?
+
+        name = "#{view_namespace}::#{name}"
+        const = rescued_const_get(name)
+
+        return const if const
+
+        const_from_file(name)
+      end
+
+      def self.rescued_const_get(name)
+        const_get(name, true) || Mustache
+      rescue NameError
+        nil
+      end
+
+      def self.const_from_file(name)
+        file_name = underscore(name)
+        file_path = "#{view_path}/#{file_name}.rb"
+
+        return Mustache unless File.exist?(file_path)
+
+        require file_path.chomp(".rb")
+        rescued_const_get(name)
+      end
+
+      # Has this template already been compiled? Compilation is somewhat
+      # expensive so it may be useful to check this before attempting it.
+      def self.compiled?
+        @template.is_a? Template
+      end
+
+      # template_partial => TemplatePartial
+      # template/partial => Template::Partial
+      def self.classify(underscored)
+        Mustache::Utils::String.new(underscored).classify
+      end
+
+      # TemplatePartial => template_partial
+      # Template::Partial => template/partial
+      # Takes a string but defaults to using the current class' name.
+      def self.underscore(classified = name)
+        classified = superclass.name if classified.to_s.empty?
+
+        Mustache::Utils::String.new(classified).underscore(view_namespace)
+      end
+
+      # @param [Template,String] obj      Turns `obj` into a template
+      # @param [Hash]            options  Options for template creation
+      def self.templateify(obj, options = {})
+        obj.is_a?(Template) ? obj : Template.new(obj, options)
+      end
+
+      def templateify(obj)
+        opts = {partial_resolver: method(:partial)}
+        opts.merge!(@options) if @options.is_a?(Hash)
+        self.class.templateify(obj, opts)
+      end
+
+      # Return the value of the configuration setting on the superclass, or return
+      # the default.
+      #
+      # @param [Symbol] attr_name Name of the attribute. It should match
+      #                           the instance variable.
+      # @param [Object] default Default value to use if the superclass does
+      #                         not respond.
+      #
+      # @return Inherited or default configuration setting.
+      def self.inheritable_config_for(attr_name, default)
+        superclass.respond_to?(attr_name) ? superclass.send(attr_name) : default
+      end
+    end
+  end
+end

data/lib/braintrust/vendor/mustache/parser.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+# Vendored from mustache gem v1.1.1
+# https://github.com/mustache/mustache
+# License: MIT
+# Modifications: Namespaced under Braintrust::Vendor
+
+require "strscan"
+
+module Braintrust
+  module Vendor
+    class Mustache
+      # The Parser is responsible for taking a string template and
+      # converting it into an array of tokens and, really, expressions. It
+      # raises SyntaxError if there is anything it doesn't understand and
+      # knows which sigil corresponds to which tag type.
+      #
+      # For example, given this template:
+      #
+      #   Hi {{thing}}!
+      #
+      # Run through the Parser we'll get these tokens:
+      #
+      #   [:multi,
+      #     [:static, "Hi "],
+      #     [:mustache, :etag, "thing"],
+      #     [:static, "!\n"]]
+      class Parser
+        # A SyntaxError is raised when the Parser comes across unclosed
+        # tags, sections, illegal content in tags, or anything of that
+        # sort.
+        class SyntaxError < StandardError
+          def initialize(message, position)
+            @message = message
+            @lineno, @column, @line, _ = position
+            @stripped_line = @line.strip
+            @stripped_column = @column - (@line.size - @line.lstrip.size)
+          end
+
+          def to_s
+            <<-EOF
+#{@message}
+  Line #{@lineno}
+    #{@stripped_line}
+    #{" " * @stripped_column}^
+EOF
+          end
+        end
+
+        # The sigil types which are valid after an opening `{{`
+        VALID_TYPES = ["#", "^", "/", "=", "!", "<", ">", "&", "{"].map(&:freeze)
+
+        def self.valid_types
+          @valid_types ||= Regexp.new(VALID_TYPES.map { |t| Regexp.escape(t) }.join("|"))
+        end
+
+        # Add a supported sigil type (with optional aliases) to the Parser.
+        #
+        # Requires a block, which will be sent the following parameters:
+        #
+        # * content - The raw content of the tag
+        # * fetch- A mustache context fetch expression for the content
+        # * padding - Indentation whitespace from the currently-parsed line
+        # * pre_match_position - Location of the scanner before a match was made
+        #
+        # The provided block will be evaluated against the current instance of
+        # Parser, and may append to the Parser's @result as needed.
+        def self.add_type(*types, &block)
+          types = types.map(&:to_s)
+          type, *aliases = types
+          method_name = :"scan_tag_#{type}"
+          define_method(method_name, &block)
+          aliases.each { |a| alias_method :"scan_tag_#{a}", method_name }
+          types.each { |t| VALID_TYPES << t unless VALID_TYPES.include?(t) }
+          @valid_types = nil
+        end
+
+        # After these types of tags, all whitespace until the end of the line will
+        # be skipped if they are the first (and only) non-whitespace content on
+        # the line.
+        SKIP_WHITESPACE = ["#", "^", "/", "<", ">", "=", "!"].map(&:freeze)
+
+        # The content allowed in a tag name.
+        ALLOWED_CONTENT = /(\w|[?!\/.=-])*/
+
+        # These types of tags allow any content,
+        # the rest only allow ALLOWED_CONTENT.
+        ANY_CONTENT = ["!", "="].map(&:freeze)
+
+        attr_reader :otag, :ctag
+
+        # Accepts an options hash which does nothing but may be used in
+        # the future.
+        def initialize(options = {})
+          @options = options
+          @option_inline_partials_at_compile_time = options[:inline_partials_at_compile_time]
+          if @option_inline_partials_at_compile_time
+            @partial_resolver = options[:partial_resolver]
+            raise ArgumentError.new "Missing or invalid partial_resolver" unless @partial_resolver.respond_to? :call
+          end
+
+          # Initialize default tags
+          self.otag ||= "{{"
+          self.ctag ||= "}}"
+        end
+
+        # The opening tag delimiter. This may be changed at runtime.
+        def otag=(value)
+          regex = regexp value
+          @otag_regex = /([ \t]*)?#{regex}/
+          @otag_not_regex = /(^[ \t]*)?#{regex}/
+          @otag = value
+        end
+
+        # The closing tag delimiter. This too may be changed at runtime.
+        def ctag=(value)
+          @ctag_regex = regexp value
+          @ctag = value
+        end
+
+        # Given a string template, returns an array of tokens.
+        def compile(template)
+          @encoding = nil
+
+          if template.respond_to?(:encoding)
+            @encoding = template.encoding
+            template = template.dup.force_encoding("BINARY")
+          end
+
+          # Keeps information about opened sections.
+          @sections = []
+          @result = [:multi]
+          @scanner = StringScanner.new(template)
+
+          # Scan until the end of the template.
+          until @scanner.eos?
+            scan_tags || scan_text
+          end
+
+          unless @sections.empty?
+            # We have parsed the whole file, but there's still opened sections.
+            type, pos, _ = @sections.pop
+            error "Unclosed section #{type.inspect}", pos
+          end
+
+          @result
+        end
+
+        private
+
+        def content_tags(type, current_ctag_regex)
+          if ANY_CONTENT.include?(type)
+            r = /\s*#{regexp(type)}?#{current_ctag_regex}/
+            scan_until_exclusive(r)
+          else
+            @scanner.scan(ALLOWED_CONTENT)
+          end
+        end
+
+        def dispatch_based_on_type(type, content, fetch, padding, pre_match_position)
+          send(:"scan_tag_#{type}", content, fetch, padding, pre_match_position)
+        end
+
+        def find_closing_tag(scanner, current_ctag_regex)
+          error "Unclosed tag" unless scanner.scan(current_ctag_regex)
+        end
+
+        # Find {{mustaches}} and add them to the @result array.
+        def scan_tags
+          # Scan until we hit an opening delimiter.
+          start_of_line = @scanner.beginning_of_line?
+          pre_match_position = @scanner.pos
+          last_index = @result.length
+
+          return unless @scanner.scan @otag_regex
+          padding = @scanner[1] || ""
+
+          # Don't touch the preceding whitespace unless we're matching the start
+          # of a new line.
+          unless start_of_line
+            @result << [:static, padding] unless padding.empty?
+            pre_match_position += padding.length
+            padding = ""
+          end
+
+          # Since {{= rewrites ctag, we store the ctag which should be used
+          # when parsing this specific tag.
+          current_ctag_regex = @ctag_regex
+          type = @scanner.scan(self.class.valid_types)
+          @scanner.skip(/\s*/)
+
+          # ANY_CONTENT tags allow any character inside of them, while
+          # other tags (such as variables) are more strict.
+          content = content_tags(type, current_ctag_regex)
+
+          # We found {{ but we can't figure out what's going on inside.
+          error "Illegal content in tag" if content.empty?
+
+          fetch = [:mustache, :fetch, content.split(".")]
+          prev = @result
+
+          dispatch_based_on_type(type, content, fetch, padding, pre_match_position)
+
+          # The closing } in unescaped tags is just a hack for
+          # aesthetics.
+          type = "}" if type == "{"
+
+          # Skip whitespace and any balancing sigils after the content
+          # inside this tag.
+          @scanner.skip(/\s+/)
+          @scanner.skip(regexp(type)) if type
+
+          find_closing_tag(@scanner, current_ctag_regex)
+
+          # If this tag was the only non-whitespace content on this line, strip
+          # the remaining whitespace.  If not, but we've been hanging on to padding
+          # from the beginning of the line, re-insert the padding as static text.
+          if start_of_line && !@scanner.eos?
+            if @scanner.peek(2) =~ /\r?\n/ && SKIP_WHITESPACE.include?(type)
+              @scanner.skip(/\r?\n/)
+            else
+              prev.insert(last_index, [:static, padding]) unless padding.empty?
+            end
+          end
+
+          # Store off the current scanner position now that we've closed the tag
+          # and consumed any irrelevant whitespace.
+          @sections.last[1] << @scanner.pos unless @sections.empty?
+
+          return unless @result == [:multi]
+        end
+
+        # Try to find static text, e.g. raw HTML with no {{mustaches}}.
+        def scan_text
+          text = scan_until_exclusive @otag_not_regex
+
+          if text.nil?
+            # Couldn't find any otag, which means the rest is just static text.
+            text = @scanner.rest
+            # Mark as done.
+            @scanner.terminate
+          end
+
+          text.force_encoding(@encoding) if @encoding
+
+          @result << [:static, text] unless text.empty?
+        end
+
+        # Scans the string until the pattern is matched. Returns the substring
+        # *excluding* the end of the match, advancing the scan pointer to that
+        # location. If there is no match, nil is returned.
+        def scan_until_exclusive(regexp)
+          pos = @scanner.pos
+          if @scanner.scan_until(regexp)
+            @scanner.pos -= @scanner.matched.size
+            @scanner.pre_match[pos..-1]
+          end
+        end
+
+        def offset
+          position[0, 2]
+        end
+
+        # Returns [lineno, column, line]
+        def position
+          # The rest of the current line
+          rest = @scanner.check_until(/\n|\Z/).to_s.chomp
+
+          # What we have parsed so far
+          parsed = @scanner.string[0...@scanner.pos]
+
+          lines = parsed.split("\n")
+
+          [lines.size, lines.last.size - 1, lines.last + rest]
+        end
+
+        # Used to quickly convert a string into a regular expression
+        # usable by the string scanner.
+        def regexp(thing)
+          Regexp.new Regexp.escape(thing) if thing
+        end
+
+        # Raises a SyntaxError. The message should be the name of the
+        # error - other details such as line number and position are
+        # handled for you.
+        def error(message, pos = position)
+          raise SyntaxError.new(message, pos)
+        end
+
+        #
+        # Scan tags
+        #
+        # These methods are called in `scan_tags`. Because they contain nonstandard
+        # characters in their method names, they are aliased to
+        # better named methods.
+        #
+
+        # This function handles the cases where the scanned tag does not have
+        # a type.
+        def scan_tag_(content, fetch, padding, pre_match_position)
+          @result << [:mustache, :etag, fetch, offset]
+        end
+
+        def scan_tag_block(content, fetch, padding, pre_match_position)
+          block = [:multi]
+          @result << [:mustache, :section, fetch, offset, block]
+          @sections << [content, position, @result]
+          @result = block
+        end
+        alias_method :'scan_tag_#', :scan_tag_block
+
+        def scan_tag_inverted(content, fetch, padding, pre_match_position)
+          block = [:multi]
+          @result << [:mustache, :inverted_section, fetch, offset, block]
+          @sections << [content, position, @result]
+          @result = block
+        end
+        alias_method :'scan_tag_^', :scan_tag_inverted
+
+        def scan_tag_close(content, fetch, padding, pre_match_position)
+          section, pos, result = @sections.pop
+          if section.nil?
+            error "Closing unopened #{content.inspect}"
+          end
+
+          raw = @scanner.pre_match[pos[3]...pre_match_position] + padding
+          (@result = result).last << raw << [otag, ctag]
+
+          if section != content
+            error "Unclosed section #{section.inspect}", pos
+          end
+        end
+        alias_method :'scan_tag_/', :scan_tag_close
+
+        def scan_tag_comment(content, fetch, padding, pre_match_position)
+        end
+        alias_method :'scan_tag_!', :scan_tag_comment
+
+        def scan_tag_delimiter(content, fetch, padding, pre_match_position)
+          self.otag, self.ctag = content.split(" ", 2)
+        end
+        alias_method :'scan_tag_=', :scan_tag_delimiter
+
+        def scan_tag_open_partial(content, fetch, padding, pre_match_position)
+          @result << if @option_inline_partials_at_compile_time
+            partial = @partial_resolver.call content
+            partial.gsub!(/^/, padding) unless padding.empty?
+            self.class.new(@options).compile partial
+          else
+            [:mustache, :partial, content, offset, padding]
+          end
+        end
+        alias_method :'scan_tag_<', :scan_tag_open_partial
+        alias_method :'scan_tag_>', :scan_tag_open_partial
+
+        def scan_tag_unescaped(content, fetch, padding, pre_match_position)
+          @result << [:mustache, :utag, fetch, offset]
+        end
+        alias_method :'scan_tag_{', :scan_tag_unescaped
+        alias_method :'scan_tag_&', :scan_tag_unescaped
+      end
+    end
+  end
+end