neon 0.1.0

data/lib/helpers/transaction_helpers.rb

@@ -0,0 +1,56 @@
+module Neon
+  module TransactionHelpers
+    module Rest
+      def  run_rest_transaction(method, *args, &block)
+        if @session.auto_tx
+          yield
+        else
+          # Fetch the query for this method
+          query = query_for method, *args
+          tx = @session.begin_tx
+          result = tx.run_query query
+          tx.success
+          tx.close
+          result = parse_result(result, method, *args)
+        end
+      end
+    end
+
+    module Embedded
+      # Used by objects to run a block of code inside a fresh transaction associated
+      def run_in_transaction(&block)
+        # Retrieve appropriate session based on current type
+        # REST:
+        #   Session: self
+        #   Entity: @session
+        # Embedded:
+        #   Session: self
+        #   Entity: get_graph_database
+        if respond_to?(:get_graph_database)
+          begin
+            tx = get_graph_database.begin_tx
+            result = yield if block_given?
+            tx.success
+            tx.close
+          rescue Exception => e
+            # Roll back the transaction
+            tx.failure
+            tx.close
+            raise e # Let the exception bubble up
+          end
+        else
+          session = @session || self
+          result = if session.auto_tx
+                        r = Transaction.run(session, &block)
+                        r.pop
+                        r = r.pop if r.length == 1
+                        r
+                      else
+                        yield if block_given?
+                      end
+        end
+        result
+      end
+    end
+  end
+end

data/lib/neon.rb

@@ -0,0 +1,23 @@
+require "helpers/argument_helpers"
+require "helpers/transaction_helpers"
+require "neon/session"
+require "neon/property_container"
+require "neon/node"
+require "neon/node/rest"
+require "neon/relationship"
+require "neon/relationship/rest"
+require "neon/transaction"
+require "neon/transaction/placebo"
+require "neon/transaction/rest"
+
+# If the platform is Java then load all java related files.
+if RUBY_PLATFORM == 'java'
+  require "java"
+  require "neo4j-community"
+  require "neon/node/embedded"
+  require "neon/relationship/embedded"
+end
+
+# @author Ujjwal Thaakar
+module Neon
+end

data/lib/neon/Gemfile

@@ -0,0 +1,8 @@
+source 'http://rubygems.org'
+ruby 'rbx'
+
+# The API is written in grap
+gem 'grape'
+
+# Use Puma for the web server
+gem 'puma'

data/lib/neon/node.rb

@@ -0,0 +1,48 @@
+require "helpers/argument_helpers"
+
+module Neon
+  module Node
+    extend ArgumentHelpers
+
+    class << self
+      # Creates a new Node in the database. All subsequent changes are immediately persisted.
+      #
+      # @overload new(attributes, labels, session)
+      #   @param attributes [Hash] the properties to initialize the node with.
+      #   @param labels [String, Symbol, Array<String, Symbol>] an optional list of labels or an array of labels. Labels can be strings or symbols.
+      #   @param session [Session] an optional session can be provided as the last value to indicate the database where to create the node.
+      #     If none is provided then the current session is assumed.
+      #
+      # @return [Node] a new node.
+      def new(attributes, *args)
+        session = extract_session(args)
+        labels = args.flatten
+        begin
+          session.create_node(attributes, labels)
+        rescue NoMethodError => e
+          _raise_invalid_session_error(session, e)
+        end
+      end
+
+      # Loads an existing node with the given id
+      #
+      # @param id [Integer] the id of the node to be loaded and returned.
+      # @param session [Session] an optional session from where to load the node.
+      #
+      # @return [Node] an existing node with the given id and specified session. It returns nil if the node is not found.
+      def load(id, session = Neon::Session.current)
+        begin
+          session.load(id)
+        rescue NoMethodError => e
+          _raise_invalid_session_error(session, e)
+        end
+      end
+
+      private
+        def _raise_invalid_session_error(session, e)
+          STDERR.puts e
+          raise Neon::Session::InvalidSessionTypeError.new(session.class)
+        end
+    end
+  end
+end

data/lib/neon/node/embedded.rb

@@ -0,0 +1,31 @@
+# Extend the Java NodeProxy
+Java::OrgNeo4jKernelImplCore::NodeProxy.class_eval do
+  include Neon::PropertyContainer::Embedded
+  include Neon::TransactionHelpers
+
+  def to_s
+    "Embedded Node[#{getId}]"
+  end
+
+  def create_rel_to(end_node, name, attributes = {})
+    run_in_transaction { _create_rel_to end_node, name, attributes }
+  end
+
+  private
+    def _destroy
+      get_relationships.each { |r| r.delete }
+      delete
+    end
+
+    def _create_rel_to(end_node, name, attributes)
+      return nil if get_graph_database != end_node.get_graph_database
+      type = Java::OrgNeo4jGraphdb::DynamicRelationshipType.with_name(name)
+      rel = create_relationship_to(end_node, type)
+      if (rel.isType(type))
+        rel.props = attributes
+        rel
+      else
+        nil
+      end
+    end
+end

data/lib/neon/node/rest.rb

@@ -0,0 +1,109 @@
+require "neon/property_container"
+
+module Neon
+  module Node
+    class Rest
+      include PropertyContainer::Rest
+      attr_reader :session # The Rest session this node belongs to.
+      attr_reader :id # The neo id of this node.
+      attr_reader :node # The neography hash containing information about the node.
+
+      # Initialize the node with a neography node and a REST session
+      #
+      # @param node [Hash] a neogrpahy node hash.
+      # @param session [Session::Rest] the session this node was initialized to.
+      #
+      # @return [Node::Rest] a new rest node.
+      def initialize(node, session)
+        @session = session # Set the session
+        @node = node # Set the node
+        @id = node["self"].split('/').last.to_i # Set the id
+      end
+
+      def to_s
+        "REST Node[#{@id}]"
+      end
+
+      # Create a unidirectional relationship starting from this node to another node.
+      #
+      # @param end_node [Node::Rest] the end node for the unidirectional relationship.
+      # @param type [String, Symbol] the type of this relationship.
+      # @param attributes [Hash] a hash of the initial property-value pairs.
+      #
+      # @return [Relationship::Rest] a new relationship between *start_node* and *end_node*.
+      def create_rel_to(end_node, type, attributes = {})
+        return nil if @session.url != end_node.session.url
+        attributes.delete_if { |key, value| value.nil? }
+        neo_rel = @session.neo.create_relationship(type, @node, end_node.node, attributes)
+        return nil if neo_rel.nil?
+        rel = Relationship::Rest.new(neo_rel, @session)
+      rescue NoMethodError => e
+        _raise_doesnt_exist_anymore_error(e)
+      end
+
+      # Move to a separate file
+      QUERIES = {
+        :[] => lambda do |node, *keys|
+          query = "START n = node({id})\nWITH "
+          query << keys.map { |key| "n.#{key.to_s.strip} as #{key.to_s.strip}" }.join(", ")
+          query << "\nRETURN "
+          query << keys.map { |key| key.to_s.strip }.join(", ")
+          [query, {id: node.id}]
+        end
+      }
+
+      def query_for(method, *args)
+        # Fetch appropriate query and covert the args to a hash corresponding the query parameters
+        QUERIES[method].call(self, *args)
+      end
+
+      # Move to a seprate file
+      RESULT_PARSER = {
+        :[] => lambda do |result, *keys|
+          parsed_result = []
+          result = result.first
+          columns = result["columns"]
+          data = result["data"].first["row"].dup
+          raise "Corrupted result" if columns.length != keys.length
+          for i in 0...keys.length
+            parsed_result << if keys[i] == columns[i]
+                              data.shift
+                            else
+                              nil
+                            end
+          end
+          if keys.length == 1
+            parsed_result.pop
+          else
+            parsed_result
+          end
+        end
+      }
+
+      def parse_result(result, method, *args)
+        RESULT_PARSER[method].call(result, *args)
+      end
+
+      private
+        def _get_properties(*keys)
+          @session.neo.get_node_properties(@node, *keys)
+        end
+
+        def _reset_properties(attributes)
+          @session.neo.reset_node_properties(@node, attributes)
+        end
+
+        def _set_private_vars_to_nil
+          @node = @session = nil
+        end
+
+        def _delete
+          @session.neo.delete_node(@node)
+        end
+
+        def _destroy
+          @session.neo.delete_node!(@node)
+        end
+    end
+  end
+end

data/lib/neon/property_container.rb

@@ -0,0 +1,277 @@
+module Neon
+  # A module to contain REST and Embedded implementation for a property container namely nodes and relationships
+  # @author Ujjwal Thaakar
+  module PropertyContainer
+    # Server implementation for a property container
+    module Rest
+      include TransactionHelpers::Rest
+      # Compares to anothe property container
+      #
+      # @param other [PropertyContainer] the other property container being compared to
+      #
+      # @return [Boolean] wether both are the same entities based on their ids and sessions
+      def ==(other)
+        @id == other.id && @session == other.session
+      end
+
+      # Fetch one or more properties e.g. node[:property, :another_Property]. Non existent keys return nil.
+      #
+      # @param keys [Array<String, Symbol>] the properties to return
+      #
+      # @return [Array<String>, String] an array of the values of the properties, sorted in the same order they were queried.
+      #   In case only a single property is fetche e.g. node[ :property] it returns a String containing the corresponding value.
+      def [](*keys)
+        # Lesson Learnt
+        # ==============
+        # Don't change what doesn't belong to you
+        keys = keys.map(&:to_s)
+        run_in_transaction(:[], *keys) do
+          properties = props # Fetch all properties as this is more efficient than firing a HTTP request for every key
+          result = []
+          keys.each { |k| result << properties[k] }
+          # If a single key was asked then return it's value else return an array of values in the correct order
+          if keys.length == 1
+            result.first
+          else
+            result
+          end
+        end
+      rescue NoMethodError => e
+        _raise_doesnt_exist_anymore_error(e)
+      end
+
+      # Set one or more properties e.g. node[:property, :another_property] = 5, "Neo4J". nil keys are ignored.
+      #
+      # @param keys [Array<String, Symbol>] the properties to set.
+      # @param values [Array<Numeric, String, Symbol, Array<Numeric, String, Symbol>>] the value to assign to the properties in the order specified.
+      #
+      # @return [void]
+      def []=(*keys, values)
+        # Flattent the values to 1 level. This creates an arrray of values in the case only a single value is provided.
+        values = [values].flatten(1)
+        keys = keys.map(&:to_s)
+        run_in_transaction(:[]=, *keys, values) do
+          properties = props
+          Hash[keys.zip(values)].each { |k, v| properties[k] = v unless k.nil? }
+          self.props = properties # Reset all the properties - write simple inefficient code until it proves inefficient
+        end
+      rescue NoMethodError => e
+        _raise_doesnt_exist_anymore_error(e)
+      end
+
+      # Return all properties of the property container.
+      #
+      # @return [Hash] a hash of all properties and their values.
+      def props
+        run_in_transaction(:props) do
+          _get_properties || {}
+        end
+      rescue NoMethodError => e
+        _raise_doesnt_exist_anymore_error(e)
+      end
+
+      # Reset all properties of the property container.
+      #
+      # @param attributes [Hash] a hash of the key-value pairs to set.
+      #
+      # @return [void]
+      def props=(attributes)
+        attributes.delete_if { |key, value| key.nil? || value.nil? } # Remove keys-value pairs where either is nil
+        run_in_transaction(:props=, attributes) do
+          _reset_properties(attributes)
+          return
+        end
+      rescue NoMethodError => e
+        _raise_doesnt_exist_anymore_error(e)
+      end
+
+      # Delete this entity.
+      def del
+        run_in_transaction(:del) do
+          _delete
+          _set_private_vars_to_nil
+        end
+      rescue NoMethodError => e
+        _raise_doesnt_exist_anymore_error(e)
+      end
+
+      # Destroy this entity i.e. delete it and it's associated entities e.g. relationships of a node
+      # and in case of relationships, both its nodes.
+      def destroy
+        run_in_transaction(:destroy) do
+          _destroy # Delete the entity after deleting connected entities
+          _set_private_vars_to_nil
+        end
+      rescue NoMethodError => e
+        _raise_doesnt_exist_anymore_error(e)
+      end
+
+      private
+        def _raise_doesnt_exist_anymore_error(e)
+          unless @session.nil?
+            STDERR.puts e
+            raise e 
+          end
+        end
+
+        def _abstract
+          raise "No properties"
+        end
+
+        alias :_get_properties :_abstract
+        alias :_reset_properties :_abstract
+        alias :_set_private_vars_to_nil :_abstract
+        alias :_delete :_abstract
+        alias :_destroy :_abstract
+        alias :query_for :_abstract
+        alias :parse_result :_abstract
+    end
+
+    # Embedded implementation for a property container
+    module Embedded
+      include TransactionHelpers::Embedded
+      def self.included(klazz)
+        raise "Cannot include PropertyContainer::Embedded without JRuby" unless RUBY_PLATFORM == 'java'
+      end
+
+      # @return [FixNum] the id of the entity.
+      def id
+        get_id
+      end
+
+      # Compares to anothe property container
+      #
+      # @param other [PropertyContainer] the other property container being compared to
+      #
+      # @return [Boolean] wether both are the same entities based on their ids and sessions
+      def ==(other)
+        id == other.id
+      end
+
+      # Fetch one or more properties e.g. node[:property, :another_Property]. Non existent keys return nil.
+      #
+      # @param keys [Array<String, Symbol>] the properties to return
+      #
+      # @return [Array<String>, String] an array of the values of the properties, sorted in the same order they were queried.
+      #   In case only a single property is fetche e.g. node[ :property] it returns a String containing the corresponding value.
+      def [](*keys)
+        run_in_transaction do
+          keys = _serialize(keys)
+          result = []
+          keys.each do |k|
+            # Result contains the values for the keys asked or nil if they key does not exist
+            result << if has_property(k)
+              get_property(k)
+            else
+              nil
+            end
+          end
+          # If a single key was asked then return it's value else return an array of values in the correct order
+          if keys.length == 1
+            result.first
+          else
+            result
+          end
+        end
+      end
+
+      # Set one or more properties e.g. node[:property, :another_property] = 5, "Neo4J". nil keys are ignored.
+      #
+      # @param keys [Array<String, Symbol>] the properties to set.
+      # @param values [Array<Numeric, String, Symbol, Array<Numeric, String, Symbol>>] the value to assign to the properties in the order specified.
+      #
+      # @return [void]
+      def []=(*keys, values)
+        run_in_transaction do
+          # Flattent the values to 1 level. This creates an arrray of values in the case only a single value is provided.
+          values = [values].flatten(1)
+          attributes = Hash[keys.zip values]
+          nil_values = lambda { |_, v| v.nil? } # Resusable lambda
+          keys_to_delete = attributes.select(&nil_values).keys # Get the keys to be removed
+          attributes.delete_if(&nil_values) # Now remove those keys from attributes
+          keys_to_delete.each { |k| remove_property(k) if has_property(k) } # Remove the keys to be deleted if they are valid
+          attributes = _serialize(attributes)
+          attributes.each { |k, v| set_property(k, v) } # Set key-value pairs for remaining attributes
+        end
+      end
+
+      # Return all properties of the property container.
+      #
+      # @return [Hash] a hash of all properties and their values.
+      def props
+        run_in_transaction do
+          result = {} # Initialize results
+          get_property_keys.each { |key| result[key] = get_property(key) } # Populate the hash with the container's key-value pairs
+          result # Return the result
+        end
+      end
+
+      # Reset all properties of the property container.
+      #
+      # @param attributes [Hash] a hash of the key-value pairs to set.
+      #
+      # @return [void]
+      def props=(attributes)
+        run_in_transaction do
+          attributes.delete_if { |key, value| key.nil? || value.nil? } # Remove keys-value pairs where either is nil before serialization
+          attributes = _serialize(attributes)
+          get_property_keys.each { |key| remove_property(key) } # Remove all properties
+          attributes.each { |key, value| set_property(key, value) } # Set key-value pairs
+        end
+      end
+
+      # Delete this entity
+      def del
+        run_in_transaction { delete }
+      end
+
+      # Destroy this entity i.e. delete it and it's associated entities e.g. relationships of a node
+      # and in case of relationships, both its nodes.
+      def destroy
+        run_in_transaction { _destroy }
+      end
+
+      private
+        # Serialize keys and values into approiate type for conversion to Java objects
+        def _serialize(*objects)
+          result = objects.map do |obj|
+            if obj.is_a?(Hash)
+              _serialize_hash(obj)
+            else
+              _appropriate_type_for obj
+            end
+          end
+          if objects.length == 1
+            result.first
+          else
+            result
+          end
+        end
+
+        # Convert all keys to strings and values to an appropriate type
+        def _serialize_hash(hash)
+          attributes = {}
+          hash.each { |key, value| attributes[key.to_s] = _appropriate_type_for value }
+          attributes
+        end
+
+        def _appropriate_type_for(value)
+          case value
+          when String, Numeric, TrueClass, FalseClass
+            value # Will be converted by JRuby
+          when Array
+            # Convert each of the elements to an appropriate type
+            # Convert to a Java array of the first element's type. If the types of all elements don't match then the runtime raises an exception.
+            result = value.map { |v| _appropriate_type_for v }
+            result.to_java(result.first.class.to_s.downcase.to_sym)
+          else
+            value.to_s # Try and convert to a string
+          end
+        end
+
+        def _destroy
+          raise "No properties"
+        end
+    end
+  end
+end