ollama-ruby 0.12.1 → 0.14.0

data/spec/ollama/documents_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Ollama::Documents do
-  let :ollama do
-    double('Ollama::Client')
-  end
-
-  let :model do
-    'mxbai-embed-large'
-  end
-
-  let :documents do
-    described_class.new ollama:, model:
-  end
-
-  it 'can be instantiated' do
-    expect(documents).to be_a described_class
-  end
-
-  it 'no texts can be added to it' do
-    expect(documents.add([])).to eq documents
-  end
-
-  it 'texts can be added to it' do
-    expect(ollama).to receive(:embed).
-      with(model:, input: %w[ foo bar ], options: nil).
-      and_return(double(embeddings: [ [ 0.1 ], [ 0.2 ] ]))
-    expect(documents.add(%w[ foo bar ])).to eq documents
-    expect(documents.exist?('foo')).to eq true
-    expect(documents.exist?('bar')).to eq true
-    expect(documents['foo']).to be_a Ollama::Documents::Record
-  end
-
-  it 'a text can be added to it' do
-    expect(ollama).to receive(:embed).
-      with(model:, input: %w[ foo ], options: nil).
-      and_return(double(embeddings: [ [ 0.1 ] ]))
-    expect(documents << 'foo').to eq documents
-    expect(documents.exist?('foo')).to eq true
-    expect(documents.exist?('bar')).to eq false
-    expect(documents['foo']).to be_a Ollama::Documents::Record
-  end
-
-  it 'can find strings' do
-    expect(ollama).to receive(:embed).
-      with(model:, input: [ 'foo' ], options: nil).
-      and_return(double(embeddings: [ [ 0.1 ] ]))
-    expect(documents << 'foo').to eq documents
-    expect(ollama).to receive(:embed).
-      with(model:, input: 'foo', options: nil).
-      and_return(double(embeddings: [ [ 0.1 ] ]))
-    records = documents.find('foo')
-    expect(records).to eq [
-      Ollama::Documents::Record[text: 'foo', embedding: [ 0.1 ], similarity: 1.0 ]
-    ]
-    expect(records[0].to_s).to eq '#<Ollama::Documents::Record "foo" 1.0>'
-  end
-
-  it 'can find only tagged strings' do
-    expect(ollama).to receive(:embed).
-      with(model:, input: [ 'foo' ], options: nil).
-      and_return(double(embeddings: [ [ 0.1 ] ]))
-    expect(documents.add('foo', tags: %w[ test ])).to eq documents
-    expect(ollama).to receive(:embed).
-      with(model:, input: 'foo', options: nil).
-      and_return(double(embeddings: [ [ 0.1 ] ]))
-    records = documents.find('foo', tags: %w[ nix ])
-    expect(records).to eq []
-    expect(ollama).to receive(:embed).
-      with(model:, input: 'foo', options: nil).
-      and_return(double(embeddings: [ [ 0.1 ] ]))
-    records = documents.find('foo', tags: %w[ test ])
-    expect(records).to eq [
-      Ollama::Documents::Record[text: 'foo', embedding: [ 0.1 ], similarity: 1.0 ]
-    ]
-    expect(records[0].to_s).to eq '#<Ollama::Documents::Record "foo" #test 1.0>'
-  end
-
-  it 'can find strings conditionally' do
-    expect(ollama).to receive(:embed).
-      with(model:, input: [ 'foobar' ], options: nil).
-      and_return(double(embeddings: [ [ 0.01 ] ]))
-    expect(ollama).to receive(:embed).
-      with(model:, input: [ 'foo' ], options: nil).
-      and_return(double(embeddings: [ [ 0.1 ] ]))
-    expect(documents << 'foobar').to eq documents
-    expect(documents << 'foo').to eq documents
-    expect(ollama).to receive(:embed).at_least(:once).
-      with(model:, input: 'foo', options: nil).
-      and_return(double(embeddings: [ [ 0.1 ] ]))
-    records = documents.find_where('foo', text_count: 1)
-    expect(records).to eq [
-      Ollama::Documents::Record[text: 'foo', embedding: [ 0.1 ], similarity: 1.0 ],
-    ]
-    records = documents.find_where('foo', text_size: 3)
-    expect(records).to eq [
-      Ollama::Documents::Record[text: 'foo', embedding: [ 0.1 ], similarity: 1.0 ],
-    ]
-    records = documents.find_where('foo')
-    expect(records).to eq [
-      Ollama::Documents::Record[text: 'foo', embedding: [ 0.1 ], similarity: 1.0 ],
-      Ollama::Documents::Record[text: 'foobar', embedding: [ 0.1 ], similarity: 1.0 ],
-    ]
-  end
-
-
-  context 'it uses cache' do
-    before do
-      allow(ollama).to receive(:embed).
-        with(model:, input: %w[ foo ], options: nil).
-        and_return(double(embeddings: [ [ 0.1 ] ]))
-    end
-
-    it 'can delete texts' do
-      expect(documents << 'foo').to eq documents
-      expect {
-        documents.delete('foo')
-      }.to change { documents.exist?('foo') }.from(true).to(false)
-    end
-
-    it 'tracks size' do
-      expect {
-        expect(documents << 'foo').to eq documents
-      }.to change { documents.size }.from(0).to(1)
-    end
-
-    it 'can clear texts' do
-      expect(documents << 'foo').to eq documents
-      expect {
-        documents.clear
-      }.to change { documents.size }.from(1).to(0)
-    end
-
-    it 'can clear texts with tags' do
-      expect(ollama).to receive(:embed).
-        with(model:, input: %w[ bar ], options: nil).
-        and_return(double(embeddings: [ [ 0.1 ] ]))
-      expect(documents.add('foo', tags: %w[ test ])).to eq documents
-      expect(documents.add('bar', tags: %w[ test2 ])).to eq documents
-      expect(documents.tags.to_a).to eq %w[ test test2 ]
-      expect {
-        documents.clear tags: 'test'
-      }.to change { documents.size }.from(2).to(1)
-      expect {
-        documents.clear tags: :test2
-      }.to change { documents.size }.from(1).to(0)
-    end
-
-    it 'returns collections' do
-      expect(documents.collections).to eq [ :default ]
-    end
-
-    it 'can change collection' do
-      expect(documents.instance_eval { @cache }).to receive(:prefix=).
-        with(/#@collection/).and_call_original
-      expect { documents.collection = :new_collection }.
-        to change { documents.collection }.
-        from(:default).
-        to(:new_collection)
-    end
-  end
-end

data/spec/ollama/utils/cache_fetcher_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Ollama::Utils::CacheFetcher do
-  let :url do
-    'https://www.example.com/hello'
-  end
-
-  let :cache do
-    double('RedisCache')
-  end
-
-  let :fetcher do
-    described_class.new(cache).expose
-  end
-
-  it 'can be instantiated' do
-    expect(fetcher).to be_a described_class
-  end
-
-  it 'has #get' do
-    expect(cache).to receive(:[]).with('body-69ce405ab83f42dffa9fd22bbd47783f').and_return 'world'
-    expect(cache).to receive(:[]).with('content_type-69ce405ab83f42dffa9fd22bbd47783f').and_return 'text/plain'
-    yielded_io = nil
-    block = -> io { yielded_io = io }
-    fetcher.get(url, &block)
-    expect(yielded_io).to be_a StringIO
-    expect(yielded_io.read).to eq 'world'
-  end
-
-  it '#get needs block' do
-    expect { fetcher.get(url) }.to raise_error(ArgumentError)
-  end
-
-  it 'has #put' do
-    io = StringIO.new('world')
-    io.extend(Ollama::Utils::Fetcher::HeaderExtension)
-    io.content_type = MIME::Types['text/plain'].first
-    io.ex = 666
-    expect(cache).to receive(:set).with('body-69ce405ab83f42dffa9fd22bbd47783f', 'world', ex: 666)
-    expect(cache).to receive(:set).with('content_type-69ce405ab83f42dffa9fd22bbd47783f', 'text/plain', ex: 666)
-    fetcher.put(url, io)
-  end
-end

data/spec/ollama/utils/colorize_texts_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Ollama::Utils::ColorizeTexts do
-  it 'colorizes texts' do
-    ct = described_class.new(%w[ foo bar ])
-    colored   = ct.to_s
-    uncolored = Term::ANSIColor.uncolor(ct.to_s)
-    expect(colored.size).to be > uncolored.size
-    expect(uncolored).to eq(
-      "foo\n#3 \n\nbar\n#3 \n\n"
-    )
-  end
-end

data/spec/ollama/utils/fetcher_spec.rb

@@ -1,137 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Ollama::Utils::Fetcher do
-  let :url do
-    'https://www.example.com/hello'
-  end
-
-  let :fetcher do
-    described_class.new.expose
-  end
-
-  it 'can be instantiated' do
-    expect(fetcher).to be_a described_class
-  end
-
-  it 'has .get' do
-    expect(described_class).to receive(:new).and_return double(get: true)
-    described_class.get(url)
-  end
-
-  it 'can #get with streaming' do
-    stub_request(:get, url).
-      with(headers: fetcher.headers).
-      to_return(
-        status: 200,
-        body: 'world',
-        headers: { 'Content-Type' => 'text/plain' },
-      )
-    fetcher.get(url) do |tmp|
-      expect(tmp).to be_a Tempfile
-      expect(tmp.read).to eq 'world'
-      expect(tmp.content_type).to eq 'text/plain'
-    end
-  end
-
-  it 'can #get without ssl peer verification' do
-    fetcher = described_class.new(
-      http_options: { ssl_verify_peer: false }
-    ).expose
-    stub_request(:get, url).
-      with(headers: fetcher.headers).
-      to_return(
-        status: 200,
-        body: 'world',
-        headers: { 'Content-Type' => 'text/plain' },
-      )
-    expect(Excon).to receive(:new).with(
-      url,
-      hash_including(ssl_verify_peer: false)
-    ).and_call_original
-    fetcher.get(url) do |tmp|
-      expect(tmp).to be_a Tempfile
-      expect(tmp.read).to eq 'world'
-      expect(tmp.content_type).to eq 'text/plain'
-    end
-  end
-
-  it 'can #get and fallback from streaming' do
-    stub_request(:get, url).
-      with(headers: fetcher.headers).
-      to_return(
-        { status: 501 },
-        {
-          status: 200,
-          body: 'world',
-          headers: { 'Content-Type' => 'text/plain' },
-        }
-      )
-    fetcher.get(url) do |tmp|
-      expect(tmp).to be_a Tempfile
-      expect(tmp.read).to eq 'world'
-      expect(tmp.content_type).to eq 'text/plain'
-    end
-  end
-
-  it 'can #get and finally fail' 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
-  end
-
-  it 'can redirect' do
-    expect(fetcher.middlewares).to include Excon::Middleware::RedirectFollower
-  end
-
-  it 'can .read' do
-    described_class.read(__FILE__) do |file|
-      expect(file).to be_a File
-      expect(file.read).to include 'can .read'
-      expect(file.content_type).to eq 'application/x-ruby'
-    end
-  end
-
-  it 'can .execute' do
-    described_class.execute('echo -n hello world') do |file|
-      expect(file).to be_a Tempfile
-      expect(file.read).to eq 'hello world'
-      expect(file.content_type).to eq 'text/plain'
-    end
-  end
-
-  it 'can .execute and fail' do
-    expect(IO).to receive(:popen).and_raise StandardError
-    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
-      expect(file.content_type).to eq 'text/plain'
-    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
-
-    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
-end

data/spec/ollama/utils/file_argument_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Ollama::Utils::FileArgument do
-  it 'it can return content' do
-    expect(described_class.get_file_argument('foo')).to eq 'foo'
-  end
-
-  it 'it can return content at path' do
-    expect(described_class.get_file_argument(asset('prompt.txt'))).to include\
-      'test prompt'
-  end
-
-  it 'it can return default content' do
-    expect(described_class.get_file_argument('', default: 'foo')).to eq 'foo'
-    expect(described_class.get_file_argument(nil, default: 'foo')).to eq 'foo'
-  end
-end

data/spec/ollama/utils/tags_spec.rb

@@ -1,53 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Ollama::Utils::Tags do
-  it 'can be instantiated' do
-    expect(described_class.new).to be_a described_class
-  end
-
-  it 'can contain unique tags and is sorted' do
-    tags = described_class.new(%w[ bar foo ])
-    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'
-    expect(tags.to_a).to eq %w[ bar foo ]
-  end
-
-  it 'can increase in size' do
-    tags = described_class.new
-    expect { tags.add 'foo' }.to change { tags.size }.from(0).to(1)
-    expect { tags.add 'bar' }.to change { tags.size }.from(1).to(2)
-  end
-
-  it 'can be cleared' do
-    tags = described_class.new([ 'foo', 'bar' ])
-    expect { tags.clear }.to change { tags.size }.from(2).to(0)
-  end
-
-  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'
-  end
-
-  it 'can be output nicely with links to source' do
-    tags = described_class.new([ 'foo' ], source: 'https://foo.example.com')
-    tags.add 'bar', source: '/path/to/bar.html'
-    expect(tags.to_a).to eq %w[ bar foo ]
-    tags.all? { expect(_1).to be_a(Ollama::Utils::Tags::Tag) }
-    expect(tags.to_s).to eq(
-      "\e]8;;file:///path/to/bar.html\e\\#bar\e]8;;\e\\ \e]8;;https://foo.example.com\e\\#foo\e]8;;\e\\"
-    )
-  end
-end