glancer 1.0.0

data/spec/models/glancer/embedding_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Embedding do
+  # ── Persistence ───────────────────────────────────────────────────────────
+
+  describe "persistence" do
+    it "saves an embedding with an array of floats" do
+      embedding = described_class.create!(
+        content: "create_table users ...",
+        embedding: [0.1, 0.2, 0.3],
+        source_type: "schema",
+        source_path: "/path/to/schema.rb#users"
+      )
+      expect(embedding).to be_persisted
+    end
+
+    it "retrieves the embedding array after save" do
+      described_class.create!(
+        content: "some content",
+        embedding: [1.0, 2.0, 3.0]
+      )
+      loaded = described_class.last
+      expect(loaded.embedding).to be_a(Array)
+      expect(loaded.embedding.map(&:to_f)).to eq([1.0, 2.0, 3.0])
+    end
+
+    it "stores and retrieves an empty array" do
+      described_class.create!(content: "empty", embedding: [])
+      loaded = described_class.last
+      expect(loaded.embedding).to eq([])
+    end
+  end
+
+  # ── Serialisation ─────────────────────────────────────────────────────────
+
+  describe "serialize :embedding, Array" do
+    it "serialises the embedding to a storable format" do
+      emb = described_class.new(content: "x", embedding: [0.5, 0.6])
+      emb.save!
+      raw = ActiveRecord::Base.connection
+                              .exec_query("SELECT embedding FROM glancer_embeddings WHERE id = #{emb.id}")
+                              .first["embedding"]
+      # The serialised form should be a String (YAML or JSON)
+      expect(raw).to be_a(String)
+    end
+  end
+
+  # ── Scopes via where ──────────────────────────────────────────────────────
+
+  describe "filtering by source_type" do
+    before do
+      described_class.create!(content: "schema chunk",  embedding: [], source_type: "schema",  source_path: "schema.rb#users")
+      described_class.create!(content: "model chunk",   embedding: [], source_type: "models",  source_path: "user.rb")
+      described_class.create!(content: "context chunk", embedding: [], source_type: "context", source_path: "context.md")
+    end
+
+    it "can filter schema embeddings" do
+      schema_embeds = described_class.where(source_type: "schema")
+      expect(schema_embeds.count).to eq(1)
+      expect(schema_embeds.first.content).to include("schema chunk")
+    end
+
+    it "can filter model embeddings" do
+      expect(described_class.where(source_type: "models").count).to eq(1)
+    end
+
+    it "can filter context embeddings" do
+      expect(described_class.where(source_type: "context").count).to eq(1)
+    end
+  end
+end

data/spec/models/glancer/message_spec.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Message do
+  let(:chat)         { Glancer::Chat.create!(title: "Test Chat") }
+  let(:user_message) { described_class.create!(chat: chat, role: "user", content: "How many orders?") }
+
+  subject(:message) { described_class.new(chat: chat, role: "user", content: "Hello") }
+
+  # ── Validations ───────────────────────────────────────────────────────────
+
+  describe "validations" do
+    it "is valid with required attributes" do
+      expect(message).to be_valid
+    end
+
+    it "is invalid without content" do
+      message.content = nil
+      expect(message).not_to be_valid
+      expect(message.errors[:content]).to include("can't be blank")
+    end
+
+    it "is invalid with an empty content string" do
+      message.content = ""
+      expect(message).not_to be_valid
+    end
+  end
+
+  # ── Enum: role ────────────────────────────────────────────────────────────
+
+  describe "role enum" do
+    it "accepts 'user'" do
+      msg = described_class.create!(chat: chat, role: "user", content: "hi")
+      expect(msg.role).to eq("user")
+      expect(msg.user?).to be(true)
+    end
+
+    it "accepts 'assistant'" do
+      msg = described_class.create!(chat: chat, role: "assistant", content: "hello")
+      expect(msg.role).to eq("assistant")
+      expect(msg.assistant?).to be(true)
+    end
+
+    it "accepts 'system'" do
+      msg = described_class.create!(chat: chat, role: "system", content: "init")
+      expect(msg.role).to eq("system")
+      expect(msg.system?).to be(true)
+    end
+
+    it "raises on an invalid role" do
+      expect { described_class.create!(chat: chat, role: "unknown", content: "x") }
+        .to raise_error(ArgumentError)
+    end
+  end
+
+  # ── Associations ─────────────────────────────────────────────────────────
+
+  describe "associations" do
+    it "belongs_to a chat" do
+      expect(user_message.chat).to eq(chat)
+    end
+
+    it "belongs_to a user_message (optional)" do
+      assistant = described_class.create!(
+        chat: chat,
+        role: "assistant",
+        content: "There are 10 orders.",
+        user_message: user_message
+      )
+      expect(assistant.user_message).to eq(user_message)
+    end
+
+    it "allows nil user_message (optional association)" do
+      msg = described_class.create!(chat: chat, role: "user", content: "test")
+      expect(msg.user_message).to be_nil
+    end
+
+    it "has many code_versions" do
+      msg = described_class.create!(chat: chat, role: "assistant", content: "result", code: "SELECT 1")
+      version = Glancer::CodeVersion.create!(message: msg, code: "SELECT 1", source: "generated")
+      expect(msg.code_versions).to include(version)
+    end
+
+    it "destroys code_versions when the message is destroyed" do
+      msg = described_class.create!(chat: chat, role: "assistant", content: "result", code: "SELECT 1")
+      Glancer::CodeVersion.create!(message: msg, code: "SELECT 1", source: "generated")
+      expect { msg.destroy }.to change(Glancer::CodeVersion, :count).by(-1)
+    end
+
+    it "nullifies audits when the message is destroyed" do
+      msg = described_class.create!(chat: chat, role: "assistant", content: "result", code: "SELECT 1")
+      audit = Glancer::Audit.create!(
+        code: "SELECT 1",
+        adapter: "sqlite",
+        run_id: SecureRandom.uuid,
+        executed_at: Time.current,
+        message: msg
+      )
+      msg.destroy
+      expect(audit.reload.message_id).to be_nil
+    end
+  end
+
+  # ── before_destroy callback ───────────────────────────────────────────────
+
+  describe "before_destroy callback" do
+    it "nullifies user_message_id on assistant messages pointing to this user message" do
+      assistant = described_class.create!(
+        chat: chat,
+        role: "assistant",
+        content: "reply",
+        user_message: user_message
+      )
+
+      user_message.destroy
+      expect(assistant.reload.user_message_id).to be_nil
+    end
+  end
+
+  # ── #sql_result_json ──────────────────────────────────────────────────────
+
+  describe "#sql_result_json" do
+    it "parses valid JSON content" do
+      msg = described_class.new(content: '[{"id":1}]')
+      expect(msg.sql_result_json).to eq([{ "id" => 1 }])
+    end
+
+    it "returns [] for non-JSON content" do
+      msg = described_class.new(content: "plain text response")
+      expect(msg.sql_result_json).to eq([])
+    end
+
+    it "returns [] for nil content" do
+      msg = described_class.new(content: nil)
+      expect(msg.sql_result_json).to eq([])
+    end
+
+    it "returns [] for malformed JSON" do
+      msg = described_class.new(content: "{bad json}")
+      expect(msg.sql_result_json).to eq([])
+    end
+  end
+end

data/spec/models/glancer/setting_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Glancer::Setting do
+  # ── Validations ───────────────────────────────────────────────────────────
+
+  describe "validations" do
+    it "is valid with a unique key" do
+      setting = described_class.new(key: "some_key", value: "val")
+      expect(setting).to be_valid
+    end
+
+    it "is invalid without a key" do
+      setting = described_class.new(key: nil, value: "val")
+      expect(setting).not_to be_valid
+    end
+
+    it "enforces key uniqueness" do
+      described_class.create!(key: "duplicate", value: "first")
+      dup = described_class.new(key: "duplicate", value: "second")
+      expect(dup).not_to be_valid
+      expect(dup.errors[:key]).to be_present
+    end
+  end
+
+  # ── .get ──────────────────────────────────────────────────────────────────
+
+  describe ".get" do
+    it "returns the value for an existing key" do
+      described_class.create!(key: "my_key", value: "hello")
+      expect(described_class.get("my_key")).to eq("hello")
+    end
+
+    it "returns the default when the key does not exist" do
+      expect(described_class.get("missing", default: "fallback")).to eq("fallback")
+    end
+
+    it "returns nil by default when key is missing and no default given" do
+      expect(described_class.get("nonexistent")).to be_nil
+    end
+
+    it "accepts symbol keys" do
+      described_class.create!(key: "sym_key", value: "sym_val")
+      expect(described_class.get(:sym_key)).to eq("sym_val")
+    end
+  end
+
+  # ── .set ──────────────────────────────────────────────────────────────────
+
+  describe ".set" do
+    it "creates a new setting record" do
+      expect { described_class.set("brand_new", "value") }.to change(described_class, :count).by(1)
+    end
+
+    it "updates an existing record instead of creating a duplicate" do
+      described_class.set("existing", "old")
+      expect { described_class.set("existing", "new") }.not_to change(described_class, :count)
+      expect(described_class.get("existing")).to eq("new")
+    end
+
+    it "converts the value to a String" do
+      described_class.set("numeric_key", 42)
+      expect(described_class.get("numeric_key")).to eq("42")
+    end
+
+    it "converts the key to a String" do
+      described_class.set(:symbol_key, "v")
+      expect(described_class.get("symbol_key")).to eq("v")
+    end
+  end
+
+  # ── .store_many ───────────────────────────────────────────────────────────
+
+  describe ".store_many" do
+    it "stores all key-value pairs in the hash" do
+      described_class.store_many(foo: "bar", baz: "qux")
+      expect(described_class.get(:foo)).to eq("bar")
+      expect(described_class.get(:baz)).to eq("qux")
+    end
+
+    it "updates existing keys" do
+      described_class.set("k", "original")
+      described_class.store_many(k: "updated")
+      expect(described_class.get("k")).to eq("updated")
+    end
+  end
+end

data/spec/models/glancer/sql_version_spec.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Glancer::SqlVersion is now an alias for Glancer::CodeVersion.
+# Tests have been moved to spec/models/glancer/code_version_spec.rb.

data/spec/spec_helper.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+if ENV["COVERAGE"] || ENV["CI"]
+  require "simplecov"
+  require "simplecov-json"
+
+  SimpleCov.formatters = [
+    SimpleCov::Formatter::HTMLFormatter,
+    SimpleCov::Formatter::JSONFormatter
+  ]
+
+  SimpleCov.start do
+    add_filter "/spec/"
+    add_filter "/lib/generators/"
+    add_filter "/lib/glancer/version.rb" # loaded by bundler before SimpleCov starts
+
+    add_group "Workflow",      "lib/glancer/workflow"
+    add_group "Indexers",      "lib/glancer/indexer"
+    add_group "Controllers",   "app/controllers"
+    add_group "Models",        "app/models"
+    add_group "Configuration", "lib/glancer/configuration.rb"
+
+    minimum_coverage 80
+    track_files "lib/**/*.rb"
+  end
+end
+
+# Must load Rails BEFORE requiring glancer, because engine.rb inherits Rails::Engine
+require "active_record"
+require "active_record/railtie"
+require "action_dispatch"
+require "rails"
+
+# Minimal Rails application — provides Rails.root and Rails.application.
+# Do NOT call initialize! (avoids assets, LLM config, migration initializers).
+module GlancerTestApp
+  class Application < Rails::Application
+    config.eager_load = false
+    config.logger     = Logger.new(nil)
+    config.active_support.deprecation = :silence
+  end
+end
+GlancerTestApp::Application.new # sets Rails.application
+
+# ApplicationRecord must exist BEFORE Glancer models are autoloaded.
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end
+
+require "glancer"
+
+# Rails 7.1+ removed the positional `serialize :attr, SomeClass` form in favour of
+# keyword arguments.  The production Glancer::Embedding model uses the old two-arg
+# form (`serialize :embedding, Array`).  We shim ActiveRecord::Base.serialize to
+# translate the legacy positional argument into the correct keyword form so the
+# model loads under Rails 7.2 without modifying production code.
+#
+# When the legacy coder is a type class (Array, Hash, …) Rails 7.2 expects it as
+# `type:` with the default YAML coder, not as `coder:` (which would try to call
+# Array.new with the wrong arguments).
+module SerializeCompatShim
+  TYPE_CLASSES = [Array, Hash, String, Integer, Float].freeze
+
+  def serialize(attr_name, legacy_coder = nil, coder: nil, type: Object, **opts)
+    if legacy_coder && coder.nil?
+      if TYPE_CLASSES.include?(legacy_coder)
+        # Old form: serialize :col, Array  →  coder: YAML, type: Array
+        super(attr_name, type: legacy_coder, **opts)
+      else
+        # Old form: serialize :col, SomeCoder  →  coder: SomeCoder
+        super(attr_name, coder: legacy_coder, type: type, **opts)
+      end
+    else
+      super(attr_name, coder: coder, type: type, **opts)
+    end
+  end
+end
+ActiveRecord::Base.singleton_class.prepend(SerializeCompatShim)
+
+# Explicitly require Glancer model files (the engine's autoloading is not active
+# in the minimal test Rails application).
+Dir[File.expand_path("../app/models/**/*.rb", __dir__)].sort.each { |f| require f }
+
+# SQLite3 in-memory database for tests.
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+
+# Suppress migration output.
+ActiveRecord::Migration.verbose = false
+
+# Create all tables used by Glancer.
+load File.expand_path("support/schema.rb", __dir__)
+
+# Silence Glancer logger during the test run.
+Glancer.configure 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
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = ".rspec_status"
+  config.disable_monkey_patching!
+
+  config.expect_with(:rspec) { |c| c.syntax = :expect }
+
+  config.order = :random
+  Kernel.srand config.seed
+
+  config.before do
+    # Clean DB between tests (order matters: child tables first).
+    [Glancer::CodeVersion, Glancer::Audit, Glancer::Embedding,
+     Glancer::Message, Glancer::Chat, Glancer::Setting].each(&:delete_all)
+
+    # Clear the in-memory workflow cache.
+    Glancer::Workflow::Cache.clear
+
+    # Reset Glancer configuration to safe test defaults.
+    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  = :silent
+    end
+  end
+end

data/spec/support/schema.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define do
+  create_table :glancer_chats, force: :cascade do |t|
+    t.string :title
+    t.timestamps
+  end
+
+  create_table :glancer_messages, force: :cascade do |t|
+    t.integer :chat_id, null: false
+    t.integer :user_message_id
+    t.string  :role
+    t.text    :content
+    t.text    :code
+    t.string  :code_type,        null: false, default: "sql"
+    t.boolean :successful,       default: true
+    t.boolean :user_edited_code, default: false, null: false
+    t.string  :llm_model
+    t.text    :enriched_question
+    t.integer :status, null: false, default: 2
+    t.timestamps
+  end
+
+  create_table :glancer_embeddings, force: :cascade do |t|
+    t.text    :content, null: false
+    t.json    :embedding
+    t.string  :source_type
+    t.string  :source_path
+    t.timestamps
+  end
+
+  create_table :glancer_audits, force: :cascade do |t|
+    t.text     :question
+    t.text     :code,        null: false
+    t.string   :code_type,   null: false, default: "sql"
+    t.string   :adapter,     null: false
+    t.string   :run_id,      null: false
+    t.datetime :executed_at, null: false
+    t.integer  :message_id
+    t.timestamps
+  end
+
+  create_table :glancer_code_versions, force: :cascade do |t|
+    t.integer :message_id, null: false
+    t.text    :code,       null: false
+    t.string  :source,     null: false, default: "generated"
+    t.timestamps
+  end
+
+  create_table :glancer_settings, force: :cascade do |t|
+    t.string :key, null: false
+    t.text   :value
+    t.timestamps
+  end
+end