agama 0.5.0 → 0.5.1

data/VERSION

@@ -1 +1 @@
-0.5.0
+0.5.1

data/agama.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{agama}
+  s.version = "0.5.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Aditya Rachakonda"]
+  s.date = %q{2011-05-10}
+  s.description = %q{A simple Graph DB on a key-value store}
+  s.email = %q{aditya.rachakonda@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "agama.gemspec",
+    "lib/agama.rb",
+    "lib/agama/adapters/tokyocabinet.rb",
+    "lib/agama/config.rb",
+    "lib/agama/graph.rb",
+    "lib/agama/keyify.rb",
+    "lib/agama/traverser.rb",
+    "test/helper.rb",
+    "test/test_agama.rb"
+  ]
+  s.homepage = %q{http://github.com/arrac/agama}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{A simple Graph DB on a key-value store}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.0"])
+      s.add_development_dependency(%q<rcov>, [">= 0"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
+      s.add_dependency(%q<rcov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.0"])
+    s.add_dependency(%q<rcov>, [">= 0"])
+  end
+end
+

data/lib/agama.rb

@@ -0,0 +1,4 @@
+require 'agama/graph'
+require 'agama/traverser'
+require 'agama/keyify'
+require 'agama/config'

data/lib/agama/adapters/tokyocabinet.rb

@@ -0,0 +1,160 @@
+require 'tokyocabinet'
+include TokyoCabinet
+
+module Agama
+  module Adapters
+    class TC
+
+
+          
+      def open (path)
+        @meta = HDB::new        
+        # open the meta database
+        if !@meta.open(path + "/meta.tch", HDB::OWRITER | HDB::OCREAT)
+          ecode = @meta.ecode
+          raise "Error opening meta_db: #{@meta.errmsg(ecode)}"
+        end
+
+        @nodes = HDB::new        
+        # open the nodes database
+        if !@nodes.open(path + "/nodes.tch", HDB::OWRITER | HDB::OCREAT)
+          ecode = @nodes.ecode
+          raise "Error opening nodes_db: #{@nodes.errmsg(ecode)}"
+        end
+        
+        @edges = BDB::new       
+        # open the edges database
+        if !@edges.open(path + "/edges.tcb", BDB::OWRITER | BDB::OCREAT)
+          ecode = @edges.ecode
+          raise "Error opening edges_db: #{@edges.errmsg(ecode)}"
+        end
+      end
+
+
+      
+      def close
+        if !@meta.close
+          ecode = @meta.ecode
+          raise "Error closing meta_db: #{@meta.errmsg(ecode)}"
+        end
+        if !@nodes.close
+          ecode = @nodes.ecode
+          raise "Error closing nodes_db: #{@nodes.errmsg(ecode)}"
+        end
+        if !@edges.close
+          ecode = @edges.ecode
+          raise "Error closing edges_db: #{@edges.errmsg(ecode)}"
+        end
+      end
+
+
+
+      
+      def m_put (key, value)
+        unless @meta.put(key, value)
+          ecode = @meta.ecode
+          raise "Error inserting meta_db: #{@meta.errmsg(ecode)}"
+        end
+      end
+      
+      def m_get (key)
+        return @meta.get(key)
+      end
+      
+      def m_del (key)
+        unless @meta.out(key)
+          ecode = @meta.ecode
+          raise "Error deleting from meta_db: #{@meta.errmsg(ecode)}"
+        end
+      end
+
+
+
+
+      def n_put (key, value)
+        unless @nodes.put(key, value)
+          ecode = @nodes.ecode
+          raise "Error inserting into nodes_db: #{@nodes.errmsg(ecode)}"
+        end
+        
+        true
+      end
+      
+      def n_get (key)
+        return @nodes.get(key)
+      end
+      
+      def n_del (key)
+        unless @nodes.out(key)
+          ecode = @nodes.ecode
+          raise "Error deleting from nodes_db: #{@nodes.errmsg(ecode)}"
+        end
+        
+        true
+      end
+      
+      
+      def e_put (key, value)
+        unless @edges.put(key, value)
+          ecode = @edges.ecode
+          raise "Error inserting into edges_db: #{@edges.errmsg(ecode)}"
+        end
+        
+        true
+      end
+      
+      def e_get (key)
+        return @edges.get(key)
+      end
+      
+      def e_del (key)
+        unless @edges.out(key, value)
+          ecode = @edges.ecode
+          raise "Error deleting from edges_db: #{@edges.errmsg(ecode)}"
+        end
+        
+        true
+      end
+      
+      def e_cursor
+        return TCCursor.new(@edges, "edge")
+      end
+      
+    end
+    
+    class TCCursor
+      def initialize(bptree, type)
+        @c = BDBCUR::new(bptree)
+        @t = type
+      end
+      
+      def first
+        @c.first
+      end
+      
+      def last
+        @c.last
+      end
+      
+      def jump(key)
+        @c.jump(key)
+      end
+      
+      def prev
+        @c.prev
+      end
+      
+      def next
+        @c.next
+      end
+      
+      def key
+        @c.key
+      end
+      
+      def value
+        @c.val
+      end      
+    end
+  end
+end

data/lib/agama/config.rb

@@ -0,0 +1,7 @@
+module Agama
+  module Config
+    DEFAULT_TYPE   = "_"
+    NODE_DELIMITOR = "\0"
+    EDGE_DELIMITOR = "\0\0"
+  end
+end

data/lib/agama/graph.rb

@@ -0,0 +1,267 @@
+module Agama
+  class Graph
+
+    #Initialises variables and sets the path
+
+    def initialize(params)
+      @db_path  = params[:path] || "./"
+      @db       = params[:db]
+    end
+
+    #Opens the database for access
+
+    def open
+      @db.open(@db_path)
+
+      #Create meta variables if they are absent
+      unless @db.m_get("n")
+        @db.m_put("n", Marshal.dump(0))             #Total node count
+        @db.m_put("m", Marshal.dump(0))             #Total edge count
+        @db.m_put("node#{Config::DEFAULT_TYPE}", 
+                  Marshal.dump(0))                  #Node count for default type
+        @db.m_put("edge#{Config::DEFAULT_TYPE}", 
+                  Marshal.dump({:directed => false, :count => 0})) #Edge count for default type
+      end
+
+    end
+
+    #Closes the database connection
+    def close
+      @db.close
+    end
+
+    #Creates/Updates a node
+
+    def set_node(node)
+      return nil unless node[:name]
+
+      #Get the type of the node
+      type = node[:type] || Config::DEFAULT_TYPE
+      node[:type] = type
+
+      #Convert the node into Key and Value strings for storage
+      key = Keyify.node(node)
+      value = Marshal.dump(self.clean_node(node)) #remove key items from value
+
+      #Check if the node type exists, and if so get its count
+      count = Marshal.load(@db.m_get("node#{type}")) if @db.m_get("node#{type}")
+
+      #Check whether the operation is an insert (not an update), if so increment count
+      unless @db.n_get(key)
+        #Increment type-specific count
+        if count
+          count += 1
+          @db.m_put("node#{type}", Marshal.dump(count))
+        else
+          @db.m_put("node#{type}", Marshal.dump(1))
+        end
+
+        #Increment global count
+        @db.m_put("n", Marshal.dump(Marshal.load(@db.m_get("n")) + 1))
+      end
+
+      #Store the node
+      if @db.n_put(key, value)
+        node
+      end
+    end
+
+    #Fetches the node requested
+
+    def get_node(node)
+      return nil unless node[:name]
+
+      #Convert the node into a Key string and fetch the corresponding data
+      key = Keyify.node(node)
+      value = @db.n_get(key)
+
+      if value
+        new_node        = Marshal.load(value)
+        new_node[:name] = node[:name]
+        new_node[:type] = node[:type] || Config::DEFAULT_TYPE
+        new_node
+      end
+    end
+
+    #Creates/Updates an edge
+
+    def set_edge(edge)
+      return false unless edge
+      return false unless edge[:from][:name]
+      return false unless edge[:to][:name]
+
+      #Get the type of the edge
+      type = edge[:type] || Config::DEFAULT_TYPE
+      edge[:type] = type
+
+      #Check if the edge type exists
+      etype = Marshal.load(@db.m_get("edge#{type}")) if @db.m_get("edge#{type}")
+
+      #Integrity check: Check whether the edge direction is not contradictory
+      if edge[:directed]
+        if etype
+          if etype[:directed] != edge[:directed]
+            raise "Edge creation error: edge direction contradicting existing edges"
+            return
+          end
+        end
+      else
+        if etype
+          edge[:directed] = etype[:directed]
+        else
+          edge[:directed] = false
+        end
+      end
+
+      #Convert the edge into Key, Reversed Key and Value strings for storage
+      key, reverse_key = Keyify.edge(edge)
+      value = Marshal.dump(clean_edge(edge))
+
+      #Integrity check: Check if the incident nodes are defined
+      unless (self.get_node(edge[:from]) and self.get_node(edge[:to]))
+        raise "Edge creation error: node(s) not defined"
+        return
+      end
+
+      #Check whether the operation is an insert (not an update), if so increment count
+      unless @db.e_get(key)
+        if etype
+          etype[:count] += 1
+          @db.m_put("edge#{type}", Marshal.dump(etype))
+        else
+          @db.m_put("edge#{type}", 
+                    Marshal.dump({:directed => edge[:directed], :count => 1}))
+        end
+
+        #Increment global count
+        @db.m_put("m", Marshal.dump(Marshal.load(@db.m_get("m")) + 1))
+      end
+
+      #Add the edge and the reversed edge
+      if @db.e_put(key, value) and @db.e_put(reverse_key, value)
+        return edge
+      end
+    end
+
+    #Fetches the value assigned to the edge from the _from_ node to the _to_ node
+
+    def get_edge(edge)
+      return nil unless edge[:from][:name]
+      return nil unless edge[:to][:name]
+
+      #Get the type of the edge
+      type = edge[:type] || Config::DEFAULT_TYPE
+      edge[:type] = type
+
+      #Check if the edge type exists
+      etype = Marshal.load(@db.m_get("edge#{type}")) if @db.m_get("edge#{type}")
+
+      #Integrity check: Check whether the edge direction is not contradictory
+      if edge[:directed]
+        if etype
+          if etype[:directed] != edge[:directed]
+            return false
+          end
+        else
+          #If there is no edge of that type then pre-empt the result
+          return false
+        end
+      else
+        if etype
+          edge[:directed] = etype[:directed]
+        else
+          #If there is no edge of that type then pre-empt the result
+          return false
+        end
+      end
+
+      #Convert the edge into a Key string and fetch the corresponding data
+      key, reverse_key = Keyify.edge(edge)
+      value = @db.e_get(key)
+
+      if value
+        new_edge            = Marshal.load(value)
+        new_edge[:from]     = self.get_node(edge[:from])
+        new_edge[:to]       = self.get_node(edge[:to])
+        new_edge[:type]     = edge[:type]
+        new_edge[:directed] = etype[:directed] #Pick direction alone from the meta_db for consistency
+        new_edge
+      end
+    end
+
+    def neighbours(node)
+      traverser = Traverser.new(@db, self)
+      traverser.set(:from => node)
+    end
+
+    #def filter(params)
+    #end
+
+    #def delete_node(node)
+      #return nil unless node[:name]
+
+      #key = Key.node(node)
+
+    #end
+
+    #def delete_edge(edge)
+
+    #end
+
+#    def put(store, key, value)
+#      unless store.put(key, value)
+#        STDERR.printf("put error: %s\n", store.errmsg(store.ecode))
+#      end
+#    end
+
+    #Accessors for meta values
+
+    def node_count(type = nil)
+      if type
+        value = @db.m_get("node#{type}")
+        if value
+          Marshal.load(value)
+        end
+      else
+        Marshal.load(@db.m_get("n"))
+      end
+    end
+
+    def edge_count(type = nil)
+      if type
+        value = @db.m_get("edge#{type}")
+        if value
+          etype = Marshal.load(value)
+          etype[:count]
+        end
+      else
+        Marshal.load(@db.m_get("m"))
+      end
+    end
+
+    #Methods to seperate key from the value
+
+    def clean_node(node)
+      new_node = {}
+      node.each do |key, value|
+        next if (key == :type or key == :name)
+        new_node[key] = value
+      end
+
+      return new_node
+    end
+
+    def clean_edge(edge)
+      new_edge = {}
+      edge.each do |key, value|
+        next if (key == :type or key == :from or key == :to or key == :directed)
+        new_edge[key] = value
+      end
+
+      return new_edge
+    end
+
+  end
+
+end
+

data/lib/agama/keyify.rb

@@ -0,0 +1,62 @@
+module Agama
+
+  module Keyify
+    
+    def self.node(node)
+      type = node[:type] || Config::DEFAULT_TYPE
+      [type, node[:name]].join(Config::NODE_DELIMITOR)      
+    end
+
+    def self.edge(edge)
+      from = self.node(edge[:from])
+      type = edge[:type] || Config::DEFAULT_TYPE
+      outgoing, incoming = if edge[:directed] then
+                             ["O", "I"]
+                           else
+                             ["N", "N"]
+                           end
+
+      to = self.node(edge[:to])
+
+      key = [from, type, outgoing, to].join(Config::EDGE_DELIMITOR)
+      reverse_key = [to, type, incoming, from].join(Config::EDGE_DELIMITOR)
+
+      [key, reverse_key]
+    end
+
+    def self.range(params)
+      from = self.node(params[:from]) if params[:from]
+
+      type = params[:edge_type]
+
+      if type
+        dir = params[:direction]
+        if dir
+          to_type = params[:to_type]
+          if to_type
+            [from, type, dir, to_type].join(Config::EDGE_DELIMITOR)
+          else
+            [from, type, dir, nil].join(Config::EDGE_DELIMITOR)
+          end
+        else
+          [from, type, nil].join(Config::EDGE_DELIMITOR)
+        end
+      else
+        [from, nil].join(Config::EDGE_DELIMITOR)
+      end
+    end
+
+    def self.parse(key)
+      from_key, edge_type, direction, to_key = key.split(Config::EDGE_DELIMITOR)
+      type, name = to_key.split(Config::NODE_DELIMITOR)
+      directed = true
+      directed = false if (direction == "N")
+      [{:type => type, :name => name}, edge_type, direction, directed]
+    end
+
+    def self.subkey?(subkey, key)
+      key [0, subkey.length] == subkey
+    end
+  end
+end
+

data/lib/agama/traverser.rb

@@ -0,0 +1,78 @@
+module Agama
+  class Traverser
+
+    attr_accessor :params
+
+    def initialize(db, graph)
+      @cursor = db.e_cursor
+      @search_key = ""
+      @unset = true
+      @graph = graph
+      @from = nil
+      @params = {}
+    end
+
+    def set(params)
+      @params.merge!(params)
+      self
+    end
+
+    def along(edge_type)
+      self.set(:edge_type => edge_type)
+    end
+
+    def outgoing
+      self.set(:edge_type => Config::DEFAULT_TYPE) unless @params[:edge_type]
+      self.set(:direction => "O")
+    end
+
+    def incoming
+      self.set(:edge_type => Config::DEFAULT_TYPE) unless @params[:edge_type]
+      self.set(:direction => "I")
+    end
+
+    def undirected
+      self.set(:edge_type => Config::DEFAULT_TYPE) unless @params[:edge_type]
+      self.set(:direction => "N")
+    end
+
+    def of_type(node_type)
+      self.set(:edge_type => Config::DEFAULT_TYPE) unless @params[:edge_type]
+      self.set(:direction => "N") unless @params[:direction]
+      self.set(:to_type => node_type)
+    end
+
+    def each
+      search_key = ""
+      from = nil
+      if @unset
+        search_key = Keyify.range(@params)
+        from = @graph.get_node(@params[:from])
+
+        @cursor.jump(search_key)
+        @unset = false
+      end
+
+      while @cursor.key and Keyify.subkey?(search_key, @cursor.key)
+        to, type, direction, directed = Keyify.parse(@cursor.key)
+
+        if @cursor.value
+          new_edge = Marshal.load(@cursor.value)
+          new_edge[:type] = type
+          new_edge[:directed] = directed
+          if direction == "I"
+            new_edge[:to] = from
+            new_edge[:from] = @graph.get_node(to)
+          else
+            new_edge[:from] = from
+            new_edge[:to] = @graph.get_node(to)
+          end
+          yield new_edge
+        end
+
+        @cursor.next
+      end
+    end
+
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: agama
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: false
   segments: 
   - 0
   - 5
-  - 0
-  version: 0.5.0
+  - 1
+  version: 0.5.1
 platform: ruby
 authors: 
 - Aditya Rachakonda
@@ -95,7 +95,13 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- agama.gemspec
 - lib/agama.rb
+- lib/agama/adapters/tokyocabinet.rb
+- lib/agama/config.rb
+- lib/agama/graph.rb
+- lib/agama/keyify.rb
+- lib/agama/traverser.rb
 - test/helper.rb
 - test/test_agama.rb
 has_rdoc: true