neo4r 0.0.3

data/lib/neo4r/node_traverser.rb

@@ -0,0 +1,154 @@
+module Neo4r
+  # Node traverser class
+  class NodeTraverser
+    include Enumerable
+
+    attr_accessor :order, :uniqueness, :depth, :prune, :filter, :relationships
+    attr_reader :rest
+
+    def initialize(from, types = nil, dir = "all")
+      @rest = RestWrapper.new
+      @from  = from
+      @order = "depth first"
+      @uniqueness = "none"
+      @relationships = []
+      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 = Relationship.create(
+          type: @relationships.first["type"], start: @from, end: other_node)
+      when "incoming", "in"
+        rel = Relationship.create(
+          type: @relationships.first["type"], start: other_node, end: @from)
+      else
+        rel = []
+        rel << Relationship.create(
+          type: @relationships.first["type"], start: @from, end: other_node)
+        rel << Relationship.create(
+          type: @relationships.first["type"], start: other_node, end: @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 = {
+        "language" => "javascript",
+        "body"     => body
+      }
+      self
+    end
+
+    def prune(body)
+      @prune = {
+        "language" => "javascript",
+        "body"     => body
+      }
+      self
+    end
+
+    def depth(d)
+      d = 2_147_483_647 if d == :all
+      @depth = d
+      self
+    end
+
+    def include_start_node
+      @filter = {
+        "language" => "builtin",
+        "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
+      nodes = []
+      iterator.each do |i|
+        node = @from.class.new(i)
+        nodes << node
+        yield node
+      end
+      nodes
+    end
+
+    def iterator
+      options = {
+        "order"         => @order,
+        "uniqueness"    => @uniqueness,
+        "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 = rest.get_node_relationships(
+          @from.neo_id, @relationships[0]["direction"]) || []
+        case @relationships[0]["direction"]
+        when "in"
+          rels.map { |r| rest.get_node(r["start"]) }
+        when "out"
+          rels.map { |r| rest.get_node(r["end"]) }
+        else
+          rels.map do |r|
+            if @from.neo_id == r["start"].split('/').last.to_i
+              rest.get_node(r["end"])
+            else
+              rest.get_node(r["start"])
+            end
+          end
+        end
+      else
+        rest.traverse(@from.neo_id, "nodes", options)
+      end
+    end
+  end
+end

data/lib/neo4r/paginated.rb

@@ -0,0 +1,25 @@
+module Neo4r
+  # The class provides the pagination based on the given source.
+  # The source must be an Enumerable implementing methods drop,
+  # first and count (or size).
+  # This can be used to paginage any Enumerable collection and
+  # provides the integration point for other gems, like
+  # will_paginate and kaminari.
+  class Paginated
+    include Enumerable
+    attr_accessor :items, :total, :current_page
+    delegate :each, to: :items
+
+    def initialize(items, total, current_page)
+      @items = items
+      @total = total
+      @current_page = current_page
+    end
+
+    def self.create_from(source, page, per_page)
+      dup = source.dup
+      partial = dup.offset((page - 1) * per_page).limit(per_page)
+      Paginated.new(partial, dup.count, page)
+    end
+  end
+end

data/lib/neo4r/property_container.rb

@@ -0,0 +1,38 @@
+module Neo4r
+  # Peoperty container class
+  class PropertyContainer < OpenStruct
+    include Neo4r::Attributes
+
+    attr_reader :neo_id, :rest
+
+    def initialize(args = {})
+      @rest = RestWrapper.new
+      if args["self"] && args["data"]
+        @neo_id = args["self"].split("/").last.to_i
+        super(self.class.to_ruby(args["data"]))
+      else
+        super(args)
+      end
+    end
+
+    def is_new?
+      @neo_id.nil?
+    end
+
+    def to_id(target)
+      if target.is_a?(String)
+        target.split("/").last.to_i
+      elsif target.class < PropertyContainer
+        target.neo_id
+      else
+        target
+      end
+    end
+
+    def inspect
+      str = super
+      str.sub!(/ /, "[#{@neo_id}] ") unless @neo_id.nil?
+      str
+    end
+  end
+end

data/lib/neo4r/relation.rb

@@ -0,0 +1,174 @@
+require "neo4r/will_paginate"
+require "neo4r/rest_wrapper"
+
+module Neo4r
+  # Neo4r relation class
+  class Relation
+    include Enumerable
+    include ::Neo4r::WillPaginate
+
+    alias_method :all, :to_a
+    alias_method :size, :count
+
+    def initialize(klass)
+      @klass = klass
+      @labels = klass.name.split("::")
+      @props = {}
+      @has = []
+      @order_by = []
+      @limit = nil
+      @offset = nil
+    end
+
+    def clear
+      @labels = []
+      @props = {}
+      @has = []
+      @order_by = []
+      @limit = nil
+      @offset = nil
+      self
+    end
+
+    def count
+      rest = RestWrapper.new
+      rest.execute_query(to_cypher(return: :count))["data"].first.first
+    end
+
+    def each
+      rest = RestWrapper.new
+      data = rest.execute_query(to_cypher)["data"]
+      data.map do |d|
+        yield @klass.new(d.first)
+      end
+    end
+
+    def labels(*labels)
+      @labels.concat(labels).uniq!
+      self
+    end
+
+    def where(hash)
+      @props.merge!(hash)
+      self
+    end
+
+    def asc(*props)
+      props.each do |prop|
+        @order_by << "a.#{prop}"
+      end
+      self
+    end
+
+    def desc(*props)
+      props.each do |prop|
+        @order_by << "a.#{prop} DESC"
+      end
+      self
+    end
+
+    def limit(n)
+      @limit = n
+      self
+    end
+
+    def offset(n)
+      @offset = n
+      self
+    end
+
+    def has(*props)
+      @has.concat(props).uniq!
+      self
+    end
+
+    def to_cypher(options = {})
+      [
+        to_match,
+        to_where,
+        to_return(options),
+        to_order_by(options),
+        to_skip(options),
+        to_limit(options)
+      ].compact.join("\n")
+    end
+
+    private
+
+    def to_match
+      "MATCH (a#{to_labels}#{to_props})"
+    end
+
+    def to_labels
+      @labels.reduce("") do |result, label|
+        result + ":#{label}"
+      end
+    end
+
+    def to_props
+      format_props = @props.map do |name, value|
+        "#{name}: #{format_value(value)}"
+      end.join(", ")
+
+      if format_props.length > 0
+        " {#{format_props}}"
+      else
+        ""
+      end
+    end
+
+    def format_value(value)
+      case value
+      when String
+        '"' + value.gsub('"', '\"') + '"'
+      else
+        value.to_s
+      end
+    end
+
+    def to_return(options)
+      case options[:return]
+      when :count
+        "RETURN count(a)"
+      else
+        "RETURN a"
+      end
+    end
+
+    def to_order_by(options)
+      if @order_by.length > 0 && options[:return].nil?
+        "ORDER BY " + @order_by.join(", ")
+      else
+        nil
+      end
+    end
+
+    def to_skip(options)
+      if @offset && options[:return].nil?
+        "SKIP #{@offset}"
+      else
+        nil
+      end
+    end
+
+    def to_limit(options)
+      if @limit && options[:return].nil?
+        "LIMIT #{@limit}"
+      else
+        nil
+      end
+    end
+
+    def to_where
+      expr = @has.map do |prop|
+        "HAS (a.#{prop})"
+      end.join(" AND ")
+
+      if expr.length > 0
+        "WHERE #{expr}"
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/neo4r/relationship.rb

@@ -0,0 +1,51 @@
+module Neo4r
+  class Relationship < PropertyContainer
+    def self.create(args)
+      rel = Relationship.new(args)
+      if rel.save
+        rel
+      else
+        nil
+      end
+    end
+
+    attr_reader :start_node_id, :end_node_id, :rel_type
+
+    def initialize(args)
+      super(args)
+      if is_new?
+        @start_node_id = to_id(delete_field(:start))
+        @end_node_id = to_id(delete_field(:end))
+        @rel_type = delete_field(:type)
+      else
+        @start_node_id = to_id(args["start"])
+        @end_node_id = to_id(args["end"])
+        @rel_type = args["type"]
+      end
+    end
+
+    def save
+      if is_new?
+        rel = rest.create_relationship(
+          @rel_type, @start_node_id, @end_node_id, @table)
+        @neo_id = rel["self"].split("/").last.to_i
+      else
+        rest.reset_relationship_properties(@neo_id, @table)
+      end
+      true
+    end
+
+    def destroy
+      rest.delete_relationship(neo_id)
+      true
+    end
+
+    def start_node
+      @start_node ||= Experiment.find(@start_node_id)
+    end
+
+    def end_node
+      @end_node ||= Experiment.find(@end_node_id)
+    end
+  end
+end

data/lib/neo4r/relationship_traverser.rb

@@ -0,0 +1,86 @@
+require "neo4r/relationship"
+
+module Neo4r
+  # Relationship traverser class
+  class RelationshipTraverser
+    include Enumerable
+
+    attr_reader :rest
+
+    def initialize(node, types, direction)
+      @rest = RestWrapper.new
+      @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
+      rels = []
+      iterator.each do |i|
+        rel = Relationship.new(i)
+        rels << rel
+        yield rel if match_to_other?(rel)
+      end
+      rels
+    end
+
+    def empty?
+      first.nil?
+    end
+
+    def iterator
+      Array(rest.get_node_relationships(@node.neo_id, @direction, @types))
+    end
+
+    def match_to_other?(rel)
+      if @to_other.nil?
+        true
+      elsif @direction == :outgoing
+        rel.end_node_id == @to_other.neo_id
+      elsif @direction == :incoming
+        rel.start_node_id == @to_other.neo_id
+      else
+        rel.start_node_id == @to_other.neo_id || rel.end_node_id == @to_other.neo_id
+      end
+    end
+
+    def to_other(to_other)
+      @to_other = to_other
+      self
+    end
+
+    def destroy
+      each { |rel| rel.destroy }
+    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