glancer 1.0.0

data/spec/lib/glancer/engine_spec.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Engine do
+  # ── configure_provider_key ────────────────────────────────────────────────
+
+  describe ".configure_provider_key" do
+    let(:llm_config) { double("RubyLLM::Config") }
+
+    context "gemini provider" do
+      it "sets gemini_api_key from gemini_api_key config" do
+        Glancer.configuration.gemini_api_key = "g-key"
+        allow(llm_config).to receive(:gemini_api_key=)
+        described_class.configure_provider_key(llm_config, Glancer.configuration, :gemini)
+        expect(llm_config).to have_received(:gemini_api_key=).with("g-key")
+      end
+
+      it "falls back to api_key when gemini_api_key is nil" do
+        Glancer.configuration.gemini_api_key = nil
+        Glancer.configuration.api_key = "fallback-key"
+        allow(llm_config).to receive(:gemini_api_key=)
+        described_class.configure_provider_key(llm_config, Glancer.configuration, :gemini)
+        expect(llm_config).to have_received(:gemini_api_key=).with("fallback-key")
+      end
+
+      it "raises Glancer::Error when no API key is available" do
+        Glancer.configuration.gemini_api_key = nil
+        Glancer.configuration.api_key = nil
+        expect { described_class.configure_provider_key(llm_config, Glancer.configuration, :gemini) }
+          .to raise_error(Glancer::Error, /Gemini API key/)
+      end
+    end
+
+    context "openai provider" do
+      it "sets openai_api_key" do
+        Glancer.configuration.openai_api_key = "oai-key"
+        allow(llm_config).to receive(:openai_api_key=)
+        described_class.configure_provider_key(llm_config, Glancer.configuration, :openai)
+        expect(llm_config).to have_received(:openai_api_key=).with("oai-key")
+      end
+
+      it "raises Glancer::Error when no API key is available" do
+        Glancer.configuration.openai_api_key = nil
+        Glancer.configuration.api_key = nil
+        expect { described_class.configure_provider_key(llm_config, Glancer.configuration, :openai) }
+          .to raise_error(Glancer::Error, /OpenAI API key/)
+      end
+    end
+
+    context "openrouter provider" do
+      it "sets openrouter_api_key" do
+        Glancer.configuration.openrouter_api_key = "or-key"
+        allow(llm_config).to receive(:openrouter_api_key=)
+        described_class.configure_provider_key(llm_config, Glancer.configuration, :openrouter)
+        expect(llm_config).to have_received(:openrouter_api_key=).with("or-key")
+      end
+
+      it "raises Glancer::Error when no API key is available" do
+        Glancer.configuration.openrouter_api_key = nil
+        Glancer.configuration.api_key = nil
+        expect { described_class.configure_provider_key(llm_config, Glancer.configuration, :openrouter) }
+          .to raise_error(Glancer::Error, /OpenRouter API key/)
+      end
+    end
+
+    context "unsupported provider" do
+      it "raises Glancer::Error" do
+        expect { described_class.configure_provider_key(llm_config, Glancer.configuration, :unknown_llm) }
+          .to raise_error(Glancer::Error, /Unsupported LLM provider/)
+      end
+    end
+  end
+
+  # ── Initializer registration ──────────────────────────────────────────────
+
+  describe "registered initializers" do
+    let(:initializer_names) { described_class.initializers.map { |i| i.name.to_s } }
+
+    it "registers glancer.append_migrations" do
+      expect(initializer_names).to include("glancer.append_migrations")
+    end
+
+    it "registers glancer.assets" do
+      expect(initializer_names).to include("glancer.assets")
+    end
+
+    it "registers glancer.load_tasks" do
+      expect(initializer_names).to include("glancer.load_tasks")
+    end
+
+    it "registers glancer.configure_ruby_llm" do
+      expect(initializer_names).to include("glancer.configure_ruby_llm")
+    end
+  end
+
+  # ── glancer.configure_ruby_llm initializer body ───────────────────────────
+
+  describe "glancer.configure_ruby_llm initializer" do
+    let(:ruby_llm_config) { double("RubyLLM::Config") }
+
+    before do
+      allow(ruby_llm_config).to receive(:gemini_api_key=)
+      allow(ruby_llm_config).to receive(:default_embedding_model=)
+      allow(ruby_llm_config).to receive(:default_embedding_model).and_return("text-embedding-004")
+      allow(RubyLLM).to receive(:configure).and_yield(ruby_llm_config)
+    end
+
+    def run_llm_initializer
+      init = Glancer::Engine.initializers.find { |i| i.name.to_s == "glancer.configure_ruby_llm" }
+      init.run(nil)
+    end
+
+    it "calls RubyLLM.configure" do
+      expect(RubyLLM).to receive(:configure).and_yield(ruby_llm_config)
+      run_llm_initializer
+    end
+
+    it "sets gemini_api_key on the RubyLLM config" do
+      run_llm_initializer
+      expect(ruby_llm_config).to have_received(:gemini_api_key=).with("test-api-key")
+    end
+
+    it "sets default_embedding_model on the RubyLLM config" do
+      run_llm_initializer
+      expect(ruby_llm_config).to have_received(:default_embedding_model=)
+    end
+
+    it "raises Glancer::Error when configure_provider_key raises" do
+      allow(RubyLLM).to receive(:configure).and_raise(StandardError, "LLM error")
+      expect { run_llm_initializer }.to raise_error(Glancer::Error, /RubyLLM configuration failed/)
+    end
+
+    it "skips when Glancer.configuration is nil" do
+      Glancer.configuration = nil
+      expect(RubyLLM).not_to receive(:configure)
+      expect { run_llm_initializer }.not_to raise_error
+    ensure
+      Glancer.configuration = Glancer::Configuration.new.tap do |c|
+        c.adapter        = :sqlite
+        c.llm_provider   = :gemini
+        c.llm_model      = "test-model"
+        c.gemini_api_key = "test-api-key"
+        c.log_verbosity  = :none
+      end
+    end
+  end
+
+  # ── glancer.append_migrations initializer body ───────────────────────────
+
+  describe "glancer.append_migrations initializer" do
+    def run_migrations_initializer(app)
+      init = Glancer::Engine.initializers.find { |i| i.name.to_s == "glancer.append_migrations" }
+      init.bind(Glancer::Engine).run(app)
+    end
+
+    it "skips migration append when app root matches engine root" do
+      app = double("app")
+      allow(app).to receive(:root).and_return(Glancer::Engine.root)
+      expect(app).not_to receive(:config)
+      run_migrations_initializer(app)
+    end
+
+    it "appends migration paths when app root differs from engine root" do
+      app = double("app")
+      allow(app).to receive(:root).and_return(Pathname.new("/some/other/app"))
+      migrate_paths = double("migrate_paths")
+      allow(migrate_paths).to receive(:<<)
+      app_paths = double("app_paths")
+      allow(app_paths).to receive(:[]).with("db/migrate").and_return(migrate_paths)
+      allow(app).to receive(:config).and_return(double("app_config", paths: app_paths))
+      expect { run_migrations_initializer(app) }.not_to raise_error
+    end
+  end
+
+  # ── glancer.assets initializer body ──────────────────────────────────────
+
+  describe "glancer.assets initializer" do
+    def run_assets_initializer(app)
+      init = Glancer::Engine.initializers.find { |i| i.name.to_s == "glancer.assets" }
+      init.bind(Glancer::Engine).run(app)
+    end
+
+    it "registers asset paths and precompile list without raising" do
+      asset_paths = []
+      precompile  = []
+      assets = double("assets")
+      allow(assets).to receive(:paths).and_return(asset_paths)
+      allow(assets).to receive(:precompile).and_return(precompile)
+      allow(assets).to receive(:precompile=)
+      app = double("app", config: double("config", assets: assets))
+      expect { run_assets_initializer(app) }.not_to raise_error
+    end
+  end
+
+  # ── glancer.load_tasks initializer body ──────────────────────────────────
+
+  describe "glancer.load_tasks initializer" do
+    def run_load_tasks_initializer
+      init = Glancer::Engine.initializers.find { |i| i.name.to_s == "glancer.load_tasks" }
+      init.bind(Glancer::Engine).run(nil)
+    end
+
+    it "loads rake task files without raising" do
+      allow(Dir).to receive(:[]).and_return([])
+      expect { run_load_tasks_initializer }.not_to raise_error
+    end
+  end
+end

data/spec/lib/glancer/indexer/context_indexer_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Indexer::ContextIndexer do
+  let(:context_path) { "/fake/config/context.md" }
+  let(:context_content) do
+    <<~MD
+      # Domain Context
+      This application manages e-commerce orders and customers.
+
+      ## Users
+      Users have email, name, and created_at attributes.
+
+      ## Orders
+      Orders belong to users and have a total and status.
+    MD
+  end
+
+  before do
+    Glancer.configuration.context_file_path = context_path
+    allow(File).to receive(:exist?).with(context_path).and_return(true)
+    allow(File).to receive(:read).with(context_path).and_return(context_content)
+  end
+
+  # ── index! ────────────────────────────────────────────────────────────────
+
+  describe ".index!" do
+    it "returns an array of chunk hashes" do
+      result = described_class.index!
+      expect(result).to be_an(Array)
+      expect(result).not_to be_empty
+    end
+
+    it "sets source_type to 'context' on all chunks" do
+      result = described_class.index!
+      expect(result.map { |c| c[:source_type] }).to all(eq("context"))
+    end
+
+    it "sets source_path to the configured context_file_path" do
+      result = described_class.index!
+      expect(result.map { |c| c[:source_path] }).to all(eq(context_path))
+    end
+
+    it "includes the content from the context file" do
+      result   = described_class.index!
+      combined = result.map { |c| c[:content] }.join
+      expect(combined).to include("Domain Context")
+    end
+
+    it "returns [] when the file starts with --glancer-ignore" do
+      allow(File).to receive(:read).with(context_path).and_return("--glancer-ignore\nsome content")
+      expect(described_class.index!).to eq([])
+    end
+
+    it "raises Glancer::Error when the file does not exist" do
+      allow(File).to receive(:exist?).with(context_path).and_return(false)
+      expect { described_class.index! }.to raise_error(Glancer::Error, /Context file not found/)
+    end
+
+    it "raises Glancer::Error when context_file_path is nil" do
+      Glancer.configuration.context_file_path = "non_existent_file.md"
+      allow(File).to receive(:exist?).and_return(false)
+      expect { described_class.index! }.to raise_error(Glancer::Error)
+    end
+
+    it "raises Glancer::Error when File.read raises" do
+      allow(File).to receive(:read).and_raise(IOError, "unreadable file")
+      expect { described_class.index! }.to raise_error(Glancer::Error, /Context indexing failed/)
+    end
+  end
+
+  # ── split_into_chunks ─────────────────────────────────────────────────────
+
+  describe ".split_into_chunks" do
+    before do
+      Glancer.configuration.chunk_size    = 100
+      Glancer.configuration.chunk_overlap = 10
+    end
+
+    it "returns one chunk for text shorter than chunk_size" do
+      result = described_class.split_into_chunks("short")
+      expect(result.size).to eq(1)
+    end
+
+    it "splits long text into multiple chunks" do
+      result = described_class.split_into_chunks("x" * 300)
+      expect(result.size).to be > 1
+    end
+
+    it "produces chunks of at most chunk_size characters" do
+      result = described_class.split_into_chunks("y" * 300)
+      result.each { |chunk| expect(chunk.length).to be <= 100 }
+    end
+  end
+end

data/spec/lib/glancer/indexer/model_indexer_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Indexer::ModelIndexer do
+  let(:fake_root) { Pathname.new("/fake/app") }
+  let(:model_content) do
+    <<~RUBY
+      class User < ApplicationRecord
+        has_many :orders
+        validates :email, presence: true
+      end
+    RUBY
+  end
+  let(:model_file) { "/fake/app/app/models/user.rb" }
+
+  before do
+    allow(Rails).to receive(:root).and_return(fake_root)
+    allow(Dir).to receive(:[]).with(fake_root.join("app/models/**/*.rb")).and_return([model_file])
+    allow(File).to receive(:read).with(model_file).and_return(model_content)
+  end
+
+  # ── index! ────────────────────────────────────────────────────────────────
+
+  describe ".index!" do
+    it "returns an array of chunk hashes" do
+      result = described_class.index!
+      expect(result).to be_an(Array)
+      expect(result).not_to be_empty
+    end
+
+    it "sets source_type to 'models' on all chunks" do
+      result = described_class.index!
+      expect(result.map { |c| c[:source_type] }).to all(eq("models"))
+    end
+
+    it "sets source_path to the file path" do
+      result = described_class.index!
+      expect(result.map { |c| c[:source_path] }).to all(eq(model_file))
+    end
+
+    it "includes the content of the model file" do
+      result = described_class.index!
+      combined = result.map { |c| c[:content] }.join
+      expect(combined).to include("class User")
+    end
+
+    it "returns [] when no model files are found" do
+      allow(Dir).to receive(:[]).and_return([])
+      expect(described_class.index!).to eq([])
+    end
+
+    it "handles multiple model files" do
+      second_file    = "/fake/app/app/models/order.rb"
+      second_content = "class Order < ApplicationRecord; end"
+      allow(Dir).to receive(:[]).and_return([model_file, second_file])
+      allow(File).to receive(:read).with(second_file).and_return(second_content)
+
+      result = described_class.index!
+      paths  = result.map { |c| c[:source_path] }.uniq
+      expect(paths).to include(model_file, second_file)
+    end
+
+    it "raises Glancer::Error when File.read raises" do
+      allow(File).to receive(:read).and_raise(IOError, "unreadable")
+      expect { described_class.index! }.to raise_error(Glancer::Error, /Model indexing failed/)
+    end
+  end
+
+  # ── split_into_chunks ─────────────────────────────────────────────────────
+
+  describe ".split_into_chunks" do
+    before do
+      Glancer.configuration.chunk_size    = 100
+      Glancer.configuration.chunk_overlap = 20
+    end
+
+    it "returns at least one chunk for any non-empty text" do
+      result = described_class.split_into_chunks("x" * 50)
+      expect(result.size).to be >= 1
+    end
+
+    it "splits long text into multiple chunks" do
+      long_text = "a" * 250
+      result    = described_class.split_into_chunks(long_text)
+      expect(result.size).to be > 1
+    end
+
+    it "respects chunk_size from configuration" do
+      Glancer.configuration.chunk_size    = 200
+      Glancer.configuration.chunk_overlap = 0 # no overlap so the text fits in exactly 1 chunk
+      result = described_class.split_into_chunks("b" * 200)
+      expect(result.size).to eq(1)
+    end
+
+    it "applies overlap so successive chunks share content" do
+      text   = "a" * 180
+      result = described_class.split_into_chunks(text)
+      # With size=100 and overlap=20, second chunk starts at index 80
+      expect(result[1]).to start_with("a" * 20)
+    end
+  end
+end