braintrust 0.1.1 → 0.1.2

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

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+# Vendored from mustache gem v1.1.1
+# https://github.com/mustache/mustache
+# License: MIT
+# Modifications: Namespaced under Braintrust::Vendor
+
+# Settings which can be configured for all view classes, a single
+# view class, or a single Mustache instance.
+module Braintrust
+  module Vendor
+    class Mustache
+      def initialize_settings
+        @template = nil
+        @template_path = nil
+        @template_extension = nil
+        @template_name = nil
+        @template_file = nil
+        @raise_on_context_miss = nil
+      end
+
+      def self.initialize_settings
+        @template = nil
+        @template_path = nil
+        @template_extension = nil
+        @template_name = nil
+        @template_file = nil
+        @raise_on_context_miss = nil
+      end
+
+      initialize_settings
+
+      def self.inherited(subclass)
+        subclass.initialize_settings
+      end
+
+      #
+      # Template Path
+      #
+
+      # The template path informs your Mustache view where to look for its
+      # corresponding template. By default it's the current directory (".")
+      #
+      # A class named Stat with a template_path of "app/templates" will look
+      # for "app/templates/stat.mustache"
+
+      def self.template_path
+        @template_path ||= inheritable_config_for :template_path, "."
+      end
+
+      def self.template_path=(path)
+        @template_path = File.expand_path(path)
+        @template = nil
+      end
+
+      def template_path
+        @template_path ||= self.class.template_path
+      end
+      alias_method :path, :template_path
+
+      def template_path=(path)
+        @template_path = File.expand_path(path)
+        @template = nil
+      end
+
+      # Alias for `template_path`
+      def self.path
+        template_path
+      end
+
+      # Alias for `template_path`
+      def self.path=(path)
+        self.template_path = path
+      end
+
+      #
+      # Template Extension
+      #
+
+      # A Mustache template's default extension is 'mustache', but this can be changed.
+
+      def self.template_extension
+        @template_extension ||= inheritable_config_for :template_extension, "mustache"
+      end
+
+      def self.template_extension=(template_extension)
+        @template_extension = template_extension
+        @template = nil
+      end
+
+      def template_extension
+        @template_extension ||= self.class.template_extension
+      end
+
+      def template_extension=(template_extension)
+        @template_extension = template_extension
+        @template = nil
+      end
+
+      #
+      # Template Name
+      #
+
+      # The template name is the Mustache template file without any
+      # extension or other information. Defaults to `class_name`.
+      #
+      # You may want to change this if your class is named Stat but you want
+      # to re-use another template.
+      #
+      #   class Stat
+      #     self.template_name = "graphs" # use graphs.mustache
+      #   end
+
+      def self.template_name
+        @template_name || underscore
+      end
+
+      def self.template_name=(template_name)
+        @template_name = template_name
+        @template = nil
+      end
+
+      def template_name
+        @template_name ||= self.class.template_name
+      end
+
+      def template_name=(template_name)
+        @template_name = template_name
+        @template = nil
+      end
+
+      #
+      # Template File
+      #
+
+      # The template file is the absolute path of the file Mustache will
+      # use as its template. By default it's ./class_name.mustache
+
+      def self.template_file
+        @template_file || "#{path}/#{template_name}.#{template_extension}"
+      end
+
+      def self.template_file=(template_file)
+        @template_file = template_file
+        @template = nil
+      end
+
+      # The template file is the absolute path of the file Mustache will
+      # use as its template. By default it's ./class_name.mustache
+      def template_file
+        @template_file || "#{path}/#{template_name}.#{template_extension}"
+      end
+
+      def template_file=(template_file)
+        @template_file = template_file
+        @template = nil
+      end
+
+      #
+      # Template
+      #
+
+      # The template is the actual string Mustache uses as its template.
+      # There is a bit of magic here: what we get back is actually a
+      # Mustache::Template object, but you can still safely use `template=`
+      #  with a string.
+
+      def self.template
+        @template ||= templateify(File.read(template_file))
+      end
+
+      def self.template=(template)
+        @template = templateify(template)
+      end
+
+      # The template can be set at the instance level.
+      def template
+        return @template if @template
+
+        # If they sent any instance-level options use that instead of the class's.
+        if @template_path || @template_extension || @template_name || @template_file
+          @template = templateify(File.read(template_file))
+        else
+          @template = self.class.template
+        end
+      end
+
+      def template=(template)
+        @template = templateify(template)
+      end
+
+      #
+      # Raise on context miss
+      #
+
+      # Should an exception be raised when we cannot find a corresponding method
+      # or key in the current context? By default this is false to emulate ctemplate's
+      # behavior, but it may be useful to enable when debugging or developing.
+      #
+      # If set to true and there is a context miss, `Mustache::ContextMiss` will
+      # be raised.
+
+      def self.raise_on_context_miss?
+        @raise_on_context_miss
+      end
+
+      def self.raise_on_context_miss=(boolean)
+        @raise_on_context_miss = boolean
+      end
+
+      # Instance level version of `Mustache.raise_on_context_miss?`
+      def raise_on_context_miss?
+        self.class.raise_on_context_miss? || @raise_on_context_miss
+      end
+
+      def raise_on_context_miss=(boolean)
+        @raise_on_context_miss = boolean
+      end
+
+      #
+      # View Namespace
+      #
+
+      # The constant under which Mustache will look for views when autoloading.
+      # By default the view namespace is `Object`, but it might be nice to set
+      # it to something like `Hurl::Views` if your app's main namespace is `Hurl`.
+
+      def self.view_namespace
+        @view_namespace ||= inheritable_config_for(:view_namespace, Object)
+      end
+
+      def self.view_namespace=(namespace)
+        @view_namespace = namespace
+      end
+
+      #
+      # View Path
+      #
+
+      # Mustache searches the view path for .rb files to require when asked to find a
+      # view class. Defaults to "."
+
+      def self.view_path
+        @view_path ||= inheritable_config_for(:view_path, ".")
+      end
+
+      def self.view_path=(path)
+        @view_path = path
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+# Vendored from mustache gem v1.1.1
+# https://github.com/mustache/mustache
+# License: MIT
+# Modifications: Namespaced under Braintrust::Vendor
+
+require "cgi"
+
+require_relative "parser"
+require_relative "generator"
+
+module Braintrust
+  module Vendor
+    class Mustache
+      # A Template represents a Mustache template. It compiles and caches
+      # a raw string template into something usable.
+      #
+      # The idea is this: when handed a Mustache template, convert it into
+      # a Ruby string by transforming Mustache tags into interpolated
+      # Ruby.
+      #
+      # You shouldn't use this class directly, instead:
+      #
+      # >> Braintrust::Vendor::Mustache.render(template, hash)
+      class Template
+        attr_reader :source
+
+        # Expects a Mustache template as a string along with a template
+        # path, which it uses to find partials. Options may be passed.
+        def initialize(source, options = {})
+          @source = source
+          @options = options
+        end
+
+        # Renders the `@source` Mustache template using the given
+        # `context`, which should be a simple hash keyed with symbols.
+        #
+        # The first time a template is rendered, this method is overriden
+        # and from then on it is "compiled". Subsequent calls will skip
+        # the compilation step and run the Ruby version of the template
+        # directly.
+        def render(context)
+          # Compile our Mustache template into a Ruby string
+          compiled = "def render(ctx) #{compile} end"
+
+          # Here we rewrite ourself with the interpolated Ruby version of
+          # our Mustache template so subsequent calls are very fast and
+          # can skip the compilation stage.
+          instance_eval(compiled, __FILE__, __LINE__ - 1)
+
+          # Call the newly rewritten version of #render
+          render(context)
+        end
+
+        # Does the dirty work of transforming a Mustache template into an
+        # interpolation-friendly Ruby string.
+        def compile(src = @source)
+          Generator.new(@options).compile(tokens(src))
+        end
+        alias_method :to_s, :compile
+
+        # Returns an array of tokens for a given template.
+        #
+        # @return [Array] Array of tokens.
+        #
+        def tokens(src = @source)
+          Parser.new(@options).compile(src)
+        end
+
+        # Returns an array of tags.
+        #
+        # Tags that belong to sections will be of the form `section1.tag`.
+        #
+        # @return [Array] Returns an array of tags.
+        #
+        def tags
+          Template.recursor(tokens, []) do |token, section|
+            if [:etag, :utag].include?(token[1])
+              [new_token = nil, new_section = nil, result = ((section + [token[2][2][0]]).join(".")), stop = true]
+            elsif [:section, :inverted_section].include?(token[1])
+              [new_token = token[4], new_section = (section + [token[2][2][0]]), result = nil, stop = false]
+            else
+              [new_token = token, new_section = section, result = nil, stop = false]
+            end
+          end.flatten.reject(&:nil?).uniq
+        end
+
+        # Returns an array of sections.
+        #
+        # Sections that belong to other sections will be of the form `section1.childsection`
+        #
+        # @return [Array] Returns an array of section.
+        #
+        def sections
+          Template.recursor(tokens, []) do |token, section|
+            if [:section, :inverted_section].include?(token[1])
+              new_section = (section + [token[2][2][0]])
+              [new_token = token[4], new_section, result = new_section.join("."), stop = false]
+            else
+              [new_token = token, new_section = section, result = nil, stop = false]
+            end
+          end.flatten.reject(&:nil?).uniq
+        end
+
+        # Returns an array of partials.
+        #
+        # Partials that belong to sections are included, but the section name is not preserved
+        #
+        # @return [Array] Returns an array of partials.
+        #
+        def partials
+          Template.recursor(tokens, []) do |token, section|
+            if token[1] == :partial
+              [new_token = token, new_section = section, result = token[2], stop = true]
+            else
+              [new_token = token, new_section = section, result = nil, stop = false]
+            end
+          end.flatten.reject(&:nil?).uniq
+        end
+
+        # Simple recursive iterator for tokens
+        def self.recursor(toks, section, &block)
+          toks.map do |token|
+            next unless token.is_a? Array
+
+            if token.first == :mustache
+              new_token, new_section, result, stop = yield(token, section)
+              [result] + (stop ? [] : recursor(new_token, new_section, &block))
+            else
+              recursor(token, section, &block)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# Vendored from mustache gem v1.1.1
+# https://github.com/mustache/mustache
+# License: MIT
+# Modifications: Namespaced under Braintrust::Vendor
+
+module Braintrust
+  module Vendor
+    class Mustache
+      module Utils
+        class String
+          def initialize(string)
+            @string = string
+          end
+
+          def classify
+            @string.split("/").map do |namespace|
+              namespace.split(/[-_]/).map do |part|
+                part[0] = part.chars.first.upcase
+                part
+              end.join
+            end.join("::")
+          end
+
+          def underscore(view_namespace)
+            @string
+              .dup
+              .split("#{view_namespace}::")
+              .last
+              .split("::")
+              .map do |part|
+                part[0] = part[0].downcase
+                part.gsub(/[A-Z]/) { |s| "_" << s.downcase }
+              end
+              .join("/")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/braintrust/vendor/mustache.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Vendored Mustache template engine
+# From mustache gem v1.1.1 - https://github.com/mustache/mustache
+# License: MIT
+#
+# Modifications from original:
+#   - Namespaced under Braintrust::Vendor to avoid conflicts
+#   - Disabled HTML escaping (LLM prompts don't need HTML entity encoding)
+#
+# This vendored version ensures:
+#   - No external dependency required
+#   - Consistent behavior across all SDK users
+#   - No HTML escaping that would corrupt prompts containing < > & characters
+
+require_relative "mustache/mustache"

data/lib/braintrust/version.rb

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

data/lib/braintrust.rb

@@ -5,6 +5,7 @@ require_relative "braintrust/config"
 require_relative "braintrust/state"
 require_relative "braintrust/trace"
 require_relative "braintrust/api"
+require_relative "braintrust/prompt"
 require_relative "braintrust/internal/experiments"
 require_relative "braintrust/internal/env"
 require_relative "braintrust/eval"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: braintrust
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Braintrust
@@ -240,15 +240,27 @@ files:
 - lib/braintrust/internal/encoding.rb
 - lib/braintrust/internal/env.rb
 - lib/braintrust/internal/experiments.rb
+- lib/braintrust/internal/template.rb
 - lib/braintrust/internal/thread_pool.rb
 - lib/braintrust/internal/time.rb
 - lib/braintrust/logger.rb
+- lib/braintrust/prompt.rb
 - lib/braintrust/setup.rb
 - lib/braintrust/state.rb
 - lib/braintrust/trace.rb
 - lib/braintrust/trace/attachment.rb
 - lib/braintrust/trace/span_filter.rb
 - lib/braintrust/trace/span_processor.rb
+- lib/braintrust/vendor/mustache.rb
+- lib/braintrust/vendor/mustache/context.rb
+- lib/braintrust/vendor/mustache/context_miss.rb
+- lib/braintrust/vendor/mustache/enumerable.rb
+- lib/braintrust/vendor/mustache/generator.rb
+- lib/braintrust/vendor/mustache/mustache.rb
+- lib/braintrust/vendor/mustache/parser.rb
+- lib/braintrust/vendor/mustache/settings.rb
+- lib/braintrust/vendor/mustache/template.rb
+- lib/braintrust/vendor/mustache/utils.rb
 - lib/braintrust/version.rb
 homepage: https://github.com/braintrustdata/braintrust-sdk-ruby
 licenses: