mudis-ql 0.1.0

data/spec/mudis-ql/scope_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+RSpec.describe MudisQL::Scope do
+  let(:namespace) { "test_products" }
+  let(:store) { MudisQL::Store.new(namespace) }
+  let(:scope) { described_class.new(store) }
+
+  before do
+    Mudis.serializer = JSON
+
+    # Seed test data
+    store.write("prod1", { name: "Laptop", price: 1200, category: "electronics", stock: 5 })
+    store.write("prod2", { name: "Mouse", price: 25, category: "electronics", stock: 50 })
+    store.write("prod3", { name: "Desk", price: 300, category: "furniture", stock: 10 })
+    store.write("prod4", { name: "Chair", price: 150, category: "furniture", stock: 20 })
+    store.write("prod5", { name: "Keyboard", price: 75, category: "electronics", stock: 30 })
+  end
+
+  describe "#where" do
+    it "filters by exact match" do
+      results = scope.where(category: "electronics").all
+      expect(results.size).to eq(3)
+      expect(results.map { |r| r["name"] }).to contain_exactly("Laptop", "Mouse", "Keyboard")
+    end
+
+    it "filters with proc" do
+      results = scope.where(price: ->(p) { p > 100 }).all
+      expect(results.size).to eq(3)
+      expect(results.map { |r| r["name"] }).to contain_exactly("Laptop", "Desk", "Chair")
+    end
+
+    it "filters with regex" do
+      results = scope.where(name: /^[KM]/).all
+      expect(results.size).to eq(2)
+      expect(results.map { |r| r["name"] }).to contain_exactly("Mouse", "Keyboard")
+    end
+
+    it "filters with range" do
+      results = scope.where(price: 50..200).all
+      expect(results.size).to eq(2)
+      expect(results.map { |r| r["name"] }).to contain_exactly("Chair", "Keyboard")
+    end
+
+    it "chains multiple conditions" do
+      results = scope
+        .where(category: "electronics")
+        .where(price: ->(p) { p < 100 })
+        .all
+
+      expect(results.size).to eq(2)
+      expect(results.map { |r| r["name"] }).to contain_exactly("Mouse", "Keyboard")
+    end
+  end
+
+  describe "#order" do
+    it "orders ascending by default" do
+      results = scope.order(:price).all
+      prices = results.map { |r| r["price"] }
+      expect(prices).to eq([25, 75, 150, 300, 1200])
+    end
+
+    it "orders descending" do
+      results = scope.order(:price, :desc).all
+      prices = results.map { |r| r["price"] }
+      expect(prices).to eq([1200, 300, 150, 75, 25])
+    end
+
+    it "orders by string field" do
+      results = scope.order(:name).all
+      names = results.map { |r| r["name"] }
+      expect(names).to eq(["Chair", "Desk", "Keyboard", "Laptop", "Mouse"])
+    end
+  end
+
+  describe "#limit" do
+    it "limits the number of results" do
+      results = scope.limit(3).all
+      expect(results.size).to eq(3)
+    end
+
+    it "works with ordering" do
+      results = scope.order(:price).limit(2).all
+      expect(results.map { |r| r["name"] }).to eq(["Mouse", "Keyboard"])
+    end
+  end
+
+  describe "#offset" do
+    it "skips the first N results" do
+      results = scope.order(:price).offset(2).all
+      expect(results.size).to eq(3)
+      expect(results.map { |r| r["name"] }).to eq(["Chair", "Desk", "Laptop"])
+    end
+
+    it "works with limit for pagination" do
+      page1 = scope.order(:name).limit(2).offset(0).all
+      page2 = scope.order(:name).limit(2).offset(2).all
+
+      expect(page1.map { |r| r["name"] }).to eq(["Chair", "Desk"])
+      expect(page2.map { |r| r["name"] }).to eq(["Keyboard", "Laptop"])
+    end
+  end
+
+  describe "#first" do
+    it "returns the first matching result" do
+      result = scope.where(category: "furniture").order(:price).first
+      expect(result["name"]).to eq("Chair")
+    end
+
+    it "returns nil when no results" do
+      result = scope.where(category: "nonexistent").first
+      expect(result).to be_nil
+    end
+  end
+
+  describe "#last" do
+    it "returns the last result" do
+      result = scope.order(:price).last
+      expect(result["name"]).to eq("Laptop")
+    end
+  end
+
+  describe "#count" do
+    it "counts matching records" do
+      count = scope.where(category: "electronics").count
+      expect(count).to eq(3)
+    end
+
+    it "counts all records when no filters" do
+      count = scope.count
+      expect(count).to eq(5)
+    end
+  end
+
+  describe "#exists?" do
+    it "returns true when records exist" do
+      expect(scope.where(category: "electronics").exists?).to be true
+    end
+
+    it "returns false when no records match" do
+      expect(scope.where(category: "nonexistent").exists?).to be false
+    end
+  end
+
+  describe "#pluck" do
+    it "extracts a single field" do
+      names = scope.order(:name).pluck(:name)
+      expect(names).to eq(["Chair", "Desk", "Keyboard", "Laptop", "Mouse"])
+    end
+
+    it "extracts multiple fields" do
+      pairs = scope.where(category: "furniture").pluck(:name, :price)
+      expect(pairs).to contain_exactly(["Chair", 150], ["Desk", 300])
+    end
+  end
+
+  describe "complex queries" do
+    it "combines multiple operations" do
+      results = scope
+        .where(category: "electronics")
+        .where(stock: ->(s) { s >= 25 })
+        .order(:price)
+        .limit(2)
+        .all
+
+      expect(results.map { |r| r["name"] }).to eq(["Mouse", "Keyboard"])
+    end
+  end
+end
+

data/spec/mudis-ql/store_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+RSpec.describe MudisQL::Store do
+  let(:namespace) { "test_users" }
+  let(:store) { described_class.new(namespace) }
+
+  before do
+    # Ensure mudis is configured
+    Mudis.serializer = JSON
+  end
+
+  describe "#initialize" do
+    it "sets the namespace" do
+      expect(store.namespace).to eq(namespace)
+    end
+  end
+
+  describe "#write and #read" do
+    it "writes and reads values from mudis" do
+      store.write("user1", { name: "Alice", age: 30 })
+      result = store.read("user1")
+
+      expect(result).to eq({ "name" => "Alice", "age" => 30 })
+    end
+
+    it "supports TTL" do
+      store.write("user1", { name: "Bob" }, expires_in: 1)
+      expect(store.read("user1")).not_to be_nil
+
+      sleep 1.1
+      expect(store.read("user1")).to be_nil
+    end
+  end
+
+  describe "#delete" do
+    it "removes a key from the cache" do
+      store.write("user1", { name: "Charlie" })
+      expect(store.read("user1")).not_to be_nil
+
+      store.delete("user1")
+      expect(store.read("user1")).to be_nil
+    end
+  end
+
+  describe "#keys" do
+    it "returns all keys in the namespace" do
+      store.write("user1", { name: "Alice" })
+      store.write("user2", { name: "Bob" })
+
+      keys = store.keys
+      expect(keys).to contain_exactly("user1", "user2")
+    end
+  end
+
+  describe "#all" do
+    it "returns all records with their keys" do
+      store.write("user1", { name: "Alice", age: 30 })
+      store.write("user2", { name: "Bob", age: 25 })
+
+      results = store.all
+      expect(results).to contain_exactly(
+        { "name" => "Alice", "age" => 30, "_key" => "user1" },
+        { "name" => "Bob", "age" => 25, "_key" => "user2" }
+      )
+    end
+
+    it "handles non-hash values" do
+      store.write("simple", "just a string")
+
+      results = store.all
+      expect(results).to contain_exactly(
+        { "_key" => "simple", "value" => "just a string" }
+      )
+    end
+  end
+end
+

data/spec/mudis-ql_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+RSpec.describe MudisQL do
+  it "has a version number" do
+    expect(MudisQL::VERSION).not_to be nil
+  end
+
+  describe ".from" do
+    it "returns a Scope object" do
+      scope = MudisQL.from("test")
+      expect(scope).to be_a(MudisQL::Scope)
+    end
+
+    it "supports optional namespace (defaults to nil)" do
+      scope = MudisQL.from
+      expect(scope).to be_a(MudisQL::Scope)
+      expect(scope.instance_variable_get(:@store).namespace).to be_nil
+    end
+
+    it "works with keys without explicit namespace" do
+      Mudis.write("test:key1", { name: "No namespace" })
+      Mudis.write("test:key2", { name: "Also no namespace" })
+
+      # Note: MudisQL.from with no namespace won't list keys since Mudis.keys requires namespace
+      # But individual key access works fine
+      scope = MudisQL.from
+      expect(scope).to be_a(MudisQL::Scope)
+    end
+  end
+
+  describe ".configure" do
+    it "yields a configuration object" do
+      expect { |b| MudisQL.configure(&b) }.to yield_with_args(MudisQL::Configuration)
+    end
+
+    it "allows setting default_limit" do
+      MudisQL.configure do |config|
+        config.default_limit = 50
+      end
+
+      expect(MudisQL.configuration.default_limit).to eq(50)
+    end
+  end
+
+  describe ".metrics" do
+    it "returns a MetricsScope object" do
+      metrics = MudisQL.metrics
+      expect(metrics).to be_a(MudisQL::MetricsScope)
+    end
+  end
+end
+

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: mudis-ql
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- kiebor81
+bindir: bin
+cert_chain: []
+date: 2025-12-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mudis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: climate_control
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+description: Mudis-QL extends Mudis by providing a SQL-like query interface for data
+  stored in the mudis cache
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/mudis-ql.rb
+- lib/mudis-ql/metrics_scope.rb
+- lib/mudis-ql/scope.rb
+- lib/mudis-ql/store.rb
+- lib/mudis-ql/version.rb
+- spec/mudis-ql/error_handling_spec.rb
+- spec/mudis-ql/integration_spec.rb
+- spec/mudis-ql/metrics_scope_spec.rb
+- spec/mudis-ql/performance_spec.rb
+- spec/mudis-ql/scope_spec.rb
+- spec/mudis-ql/store_spec.rb
+- spec/mudis-ql_spec.rb
+homepage: https://github.com/kiebor81/mudis-ql
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kiebor81/mudis-ql
+  source_code_uri: https://github.com/kiebor81/mudis-ql
+  changelog_uri: https://github.com/kiebor81/mudis-ql/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: A simple query DSL for Mudis cache
+test_files:
+- spec/mudis-ql/error_handling_spec.rb
+- spec/mudis-ql/integration_spec.rb
+- spec/mudis-ql/metrics_scope_spec.rb
+- spec/mudis-ql/performance_spec.rb
+- spec/mudis-ql/scope_spec.rb
+- spec/mudis-ql/store_spec.rb
+- spec/mudis-ql_spec.rb