lluminary 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a5f888a309d13934cdfdd0c6aa60f78fd66f063d518b86765614970f7275e3d
-  data.tar.gz: f8793e6f888d7dec7037b92d31d64032328436f66b439aaa34bf82440773a9d9
+  metadata.gz: 20a5892da2184571fc6e1a681fc5ed81143c87a5abafc745249b0a28d5ef4f3a
+  data.tar.gz: 984b6467b9ac1a82af4107efbd72a4ae14ab05cae8e3838120dd0252ea0a5dc0
 SHA512:
-  metadata.gz: 8e1d020d9a1f29ab98221b474ed75a0b8800f7f3e102ed5a31ad141b8f11a6ad414c0b4c649f392912468a5d95f323b0e4c214312d04e5d35281d88fbbf41949
-  data.tar.gz: d38bf71f39c468e332ebdf5d7d64bf2bb353a8d4cbbc911e116614684d0eb790270fa683d7325d0f4858e11e12c5a6db19308524bf18921aede6338033bab3da
+  metadata.gz: 85ad7a6f048fc3bad3ca587a638da18e5026dce9a7f5068e551170c5531f26a1b5da83b6fe193339dbeae1eaf087d50283d96742e5f0ace04905a9eb8abb73b1
+  data.tar.gz: 0c501c6277d1b58114998b005b02d0a6ab10aec14ed8f21026d8c682a20c9d09692ee818cb24252c2befd88f99aa578fa4302b880d6f8ed67b05ae8b56b94b87

data/lib/lluminary/models/base.rb

@@ -25,11 +25,11 @@ module Lluminary
 
           #{output_preamble}
           
-          #{format_field_descriptions(task.class.output_fields)}
+          #{format_fields_descriptions(task.class.output_fields)}
           
           #{json_preamble}
           
-          #{format_json_example(task.class.output_fields)}
+          #{generate_example_json_object(task.class.output_fields)}
         PROMPT
       end
 
@@ -46,30 +46,142 @@ module Lluminary
         "Your response must be ONLY this JSON object:"
       end
 
-      def format_field_descriptions(fields)
+      def format_fields_descriptions(fields)
         fields
-          .map do |name, field|
-            desc = "# #{name}"
-            desc += "\nType: #{format_type(field)}"
+          .map { |name, field| format_field_description(name, field) }
+          .compact # Remove nil entries from skipped types
+          .join("\n\n")
+      end
 
-            desc += "\nDescription: #{field[:description].chomp}" if field[
-              :description
-            ]
+      def format_field_description(name, field, name_for_example = nil)
+        case field[:type]
+        when :hash
+          format_hash_description(name, field, name_for_example)
+        when :array
+          format_array_description(name, field, name_for_example)
+        else
+          format_simple_field_description(name, field, name_for_example)
+        end
+      end
+
+      def format_hash_description(name, field, name_for_example = nil)
+        return nil unless field[:fields]
+
+        lines = build_field_description_lines(name, field, name_for_example)
+
+        # Add descriptions for each field in the hash
+        field[:fields].each do |subname, subfield|
+          lines << "\n#{format_field_description("#{name}.#{subname}", subfield, subname)}"
+        end
 
-            if (validations = describe_validations(field[:validations]))
-              desc += "\nValidations: #{validations}"
+        lines.join("\n")
+      end
+
+      # Helper to ensure consistent JSON formatting for examples
+      def format_json_for_examples(value)
+        case value
+        when Hash, Array
+          JSON.generate(value)
+        else
+          value.inspect
+        end
+      end
+
+      def format_simple_field_description(name, field, name_for_example = nil)
+        build_field_description_lines(name, field, name_for_example).join("\n")
+      end
+
+      def format_array_description(name, field, name_for_example = nil)
+        lines = build_field_description_lines(name, field, name_for_example)
+
+        if field[:element_type]
+          if field[:element_type][:type] == :array
+            # Create a nested array field by adding [] to the name
+            # and recursively call format_array_description
+            element_field = field[:element_type].dup
+            nested_description =
+              format_array_description("#{name}[]", element_field, "item")
+            lines << "\n#{nested_description}"
+          elsif field[:element_type][:type] == :hash &&
+                field[:element_type][:fields]
+            field[:element_type][:fields].each do |subname, subfield|
+              inner_field = {
+                type: subfield[:type],
+                description: subfield[:description]
+              }
+              inner_lines =
+                build_field_description_lines(
+                  "#{name}[].#{subname}",
+                  inner_field,
+                  subname
+                )
+              lines << "\n#{inner_lines.join("\n")}"
             end
+          else
+            inner_field = {
+              type: field[:element_type][:type],
+              description: field[:element_type][:description]
+            }
+            inner_lines =
+              build_field_description_lines("#{name}[]", inner_field, "item")
+            lines << "\n#{inner_lines.join("\n")}"
+          end
+        end
+
+        lines.join("\n")
+      end
+
+      # Common method for building field description lines
+      def build_field_description_lines(name, field, name_for_example = nil)
+        lines = []
+        # Add field description
+        lines << "# #{name}"
+        lines << "Description: #{field[:description]}" if field[:description]
+        lines << "Type: #{format_type(field)}"
+
+        # Add validation info
+        if (validations = describe_validations(field))
+          lines << "Validations: #{validations}"
+        end
+
+        # Generate and add example
+        example_value =
+          generate_example_value(
+            name_for_example || name.to_s.split(".").last,
+            field
+          )
+        lines << "Example: #{format_json_for_examples(example_value)}"
+
+        lines
+      end
 
-            desc += "\nExample: #{generate_example_value(name, field)}"
-            desc
+      def format_type(field)
+        case field[:type]
+        when :datetime
+          "datetime in ISO8601 format"
+        when :array
+          if field[:element_type].nil?
+            "array"
+          elsif field[:element_type][:type] == :array
+            "array of arrays"
+          elsif field[:element_type][:type] == :datetime
+            "array of datetimes in ISO8601 format"
+          elsif field[:element_type][:type] == :hash
+            "array of objects"
+          else
+            "array of #{field[:element_type][:type]}s"
           end
-          .join("\n\n")
+        when :hash
+          "object"
+        else
+          field[:type].to_s
+        end
       end
 
-      def describe_validations(validations)
-        return unless validations&.any?
+      def describe_validations(field)
+        return unless field[:validations]&.any?
 
-        validations
+        field[:validations]
           .map do |options|
             case options.keys.first
             when :presence
@@ -81,7 +193,7 @@ module Lluminary
             when :format
               "must match format: #{options[:format][:with]}"
             when :length
-              describe_length_validation(options[:length])
+              describe_length_validation(options[:length], field[:type])
             when :numericality
               describe_numericality_validation(options[:numericality])
             when :comparison
@@ -94,43 +206,29 @@ module Lluminary
           .join(", ")
       end
 
-      def describe_length_validation(options)
+      def describe_length_validation(options, field_type = nil)
         descriptions = []
+        units = field_type == :array ? "elements" : "characters"
+
         if options[:minimum]
-          descriptions << "must be at least #{options[:minimum]} characters"
+          descriptions << "must have at least #{options[:minimum]} #{units}"
         end
         if options[:maximum]
-          descriptions << "must be at most #{options[:maximum]} characters"
+          descriptions << "must have at most #{options[:maximum]} #{units}"
         end
         if options[:is]
-          descriptions << "must be exactly #{options[:is]} characters"
+          descriptions << "must have exactly #{options[:is]} #{units}"
         end
         if options[:in]
-          descriptions << "must be between #{options[:in].min} and #{options[:in].max} characters"
+          descriptions << "must have between #{options[:in].min} and #{options[:in].max} #{units}"
         end
         descriptions.join(", ")
       end
 
       def describe_numericality_validation(options)
         descriptions = []
-        if options[:greater_than]
-          descriptions << "must be greater than #{options[:greater_than]}"
-        end
-        if options[:greater_than_or_equal_to]
-          descriptions << "must be greater than or equal to #{options[:greater_than_or_equal_to]}"
-        end
-        if options[:equal_to]
-          descriptions << "must be equal to #{options[:equal_to]}"
-        end
-        if options[:less_than]
-          descriptions << "must be less than #{options[:less_than]}"
-        end
-        if options[:less_than_or_equal_to]
-          descriptions << "must be less than or equal to #{options[:less_than_or_equal_to]}"
-        end
-        if options[:other_than]
-          descriptions << "must be other than #{options[:other_than]}"
-        end
+        descriptions.concat(describe_common_comparisons(options))
+
         if options[:in]
           descriptions << "must be in: #{options[:in].to_a.join(", ")}"
         end
@@ -140,6 +238,10 @@ module Lluminary
       end
 
       def describe_comparison_validation(options)
+        describe_common_comparisons(options).join(", ")
+      end
+
+      def describe_common_comparisons(options)
         descriptions = []
         if options[:greater_than]
           descriptions << "must be greater than #{options[:greater_than]}"
@@ -159,10 +261,10 @@ module Lluminary
         if options[:other_than]
           descriptions << "must be other than #{options[:other_than]}"
         end
-        descriptions.join(", ")
+        descriptions
       end
 
-      def format_json_example(fields)
+      def generate_example_json_object(fields)
         example =
           fields.each_with_object({}) do |(name, field), hash|
             hash[name] = generate_example_value(name, field)
@@ -170,26 +272,14 @@ module Lluminary
         JSON.pretty_generate(example)
       end
 
-      def format_type(field)
-        type = field[:type]
-        case type
-        when :datetime
-          "datetime in ISO8601 format"
-        when :array
-          if field[:element_type]
-            "array of #{format_type(field[:element_type])}"
-          else
-            "array"
-          end
-        else
-          type.to_s
-        end
-      end
-
       def generate_example_value(name, field)
         case field[:type]
         when :string
-          "your #{name} here"
+          if name == "item" # For items in arrays
+            "first #{name}"
+          else
+            "your #{name} here"
+          end
         when :integer
           0
         when :datetime
@@ -200,6 +290,8 @@ module Lluminary
           0.0
         when :array
           generate_array_example(name, field)
+        when :hash
+          generate_hash_example(name, field)
         end
       end
 
@@ -208,11 +300,7 @@ module Lluminary
 
         case field[:element_type][:type]
         when :string
-          [
-            "first #{name.to_s.singularize}",
-            "second #{name.to_s.singularize}",
-            "..."
-          ]
+          ["first #{name.to_s.singularize}", "second #{name.to_s.singularize}"]
         when :integer
           [1, 2, 3]
         when :float
@@ -226,8 +314,20 @@ module Lluminary
             inner_example = generate_array_example("item", field[:element_type])
             [inner_example, inner_example]
           else
-            [["..."], ["..."]]
+            [[], []]
           end
+        when :hash
+          example =
+            generate_hash_example(name.to_s.singularize, field[:element_type])
+          [example, example]
+        end
+      end
+
+      def generate_hash_example(name, field)
+        return {} unless field[:fields]
+
+        field[:fields].each_with_object({}) do |(subname, subfield), hash|
+          hash[subname] = generate_example_value(subname, subfield)
         end
       end
     end

data/lib/lluminary/schema.rb

@@ -42,6 +42,21 @@ module Lluminary
       @fields[name] = field
     end
 
+    def hash(name, description: nil, &block)
+      unless block
+        raise ArgumentError, "Hash fields must be defined with a block"
+      end
+
+      nested_schema = Schema.new
+      nested_schema.instance_eval(&block)
+
+      @fields[name] = {
+        type: :hash,
+        description: description,
+        fields: nested_schema.fields
+      }
+    end
+
     attr_reader :fields
 
     def validates(*args, **options)
@@ -100,6 +115,17 @@ module Lluminary
         ) if block
         field
       end
+
+      def hash(description: nil, &block)
+        unless block
+          raise ArgumentError, "Hash fields must be defined with a block"
+        end
+
+        nested_schema = Schema.new
+        nested_schema.instance_eval(&block)
+
+        { type: :hash, description: description, fields: nested_schema.fields }
+      end
     end
   end
 end

data/lib/lluminary/schema_model.rb

@@ -21,6 +21,12 @@ module Lluminary
 
     def self.build(fields:, validations:)
       Class.new(self) do
+        class << self
+          attr_accessor :schema_fields
+        end
+
+        self.schema_fields = fields
+
         # Add accessors for each field
         fields.each_key do |name|
           define_method(name) { @attributes[name.to_s] }
@@ -29,7 +35,7 @@ module Lluminary
 
         # Add raw_response field and validation
         define_method(:raw_response) { @attributes["raw_response"] }
-        define_method(:raw_response=) do |value|
+        define_method("raw_response=") do |value|
           @attributes["raw_response"] = value
         end
 
@@ -41,92 +47,44 @@ module Lluminary
               record.errors.add(:raw_response, "must be valid JSON")
             end
           end
-        end
-
-        # Add type validations
-        validate do |record|
-          def validate_array_field(
-            record,
-            name,
-            value,
-            element_type,
-            path = nil
-          )
-            field_name = path || name
-
-            unless value.is_a?(Array)
-              record.errors.add(field_name, "must be an Array")
-              return
-            end
-
-            return unless element_type # untyped array
-
-            value.each_with_index do |element, index|
-              current_path = "#{field_name}[#{index}]"
-
-              case element_type[:type]
-              when :array
-                validate_array_field(
-                  record,
-                  name,
-                  element,
-                  element_type[:element_type],
-                  current_path
-                )
-              when :string
-                unless element.is_a?(String)
-                  record.errors.add(current_path, "must be a String")
-                end
-              when :integer
-                unless element.is_a?(Integer)
-                  record.errors.add(current_path, "must be an Integer")
-                end
-              when :boolean
-                unless [true, false].include?(element)
-                  record.errors.add(current_path, "must be true or false")
-                end
-              when :float
-                unless element.is_a?(Float)
-                  record.errors.add(current_path, "must be a float")
-                end
-              when :datetime
-                unless element.is_a?(DateTime)
-                  record.errors.add(current_path, "must be a DateTime")
-                end
-              end
-            end
-          end
 
           record.attributes.each do |name, value|
             next if name == "raw_response"
             next if value.nil?
 
-            field = fields[name.to_sym]
+            field = self.class.schema_fields[name.to_sym]
             next unless field
 
             case field[:type]
+            when :hash
+              validate_hash_field(record, name.to_s.capitalize, value, field)
+            when :array
+              validate_array_field(
+                record,
+                name.to_s.capitalize,
+                value,
+                field[:element_type]
+              )
             when :string
               unless value.is_a?(String)
-                record.errors.add(name, "must be a String")
+                record.errors.add(name.to_s.capitalize, "must be a String")
               end
             when :integer
               unless value.is_a?(Integer)
-                record.errors.add(name, "must be an Integer")
+                record.errors.add(name.to_s.capitalize, "must be an Integer")
               end
             when :boolean
               unless [true, false].include?(value)
-                record.errors.add(name, "must be true or false")
+                record.errors.add(name.to_s.capitalize, "must be true or false")
               end
             when :float
               unless value.is_a?(Float)
-                record.errors.add(name, "must be a float")
+                record.errors.add(name.to_s.capitalize, "must be a float")
               end
             when :datetime
               unless value.is_a?(DateTime)
-                record.errors.add(name, "must be a DateTime")
+                record.errors.add(name.to_s.capitalize, "must be a DateTime")
               end
-            when :array
-              validate_array_field(record, name, value, field[:element_type])
             end
           end
         end
@@ -138,6 +96,118 @@ module Lluminary
         define_singleton_method(:model_name) do
           ActiveModel::Name.new(self, nil, "SchemaModel")
         end
+
+        private
+
+        def validate_hash_field(
+          record,
+          name,
+          value,
+          field_definition,
+          path = nil
+        )
+          field_name = path || name
+
+          unless value.is_a?(Hash)
+            record.errors.add(field_name, "must be a Hash")
+            return
+          end
+
+          field_definition[:fields].each do |key, field|
+            current_path = path ? "#{path}[#{key}]" : "#{field_name}[#{key}]"
+            # Try both string and symbol keys
+            field_value = value[key.to_s] || value[key.to_sym]
+
+            next if field_value.nil?
+
+            case field[:type]
+            when :hash
+              validate_hash_field(record, key, field_value, field, current_path)
+            when :array
+              validate_array_field(
+                record,
+                key,
+                field_value,
+                field[:element_type],
+                current_path
+              )
+            when :string
+              unless field_value.is_a?(String)
+                record.errors.add(current_path, "must be a String")
+              end
+            when :integer
+              unless field_value.is_a?(Integer)
+                record.errors.add(current_path, "must be an Integer")
+              end
+            when :boolean
+              unless [true, false].include?(field_value)
+                record.errors.add(current_path, "must be true or false")
+              end
+            when :float
+              unless field_value.is_a?(Float)
+                record.errors.add(current_path, "must be a float")
+              end
+            when :datetime
+              unless field_value.is_a?(DateTime)
+                record.errors.add(current_path, "must be a DateTime")
+              end
+            end
+          end
+        end
+
+        def validate_array_field(record, name, value, element_type, path = nil)
+          field_name = path || name
+
+          unless value.is_a?(Array)
+            record.errors.add(field_name, "must be an Array")
+            return
+          end
+
+          return unless element_type # untyped array
+
+          value.each_with_index do |element, index|
+            current_path = "#{field_name}[#{index}]"
+
+            case element_type[:type]
+            when :hash
+              validate_hash_field(
+                record,
+                name,
+                element,
+                element_type,
+                current_path
+              )
+            when :array
+              validate_array_field(
+                record,
+                name,
+                element,
+                element_type[:element_type],
+                current_path
+              )
+            when :string
+              unless element.is_a?(String)
+                record.errors.add(current_path, "must be a String")
+              end
+            when :integer
+              unless element.is_a?(Integer)
+                record.errors.add(current_path, "must be an Integer")
+              end
+            when :boolean
+              unless [true, false].include?(element)
+                record.errors.add(current_path, "must be true or false")
+              end
+            when :float
+              unless element.is_a?(Float)
+                record.errors.add(current_path, "must be a float")
+              end
+            when :datetime
+              unless element.is_a?(DateTime)
+                record.errors.add(current_path, "must be a DateTime")
+              end
+            end
+          end
+        end
       end
     end
   end