architect4r 0.3.2

data/lib/architect4r/core/configuration.rb

@@ -0,0 +1,148 @@
+module Architect4r #:nodoc:
+  module Core #:nodoc:
+    
+    # Architect4r can be configured by creating a config/architect4r file 
+    # and provide environment specific data.
+    #
+    # Thanks to the sunspot-rails gem team, as this class is heavily inspired by their work!
+    #
+    #   development:
+    #     host: localhost
+    #     port: 7474
+    #     log_level: DEBUG
+    #   test:
+    #     host: localhost
+    #     port: 7474
+    #     log_level: OFF
+    #   production:
+    #     host: localhost
+    #     port: 8080
+    #     path: /my_neo_instance
+    #     log_level: WARNING
+    #
+    class Configuration
+      
+      def initialize(options = {})
+        options ||= {}
+        @environment = options.delete(:environment).to_s if options.has_key?(:environment)
+        self.custom_configuration = options.delete(:config) if options.has_key?(:config)
+      end
+      
+      def environment
+        @environment ||= 'development'
+      end
+      
+      def host
+        unless defined?(@hostname)
+          @hostname   = neo4j_url.host if neo4j_url
+          @hostname ||= custom_configuration_from_key('host')
+          @hostname ||= default_hostname
+        end
+        @hostname
+      end
+      
+      def port
+        unless defined?(@port)
+          @port   = neo4j_url.port if neo4j_url
+          @port ||= custom_configuration_from_key('port')
+          @port ||= default_port
+          @port   = @port.to_i
+        end
+        @port
+      end
+      
+      def path
+        unless defined?(@path)
+          @path   = neo4j_url.path if neo4j_url
+          @path ||= custom_configuration_from_key('path')
+          @path ||= default_path
+        end
+        @path
+      end
+      
+      def log_level
+        @log_level ||= (custom_configuration_from_key('log_level') || default_log_level)
+      end
+      
+      def log_file
+        @log_file ||= (custom_configuration_from_key('log_file') || default_log_file_location )
+      end
+      
+      
+      private
+      
+      def default_log_file_location
+        File.join(Dir.pwd, 'log', "architect4r.#{self.environment}.log")
+      end
+      
+      def custom_configuration_from_key( *keys )
+        keys.inject(custom_configuration) do |hash, key|
+          hash[key] if hash
+        end
+      end
+      
+      def custom_configuration=(input)
+        @custom_configuration = if input.is_a?(Hash)
+          input.stringify_keys
+        elsif input.is_a?(String)
+          begin
+            if File.exist?(input)
+              File.open(input) do |file|
+                YAML.load(file)[self.environment]
+              end
+            else
+              {}
+            end
+          end
+        else
+          {}
+        end
+      end
+      
+      def custom_configuration
+        @custom_configuration ||=
+          begin
+            path = File.join(Dir.pwd, 'config', 'architect4r.yml')
+            if File.exist?(path)
+              File.open(path) do |file|
+                YAML.load(file)[self.environment]
+              end
+            else
+              {}
+            end
+          end
+      end
+    
+    protected
+      
+      # Allow the user to configure the server by providing an environment variable 
+      # with a valid url to the neo4j rest endpoint.
+      def neo4j_url
+        URI.parse(ENV['NEO4J_URL']) if ENV['NEO4J_URL']
+      end
+      
+      def default_hostname
+        'localhost'
+      end
+      
+      def default_port
+        { 'test'        => 7475,
+          'development' => 7474,
+          'production'  => 7474
+        }[self.environment]  || 7474
+      end
+      
+      def default_path
+        ''
+      end
+      
+      def default_log_level
+        { 'test'        => 'OFF',
+          'development' => 'INFO',
+          'production'  => 'WARNING'
+        }[self.environment]  || 'INFO'
+      end
+      
+    end
+  end
+end

data/lib/architect4r/core/cypher_methods.rb

@@ -0,0 +1,47 @@
+module Architect4r
+  module Core
+    module CypherMethods
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+        
+        def execute_cypher(query)
+          url = prepend_base_url("/ext/CypherPlugin/graphdb/execute_query")
+          response = Typhoeus::Request.post(url, 
+            :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+            :body => { 'query' => query }.to_json)
+          
+          # Check if there might be an error with the query
+          if response.code == 400
+            raise Architect4r::InvalidCypherQuery.new(query)
+          elsif response.code == 500
+            msg = JSON.parse(response.body)
+            
+            if msg['exception'].to_s.match /org.neo4j.graphdb.NotFoundException/
+              nil
+            else
+              raise Architect4r::InvalidCypherQuery.new(query)
+            end
+          elsif response.code == 204
+            nil
+          else
+            result_data = JSON.parse(response.body)
+            
+            # Convert the columnized result array to hashes within an array
+            results = []
+            
+            result_data['data'].each_with_index do |row, ri|
+              result_row = {}
+              result_data['columns'].each_with_index do |column, ci|
+                result_row[column] = convert_if_possible(row[ci])
+              end
+              results << result_row
+            end
+            results
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/architect4r/core/management_methods.rb

@@ -0,0 +1,129 @@
+module Architect4r
+  module Core
+    module ManagementMethods
+      
+      def get_kernel_data
+        #http://localhost:7475/db/manage/server/jmx/domain/org.neo4j/
+      end
+      
+      # Deletes the database
+      def reset_database!
+        
+      end
+      
+    end
+  end
+end
+
+=begin
+{
+  "beans" : [ {
+    "description" : "Estimates of the numbers of different kinds of Neo4j primitives",
+    "name" : "org.neo4j:instance=kernel#0,name=Primitive count",
+    "attributes" : [ {
+      "description" : "An estimation of the number of nodes used in this Neo4j instance",
+      "name" : "NumberOfNodeIdsInUse",
+      "value" : 109,
+      "isReadable" : "true",
+      "type" : "long",
+      "isWriteable" : "false ",
+      "isIs" : "false "
+    }, {
+      "description" : "An estimation of the number of relationships used in this Neo4j instance",
+      "name" : "NumberOfRelationshipIdsInUse",
+      "value" : 0,
+      "isReadable" : "true",
+      "type" : "long",
+      "isWriteable" : "false ",
+      "isIs" : "false "
+    }, {
+      "description" : "An estimation of the number of properties used in this Neo4j instance",
+      "name" : "NumberOfPropertyIdsInUse",
+      "value" : 295,
+      "isReadable" : "true",
+      "type" : "long",
+      "isWriteable" : "false ",
+      "isIs" : "false "
+    }, {
+      "description" : "The number of relationship types used in this Neo4j instance",
+      "name" : "NumberOfRelationshipTypeIdsInUse",
+      "value" : 0,
+      "isReadable" : "true",
+      "type" : "long",
+      "isWriteable" : "false ",
+      "isIs" : "false "
+    } ],
+    "url" : "org.neo4j/instance%3Dkernel%230%2Cname%3DPrimitive+count"
+  }, {
+    "description" : "Information about the Neo4j kernel",
+    "name" : "org.neo4j:instance=kernel#0,name=Kernel",
+    "attributes" : [ {
+      "description" : "Whether this is a read only instance",
+      "name" : "ReadOnly",
+      "value" : false,
+      "isReadable" : "true",
+      "type" : "boolean",
+      "isWriteable" : "false ",
+      "isIs" : "true"
+    }, {
+      "description" : "An ObjectName that can be used as a query for getting all management beans for this Neo4j instance.",
+      "name" : "MBeanQuery",
+      "value" : "org.neo4j:instance=kernel#0,name=*",
+      "isReadable" : "true",
+      "type" : "javax.management.ObjectName",
+      "isWriteable" : "false ",
+      "isIs" : "false "
+    }, {
+      "description" : "The time from which this Neo4j instance was in operational mode.",
+      "name" : "KernelStartTime",
+      "value" : "Sat Sep 10 17:42:53 CEST 2011",
+      "isReadable" : "true",
+      "type" : "java.util.Date",
+      "isWriteable" : "false ",
+      "isIs" : "false "
+    }, {
+      "description" : "The time when this Neo4j graph store was created.",
+      "name" : "StoreCreationDate",
+      "value" : "Sat Sep 03 20:19:29 CEST 2011",
+      "isReadable" : "true",
+      "type" : "java.util.Date",
+      "isWriteable" : "false ",
+      "isIs" : "false "
+    }, {
+      "description" : "An identifier that uniquely identifies this Neo4j graph store.",
+      "name" : "StoreId",
+      "value" : "a75e32d2bd11e487",
+      "isReadable" : "true",
+      "type" : "java.lang.String",
+      "isWriteable" : "false ",
+      "isIs" : "false "
+    }, {
+      "description" : "The current version of the Neo4j store logical log.",
+      "name" : "StoreLogVersion",
+      "value" : 2,
+      "isReadable" : "true",
+      "type" : "long",
+      "isWriteable" : "false ",
+      "isIs" : "false "
+    }, {
+      "description" : "The version of Neo4j",
+      "name" : "KernelVersion",
+      "value" : "Neo4j - Graph Database Kernel 1.4.1",
+      "isReadable" : "true",
+      "type" : "java.lang.String",
+      "isWriteable" : "false ",
+      "isIs" : "false "
+    }, {
+      "description" : "The location where the Neo4j store is located",
+      "name" : "StoreDirectory",
+      "value" : "/Users/namxam/packages/neo4j-community-1.4.1.test/data/graph.db",
+      "isReadable" : "true",
+      "type" : "java.lang.String",
+      "isWriteable" : "false ",
+      "isIs" : "false "
+    } ],
+    "url" : "org.neo4j/instance%3Dkernel%230%2Cname%3DKernel"
+  } ],
+  "domain" : "org.neo4j"
+}
+=end

data/lib/architect4r/core/node_methods.rb

@@ -0,0 +1,73 @@
+module Architect4r
+  module Core
+    module NodeMethods
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+        
+        def create_node(properties)
+          # Send request
+          response = Typhoeus::Request.post(prepend_base_url('/node'), 
+            :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+            :body => properties.to_json)
+          
+          # Evaluate response
+          response.code == 201 ? JSON.parse(response.body) : nil
+        end
+        
+        def get_node(id)
+          # Example response for a node
+          # extensions: {}
+          # 
+          # paged_traverse: http://localhost:7475/db/data/node/0/paged/traverse/{returnType}{?pageSize,leaseTime}
+          # self: http://localhost:7475/db/data/node/0
+          # property: http://localhost:7475/db/data/node/0/properties/{key}
+          # data: {}
+          # 
+          # incoming_typed_relationships: http://localhost:7475/db/data/node/0/relationships/in/{-list|&|types}
+          # outgoing_typed_relationships: http://localhost:7475/db/data/node/0/relationships/out/{-list|&|types}
+          # incoming_relationships: http://localhost:7475/db/data/node/0/relationships/in
+          # all_relationships: http://localhost:7475/db/data/node/0/relationships/all
+          # create_relationship: http://localhost:7475/db/data/node/0/relationships
+          # traverse: http://localhost:7475/db/data/node/0/traverse/{returnType}
+          # properties: http://localhost:7475/db/data/node/0/properties
+          # all_typed_relationships: http://localhost:7475/db/data/node/0/relationships/all/{-list|&|types}
+          # outgoing_relationships: http://localhost:7475/db/data/node/0/relationships/out
+          
+          # Handle cases where id might be a url
+          
+          response = Typhoeus::Request.get(node_url(id), :headers => { 'Accept' => 'application/json' })
+          response.code == 200 ? JSON.parse(response.body) : nil
+        end
+
+        def update_node(id, properties)
+          # Handle urls
+          url = id.to_i == 0 ? id : node_url(id)
+
+          # Append the properties
+          url += "/properties"
+
+          response = Typhoeus::Request.put(url, 
+            :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+            :body => properties.to_json)
+          response.code == 204 ? true : false
+        end
+        
+        def delete_node(id)
+          # Delete all relationships
+          get_node_relationships(id, :all).each do |rel|
+            delete_relationship(rel)
+          end
+          
+          # Delete node itself
+          response = Typhoeus::Request.delete(node_url(id), :headers => { 'Accept' => 'application/json' })
+          response.code == 204 ? true : false
+        end
+        
+        def root
+          get_node(get('/')['reference_node'])
+        end
+      end
+    end
+  end
+end

data/lib/architect4r/core/relationship_methods.rb

@@ -0,0 +1,82 @@
+module Architect4r
+  module Core
+    module RelationshipMethods
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+        
+        def create_relationship(start_node, end_node, type, properties={})
+          # POST http://localhost:7474/db/data/node/3/relationships
+          # {"to" : "http://localhost:7474/db/data/node/4", "type" : "LOVES"}
+          # 201: Created
+          # Location: http://localhost:7474/db/data/relationship/2
+          
+          # Add the destination node and type to the properties
+          properties = { 'to' => node_url(end_node), 'type' => type.to_s, 'data' => properties }
+          
+          # Send request
+          response = Typhoeus::Request.post(node_url(start_node) + "/relationships", 
+            :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+            :body => properties.to_json)
+          
+          # Evaluate response
+          response.code == 201 ? JSON.parse(response.body) : nil
+        end
+        
+        def get_relationship(relationship)
+          response = Typhoeus::Request.get(relationship_url(relationship), :headers => { 'Accept' => 'application/json' })
+          response.code == 200 ? JSON.parse(response.body) : nil
+        end
+        
+        def delete_relationship(relationship)
+          response = Typhoeus::Request.delete(relationship_url(relationship), :headers => { 'Accept' => 'application/json' })
+          response.code == 204 ? true : false
+        end
+        
+        def get_node_relationships(node, direction = :all, *types)
+          # GET http://localhost:7474/db/data/node/6/relationships/all
+          # GET http://localhost:7474/db/data/node/11/relationships/in
+          # GET http://localhost:7474/db/data/node/16/relationships/out
+          # GET http://localhost:7474/db/data/node/21/relationships/all/LIKES&HATES
+          # 200: OK
+          
+          # Set direction
+          direction = case direction.to_s
+            when 'incoming'
+              'in'
+            when 'outgoing'
+              'out'
+            else
+              'all'
+          end
+          
+          # Create typ filter
+          types = types.map { |e| URI.escape(e) }.join('&')
+          
+          # Send request
+          url = node_url(node) + "/relationships/#{direction}/#{types}"
+          response = Typhoeus::Request.get(url, :headers => { 'Accept' => 'application/json' })
+          response.code == 200 ? JSON.parse(response.body) : []
+        end
+        
+        def update_relationship(id, properties)
+          # PUT http://localhost:7474/db/data/relationship/0/properties
+          # 204: No Content
+          url = relationship_url(id) + '/properties'
+          response = Typhoeus::Request.put(url, 
+            :headers => { 'Accept' => 'application/json', 'Content-Type' => 'application/json' },
+            :body => properties.to_json)
+          response.code == 204 ? true : false
+        end
+        
+        def get_relationship_types
+          # GET http://localhost:7474/db/data/relationship/types
+          # 200: OK
+          response = Typhoeus::Request.get(prepend_base_url('/relationship/types'), :headers => { 'Accept' => 'application/json' })
+          response.code == 200 ? JSON.parse(response.body) : []
+        end
+        
+      end
+    end
+  end
+end