RubyGems - kasabi - Versions diffs - 0.0.1 - Mend

kasabi 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

data/CHANGES +3 -0
data/README.md +55 -0
data/Rakefile +76 -0
data/lib/kasabi.rb +12 -0
data/lib/kasabi/api/augment.rb +40 -0
data/lib/kasabi/api/base_client.rb +29 -0
data/lib/kasabi/api/facet.rb +91 -0
data/lib/kasabi/api/lookup.rb +25 -0
data/lib/kasabi/api/reconcile.rb +124 -0
data/lib/kasabi/api/search.rb +80 -0
data/lib/kasabi/api/sparql.rb +462 -0
data/lib/kasabi/dataset/dataset.rb +21 -0
data/tests/api/tc_augment.rb +28 -0
data/tests/api/tc_facet.rb +89 -0
data/tests/api/tc_lookup.rb +21 -0
data/tests/api/tc_reconcile.rb +178 -0
data/tests/api/tc_search.rb +30 -0
data/tests/api/tc_sparql.rb +177 -0
data/tests/api/tc_sparqlhelper.rb +262 -0
data/tests/ts_kasabi.rb +9 -0
metadata +167 -0

data/lib/kasabi/dataset/dataset.rb ADDED

@@ -0,0 +1,21 @@
+module Kasabi
+  class Dataset
+    attr_reader :uri
+    attr_reader :client
+    attr_reader :apikey
+    #Initialize the client to work with a specific endpoint
+    #
+    # The _options_ hash can contain the following values:
+    # * *:apikey*: required. apikey authorized to use the API
+    # * *:client*: HTTPClient object instance
+    def initialize(uri, options={})
+      @uri = uri
+      @client = options[:client] || HTTPClient.new()
+      @apikey = options[:apikey] || nil
+    end
+  end
+end

data/tests/api/tc_augment.rb ADDED

@@ -0,0 +1,28 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'kasabi'
+require 'test/unit'
+require 'mocha'
+class AugmentTest < Test::Unit::TestCase
+  def test_augment_uri
+    mc = mock()
+    mc.expects(:get).with("http://api.kasabi.com/api/test-augment-api", {:apikey=>"test-key", "data-uri" => "http://www.example.org/index.rss"}).returns(
+    HTTP::Message.new_response("OK") )
+    client = Kasabi::Augment::Client.new( "http://api.kasabi.com/api/test-augment-api", :apikey=>"test-key", :client=>mc)
+    response = client.augment_uri("http://www.example.org/index.rss")
+    assert_equal("OK", response)
+  end
+  def test_augment
+     mc = mock()
+     mc.expects(:post).with("http://api.kasabi.com/api/test-augment-api?apikey=test-key", "data", anything).returns(
+    HTTP::Message.new_response("OK") )
+    client = Kasabi::Augment::Client.new( "http://api.kasabi.com/api/test-augment-api", :apikey=>"test-key", :client=>mc)
+    response = client.augment("data")
+    assert_equal("OK", response)
+  end
+end

data/tests/api/tc_facet.rb ADDED

@@ -0,0 +1,89 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'test/unit'
+require 'mocha'
+require 'rexml/document'
+class FacetTest < Test::Unit::TestCase
+  RESULTS = <<-EOL
+  <facet-results xmlns="http://schemas.talis.com/2007/facet-results#">
+    <head>
+      <query>austen</query>
+      <fields>title,author,publisher</fields>
+    </head>
+  <fields>
+    <field name="title">
+      <term number="19" search-uri="http://api.kasabi.com/api/test-facet-api/facet?query=austen+title:%22Pride+and+prejudice%22">Pride and prejudice</term>
+      <term number="12" search-uri="http://api.kasabi.com/api/test-facet-api/facet?query=austen+title:%22Emma%22">Emma</term>
+      <term number="9" search-uri="http://api.kasabi.com/api/test-facet-api/facet?query=austen+title:%22Northanger+Abbey%22">Northanger Abbey</term>
+      <term number="8" search-uri="http://api.kasabi.com/api/test-facet-api/facet?query=austen+title:%22Mansfield+Park%22">Mansfield Park</term>
+    </field>
+    <field name="publisher"/>
+  <field name="author">
+    <term number="91" search-uri="http://api.kasabi.com/api/test-facet-api/facet?query=austen+author:%22Austen,+Jane%22">Austen, Jane</term>
+    <term number="6" search-uri="http://api.kasabi.com/api/test-facet-api/facet?query=austen+author:%22Jane+Austen+Society.%22">Jane Austen Society.</term>
+    <term number="3" search-uri="http://api.kasabi.com/api/test-facet-api/facet?query=austen+author:%22Evans,+J.+M.+(Jessie+Maud)%22">Evans, J. M. (Jessie Maud)</term>
+    <term number="3" search-uri="http://api.kasabi.com/api/test-facet-api/facet?query=austen+author:%22Chapman,+R.+W.+(Robert+William)%22">Chapman, R. W. (Robert William)</term>
+  </field>
+  </fields>
+  </facet-results>
+EOL
+    def test_parse
+      results = Kasabi::Search::Facet::Results.parse(RESULTS)
+      assert_equal("austen", results.query)
+      assert_equal("title,author,publisher", results.fields)
+      assert_equal(3, results.facets.size)
+      assert_equal(4, results.facets["title"].length)
+      assert_expected_term(results.facets["title"][0],
+        19, "http://api.kasabi.com/api/test-facet-api/facet?query=austen+title:%22Pride+and+prejudice%22", "Pride and prejudice")
+      assert_expected_term(results.facets["title"][1],
+        12, "http://api.kasabi.com/api/test-facet-api/facet?query=austen+title:%22Emma%22", "Emma")
+      assert_expected_term(results.facets["title"][2],
+        9, "http://api.kasabi.com/api/test-facet-api/facet?query=austen+title:%22Northanger+Abbey%22", "Northanger Abbey")
+      assert_expected_term(results.facets["title"][3],
+        8, "http://api.kasabi.com/api/test-facet-api/facet?query=austen+title:%22Mansfield+Park%22", "Mansfield Park")
+      assert_equal(0, results.facets["publisher"].length)
+      assert_equal(4, results.facets["author"].length)
+      assert_expected_term(results.facets["author"][0],
+        91, "http://api.kasabi.com/api/test-facet-api/facet?query=austen+author:%22Austen,+Jane%22", "Austen, Jane")
+      assert_expected_term(results.facets["author"][1],
+        6, "http://api.kasabi.com/api/test-facet-api/facet?query=austen+author:%22Jane+Austen+Society.%22", "Jane Austen Society.")
+      assert_expected_term(results.facets["author"][2],
+        3, "http://api.kasabi.com/api/test-facet-api/facet?query=austen+author:%22Evans,+J.+M.+(Jessie+Maud)%22", "Evans, J. M. (Jessie Maud)")
+      assert_expected_term(results.facets["author"][3],
+        3, "http://api.kasabi.com/api/test-facet-api/facet?query=austen+author:%22Chapman,+R.+W.+(Robert+William)%22", "Chapman, R. W. (Robert William)")
+    end
+    def test_query
+      mc = mock()
+      mc.expects(:get).with("http://api.kasabi.com/api/test-facet-api/facet",
+        {:query => "austen", :fields => "title,author,publisher", :apikey => "test-key"}, nil).returns(
+        HTTP::Message.new_response(RESULTS) )
+      client = Kasabi::Search::Client.new("http://api.kasabi.com/api/test-facet-api", :apikey => "test-key", :client=>mc)
+      results = client.facet( "austen", ["title", "author", "publisher"])
+      assert_not_nil(results)
+      assert_equal("austen", results.query)
+      assert_equal("title,author,publisher", results.fields)
+      assert_equal(3, results.facets.size)
+    end
+    def assert_expected_term(term, hits, search_uri, value)
+      assert_equal(hits, term.hits)
+      assert_equal(search_uri, term.search_uri)
+      assert_equal(value, term.value)
+    end
+end

data/tests/api/tc_lookup.rb ADDED

@@ -0,0 +1,21 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'kasabi'
+require 'test/unit'
+require 'mocha'
+class LookupTest < Test::Unit::TestCase
+  def test_describe_with_json
+    mc = mock()
+    mc.expects(:get).with("http://api.kasabi.com/api/test-lookup",
+      {:apikey=>"test-key", :about => "http://www.example.org", :output=>"json"} ).returns(
+    HTTP::Message.new_response("{}"))
+    client = Kasabi::Lookup::Client.new("http://api.kasabi.com/api/test-lookup",
+      :apikey=>"test-key", :client=>mc)
+    response = client.lookup("http://www.example.org")
+    assert_not_nil( response )
+  end
+end

data/tests/api/tc_reconcile.rb ADDED

@@ -0,0 +1,178 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'rubygems'
+require 'test/unit'
+require 'kasabi'
+require 'mocha'
+class ClientTest < Test::Unit::TestCase
+  def test_make_query_basic()
+    query = Kasabi::Reconcile::Client.make_query("train")
+    assert_equal("train", query[:query])
+    assert_equal(3, query[:limit])
+    assert_equal(:any, query[:type_strict])
+    assert_equal(nil, query[:type])
+    assert_equal(nil, query[:properties])
+  end
+  def test_make_queries()
+    queries = Kasabi::Reconcile::Client.make_queries( ["train", "car", "boat"] )
+    assert_equal(3, queries.size)
+    ["train", "car", "boat"].each_with_index do |label, i|
+      assert_equal(label, queries[i][:query])
+      assert_equal(3, queries[i][:limit])
+      assert_equal(:any, queries[i][:type_strict])
+      assert_equal(nil, queries[i][:type])
+      assert_equal(nil, queries[i][:properties])
+    end
+  end
+  def test_make_query_with_limit()
+    query = Kasabi::Reconcile::Client.make_query("train", 10)
+    assert_equal("train", query[:query])
+    assert_equal(10, query[:limit])
+  end
+  def test_make_query_with_type()
+    query = Kasabi::Reconcile::Client.make_query("train", 3, :any, "http://example.org/type")
+    assert_equal("train", query[:query])
+    assert_equal(3, query[:limit])
+    assert_equal(:any, query[:type_strict])
+    assert_equal("http://example.org/type", query[:type])
+  end
+  def test_make_query_with_type_array()
+    query = Kasabi::Reconcile::Client.make_query("train", 3, :any,
+        ["http://example.org/type"])
+    assert_equal("train", query[:query])
+    assert_equal(3, query[:limit])
+    assert_equal(:any, query[:type_strict])
+    assert_equal(["http://example.org/type"], query[:type])
+  end
+  def test_make_property_filter()
+    assert_raises RuntimeError do
+      filter = Kasabi::Reconcile::Client.make_property_filter("Ivor")
+    end
+  end
+  def test_make_property_filter_with_name()
+    filter = Kasabi::Reconcile::Client.make_property_filter("Ivor", "name")
+    assert_not_nil(filter)
+    assert_equal("Ivor", filter[:v])
+    assert_equal("name", filter[:p])
+    assert_equal(nil, filter[:pid])
+  end
+  def test_make_property_filter_with_id()
+    filter = Kasabi::Reconcile::Client.make_property_filter("Ivor", nil, "http://xmlns.com/foaf/0.1/name")
+    assert_not_nil(filter)
+    assert_equal("Ivor", filter[:v])
+    assert_equal(nil, filter[:p])
+    assert_equal("http://xmlns.com/foaf/0.1/name", filter[:pid])
+  end
+  def test_reconcile_label()
+    mc = mock();
+    mc.expects(:get).with("http://api.kasabi.com/api/test-reconcile",
+        {:apikey=>"test-key", "query" => {:query => "test", :limit => 3, :type_strict => :any}.to_json }
+      ).returns( HTTP::Message.new_response("{}") )
+    reconciler = Kasabi::Reconcile::Client.new("http://api.kasabi.com/api/test-reconcile", :apikey=>"test-key", :client=>mc)
+    result = reconciler.reconcile_label("test")
+    assert_equal(nil, result)
+  end
+  def test_reconcile_label_with_result()
+    resp = { "result" => [
+         {
+           "id" => "123",
+           "score" => 1.0,
+           "match" => true,
+           "label" => "test"
+         }
+      ] }
+    mc = mock();
+    mc.expects(:get).with("http://api.kasabi.com/api/test-reconcile",
+    {:apikey=>"test-key", "query" => {:query => "test", :limit => 3, :type_strict => :any}.to_json }
+      ).returns( HTTP::Message.new_response( resp.to_json ) )
+    reconciler = Kasabi::Reconcile::Client.new("http://api.kasabi.com/api/test-reconcile", :apikey=>"test-key", :client=>mc)
+    result = reconciler.reconcile_label("test")
+    assert_not_nil(result)
+    assert_equal(1, result.size)
+    assert_equal("123", result[0]["id"])
+  end
+  def test_reconcile_label_with_block()
+    resp = { "result" => [
+         {
+           "id" => "123",
+           "score" => 1.0,
+           "match" => true,
+           "label" => "test"
+         }
+      ] }
+    mc = mock();
+    mc.expects(:get).with("http://api.kasabi.com/api/test-reconcile",
+        {:apikey=>"test-key", "query" => {:query => "test", :limit => 3, :type_strict => :any}.to_json }
+      ).returns( HTTP::Message.new_response( resp.to_json ) )
+    reconciler = Kasabi::Reconcile::Client.new("http://api.kasabi.com/api/test-reconcile", :apikey=>"test-key", :client=>mc)
+    count = 0
+    result = reconciler.reconcile_label("test") do |r, index|
+      count = count + 1
+    end
+    assert_equal(1, count)
+    assert_not_nil(result)
+    assert_equal(1, result.size)
+  end
+  def test_reconcile_all_with_block()
+    resp = { "q0" => { "result" => [
+                       {
+                         "id" => "123",
+                         "score" => 1.0,
+                         "match" => true,
+                         "label" => "test"
+                       }
+                      ]
+            }
+    }
+    mc = mock();
+    expected_query = { "q0" => { :query => "test", :limit => 3, :type_strict => :any} }
+    mc.expects(:get).with("http://api.kasabi.com/api/test-reconcile",
+    {:apikey=>"test-key", "queries" => expected_query.to_json }
+      ).returns( HTTP::Message.new_response( resp.to_json ) )
+    reconciler = Kasabi::Reconcile::Client.new("http://api.kasabi.com/api/test-reconcile", :apikey=>"test-key", :client=>mc)
+    count = 0
+    queries = Kasabi::Reconcile::Client.make_queries(["test"])
+    result = reconciler.reconcile_all(queries) do |r, index, query|
+      count = count + 1
+    end
+    assert_equal(1, count)
+    assert_not_nil(result)
+    assert_equal(1, result.size)
+  end
+end

data/tests/api/tc_search.rb ADDED

@@ -0,0 +1,30 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'kasabi'
+require 'test/unit'
+require 'mocha'
+class SearchTest < Test::Unit::TestCase
+  def test_simple_search
+    mc = mock()
+    mc.expects(:get).with("http://api.kasabi.com/api/test-search/search", {:apikey=>"test-key", :query => "lunar", :output=>"json"}).returns(
+      HTTP::Message.new_response("{}") )
+    client = Kasabi::Search::Client.new("http://api.kasabi.com/api/test-search", :apikey=>"test-key", :client=>mc)
+    response = client.search("lunar")
+    assert_not_nil(response)
+  end
+  def test_parameter_search
+    mc = mock()
+    mc.expects(:get).with("http://api.kasabi.com/api/test-search/search",
+      {:apikey=>"test-key", :query => "lunar", :max => "50", :offset => "10", :output=>"json"}).returns(
+    HTTP::Message.new_response("{}") )
+    client = Kasabi::Search::Client.new("http://api.kasabi.com/api/test-search", :apikey=>"test-key", :client=>mc)
+    response = client.search("lunar", {:max => "50", :offset => "10"})
+    assert_not_nil(response)
+  end
+end

data/tests/api/tc_sparql.rb ADDED

@@ -0,0 +1,177 @@
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require 'kasabi'
+require 'test/unit'
+require 'mocha'
+class SparqlTest < Test::Unit::TestCase
+  def test_simple_query
+    mc = mock()
+    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL"}, {})
+    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql",
+    {:client => mc})
+    sparql_client.query("SPARQL")
+  end
+  def test_query_with_default_graph
+    mc = mock()
+    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL", "default-graph-uri" => ["http://www.example.com"]}, {})
+    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", {:client => mc})
+    sparql_client.add_default_graph("http://www.example.com")
+    sparql_client.query("SPARQL")
+  end
+  def test_query_with_named_graph
+    mc = mock()
+    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL", "named-graph-uri" => ["http://www.example.com"]}, {})
+    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", {:client => mc})
+    sparql_client.add_named_graph("http://www.example.com")
+    sparql_client.query("SPARQL")
+  end
+  def test_query_with_both_graphs
+    mc = mock()
+    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL", "named-graph-uri" => ["http://www.example.com"], "default-graph-uri" => ["http://www.example.org"]}, {})
+    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", {:client => mc})
+    sparql_client.add_named_graph("http://www.example.com")
+    sparql_client.add_default_graph("http://www.example.org")
+    sparql_client.query("SPARQL")
+  end
+  def test_sparql_with_mimetype
+    mc = mock()
+    mc.expects(:get).with("http://www.example.org/sparql", {"query" => "SPARQL"}, {"Accept" => "application/sparql-results+xml"})
+    sparql_client = Kasabi::Sparql::Client.new("http://www.example.org/sparql", {:client => mc})
+    sparql_client.query("SPARQL", "application/sparql-results+xml")
+  end
+  def test_ask
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/sparql-results+json"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    response = client.ask("SPARQL")
+    assert_equal("RESULTS", response.content)
+  end
+  def test_store_sparql_select
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/sparql-results+json"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    response = client.select("SPARQL")
+    assert_equal("RESULTS", response.content)
+  end
+  def test_construct
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/rdf+xml"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    response = client.construct("SPARQL")
+    assert_equal("RESULTS", response.content)
+  end
+  def test_describe
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "SPARQL"}, {"Accept" => "application/rdf+xml"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    response = client.describe("SPARQL")
+    assert_equal("RESULTS", response.content)
+  end
+  def test_multi_describe
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql",
+      {"query" => "DESCRIBE <http://www.example.org> <http://www.example.com>"},
+        {"Accept" => "application/rdf+xml"} ).returns( HTTP::Message.new_response("RESULTS"))
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    uris = []
+    uris << "http://www.example.org"
+    uris << "http://www.example.com"
+    response = client.multi_describe(uris)
+    assert_equal("RESULTS", response.content)
+  end
+  def test_describe_uri
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "DESCRIBE <http://www.example.org>"}, {"Accept" => "application/rdf+xml"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    response = client.describe_uri("http://www.example.org")
+    assert_equal("RESULTS", response.content)
+  end
+  def test_describe_uri_using_cbd
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", {"query" => "DESCRIBE <http://www.example.org>"}, {"Accept" => "application/rdf+xml"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    response = client.describe_uri("http://www.example.org", "application/rdf+xml", :cbd)
+    assert_equal("RESULTS", response.content)
+  end
+  def test_describe_uri_using_lcbd
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", anything, {"Accept" => "application/rdf+xml"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    response = client.describe_uri("http://www.example.org", "application/rdf+xml", :lcbd)
+    assert_equal("RESULTS", response.content)
+  end
+  def test_describe_uri_using_scbd
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", anything, {"Accept" => "application/rdf+xml"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    response = client.describe_uri("http://www.example.org", "application/rdf+xml", :scbd)
+    assert_equal("RESULTS", response.content)
+  end
+  def test_describe_uri_using_slcbd
+    mc = mock()
+    mc.expects(:get).with("http://api.talis.com/stores/testing/services/sparql", anything, {"Accept" => "application/rdf+xml"} ).returns(
+      HTTP::Message.new_response("RESULTS"))
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    response = client.describe_uri("http://www.example.org", "application/rdf+xml", :slcbd)
+    assert_equal("RESULTS", response.content)
+  end
+  def test_describe_uri_using_unknown
+    mc = mock()
+    client = Kasabi::Sparql::Client.new("http://api.talis.com/stores/testing/services/sparql", {:client => mc})
+    assert_raises RuntimeError do
+        response = client.describe_uri("http://www.example.org", "application/rdf+xml", :unknown)
+    end
+  end
+end