neography-down 1.6.4

data/lib/neography/path_traverser.rb

@@ -0,0 +1,100 @@
+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_nodes = Array.new
+      @loaded_rels = 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_nodes[get_id(n)] = Neography::Node.load(n) if @loaded_nodes.at(get_id(n)).nil?
+            paths[i * 2] =  @loaded_nodes[get_id(n)]
+          end
+        end
+
+        if @get.include?("rel") 
+          path["relationships"].each_with_index do |r, i|
+            @loaded_rels[get_id(r)] = Neography::Relationship.load(r)  if @loaded_rels.at(get_id(r)).nil?
+            paths[i * 2 + 1] =  @loaded_rels[get_id(r)]
+          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
+    
+    private 
+    def get_id(object)
+      object.split('/').last.to_i
+    end
+
+  end
+end

data/lib/neography/property.rb

@@ -0,0 +1,110 @@
+module Neography
+  module Property
+
+    def [](key)
+      @table[key.to_sym]
+    end
+
+    def []=(key, value)
+      key = key.to_sym
+      k_str = key.to_s
+      if value.nil?
+        unless @table[key].nil?
+          if node?
+            neo_server.remove_node_properties(self.neo_id, [k_str])
+          else
+            neo_server.remove_relationship_properties(self.neo_id, [k_str])
+          end
+        end
+        remove_ostruct_member(key)
+      else
+        if node?
+          neo_server.set_node_properties(self.neo_id, {k_str => value})
+        else
+          neo_server.set_relationship_properties(self.neo_id, {k_str => value})
+        end
+        new_ostruct_member(key, value)
+      end
+    end
+
+    # Set many properties at once and only issue one http
+    # request and update the node/relationship instance on the fly.
+    #
+    # To remove a property, set its value to nil.
+    def set_properties(hash)
+      hash.each do |key, value|
+        add_or_remove_ostruct_member(key, value)
+      end
+      rest_reset_properties
+    end
+
+    # As #set_properties, but this one hard resets the node's/relationship's
+    # properties to exactly what's given in the hash.
+    def reset_properties(hash)
+      @table.keys.each{|key| remove_ostruct_member(key)}
+      hash.each{|key,value| new_ostruct_member(key,value)}
+      rest_reset_properties
+    end
+
+    def add_or_remove_ostruct_member(name, value)
+      if value.nil?
+        remove_ostruct_member(name)
+      else
+        new_ostruct_member(name, value)
+      end
+    end
+
+    def new_ostruct_member(name, value)
+      name = name.to_sym
+      @table[name] = value
+      unless self.respond_to?(name)
+        meta = class << self; self; end
+        meta.send(:define_method, name) { @table[name] }
+        meta.send(:define_method, "#{name}=") do |new_value|
+          self[name.to_sym] = new_value
+        end
+      end
+      name
+    end
+
+    def remove_ostruct_member(name)
+      @table.delete(name.to_sym)
+      meta = class << self; self; end
+      names = [name, "#{name}="].map(&:to_sym)
+      names.each do |n|
+        meta.send(:remove_method, n) if self.respond_to?(n)
+      end
+    end
+
+    def method_missing(method_sym, *arguments, &block)
+      if (method_sym.to_s =~ /=$/) != nil
+        new_ostruct_member(method_sym.to_s.chomp("="), *arguments)
+
+        # We just defined the getter/setter above, but we haven't actually
+        # applied them yet.
+        self.send(method_sym, *arguments)
+      else
+        super
+      end
+    end
+
+    def attributes
+      @table.keys
+    end
+
+    def node?
+      self.is_a?(Neography::Node)
+    end
+
+    private
+
+    def rest_reset_properties
+      if node?
+        neo_server.reset_node_properties(self.neo_id, @table)
+      else
+        neo_server.reset_relationship_properties(self.neo_id, @table)
+      end
+    end
+
+  end
+end

data/lib/neography/property_container.rb

@@ -0,0 +1,28 @@
+module Neography
+  class PropertyContainer < OpenStruct
+    attr_reader :neo_id
+
+    def initialize(hash=nil)
+      @table = {}
+      unless hash.nil?
+        if hash["self"] # coming from REST API
+          @neo_id = hash["self"].split('/').last
+          data = hash["data"]
+        elsif hash.is_a? Neography::Node # is already a Neography::Node
+          @neo_id = hash.neo_id
+          data = Hash[*hash.attributes.collect{|x| [x.to_sym, hash.send(x)]}.flatten]
+        elsif hash["data"] # coming from CYPHER
+          @neo_id = hash["data"].first.first["self"].split('/').last
+          data = hash["data"].first.first["data"]
+        end
+      else
+        data = []
+      end
+
+      for k,v in data
+        new_ostruct_member(k.to_sym, v)
+      end
+    end
+
+  end
+end

data/lib/neography/railtie.rb

@@ -0,0 +1,19 @@
+require 'rails'
+
+module Neography
+  class Railtie < Rails::Railtie
+
+    # To add an initialization step from your Railtie to Rails boot process, you just need to create an initializer block:
+    # See: http://api.rubyonrails.org/classes/Rails/Railtie.html
+    initializer 'neography.configure' do
+      # Provides a hook so people implementing the gem can do this in a railtie of their own:
+      #   initializer "my_thing.neography_initialization", before: 'neography.configure' do
+      #     require 'my_thing/neography'
+      #   end
+    end
+
+    rake_tasks do
+      load 'neography/tasks.rb'
+    end
+  end
+end

data/lib/neography/relationship.rb

@@ -0,0 +1,78 @@
+module Neography
+  class Relationship < PropertyContainer
+    include Neography::Equal
+    include Neography::Property
+    include 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 create_unique(index, key, value, type, from_node, to_node, props = nil)
+        rel = Neography::Relationship.new(from_node.neo_server.create_unique_relationship(index, key, value, type, from_node, to_node, props))
+        rel.start_node = from_node
+        rel.end_node = to_node
+        rel.rel_type = type
+        rel
+      end
+
+      def load(rel, db = Neography::Rest.new)
+        raise ArgumentError.new("syntax deprecated") if rel.is_a?(Neography::Rest)
+
+        rel = db.get_relationship(rel)
+        if rel
+          rel = Neography::Relationship.new(rel, db)
+          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"]
+      self.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
+      start_node.neo_server.delete_relationship(neo_id)
+    end
+
+    def exist?
+      begin
+        start_node.neo_server.get_relationship(neo_id)
+        true
+      rescue Neography::RelationshipNotFoundException
+        false
+      end
+    end
+
+    def other_node(node)
+      if node == @start_node
+        @end_node
+      else
+        @start_node
+      end
+    end
+
+  end
+end

data/lib/neography/relationship_traverser.rb

@@ -0,0 +1,80 @@
+module Neography
+  class RelationshipTraverser
+    include Enumerable
+
+    def initialize(node, types, direction)
+      @node      = node
+      @types     = [types]
+      @direction = direction
+    end
+
+    def to_s
+      if @types.size == 1 && !@types.empty?
+        "#{self.class} [type: #{@type} dir:#{@direction}]"
+      elsif !@types.empty?
+        "#{self.class} [types: #{@types.join(',')} dir:#{@direction}]"
+      else
+        "#{self.class} [types: ANY dir:#{@direction}]"
+      end
+    end
+
+    def each
+      iterator.each do |i| 
+        rel = Neography::Relationship.new(i, @node.neo_server)
+        rel.start_node = Neography::Node.load(rel.start_node, @node.neo_server)
+        rel.end_node = Neography::Node.load(rel.end_node, @node.neo_server)
+
+        yield rel if match_to_other?(rel)
+      end
+    end
+
+    def empty?
+      first == nil
+    end
+
+    def iterator
+      Array(@node.neo_server.get_node_relationships(@node, @direction, @types))
+    end
+
+    def match_to_other?(rel)
+      if @to_other.nil?
+        true
+      elsif @direction == :outgoing
+        rel.end_node == @to_other
+      elsif @direction == :incoming
+        rel.start_node == @to_other
+      else
+        rel.start_node == @to_other || rel.end_node == @to_other
+      end
+    end
+
+    def to_other(to_other)
+      @to_other = to_other
+      self
+    end
+
+    def del
+      each { |rel| @node.neo_server.delete_relationship(rel) }
+    end
+
+    def size
+      [*self].size
+    end
+
+    def both
+      @direction = :both
+      self
+    end
+
+    def incoming
+      @direction = :incoming
+      self
+    end
+
+    def outgoing
+      @direction = :outgoing
+      self
+    end
+
+  end
+end

data/lib/neography/rest.rb

@@ -0,0 +1,99 @@
+require 'forwardable'
+
+require 'neography/rest/helpers'
+require 'neography/rest/schema_indexes'
+require 'neography/rest/nodes'
+require 'neography/rest/node_properties'
+require 'neography/rest/node_relationships'
+require 'neography/rest/other_node_relationships'
+require 'neography/rest/node_indexes'
+require 'neography/rest/node_auto_indexes'
+require 'neography/rest/node_traversal'
+require 'neography/rest/node_paths'
+require 'neography/rest/node_labels'
+require 'neography/rest/relationships'
+require 'neography/rest/relationship_properties'
+require 'neography/rest/relationship_indexes'
+require 'neography/rest/relationship_auto_indexes'
+require 'neography/rest/relationship_types'
+require 'neography/rest/cypher'
+require 'neography/rest/gremlin'
+require 'neography/rest/extensions'
+require 'neography/rest/batch'
+require 'neography/rest/clean'
+require 'neography/rest/transactions'
+require 'neography/rest/spatial'
+require 'neography/rest/constraints'
+require 'neography/errors'
+require 'neography/connection'
+
+module Neography
+
+  class Rest
+    include Helpers
+    include RelationshipTypes
+    include NodeLabels
+    include SchemaIndexes
+    include Constraints
+    include Transactions
+    include Nodes
+    include NodeProperties
+    include Relationships
+    include RelationshipProperties
+    include NodeRelationships
+    include OtherNodeRelationships
+    include NodeIndexes
+    include NodeAutoIndexes
+    include RelationshipIndexes
+    include RelationshipAutoIndexes
+    include NodeTraversal
+    include NodePaths
+    include Cypher
+    include Gremlin
+    include Batch
+    include Extensions
+    include Spatial
+    include Clean
+    extend Forwardable
+
+    attr_reader :connection
+
+    def_delegators :@connection, :configuration
+
+    def initialize(options = ENV['NEO4J_URL'] || {})
+      @connection = Connection.new(options)
+    end   
+
+    alias_method :list_indexes, :list_node_indexes
+    alias_method :add_to_index, :add_node_to_index
+    alias_method :remove_from_index, :remove_node_from_index
+    alias_method :get_index, :get_node_index
+      
+    def delete_node!(id)
+      relationships = get_node_relationships(get_id(id))
+      relationships.each do |relationship|
+        delete_relationship(relationship["self"].split('/').last)
+      end unless relationships.nil?
+
+      delete_node(id)
+    end
+
+    #  This is not yet implemented in the REST API
+    #
+    # def get_all_node
+    #   puts "get all nodes"
+    #   get("/nodes/")
+    # end
+
+    # relationships
+
+    def get_relationship_start_node(rel)
+      get_node(rel["start"])
+    end
+
+    def get_relationship_end_node(rel)
+      get_node(rel["end"])
+    end     
+    
+  end
+end