ollama-ruby 0.10.0 → 0.12.0

data/spec/ollama/documents/{redis_backed_memory_cache_spec.rb → cache/redis_backed_memory_cache_spec.rb}

@@ -1,17 +1,21 @@
 require 'spec_helper'
 
 RSpec.describe Ollama::Documents::RedisBackedMemoryCache do
+  let :prefix do
+    'test-'
+  end
+
+  let :cache do
+    described_class.new prefix: 'test-', url: 'something'
+  end
+
   it 'raises ArgumentError if url is missing' do
     expect {
-      described_class.new prefix: 'test-', url: nil
+      described_class.new prefix:, url: nil
     }.to raise_error ArgumentError
   end
 
   context 'test redis interactions' do
-    let :cache do
-      described_class.new prefix: 'test-', url: 'something'
-    end
-
     let :data do
       cache.instance_eval { @data }
     end
@@ -31,12 +35,10 @@ RSpec.describe Ollama::Documents::RedisBackedMemoryCache do
     end
 
     it 'can be instantiated and initialized' do
-      cache = described_class.new prefix: 'test-', url: 'something'
       expect(cache).to be_a described_class
     end
 
     it 'defaults to nil object_class' do
-      cache = described_class.new prefix: 'test-', url: 'something'
       expect(cache.object_class).to be_nil
     end
 
@@ -77,6 +79,16 @@ RSpec.describe Ollama::Documents::RedisBackedMemoryCache do
       cache.delete(key)
     end
 
+    it 'can iterate over keys, values' do
+      key, value = 'foo', { 'test' => true }
+      expect(redis).to receive(:set).with('test-' + key, JSON(value))
+      cache[key] = value
+      cache.each do |k, v|
+        expect(k).to eq prefix + key
+        expect(v).to eq value
+      end
+    end
+
     it 'returns size' do
       expect(cache).to receive(:count).and_return 3
       expect(cache.size).to eq 3

data/spec/ollama/documents/{redis_cache_spec.rb → cache/redis_cache_spec.rb}

@@ -1,33 +1,35 @@
 require 'spec_helper'
 
 RSpec.describe Ollama::Documents::RedisCache do
+  let :prefix do
+    'test-'
+  end
+
+  let :cache do
+    described_class.new prefix:, url: 'something'
+  end
+
   it 'can be instantiated' do
-    cache = described_class.new prefix: 'test-', url: 'something'
     expect(cache).to be_a described_class
   end
 
   it 'defaults to nil object_class' do
-    cache = described_class.new prefix: 'test-', url: 'something'
     expect(cache.object_class).to be_nil
   end
 
   it 'can be configured with object_class' do
     object_class = Class.new(JSON::GenericObject)
-    cache = described_class.new(prefix: 'test-', url: 'something', object_class:)
+    cache = described_class.new(prefix:, url: 'something', object_class:)
     expect(cache.object_class).to eq object_class
   end
 
   it 'raises ArgumentError if url is missing' do
     expect {
-      described_class.new prefix: 'test-', url: nil
+      described_class.new prefix:, url: nil
     }.to raise_error ArgumentError
   end
 
   context 'test redis interactions' do
-    let :cache do
-      described_class.new prefix: 'test-', url: 'something'
-    end
-
     let :redis do
       double('Redis')
     end
@@ -42,43 +44,56 @@ RSpec.describe Ollama::Documents::RedisCache do
 
     it 'can get a key' do
       key = 'foo'
-      expect(redis).to receive(:get).with('test-' + key).and_return '"some_json"'
+      expect(redis).to receive(:get).with(prefix + key).and_return '"some_json"'
       expect(cache[key]).to eq 'some_json'
     end
 
     it 'can set a value for a key' do
       key, value = 'foo', { test: true }
-      expect(redis).to receive(:set).with('test-' + key, JSON(value), ex: nil)
+      expect(redis).to receive(:set).with(prefix + key, JSON(value), ex: nil)
       cache[key] = value
     end
 
     it 'can set a value for a key with ttl' do
-      cache = described_class.new prefix: 'test-', url: 'something', ex: 3_600
+      cache = described_class.new prefix:, url: 'something', ex: 3_600
       key, value = 'foo', { test: true }
-      expect(redis).to receive(:set).with('test-' + key, JSON(value), ex: 3_600)
+      expect(redis).to receive(:set).with(prefix + key, JSON(value), ex: 3_600)
       cache[key] = value
-      expect(redis).to receive(:ttl).with('test-' + key).and_return 3_600
+      expect(redis).to receive(:ttl).with(prefix + key).and_return 3_600
       expect(cache.ttl(key)).to eq 3_600
     end
 
     it 'can determine if key exists' do
       key = 'foo'
-      expect(redis).to receive(:exists?).with('test-' + key).and_return(false, true)
+      expect(redis).to receive(:exists?).with(prefix + key).and_return(false, true)
       expect(cache.key?('foo')).to eq false
       expect(cache.key?('foo')).to eq true
     end
 
     it 'can delete' do
       key = 'foo'
-      expect(redis).to receive(:del).with('test-' + key)
+      expect(redis).to receive(:del).with(prefix + key)
       cache.delete(key)
     end
 
+    it 'can iterate over keys, values' do
+      key, value = 'foo', { 'test' => true }
+      expect(redis).to receive(:set).with(prefix + key, JSON(value), ex: nil)
+      cache[key] = value
+      expect(redis).to receive(:scan_each).with(match: "#{prefix}*").
+        and_yield("#{prefix}foo")
+      expect(redis).to receive(:get).with(prefix + key).and_return(JSON(test: true))
+      cache.each do |k, v|
+        expect(k).to eq prefix + key
+        expect(v).to eq value
+      end
+    end
+
     it 'returns size' do
-      allow(redis).to receive(:scan_each).with(match: 'test-*').
-        and_yield('test-foo').
-        and_yield('test-bar').
-        and_yield('test-baz')
+      expect(redis).to receive(:scan_each).with(match: "#{prefix}*").
+        and_yield("#{prefix}foo").
+        and_yield("#{prefix}bar").
+        and_yield("#{prefix}baz")
       expect(cache.size).to eq 3
     end
 

data/spec/ollama/documents/cache/sqlite_cache_spec.rb

@@ -0,0 +1,141 @@
+require 'spec_helper'
+
+RSpec.describe Ollama::Documents::SQLiteCache do
+  let :prefix do
+    'test-'
+  end
+
+  let :test_value do
+    {
+      key:       'test',
+      text:      'test text',
+      norm:      0.5,
+      source:    'for-test.txt',
+      tags:      %w[ test ],
+      embedding: [ 0.5 ] * 1_024,
+    }
+  end
+
+  let :cache do
+    described_class.new prefix:
+  end
+
+  it 'can be instantiated' do
+    expect(cache).to be_a described_class
+  end
+
+  it 'defaults to :memory: mode' do
+    expect(cache.filename).to eq ':memory:'
+  end
+
+  it 'can be switchted to file mode' do
+    expect(SQLite3::Database).to receive(:new).with('foo.sqlite').
+      and_return(double.as_null_object)
+    cache = described_class.new prefix:, filename: 'foo.sqlite'
+    expect(cache.filename).to eq 'foo.sqlite'
+  end
+
+  it 'can get/set a key' do
+    key, value = 'foo', test_value
+    queried_value = nil
+    expect {
+      cache[key] = value
+    }.to change {
+      queried_value = cache[key]
+    }.from(nil).to(Ollama::Documents::Record[value])
+    expect(queried_value.embedding).to eq [ 0.5 ] * 1_024
+  end
+
+  it 'can determine if key exists' do
+    key, value = 'foo', test_value
+    expect {
+      cache[key] = value
+    }.to change {
+      cache.key?(key)
+    }.from(false).to(true)
+  end
+
+  it 'can set key with different prefixes' do
+    key, value = 'foo', test_value
+    expect {
+      cache[key] = value
+    }.to change {
+      cache.size
+    }.from(0).to(1)
+    cache2 = cache.dup
+    cache2.prefix = 'test2-'
+    expect {
+      cache2[key] = value
+    }.to change {
+      cache2.size
+    }.from(0).to(1)
+    expect(cache.size).to eq 1
+    s = 0
+    cache.full_each { s += 1 }
+    expect(s).to eq 2
+  end
+
+  it 'can delete' do
+    key, value = 'foo', test_value
+    expect(cache.delete(key)).to be_falsy
+    cache[key] = value
+    expect {
+      expect(cache.delete(key)).to be_truthy
+    }.to change {
+      cache.key?(key)
+    }.from(true).to(false)
+  end
+
+  it 'returns size' do
+    key, value = 'foo', test_value
+    expect {
+      cache[key] = value
+    }.to change {
+      cache.size
+    }.from(0).to(1)
+  end
+
+  it 'can convert_to_vector' do
+    vector = [ 23.0, 666.0 ]
+    expect(cache.convert_to_vector(vector)).to eq vector
+  end
+
+  it 'can clear' do
+    key, value = 'foo', { embedding: [ 0.5 ] * 1_024 }
+    cache[key] = value
+    expect {
+      expect(cache.clear).to eq cache
+    }.to change {
+      cache.size
+    }.from(1).to(0)
+  end
+
+  it 'can clear for tags' do
+    key, value = 'foo', { tags: %w[ foo ], embedding: [ 0.5 ] * 1_024 }
+    cache[key] = value
+    key, value = 'bar', { embedding: [ 0.5 ] * 1_024 }
+    cache[key] = value
+    expect {
+      expect(cache.clear_for_tags(%w[ #foo ])).to eq cache
+    }.to change {
+      cache.size
+    }.from(2).to(1)
+    expect(cache).not_to be_key 'foo'
+    expect(cache).to be_key 'bar'
+  end
+
+  it 'can return tags' do
+    key, value = 'foo', { tags: %w[ foo ], embedding: [ 0.5 ] * 1_024 }
+    cache[key] = value
+    key, value = 'bar', { tags: %w[ bar baz ], embedding: [ 0.5 ] * 1_024 }
+    cache[key] = value
+    tags = cache.tags
+    expect(tags).to be_a Ollama::Utils::Tags
+    expect(tags.to_a).to eq %w[ bar baz foo ]
+  end
+
+  it 'can iterate over keys under a prefix' do
+    cache['foo'] = test_value
+    expect(cache.to_a).to eq [ [ 'test-foo', Ollama::Documents::Record[test_value] ] ]
+  end
+end

data/spec/ollama/handlers/say_spec.rb

@@ -1,30 +1,93 @@
 require 'spec_helper'
 
 RSpec.describe Ollama::Handlers::Say do
+  let :say do
+    described_class.new
+  end
+
   it 'has .to_proc' do
     expect_any_instance_of(described_class).to receive(:call).with(:foo)
     described_class.call(:foo)
   end
 
-  it 'can print response' do
-    output = double('output', :sync= => true)
+  it 'can be instantiated' do
+    expect(say).to be_a described_class
+  end
+
+  it 'can be instantiated with a given voice' do
+    expect_any_instance_of(described_class).to receive(:command).
+      with(hash_including(voice: 'TheVoice')).and_return %w[ true ]
+    say = described_class.new(voice: 'TheVoice')
+    expect(say).to be_a described_class
+  end
+
+  describe 'command' do
+    it 'can be instantiated interactively' do
+      expect_any_instance_of(described_class).to receive(:command).
+        with(hash_including(interactive: true)).and_return %w[ true ]
+      say = described_class.new(interactive: true)
+      expect(say).to be_a described_class
+    end
+
+    it 'can set the voice' do
+      expect(say.send(:command, voice: 'TheVoice', interactive: nil)).to eq(
+        %w[ say -v TheVoice ]
+      )
+    end
+
+    it 'can be instantiated interactively with green' do
+      expect_any_instance_of(described_class).to receive(:command).
+        with(hash_including(interactive: 'green')).and_return %w[ true ]
+      say = described_class.new(interactive: 'green')
+      expect(say).to be_a described_class
+    end
+
+    it 'can set interactive mode' do
+      expect(say.send(:command, voice: nil, interactive: true)).to eq(
+        %w[ say -i ]
+      )
+    end
+
+    it 'can set interactive mode to green' do
+      expect(say.send(:command, voice: nil, interactive: 'green')).to eq(
+        %w[ say --interactive=green ]
+      )
+    end
+  end
+
+  it 'can say response' do
+    output = double('output', :sync= => true, closed?: false)
     expect(output).to receive(:print).with('testing')
     expect(output).to receive(:close)
-    print = described_class.new(output:)
+    say = described_class.new(output:)
     response = double('response', response: 'testing', done: false)
-    print.call(response)
+    say.call(response)
     response = double('response', response: nil, message: nil, done: true)
-    print.call(response)
+    say.call(response)
   end
 
-  it 'can print message content' do
-    output = double('output', :sync= => true)
+  it 'can say message content' do
+    output = double('output', :sync= => true, closed?: false)
     expect(output).to receive(:print).with('testing')
     expect(output).to receive(:close)
-    print = described_class.new(output:)
+    say = described_class.new(output:)
     response = double('response', response: nil, message: double(content: 'testing'), done: false)
-    print.call(response)
+    say.call(response)
+    response = double('response', response: nil, message: nil, done: true)
+    say.call(response)
+  end
+
+  it 'can reopen output if closed' do
+    output = double('output', :sync= => true, closed?: true)
+    reopened_output = double('output', :sync= => true, closed?: false, pid: 666)
+    expect(reopened_output).to receive(:print).with('testing')
+    expect(reopened_output).to receive(:close)
+    say = described_class.new(output:)
+    expect(say).to receive(:open_output).and_return(reopened_output)
+    response = double('response', response: 'testing', done: false)
+    say.call(response)
     response = double('response', response: nil, message: nil, done: true)
-    print.call(response)
+    say.call(response)
   end
+
 end

data/spec/ollama/utils/fetcher_spec.rb

@@ -77,12 +77,12 @@ RSpec.describe Ollama::Utils::Fetcher do
     stub_request(:get, url).
       with(headers: fetcher.headers).
       to_return(status: 500)
-		expect(STDERR).to receive(:puts).with(/cannot.*get.*#{url}/i)
-    fetcher.get(url) do |tmp|
-      expect(tmp).to be_a StringIO
-      expect(tmp.read).to eq ''
-      expect(tmp.content_type).to eq 'text/plain'
-    end
+    expect(STDERR).to receive(:puts).with(/cannot.*get.*#{url}/i)
+      fetcher.get(url) do |tmp|
+        expect(tmp).to be_a StringIO
+        expect(tmp.read).to eq ''
+        expect(tmp.content_type).to eq 'text/plain'
+      end
   end
 
   it 'can redirect' do
@@ -107,7 +107,7 @@ RSpec.describe Ollama::Utils::Fetcher do
 
   it 'can .execute and fail' do
     expect(IO).to receive(:popen).and_raise StandardError
-		expect(STDERR).to receive(:puts).with(/cannot.*execute.*foobar/i)
+    expect(STDERR).to receive(:puts).with(/cannot.*execute.*foobar/i)
     described_class.execute('foobar') do |file|
       expect(file).to be_a StringIO
       expect(file.read).to be_empty
@@ -115,23 +115,23 @@ RSpec.describe Ollama::Utils::Fetcher do
     end
   end
 
-	describe '.normalize_url' do
-		it 'can handle umlauts' do
-			expect(described_class.normalize_url('https://foo.de/bär')).to eq(
-				'https://foo.de/b%C3%A4r'
-			)
-		end
+  describe '.normalize_url' do
+    it 'can handle umlauts' do
+      expect(described_class.normalize_url('https://foo.de/bär')).to eq(
+        'https://foo.de/b%C3%A4r'
+      )
+    end
 
-		it 'can handle escaped umlauts' do
-			expect(described_class.normalize_url('https://foo.de/b%C3%A4r')).to eq(
-				'https://foo.de/b%C3%A4r'
-			)
-		end
+    it 'can handle escaped umlauts' do
+      expect(described_class.normalize_url('https://foo.de/b%C3%A4r')).to eq(
+        'https://foo.de/b%C3%A4r'
+      )
+    end
 
-		it 'can remove #anchors' do
-			expect(described_class.normalize_url('https://foo.de#bar')).to eq(
-				'https://foo.de'
-			)
-		end
-	end
+    it 'can remove #anchors' do
+      expect(described_class.normalize_url('https://foo.de#bar')).to eq(
+        'https://foo.de'
+      )
+    end
+  end
 end

data/spec/ollama/utils/tags_spec.rb

@@ -10,6 +10,11 @@ RSpec.describe Ollama::Utils::Tags do
     expect(tags.to_a).to eq %w[ bar foo ]
   end
 
+  it 'can contain unique tags with leading # characters and is sorted' do
+    tags = described_class.new(%w[ #bar ##foo ])
+    expect(tags.to_a).to eq %w[ bar foo ]
+  end
+
   it 'tags can be added to it' do
     tags = described_class.new([ 'foo' ])
     tags.add 'bar'
@@ -27,13 +32,13 @@ RSpec.describe Ollama::Utils::Tags do
     expect { tags.clear }.to change { tags.size }.from(2).to(0)
   end
 
-  it 'tags can be empt' do
+  it 'tags can be empty' do
     tags = described_class.new([ 'foo' ])
     expect { tags.clear }.to change { tags.empty? }.from(false).to(true)
   end
 
   it 'can be output nicely' do
-    expect(described_class.new(%w[ foo bar ]).to_s).to eq '#bar #foo'
+    expect(described_class.new(%w[ #foo bar ]).to_s).to eq '#bar #foo'
   end
 
   it 'can be output nicely with links to source' do