architect4r 0.3.2

data/lib/architect4r/model/queries.rb

@@ -0,0 +1,38 @@
+module Architect4r
+  module Model
+    module Queries
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+        
+      end
+      
+      module ClassMethods
+        
+        def count(opts = {}, &block)
+          data = connection.execute_cypher("start s=node(#{self.model_root.id}) match (s)<-[:model_type]-(d) return count(d)")
+          data.first['count(d)']
+        end
+        
+        def find_by_id(id)
+          data = connection.execute_cypher("start s=node(#{self.model_root.id}), d=node(#{id.to_i}) match s<-[r:model_type]-d return d")
+          data &&= data.first && data.first['d']
+          self.build_from_database(data)
+        end
+        
+        def find_by_id!(id)
+          raise 'not implemented'
+        end
+        
+        def find_by_cypher(query, identifier)
+          if data = connection.execute_cypher(query)
+            data.map { |item| build_from_database(item[identifier]) }
+          else
+            nil
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/architect4r/model/relationship.rb

@@ -0,0 +1,105 @@
+module Architect4r
+  module Model
+    class Relationship
+      
+      #
+      # Architect4r extensions
+      #
+      include Architect4r::Model::Connection
+      include Architect4r::Model::Callbacks
+      include Architect4r::Model::Persistency
+      
+      
+      def self.inherited(subklass)
+        super
+        subklass.send(:include, ActiveModel::Conversion)
+        subklass.extend ActiveModel::Naming
+        subklass.send(:include, Architect4r::Model::Properties)
+        subklass.send(:include, Architect4r::Model::Validations)
+        
+        subklass.class_exec do
+          # Validations
+          validates :source, :presence => true
+          validates :destination, :presence => true
+        end
+      end
+      
+      #
+      # Virtual attributes
+      #
+      attr_accessor :source, :destination, :raw_data
+      
+      #
+      # Instance methods
+      #
+      
+      def initialize(*args)
+        # Detect source and destination
+        if s = args[0].is_a?(Architect4r::Model::Node) && args.shift
+          self.source = s
+          
+          if d = args[0].is_a?(Architect4r::Model::Node) && args.shift
+            self.destination = d
+          end
+        end
+        
+        # Detect properties
+        properties = args[0].is_a?(Hash) && args.shift
+        properties ||= {}
+        parse_properties(properties)
+      end
+      
+      # Create the document. Validation is enabled by default and will return
+      # false if the document is not valid. If all goes well, the document will
+      # be returned.
+      def create(options = {})
+        run_callbacks :create do
+          run_callbacks :save do
+            # only create valid records
+            return false unless perform_validations(options)
+            
+            # perform creation
+            if result = connection.create_relationship(self.source.id, self.destination.id, self.class.name, self._to_database_hash)
+              self.raw_data = result
+            end
+            
+            # if something goes wrong we receive a nil value and return false
+            !result.nil?
+          end
+        end
+      end
+      
+      # Trigger the callbacks (before, after, around)
+      # only if the document isn't new
+      def update(options = {})
+        run_callbacks :update do
+          run_callbacks :save do
+            # Check if record can be updated
+            raise "Cannot save a destroyed document!" if destroyed?
+            raise "Calling #{self.class.name}#update on document that has not been created!" if new?
+            
+            # Check if we can continue
+            return false unless perform_validations(options)
+            
+            # perform update
+            result = connection.update_relationship(self.id, self._to_database_hash)
+            
+            # if something goes wrong we receive a nil value and return false
+            !result.nil?
+          end
+        end
+      end
+      
+      def destroy
+        run_callbacks :destroy do
+          if result = connection.delete_relationship(self.id)
+            @_destroyed = true
+            self.freeze
+          end
+          result
+        end
+      end
+      
+    end
+  end
+end

data/lib/architect4r/model/relationships.rb

@@ -0,0 +1,16 @@
+module Architect4r
+  module Model
+    module Relationships
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+        
+        def links
+          @links_query_interface = LinksQueryInterface.new(self)
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/architect4r/model/validations.rb

@@ -0,0 +1,11 @@
+module Architect4r
+  module Model
+    module Validations
+      extend ActiveSupport::Concern
+      include ActiveModel::Validations
+      
+      # just in case that we want to add some more sugar
+      
+    end
+  end
+end

data/lib/architect4r/server.rb

@@ -0,0 +1,96 @@
+require 'json'
+require 'typhoeus'
+
+module Architect4r
+  
+  class Server
+    
+    include Architect4r::Core::CypherMethods
+    include Architect4r::Core::NodeMethods
+    include Architect4r::Core::RelationshipMethods
+    
+    def initialize(config=nil)
+      @server_config = config
+    end
+    
+    def configuration
+      @configuration ||= Core::Configuration.new(@server_config)
+    end
+    
+    # Basic rest actions
+    
+    def get(url, options = {})
+      response = Typhoeus::Request.get(prepend_base_url(url), :headers => { 'Accept' => 'application/json' })
+      response.success? ? JSON.parse(response.body) : nil
+    end
+    
+    def post(url, params = {})
+      response = Typhoeus::Request.post(prepend_base_url(url), :params => params)
+      response.success? ? JSON.parse(response.body) : nil
+    end
+    
+    def put(url, params = {})
+      response = Typhoeus::Request.put(prepend_base_url(url), :params => params)
+      response.success? ? JSON.parse(response.body) : nil
+    end
+    
+    def delete
+      response = Typhoeus::Request.delete(prepend_base_url(url), :params => params)
+      response.success? ? JSON.parse(response.body) : nil
+    end
+    
+    protected
+    
+    def prepend_base_url(url)
+      if url[0,4] == "http"
+        url
+      else
+        "http://#{configuration.host}:#{configuration.port}#{configuration.path}/db/data#{url}"
+      end
+    end
+    
+    def node_url(url_or_id)
+      if url_or_id.is_a?(Hash)
+        url_or_id['self'].to_s
+      elsif url_or_id.to_s != '0' and url_or_id.to_i == 0
+        url_or_id.to_s
+      else
+        prepend_base_url("/node/#{url_or_id.to_i}")
+      end
+    end
+    
+    def relationship_url(url_or_id)
+      if url_or_id.is_a?(Hash)
+        url_or_id['self'].to_s
+      elsif url_or_id.to_s != '0' and url_or_id.to_i == 0
+        url_or_id.to_s
+      else
+        prepend_base_url("/relationship/#{url_or_id.to_i}")
+      end
+    end
+    
+    def convert_if_possible(data)
+      data
+    end
+    
+  end
+  
+  
+end
+
+
+=begin
+
+  Example service root response
+    extensions: 
+      CypherPlugin: 
+        execute_query: http://localhost:7475/db/data/ext/CypherPlugin/graphdb/execute_query
+      GremlinPlugin: 
+        execute_script: http://localhost:7475/db/data/ext/GremlinPlugin/graphdb/execute_script
+    relationship_types: http://localhost:7475/db/data/relationship/types
+    relationship_index: http://localhost:7475/db/data/index/relationship
+    reference_node: http://localhost:7475/db/data/node/0
+    node: http://localhost:7475/db/data/node
+    extensions_info: http://localhost:7475/db/data/ext
+    node_index: http://localhost:7475/db/data/index/node
+=end

data/lib/architect4r/version.rb

@@ -0,0 +1,3 @@
+module Architect4r
+  VERSION = "0.3.2"
+end

data/spec/architect4r_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Architect4r do
+  
+  it 'should return correct version string' do
+    Architect4r.version.should == "Architect4r version #{Architect4r::VERSION}"
+  end
+  
+end

data/spec/core/configuration_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Architect4r::Core::Configuration do
+  
+  describe "default configuration" do
+    subject { Architect4r::Core::Configuration.new }
+    
+    its(:host) { should == 'localhost' }
+    its(:port) { should == 7474 }
+    its(:path) { should == '' }
+    its(:log_level) { should == 'INFO' }
+    
+    context "in test environment" do
+      subject { Architect4r::Core::Configuration.new(:environment => :test) }
+      
+      its(:host) { should == 'localhost' }
+      its(:port) { should == 7475 }
+      its(:path) { should == '' }
+      its(:log_level) { should == 'OFF' }
+    end
+    
+    context "in production environment" do
+      subject { Architect4r::Core::Configuration.new(:environment => :production) }
+      
+      its(:host) { should == 'localhost' }
+      its(:port) { should == 7474 }
+      its(:path) { should == '' }
+      its(:log_level) { should == 'WARNING' }
+    end
+    
+  end
+  
+  describe "provided by hash" do
+    subject { Architect4r::Core::Configuration.new(:environment => :development, :config => { :host => 'neo4j.local', :port => '80', :path => 'dev', :log_level => 'ERROR', :log_file => '/tmp/neo.log' }) }
+    
+    its(:host) { should == 'neo4j.local' }
+    its(:port) { should == 80 }
+    its(:path) { should == 'dev' }
+    its(:log_level) { should == 'ERROR' }
+    its(:log_file) { should == '/tmp/neo.log' }
+    
+  end
+  
+  describe "provided by a custom config file" do
+    subject { Architect4r::Core::Configuration.new(:environment => :staging, :config => File.join(Dir.pwd, 'spec', 'fixtures', 'architect4r.yml')) }
+    
+    its(:host) { should == 'staging.dev' }
+    its(:port) { should == 8080 }
+    its(:path) { should == 'my_neo_instance' }
+    its(:log_level) { should == 'WARNING' }
+    
+  end
+  
+end

data/spec/core/cypher_methods_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Architect4r::Server do
+  
+  subject { TEST_SERVER }
+  
+  describe :execute_cypher do
+    
+    it "should return an array of nodes" do
+      # nodes
+      #results = subject.execute_cypher("start root = (#{subject.root_node.id}) match (root)-[r:model_root]->(x) return r")
+      pending
+    end
+    
+    it "should return an array of relationships" do
+      # relations
+      #results = subject.find_by_cypher("start root = (#{subject.root_node.id}) match (root)-[r:model_root]->(x) return r")
+      pending
+    end
+    
+    it "should the data unprocessed" do
+      #results = subject.execute_cypher("start node = (0) return node,node.name?")
+      #results.should_not be_empty
+      pending
+    end
+    
+  end
+  
+end

data/spec/core/node_methods_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Architect4r::Server do
+  
+  subject { TEST_SERVER }
+  
+  it "should create a node" do
+    result = subject.create_node({ 'name' => 'My test node', 'friends' => 13 })
+    result.should be_a(Hash)
+    result['self'].should be_a(String)
+  end
+  
+  it "should get a node" do
+    result = subject.get_node(0)
+    result.should be_a(Hash)
+    result['self'].should be_a(String)
+  end
+  
+  it "should delete a node" do
+    # Create a node which can be deleted
+    node = subject.create_node({ 'test' => 'test' })
+    node.should be_a(Hash)
+    
+    # Delete the node
+    subject.delete_node(node['self'])
+    
+    # Check if it still exists
+    subject.get_node(node['self']).should be_nil
+  end
+  
+  it "should update a nodes properties" do
+    # Create a node which can be deleted
+    original_node = subject.create_node({ 'test1' => 'test', 'test2' => 'hello' })
+    original_node.should be_a(Hash)
+    
+    # Update some attributes
+    result = subject.update_node(original_node['self'], { 'test1' => 'world', 'test3' => 'word'})
+    result.should be_true
+    
+    # check result
+    changed_node = subject.get_node(original_node['self'])
+    changed_node['data']['test1'].should == 'world'
+    changed_node['data'].has_key?('test2').should be_false
+    changed_node['data']['test3'].should == 'word'
+  end
+
+end

data/spec/core/relationship_methods_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe Architect4r::Server do
+  
+  subject { TEST_SERVER }
+  
+  before(:all) do
+    # Lets create two nodes we can work with
+    @node1 = subject.create_node({ 'name' => 'first test node' })
+    @node2 = subject.create_node({ 'name' => 'second test node' })
+  end
+  
+  after(:all) do
+    # Lets create two nodes we can work with
+    subject.delete_node(@node1)
+    subject.delete_node(@node2)
+  end
+  
+  it "should create and delete a new relationship" do
+    result = subject.create_relationship(@node1, @node2, 'friendship', { 'reason' => 'Because I really like you!' })
+    result.should be_a(Hash)
+    subject.delete_relationship(result)
+  end
+  
+  it "should allow creating relationships without properties" do
+    result = subject.create_relationship(@node1, @node2, 'friendship')
+    result.should be_a(Hash)
+    subject.delete_relationship(result)
+  end
+  
+  it "should allow filtering relationships by direction" do
+    # create test nodes
+    n1 = subject.create_node({ 'name' => 'first test node' })
+    n2 = subject.create_node({ 'name' => 'second test node' })
+    
+    # create relationships
+    subject.create_relationship(n1, n2, 'relation')
+    subject.create_relationship(n1, n2, 'relation2')
+    subject.create_relationship(n2, n1, 'relation3')
+    
+    # test node direction
+    subject.get_node_relationships(n1).size.should == 3
+    subject.get_node_relationships(n1, :all).size.should == 3
+    subject.get_node_relationships(n1, :outgoing).size.should == 2
+    subject.get_node_relationships(n1, :incoming).size.should == 1
+    
+    # test relation type
+    subject.get_node_relationships(n1, :all, 'relation').size.should == 1
+    subject.get_node_relationships(n1, :outgoing, 'relation').size.should == 1
+    subject.get_node_relationships(n1, :incoming, 'relation').size.should == 0
+    subject.get_node_relationships(n1, :all, 'relation', 'relation2').size.should == 2
+    
+    # Clean up
+    subject.delete_node(n1)
+    subject.delete_node(n2)
+  end
+  
+  it "should retrieve all relationships" do
+    subject.get_node_relationships(0).should be_a(Array)
+  end
+  
+  it "should load a relationship" do
+    node = subject.create_node({ 'name' => 'A test node' })
+    rel = subject.create_relationship(node, node, 'test', { 'some' => 'data' })
+    data = subject.get_relationship(rel)
+    data.should be_a(Hash)
+    data['data']['some'].should == 'data'
+  end
+  
+  it "should update a nodes properties" do
+    node = subject.create_node({ 'name' => 'A test node' })
+    original_rel = subject.create_relationship(node, node, 'self-reference', { 'note' => 'Some random note', 'obsolete' => '1' })
+    original_rel.should be_a(Hash)
+    
+    # Update some attributes
+    result = subject.update_relationship(original_rel, { 'note' => 'Some changed note', 'highlight' => 'note'})
+    result.should be_true
+    
+    # check result
+    changed_rel = subject.get_relationship(original_rel)
+    changed_rel['data']['note'].should == 'Some changed note'
+    changed_rel['data'].has_key?('obsolete').should be_false
+    changed_rel['data']['highlight'].should == 'note'
+  end
+  
+  it "should know about all relationship types" do
+    node = subject.create_node({ 'name' => 'A test node' })
+    subject.create_relationship(node, node, 'self-reference')
+    subject.get_relationship_types.should include('self-reference')
+  end
+
+end