lluminary 0.1.1 → 0.1.2

data/spec/examples/summarize_text_spec.rb

@@ -1,8 +1,11 @@
-require 'spec_helper'
-require_relative '../../examples/summarize_text'
+# frozen_string_literal: true
+require "spec_helper"
+require_relative "../../examples/summarize_text"
 
 RSpec.describe SummarizeText do
-  let(:text) { "Ruby is a dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write." }
+  let(:text) { <<~TEXT }
+      Ruby is a dynamic, open source programming language with a focus on simplicity and productivity. It has an elegant syntax that is natural to read and easy to write.
+    TEXT
 
   it "summarizes text" do
     result = described_class.call(text: text)
@@ -18,4 +21,4 @@ RSpec.describe SummarizeText do
     expect(json).to have_key("summary")
     expect(json["summary"]).to eq(result.output.summary)
   end
-end 
+end

data/spec/lluminary/config_spec.rb

@@ -1,47 +1,49 @@
-require 'spec_helper'
+# frozen_string_literal: true
+require "spec_helper"
 
 RSpec.describe Lluminary::Config do
   let(:config) { described_class.new }
 
-  describe '#configure' do
-    it 'allows setting provider configurations' do
+  describe "#configure" do
+    it "allows setting provider configurations" do
       config.configure do |c|
-        c.provider(:openai, api_key: 'global-key')
-        c.provider(:bedrock, 
-          access_key_id: 'global-access-key',
-          secret_access_key: 'global-secret-key',
-          region: 'us-east-1'
+        c.provider(:openai, api_key: "global-key")
+        c.provider(
+          :bedrock,
+          access_key_id: "global-access-key",
+          secret_access_key: "global-secret-key",
+          region: "us-east-1"
         )
       end
 
-      expect(config.provider_config(:openai)).to eq({ api_key: 'global-key' })
-      expect(config.provider_config(:bedrock)).to eq({
-        access_key_id: 'global-access-key',
-        secret_access_key: 'global-secret-key',
-        region: 'us-east-1'
-      })
+      expect(config.provider_config(:openai)).to eq({ api_key: "global-key" })
+      expect(config.provider_config(:bedrock)).to eq(
+        {
+          access_key_id: "global-access-key",
+          secret_access_key: "global-secret-key",
+          region: "us-east-1"
+        }
+      )
     end
   end
 
-  describe '#provider_config' do
-    it 'returns empty hash for unconfigured providers' do
+  describe "#provider_config" do
+    it "returns empty hash for unconfigured providers" do
       expect(config.provider_config(:unknown)).to eq({})
     end
 
-    it 'returns the configuration for a configured provider' do
-      config.configure do |c|
-        c.provider(:openai, api_key: 'test-key')
-      end
+    it "returns the configuration for a configured provider" do
+      config.configure { |c| c.provider(:openai, api_key: "test-key") }
 
-      expect(config.provider_config(:openai)).to eq({ api_key: 'test-key' })
+      expect(config.provider_config(:openai)).to eq({ api_key: "test-key" })
     end
   end
 
-  describe '#reset!' do
-    it 'clears all provider configurations' do
+  describe "#reset!" do
+    it "clears all provider configurations" do
       config.configure do |c|
-        c.provider(:openai, api_key: 'test-key')
-        c.provider(:bedrock, access_key_id: 'test-access-key')
+        c.provider(:openai, api_key: "test-key")
+        c.provider(:bedrock, access_key_id: "test-access-key")
       end
 
       config.reset!
@@ -50,4 +52,4 @@ RSpec.describe Lluminary::Config do
       expect(config.provider_config(:bedrock)).to eq({})
     end
   end
-end 
+end

data/spec/lluminary/field_description_spec.rb

@@ -1,36 +1,34 @@
-require 'spec_helper'
+# frozen_string_literal: true
+require "spec_helper"
 
 RSpec.describe Lluminary::FieldDescription do
-  describe '#to_s' do
-    it 'generates a description for a string field' do
-      field = {
-        type: :string,
-        description: 'A test field'
-      }
-      description = described_class.new('test_field', field)
-      expect(description.to_s).to eq('test_field (string): A test field')
+  describe "#to_s" do
+    it "generates a description for a string field" do
+      field = { type: :string, description: "A test field" }
+      description = described_class.new("test_field", field)
+      expect(description.to_s).to eq("test_field (string): A test field")
     end
 
-    it 'generates a description for a field without a description' do
-      field = {
-        type: :integer
-      }
-      description = described_class.new('count', field)
-      expect(description.to_s).to eq('count (integer)')
+    it "generates a description for a field without a description" do
+      field = { type: :integer }
+      description = described_class.new("count", field)
+      expect(description.to_s).to eq("count (integer)")
     end
 
-    it 'includes validation descriptions when present' do
+    it "includes validation descriptions when present" do
       field = {
         type: :string,
-        description: 'A test field',
+        description: "A test field",
         validations: [
           [{}, { length: { minimum: 5, maximum: 10 } }],
-          [{}, { format: { with: '/^[A-Z]+$/' } }]
+          [{}, { format: { with: "/^[A-Z]+$/" } }]
         ]
       }
-      description = described_class.new('test_field', field)
-      expected = 'test_field (string): A test field (must be at least 5 characters, must be at most 10 characters, must match format: /^[A-Z]+$/)'
+      description = described_class.new("test_field", field)
+      expected = <<~DESCRIPTION.chomp
+          test_field (string): A test field (must be at least 5 characters, must be at most 10 characters, must match format: /^[A-Z]+$/)
+        DESCRIPTION
       expect(description.to_s).to eq(expected)
     end
   end
-end 
+end

data/spec/lluminary/providers/base_spec.rb

@@ -1,17 +1,20 @@
-require 'lluminary'
+# frozen_string_literal: true
+require "lluminary"
 
 RSpec.describe Lluminary::Providers::Base do
-  describe '#initialize' do
-    it 'accepts configuration options' do
-      config = { api_key: 'test_key', model: 'test_model' }
+  describe "#initialize" do
+    it "accepts configuration options" do
+      config = { api_key: "test_key", model: "test_model" }
       provider = described_class.new(**config)
       expect(provider.config).to eq(config)
     end
   end
 
-  describe '#call' do
-    it 'raises NotImplementedError' do
-      expect { described_class.new.call('test', double('Task')) }.to raise_error(NotImplementedError)
+  describe "#call" do
+    it "raises NotImplementedError" do
+      expect do
+        described_class.new.call("test", double("Task"))
+      end.to raise_error(NotImplementedError)
     end
   end
-end 
+end

data/spec/lluminary/providers/bedrock_spec.rb

@@ -1,109 +1,99 @@
-require 'spec_helper'
-require 'lluminary/providers/bedrock'
+# frozen_string_literal: true
+require "spec_helper"
+require "lluminary/providers/bedrock"
 
 RSpec.describe Lluminary::Providers::Bedrock do
   let(:config) do
     {
-      region: 'us-east-1',
-      access_key_id: 'test-key',
-      secret_access_key: 'test-secret'
+      region: "us-east-1",
+      access_key_id: "test-key",
+      secret_access_key: "test-secret"
     }
   end
   let(:provider) { described_class.new(**config) }
 
-  describe '#client' do
-    it 'returns the AWS Bedrock client instance' do
+  describe "#client" do
+    it "returns the AWS Bedrock client instance" do
       expect(provider.client).to be_a(Aws::BedrockRuntime::Client)
     end
   end
 
-  describe '#call' do
-    let(:prompt) { 'Test prompt' }
-    let(:task) { 'Test task' }
+  describe "#call" do
+    let(:prompt) { "Test prompt" }
+    let(:task) { "Test task" }
     let(:mock_response) do
       OpenStruct.new(
-        output: OpenStruct.new(
-          message: OpenStruct.new(
-            content: [
-              OpenStruct.new(text: '{"sentiment": "positive"}')
-            ]
+        output:
+          OpenStruct.new(
+            message:
+              OpenStruct.new(
+                content: [OpenStruct.new(text: '{"sentiment": "positive"}')]
+              )
           )
-        )
       )
     end
 
     before do
-      allow_any_instance_of(Aws::BedrockRuntime::Client).to receive(:converse).and_return(mock_response)
+      allow_any_instance_of(Aws::BedrockRuntime::Client).to receive(
+        :converse
+      ).and_return(mock_response)
     end
 
-    it 'returns a hash with raw and parsed response' do
+    it "returns a hash with raw and parsed response" do
       response = provider.call(prompt, task)
-      expect(response).to eq({
-        raw: '{"sentiment": "positive"}',
-        parsed: { 'sentiment' => 'positive' }
-      })
+      expect(response).to eq(
+        {
+          raw: '{"sentiment": "positive"}',
+          parsed: {
+            "sentiment" => "positive"
+          }
+        }
+      )
     end
 
-    context 'when the response is not valid JSON' do
+    context "when the response is not valid JSON" do
       let(:mock_response) do
         OpenStruct.new(
-          output: OpenStruct.new(
-            message: OpenStruct.new(
-              content: [
-                OpenStruct.new(text: 'not valid json')
-              ]
+          output:
+            OpenStruct.new(
+              message:
+                OpenStruct.new(
+                  content: [OpenStruct.new(text: "not valid json")]
+                )
             )
-          )
         )
       end
 
-      it 'returns raw response with nil parsed value' do
+      it "returns raw response with nil parsed value" do
         response = provider.call(prompt, task)
-        expect(response).to eq({
-          raw: 'not valid json',
-          parsed: nil
-        })
+        expect(response).to eq({ raw: "not valid json", parsed: nil })
       end
     end
 
-    context 'when the response content is nil' do
+    context "when the response content is nil" do
       let(:mock_response) do
         OpenStruct.new(
-          output: OpenStruct.new(
-            message: OpenStruct.new(
-              content: nil
-            )
-          )
+          output: OpenStruct.new(message: OpenStruct.new(content: nil))
         )
       end
 
-      it 'returns nil for both raw and parsed values' do
+      it "returns nil for both raw and parsed values" do
         response = provider.call(prompt, task)
-        expect(response).to eq({
-          raw: nil,
-          parsed: nil
-        })
+        expect(response).to eq({ raw: nil, parsed: nil })
       end
     end
 
-    context 'when the response content array is empty' do
+    context "when the response content array is empty" do
       let(:mock_response) do
         OpenStruct.new(
-          output: OpenStruct.new(
-            message: OpenStruct.new(
-              content: []
-            )
-          )
+          output: OpenStruct.new(message: OpenStruct.new(content: []))
         )
       end
 
-      it 'returns nil for both raw and parsed values' do
+      it "returns nil for both raw and parsed values" do
         response = provider.call(prompt, task)
-        expect(response).to eq({
-          raw: nil,
-          parsed: nil
-        })
+        expect(response).to eq({ raw: nil, parsed: nil })
       end
     end
   end
-end 
+end

data/spec/lluminary/providers/openai_spec.rb

@@ -1,62 +1,54 @@
-require 'spec_helper'
+# frozen_string_literal: true
+require "spec_helper"
 
 RSpec.describe Lluminary::Providers::OpenAI do
-  let(:config) { { api_key: 'test-key' } }
+  let(:config) { { api_key: "test-key" } }
   let(:provider) { described_class.new(**config) }
 
-  describe '#client' do
-    it 'returns the OpenAI client instance' do
+  describe "#client" do
+    it "returns the OpenAI client instance" do
       expect(provider.client).to be_a(OpenAI::Client)
     end
   end
 
-  describe '#call' do
-    let(:prompt) { 'Test prompt' }
-    let(:task) { 'Test task' }
+  describe "#call" do
+    let(:prompt) { "Test prompt" }
+    let(:task) { "Test task" }
     let(:mock_response) do
       {
-        'choices' => [
-          {
-            'message' => {
-              'content' => '{"summary": "Test response"}'
-            }
-          }
+        "choices" => [
+          { "message" => { "content" => '{"summary": "Test response"}' } }
         ]
       }
     end
 
     before do
-      allow_any_instance_of(OpenAI::Client).to receive(:chat).and_return(mock_response)
+      allow_any_instance_of(OpenAI::Client).to receive(:chat).and_return(
+        mock_response
+      )
     end
 
-    it 'returns a hash with raw and parsed response' do
+    it "returns a hash with raw and parsed response" do
       response = provider.call(prompt, task)
-      expect(response).to eq({
-        raw: '{"summary": "Test response"}',
-        parsed: { 'summary' => 'Test response' }
-      })
+      expect(response).to eq(
+        {
+          raw: '{"summary": "Test response"}',
+          parsed: {
+            "summary" => "Test response"
+          }
+        }
+      )
     end
 
-    context 'when the response is not valid JSON' do
+    context "when the response is not valid JSON" do
       let(:mock_response) do
-        {
-          'choices' => [
-            {
-              'message' => {
-                'content' => 'not valid json'
-              }
-            }
-          ]
-        }
+        { "choices" => [{ "message" => { "content" => "not valid json" } }] }
       end
 
-      it 'returns raw response with nil parsed value' do
+      it "returns raw response with nil parsed value" do
         response = provider.call(prompt, task)
-        expect(response).to eq({
-          raw: 'not valid json',
-          parsed: nil
-        })
+        expect(response).to eq({ raw: "not valid json", parsed: nil })
       end
     end
   end
-end 
+end

data/spec/lluminary/providers/test_spec.rb

@@ -1,14 +1,17 @@
-require 'spec_helper'
-require 'lluminary/providers/test'
+# frozen_string_literal: true
+require "spec_helper"
+require "lluminary/providers/test"
 
 RSpec.describe Lluminary::Providers::Test do
   let(:provider) { described_class.new }
   let(:prompt) { "Test prompt" }
-  let(:task_class) { double("TaskClass", output_fields: { summary: { type: :string } }) }
+  let(:task_class) do
+    double("TaskClass", output_fields: { summary: { type: :string } })
+  end
   let(:task) { double("Task", class: task_class) }
 
-  describe '#call' do
-    it 'returns a hash with raw and parsed response' do
+  describe "#call" do
+    it "returns a hash with raw and parsed response" do
       response = provider.call(prompt, task)
 
       expect(response).to be_a(Hash)
@@ -16,7 +19,7 @@ RSpec.describe Lluminary::Providers::Test do
       expect(response[:parsed]).to eq({ "summary" => "Test string value" })
     end
 
-    it 'handles prompts with schema descriptions' do
+    it "handles prompts with schema descriptions" do
       prompt_with_schema = <<~PROMPT
         Test prompt
 
@@ -36,22 +39,24 @@ RSpec.describe Lluminary::Providers::Test do
       expect(response[:parsed]).to eq({ "summary" => "Test string value" })
     end
 
-    it 'generates integer values for integer fields' do
-      task_class = double("TaskClass", output_fields: { count: { type: :integer } })
+    it "generates integer values for integer fields" do
+      task_class =
+        double("TaskClass", output_fields: { count: { type: :integer } })
       task = double("Task", class: task_class)
-      
+
       response = provider.call(prompt, task)
       expect(response[:raw]).to eq('{"count": 0}')
       expect(response[:parsed]).to eq({ "count" => 0 })
     end
 
-    it 'raises error for unsupported types' do
-      task_class = double("TaskClass", output_fields: { value: { type: :unsupported } })
+    it "raises error for unsupported types" do
+      task_class =
+        double("TaskClass", output_fields: { value: { type: :unsupported } })
       task = double("Task", class: task_class)
-      
-      expect {
-        provider.call(prompt, task)
-      }.to raise_error("Unsupported type: unsupported")
+
+      expect { provider.call(prompt, task) }.to raise_error(
+        "Unsupported type: unsupported"
+      )
     end
   end
-end 
+end

data/spec/lluminary/result_spec.rb

@@ -1,31 +1,38 @@
-require 'lluminary'
+# frozen_string_literal: true
+require "lluminary"
 
 RSpec.describe Lluminary::Result do
   let(:raw_response) { "Test response" }
   let(:output) { { summary: "Test summary" } }
   let(:prompt) { "Test prompt" }
-  let(:result) { described_class.new(raw_response: raw_response, output: output, prompt: prompt) }
+  let(:result) do
+    described_class.new(
+      raw_response: raw_response,
+      output: output,
+      prompt: prompt
+    )
+  end
 
-  describe '#raw_response' do
-    it 'returns the raw response' do
+  describe "#raw_response" do
+    it "returns the raw response" do
       expect(result.raw_response).to eq(raw_response)
     end
   end
 
-  describe '#output' do
-    it 'returns an OpenStruct with the output data' do
+  describe "#output" do
+    it "returns an OpenStruct with the output data" do
       expect(result.output).to be_a(OpenStruct)
       expect(result.output.summary).to eq(output[:summary])
     end
 
-    it 'allows accessing output fields as methods' do
+    it "allows accessing output fields as methods" do
       expect(result.output.summary).to eq(output[:summary])
     end
   end
 
-  describe '#prompt' do
-    it 'returns the prompt' do
+  describe "#prompt" do
+    it "returns the prompt" do
       expect(result.prompt).to eq(prompt)
     end
   end
-end 
+end

data/spec/lluminary/schema_model_spec.rb

@@ -1,11 +1,18 @@
-require 'spec_helper'
+# frozen_string_literal: true
+require "spec_helper"
 
 RSpec.describe Lluminary::SchemaModel do
-  describe '.build' do
+  describe ".build" do
     let(:fields) do
       {
-        name: { type: :string, description: "The user's name" },
-        age: { type: :integer, description: "The user's age" }
+        name: {
+          type: :string,
+          description: "The user's name"
+        },
+        age: {
+          type: :integer,
+          description: "The user's age"
+        }
       }
     end
 
@@ -16,35 +23,39 @@ RSpec.describe Lluminary::SchemaModel do
       ]
     end
 
-    let(:model_class) { described_class.build(fields: fields, validations: validations) }
+    let(:model_class) do
+      described_class.build(fields: fields, validations: validations)
+    end
 
-    it 'creates a class that inherits from SchemaModel' do
+    it "creates a class that inherits from SchemaModel" do
       expect(model_class.ancestors).to include(described_class)
     end
 
-    it 'includes ActiveModel::Validations' do
+    it "includes ActiveModel::Validations" do
       expect(model_class.ancestors).to include(ActiveModel::Validations)
     end
 
-    it 'adds accessors for fields' do
+    it "adds accessors for fields" do
       instance = model_class.new(name: "John", age: 30)
       expect(instance.name).to eq("John")
       expect(instance.age).to eq(30)
     end
 
-    it 'validates presence' do
+    it "validates presence" do
       instance = model_class.new(age: 30)
       expect(instance.valid?).to be false
       expect(instance.errors.full_messages).to include("Name can't be blank")
     end
 
-    it 'validates numericality' do
+    it "validates numericality" do
       instance = model_class.new(name: "John", age: 0)
       expect(instance.valid?).to be false
-      expect(instance.errors.full_messages).to include("Age must be greater than 0")
+      expect(instance.errors.full_messages).to include(
+        "Age must be greater than 0"
+      )
     end
 
-    it 'validates types' do
+    it "validates types" do
       instance = model_class.new(name: 123, age: "30")
       expect(instance.valid?).to be false
       expect(instance.errors.full_messages).to include(
@@ -53,34 +64,32 @@ RSpec.describe Lluminary::SchemaModel do
       )
     end
 
-    it 'validates float types' do
-      fields = {
-        price: { type: :float, description: "The price" }
-      }
+    it "validates float types" do
+      fields = { price: { type: :float, description: "The price" } }
       model_class = described_class.build(fields: fields, validations: [])
-      
+
       # Test that nil is allowed
       instance = model_class.new(price: nil)
       expect(instance.valid?).to be true
-      
+
       # Test invalid float value
       instance = model_class.new(price: "not a float")
       expect(instance.valid?).to be false
       expect(instance.errors.full_messages).to include("Price must be a float")
-      
+
       # Test valid float value
       instance = model_class.new(price: 12.34)
       expect(instance.valid?).to be true
     end
 
-    it 'accepts valid attributes' do
+    it "accepts valid attributes" do
       instance = model_class.new(name: "John", age: 30)
       expect(instance.valid?).to be true
     end
 
-    it 'provides access to raw attributes' do
+    it "provides access to raw attributes" do
       instance = model_class.new(name: "John", age: 30)
       expect(instance.attributes).to eq({ "name" => "John", "age" => 30 })
     end
   end
-end 
+end