neography-ajaycb 0.0.21

data/lib/neography/node_path.rb

@@ -0,0 +1,29 @@
+module Neography
+  module NodePath
+
+    def all_paths_to(to)
+      PathTraverser.new(self, to, "allPaths", true)
+    end
+
+    def all_simple_paths_to(to)
+      PathTraverser.new(self, to, "allSimplePaths", true)
+    end
+
+    def all_shortest_paths_to(to)
+      PathTraverser.new(self, to, "shortestPath", true)
+    end
+
+    def path_to(to)
+      PathTraverser.new(self, to, "allPaths", false)
+    end
+
+    def simple_path_to(to)
+      PathTraverser.new(self, to, "allSimplePaths", false)
+    end
+
+    def shortest_path_to(to)
+      PathTraverser.new(self, to, "shortestPath", false)
+    end
+
+  end
+end

data/lib/neography/node_relationship.rb

@@ -0,0 +1,35 @@
+module Neography
+  module NodeRelationship
+
+    def outgoing(types=nil)
+      NodeTraverser.new(self).outgoing(types)
+    end
+
+    def incoming(types=nil)
+      NodeTraverser.new(self).incoming(types)
+    end
+
+    def both(types=nil)
+      NodeTraverser.new(self).both(types)
+    end
+
+    def rels(*types)
+      Neography::RelationshipTraverser.new(self, types, :both)
+    end
+
+    def rel(dir, type)
+      rel = Neography::RelationshipTraverser.new(self, type, dir)
+      rel = rel.first unless rel.nil?
+      rel
+    end
+
+    def rel?(dir=nil, type=nil)
+      if DIRECTIONS.include?(dir.to_s)
+        !self.neo_server.get_node_relationships(self, dir, type).nil? 
+      else
+        !self.neo_server.get_node_relationships(self, type, dir).nil? 
+      end
+    end
+
+  end
+end

data/lib/neography/node_traverser.rb

@@ -0,0 +1,142 @@
+module Neography
+  class NodeTraverser
+    include Enumerable
+
+    attr_accessor :order, :uniqueness, :depth, :prune, :filter, :relationships
+
+    def initialize(from, types = nil, dir = "all" )
+      @from  = from
+      @order = "depth first"
+      @uniqueness = "none"
+      @relationships = Array.new
+      types.each do |type|
+        @relationships << {"type" => type.to_s, "direction" => dir.to_s }
+      end unless types.nil?
+    end
+
+    def <<(other_node)
+      create(other_node)
+      self
+    end
+
+    def create(other_node)
+      case @relationships.first["direction"]
+        when "outgoing", "out"
+          rel = Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], @from, other_node))
+        when "incoming", "in"
+          rel = Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], other_node, @from))
+        else
+          rel = Array.new
+          rel << Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], @from, other_node))
+          rel << Neography::Relationship.new(@from.neo_server.create_relationship(@relationships.first["type"], other_node, @from))
+      end
+      rel       
+    end
+
+    def both(type)
+      @relationships << {"type" => type.to_s, "direction" => "all"}
+      self
+    end
+
+    def outgoing(type)
+      @relationships << {"type" => type.to_s, "direction" => "out"}
+      self
+    end
+
+    def incoming(type)
+      @relationships << {"type" => type.to_s, "direction" => "in"}
+      self
+    end
+
+    def uniqueness(u)
+      @uniqueness = u
+      self
+    end
+
+    def order(o)
+      @order = o
+      self
+    end
+
+    def filter(body)
+      @filter = Hash.new
+      @filter["language"] = "javascript"
+      @filter["body"] = body
+      self
+    end
+
+    def prune(body)
+      @prune = Hash.new
+      @prune["language"] = "javascript"
+      @prune["body"] = body
+      self
+    end
+
+    def depth(d)
+      d = 2147483647 if d == :all
+      @depth = d
+      self
+    end
+
+    def include_start_node
+      @filter = Hash.new
+      @filter["language"] = "builtin"
+      @filter["name"] = "all"
+      self
+    end
+
+    def size
+      [*self].size
+    end
+
+    alias_method :length, :size
+
+    def [](index)
+      each_with_index {|node,i| break node if index == i}
+    end
+
+    def empty?
+      first == nil
+    end
+
+    def each
+      iterator.each do |i| 
+        node = @from.class.new(i)
+        node.neo_server = @from.neo_server
+        yield node
+      end
+    end
+
+    def iterator
+      options = Hash.new
+      options["order"] = @order
+      options["uniqueness"] = @uniqueness
+      options["relationships"] = @relationships
+      options["prune evaluator"] = @prune unless @prune.nil?
+      options["return filter"] = @filter unless @filter.nil?
+      options["depth"] = @depth unless @depth.nil?
+
+      if @relationships[0]["type"].empty?
+        rels = @from.neo_server.get_node_relationships(@from, @relationships[0]["direction"])
+        case @relationships[0]["direction"]
+          when "in"
+            rels.collect { |r| @from.neo_server.get_node(r["start"]) } #.uniq
+          when "out"
+            rels.collect { |r| @from.neo_server.get_node(r["end"]) } #.uniq
+          else
+            rels.collect { |r| 
+            if @from.neo_id == r["start"].split('/').last
+              @from.neo_server.get_node(r["end"]) 
+            else
+              @from.neo_server.get_node(r["start"]) 
+            end
+            } #.uniq
+        end
+      else
+        @from.neo_server.traverse(@from, "nodes", options)
+      end
+    end
+
+  end
+
+end

data/lib/neography/path_traverser.rb

@@ -0,0 +1,94 @@
+module Neography
+  class PathTraverser
+    include Enumerable
+
+    attr_accessor :depth, :algorithm, :relationships, :get
+
+    def initialize(from, to, algorithm, all=false, types = nil, dir = "all" )
+      @from  = from
+      @to = to
+      @algorithm = algorithm
+      @all = all
+      @relationships = Array.new
+      types.each do |type|
+        @relationships << {"type" => type.to_s, "direction" => dir.to_s }
+      end unless types.nil?
+      @get = ["node","rel"]
+      @loaded = Array.new
+    end
+
+    def nodes
+      @get = ["node"]
+      self
+    end
+
+    def relationships
+      @get = ["rel"]
+      self
+    end
+
+    alias_method :rels, :relationships
+
+    def both(type)
+      @relationships << {"type" => type.to_s, "direction" => "all"}
+      self
+    end
+
+    def outgoing(type)
+      @relationships << {"type" => type.to_s, "direction" => "out"}
+      self
+    end
+
+    def incoming(type)
+      @relationships << {"type" => type.to_s, "direction" => "in"}
+      self
+    end
+
+    def depth(d)
+      d = 2147483647 if d == :all
+      @depth = d
+      self
+    end
+
+    def size
+      [*self].size
+    end
+
+    alias_method :length, :size
+
+    def each
+      iterator.each do |path|
+        paths = Array.new
+
+        if @get.include?("node")
+          path["nodes"].each_with_index do |n, i|
+            @loaded[n.split('/').last.to_i] = Neography::Node.load(n) if @loaded.at(n.split('/').last.to_i).nil?
+            paths[i * 2] =  @loaded[n.split('/').last.to_i]
+          end
+        end
+
+        if @get.include?("rel") 
+          path["relationships"].each_with_index do |r, i|
+            @loaded[r.split('/').last.to_i] = Neography::Relationship.load(r) if @loaded.at(r.split('/').last.to_i).nil?
+            paths[i * 2 + 1] =  @loaded[r.split('/').last.to_i] 
+          end
+        end
+ 
+        yield paths.compact
+      end
+    end
+
+    def empty?
+      first == nil
+    end
+
+    def iterator
+      if @all.nil?
+        @from.neo_server.get_path(@from, @to, @relationships, @depth, @algorithm)
+      else
+        @from.neo_server.get_paths(@from, @to, @relationships, @depth, @algorithm)
+      end
+    end
+
+  end
+end

data/lib/neography/property.rb

@@ -0,0 +1,53 @@
+module Neography
+  module Property
+
+
+    def [](key)
+      return unless respond_to?(key)
+      @table[key]
+    end
+
+    def []=(key, value)
+      k = key.to_s
+      if value.nil?
+        if self.is_a? Neography::Node
+          neo_server.remove_node_properties(self.neo_id, [key])
+        else
+          neo_server.remove_relationship_properties(self.neo_id, [key])
+        end
+      else
+        if self.is_a? Neography::Node
+          neo_server.set_node_properties(self.neo_id, {k => value})
+        else
+          neo_server.set_relationship_properties(self.neo_id, {k => value})
+        end
+        new_ostruct_member(k) unless self.respond_to?(key)
+      end
+      @table[key] = value
+    end
+
+
+  def new_ostruct_member(name)
+    name = name.to_sym
+    unless self.respond_to?(name)
+      meta = class << self; self; end
+      meta.send(:define_method, name) { @table[name] }
+      meta.send(:define_method, "#{name}=") do |x| 
+        @table[name] = x 
+        self[name.to_sym] = x        
+      end
+    end
+   name
+  end
+
+
+  def self.method_missing(method_sym, *arguments, &block)
+    if (method_sym.to_s =~ /$=/) != nil
+      new_ostruct_member(method_sym.to_s.chomp("="))
+    else
+      super
+    end
+  end
+
+  end
+end

data/lib/neography/property_container.rb

@@ -0,0 +1,17 @@
+module Neography
+  class PropertyContainer < OpenStruct
+    attr_reader :neo_id
+
+    def initialize(hash=nil)
+      @table = {}
+      if hash
+        @neo_id = hash["self"].split('/').last
+        for k,v in hash["data"]
+          @table[k.to_sym] = v
+          new_ostruct_member(k)
+        end
+      end
+    end
+
+  end
+end

data/lib/neography/railtie.rb

@@ -0,0 +1,8 @@
+require 'rails'
+
+class Railtie < Rails::Railtie 
+
+  rake_tasks do
+    load "neography/tasks.rb"
+  end  
+end

data/lib/neography/relationship.rb

@@ -0,0 +1,68 @@
+module Neography
+  class Relationship < PropertyContainer
+    include Neography::Equal
+    include Neography::Property
+    extend  Neography::Index
+    
+    attr_accessor :start_node, :end_node, :rel_type
+
+    class << self
+
+      def create(type, from_node, to_node, props=nil)
+        rel = Neography::Relationship.new(from_node.neo_server.create_relationship(type, from_node, to_node, props))
+        rel.start_node = from_node
+        rel.end_node = to_node
+        rel.rel_type = type
+        rel
+      end
+
+      def load(*args)
+        # the first argument can be an hash of properties to set
+        rel = !args[0].is_a?(Neography::Rest) && args[0] || args[1]
+
+        # a db instance can be given, it is the first argument or the second
+        db = (args[0].is_a?(Neography::Rest) && args[0]) || args[1] || Neography::Rest.new
+        rel = db.get_relationship(rel)
+        unless rel.nil?
+          rel = Neography::Relationship.new(rel) 
+          rel.start_node = Neography::Node.load(rel.start_node, db) 
+          rel.end_node = Neography::Node.load(rel.end_node, db) 
+        end
+        rel
+      end
+    end
+
+    def initialize(hash=nil, server=nil)
+      super(hash)
+      @start_node = hash["start"].split('/').last
+      @end_node = hash["end"].split('/').last
+      @rel_type = hash["type"]
+      neo_server = server
+    end
+    
+    def neo_server
+      @neo_server ||= self.start_node.neo_server
+    end
+    
+    def neo_server=(server)
+      @neo_server = server
+    end
+
+    def del
+      self.start_node.neo_server.delete_relationship(self.neo_id)
+    end
+
+    def exist?
+      !self.start_node.neo_server.get_relationship(self.neo_id).nil?
+    end
+
+    def other_node(node)
+      if node == @start_node
+        @end_node
+      else
+        @start_node
+      end
+    end
+
+  end
+end