neoon 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b1ff7ac30436f19194698ede55cfe68529918122
-  data.tar.gz: 3b62de2caf2e48745e2f67d9705490b5cfe43e48
+  metadata.gz: 28243d5e5b0830a48aa0df05d3b94dfc9b7bf3b7
+  data.tar.gz: 5d7b6ea2499ed9302ae792a566410a33a60047fe
 SHA512:
-  metadata.gz: a5baa0e81c289446fee6744879834a45a878b976d265c10c871b0b666bdcc9c69f581108a665c1959533e0f73ae9241a2247da2d822043ac5ff8d084e708b0ed
-  data.tar.gz: dcb1ea83f6b94370962a93f9a829833f2a1e1f6f882e1ea4458b530f56f8776b078644433bce4090b99b56b683743fae9e444ad645db6234a0be490497ee1026
+  metadata.gz: f5be28a492cfdfbfc9356c9e7eb69b5511df51d5cb90353b857dfc195a46a489d8e9f0e9d719d0e34a056d11ee77a13bd64e0394575c485ea29bb9f91711b6f7
+  data.tar.gz: 603ac48d81ef63a99a6004d64356a5cadfe9345a83e79568ffa262c3f4a20380990cbe64717a7ad8be80c24d753f5d8f7bde1223b3f4d61700cd0f4525e1bc54

data/README.md

@@ -83,12 +83,12 @@ end
 This will be used internally to auto index models nodes.
 
 ```ruby
-Topic.neo_index_list #=> [:name, :slug]
+Topic.neo_index_list #=> { :name => true, :slug => "UNIQUENESS" }
 
 #
 # Sync the indexed nodes as described in each model config. It returns the indexed fields.
 # Remember, this will be called on each model on the boot if preload_models set to true.
-Topic.neo_schema_update #=> [:name, :slug]
+Topic.neo_schema_update #=> { :name => true, :slug => "UNIQUENESS" }
 ```
 
 ---
@@ -98,13 +98,13 @@ Topic.neo_schema_update #=> [:name, :slug]
 `Neoon::Cypher::InstanceQuery` should be initialized with an Class name or `label`. You can use `Neoon::Cypher::Query` to manually create indexes, constraints, etc.
 
 ```ruby
-l = Neoon::Cypher::Query.new('Person') #=> #<Neoon::Cypher::Query:0x007fe8926d2068 @label="Person">
+l = Neoon::Cypher::Query.new('Person')
 
-l.create_index(:name).run
-# l.drop_index(:name).run
+l.create_index(:name)
+# l.drop_index(:name)
 
-l.create_constraint(:username).run
-# l.drop_constraint(:username).run
+l.create_constraint(:username)
+# l.drop_constraint(:username)
 
 l.list_indexes                         #=> { :name => true, :username => "UNIQUENESS" }
 ```
@@ -121,25 +121,25 @@ Use it with Struct:
 
 ```ruby
 Customer = Struct.new(:id, :neo_node_properties)
-cus = Customer.new(50, {:name => 'Julie', :address => 'PS'}) #=> #<Neoon::Cypher::InstanceQuery:0x007feb35953d00 @id=50, @label="Customer", @args={:name=>"Julie", :address=>"PS"}>
+cus = Customer.new(50, {:name => 'Julie', :address => 'PS'})
 
 c = Neoon::Cypher::InstanceQuery.new(cus)
 
-c.find_node.run    #=> Return node in Neo4j if already saved
-c.create_node.run  #=> Create object node / or update it
-c.delete_node.run  #=> Remove object node
+c.find_node    #=> Return node in Neo4j if already saved
+c.create_node  #=> Create object node / or update it
+c.delete_node  #=> Remove object node
 ```
 
-Note that the key of finding nodes in Neo4j is `id` as saved in Neo4j with key `db_id`.
+Note that the key of finding nodes in Neo4j is `id` as saved in Neo4j with key `_id`.
 
 Another example on the model we defined above:
 
 ```ruby
-t = Neoon::Cypher::InstanceQuery.new(Topic.first) #=> #<Neoon::Cypher::InstanceQuery:0x007fe894410b98 @id=1, @label="Topic", @args={...}>
+t = Neoon::Cypher::InstanceQuery.new(Topic.first)
 
-t.find_node.run    #=> Returns node in Neo4j if already saved
-t.create_node.run  #=> Create object node / or update it
-t.delete_node.run  #=> Remove object node
+t.find_node    #=> Returns node in Neo4j if already saved
+t.create_node  #=> Create object node / or update it
+t.delete_node  #=> Remove object node
 ```
 
 ---

data/lib/faraday/neoon/raise_error.rb

@@ -6,15 +6,7 @@ module Faraday
         @app.call(env).on_complete do |env|
           case env[:status]
           when (400..499)
-            body = JSON.parse(env[:body])
-            raise "Neoon::Error::#{body["cause"]["exception"]}".constantize, "#{{
-              :message => body["message"],
-              :exception => body["exception"],
-              :cause => {
-                :message => body["cause"]["message"],
-                :exception => body["cause"]["exception"]
-              }
-            } if env[:body]}"
+            raise "Neoon::Error::#{JSON.parse(env[:body])["cause"]["exception"]}".constantize.new(env[:response], env[:response].body)
           when (500..599)
             raise 'Something went error with Neo4j server.'
           end

data/lib/neoon/client/connection.rb

@@ -5,10 +5,10 @@ module Neoon
       attr_reader :connection
 
       def initialize(url)
-        @uri = URI.parse(url)
-        end_point = "#{@uri.scheme}://#{@uri.host}:#{@uri.port}#{@uri.path}"
+        uri = URI.parse(url)
+        end_point = "#{uri.scheme}://#{uri.host}:#{uri.port}#{uri.path}"
         @connection ||= Faraday.new(end_point, connection_options.merge(:builder => middleware))
-        @connection.basic_auth(@uri.user, @uri.password) if @uri.user && @uri.password
+        @connection.basic_auth(uri.user, uri.password) if uri.user && uri.password
       end
 
       include Request
@@ -26,7 +26,7 @@ module Neoon
           :request => {
             :open_timeout => 5,
             :timeout => 10,
-          },
+          }
         }
       end
 

data/lib/neoon/cypher/handler.rb

@@ -2,27 +2,21 @@ module Neoon
   module Cypher
     class Handler
 
-      attr_reader :query, :args
+      attr_reader :query, :args, :result
 
       def initialize(hash)
-        @query = hash[:query]
-        @args  = hash[:args]
-      end
+        @query  = hash[:query]
+        @args   = hash[:args]
 
-      def to_cypher
-        if query.is_a?(Array)
-          query.map { |q| q.gsub(/\s+/, ' ').strip }
-        else
-          query.gsub(/\s+/, ' ').strip
+        @result = begin
+          make_cypher_request(query, args)
+        rescue Exception => e
+          { :error => e }
         end
       end
 
-      def run
-        if query.is_a?(Array)
-          query.each { |q| make_cypher_request(q, args) }
-        else
-          make_cypher_request(query, args)
-        end
+      def to_cypher
+        [query.gsub(/\s+/, ' ').strip, args]
       end
 
     protected

data/lib/neoon/cypher/instance_query.rb

@@ -7,37 +7,10 @@ module Neoon
       def initialize(object)
         @id     = object.id
         @label  = object.class.name
-        @args   = object.neo_node_properties
+        @args   = object.neo_node_properties.merge(:_id => id)
       end
 
-      def find_node
-        cypher_query = <<-CYPHER
-          MATCH node:#{label} WHERE node._id = #{id}
-          RETURN node
-        CYPHER
-        cypherable(:query => cypher_query)
-      end
-
-      def create_node
-        cypher_query = <<-CYPHER
-          MERGE (node:#{label} { _id: #{id} })
-          ON CREATE node SET node = {props}
-          ON MATCH node SET node = {props}
-          RETURN node
-        CYPHER
-        cypherable(:query => cypher_query, :args => {:props => args})
-      end
-      alias_method :update_node, :create_node
-      alias_method :save_node,   :create_node
-
-      def delete_node
-        cypher_query = <<-CYPHER
-          MATCH node:#{label}
-          WHERE node._id = #{id}
-          DELETE node
-        CYPHER
-        cypherable(:query => cypher_query)
-      end
+      include Neoon::Cypher::Node::Operations
 
     protected
 

data/lib/neoon/cypher/node/operations.rb

@@ -0,0 +1,43 @@
+module Neoon
+  module Cypher
+    module Node
+      module Operations
+
+        def find_node
+          cypher_query = <<-CYPHER
+            MATCH node:#{label} WHERE node._id = #{id}
+            RETURN node
+          CYPHER
+          cypherable(:query => cypher_query)
+        end
+
+        def save_node
+          # since you can't update a constrain with same value
+          # we have to remove the node and re-create it
+          # other way ???
+          delete_node unless (label.constantize.respond_to?(:neo_schema_index_keys) ? label.constantize.neo_schema_index_keys : Neoon::Cypher::Query.new(label).list_indexes).select{|k,v| v=='UNIQUENESS'}.empty?
+
+          cypher_query = <<-CYPHER
+            MERGE (node:#{label} { _id: #{id} })
+            ON CREATE node SET node = {props}
+            ON MATCH node SET node = {props}
+            RETURN node
+          CYPHER
+          cypherable(:query => cypher_query, :args => {:props => args})
+        end
+        alias_method :update_node, :save_node
+        alias_method :create_node, :save_node
+
+        def delete_node
+          cypher_query = <<-CYPHER
+            MATCH node:#{label}
+            WHERE node._id = #{id}
+            DELETE node
+          CYPHER
+          cypherable(:query => cypher_query)
+        end
+
+      end
+    end
+  end
+end

data/lib/neoon/error.rb

@@ -1,11 +1,27 @@
 module Neoon
   module Error
 
-    class Exception < StandardError; end
+    class Exception < StandardError
+      attr_reader :response
+
+      def initialize(response, message)
+        @response = response
+        super(message)
+      end
+    end
+
     class IndexException < Exception; end
     class SchemaException < Exception; end
     class CypherException < Exception; end
 
+    # custom
+    class NodeNotFoundException < Exception; end
+
+    # org.neo4j.kernel.impl.api.constraints
+    class ConstraintValidationKernelException < Exception; end
+    class UnableToValidateConstraintKernelException < Exception; end
+    class UniqueConstraintViolationKernelException < Exception; end
+
     # org.neo4j.kernel.api.exceptions
     class BeginTransactionFailureException < Exception; end
     class ConstraintCreationException < Exception; end

data/lib/neoon/model/node.rb

@@ -3,21 +3,26 @@ module Neoon
     module Node
 
       def neo_node
-        _cypher_query.find_node.run.data.first.first.data
+        _node = _cypher_query.find_node.result.data
+        if _node.empty?
+          excep = { :message => "Cannot find node with id [#{_cypher_query.id}] in database.", :exception => "NodeNotFoundException" }
+          raise Neoon::Error::NodeNotFoundException.new excep, excep
+        end
+        _node.first.first.data
       end
 
       def neo_create
-        _cypher_query.create_node.run.data
+        _cypher_query.create_node.result.data
       end
       alias_method :neo_save,   :neo_create
       alias_method :neo_update, :neo_create
 
       def neo_destroy
-        _cypher_query.delete_node.run.data
+        _cypher_query.delete_node.result.data
       end
 
       def neo_node_properties
-        _neo_node.merge({ :_id => self.id })
+        _neo_node.merge(:_id => self.id)
       end
 
     protected

data/lib/neoon/model/schema.rb

@@ -8,20 +8,18 @@ module Neoon
 
       def neo_index_create key
         if neo_schema_index_keys.select { |k,v| v == 'UNIQUENESS' }.include? key
-          _cypher_query.create_constraint(key).run
+          _cypher_query.create_constraint(key)
         else
-          _cypher_query.create_index(key).run
+          _cypher_query.create_index(key)
         end
-        true
       end
 
       def neo_index_drop key
         if neo_index_list[key] == 'UNIQUENESS'
-          _cypher_query.drop_constraint(key).run
+          _cypher_query.drop_constraint(key)
         else
-          _cypher_query.drop_index(key).run
+          _cypher_query.drop_index(key)
         end
-        true
       end
 
       def neo_index_drop_all

data/lib/neoon/version.rb

@@ -1,3 +1,3 @@
 module Neoon
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/lib/neoon.rb

@@ -14,6 +14,7 @@ require 'neoon/cypher/handler'
 require 'neoon/cypher/schema/indexes'
 require 'neoon/cypher/schema/constraints'
 require 'neoon/cypher/query'
+require 'neoon/cypher/node/operations'
 require 'neoon/cypher/instance_query'
 
 require 'neoon/model/config'

data/spec/neoon/model/config_spec.rb

@@ -6,6 +6,14 @@ describe Neoon::Model::Config do
     require 'app/models/topic'
   end
 
+  it 'responds to .neoon' do
+    expect(Topic).to respond_to(:neoon)
+  end
+
+  it 'responds to .neo_model_config' do
+    expect(Topic).to respond_to(:neo_model_config)
+  end
+
   it 'returns the model config singleton' do
     expect(Topic.neo_model_config.class).to eq Neoon::Model::Config
   end

data/spec/neoon/model/node_spec.rb

@@ -2,80 +2,54 @@ require 'spec_helper'
 
 describe Neoon::Model::Node do
 
-  before :each do
+  before :all do
     require 'app/models/topic'
+    Topic.neo_schema_update
     Topic.destroy_all
   end
 
-  context '' do
-    it 'responds to neoon' do
-      expect(Topic).to respond_to(:neoon)
-    end
-
-    it 'responds to neo_model_config' do
-      expect(Topic).to respond_to(:neo_model_config)
-    end
+  after :all do
+    Topic.destroy_all
   end
 
-  context 'save' do
-    before do
-      @t = Topic.where(:name => 'Apple').first_or_create
-    end
-
-    after :all do
-      Topic.destroy_all
-    end
+  let(:topic) { Topic.where(:name => 'Apple').first_or_create }
 
-    it 'responds to neo_save' do
-      @t.respond_to?(:neo_save).should be_true
+  context 'save' do
+    it 'responds to .neo_save' do
+      expect(topic).to respond_to(:neo_save)
     end
 
     it 'sets neo_node_properties' do
-      @t.neo_node_properties[:_id].should == @t.id
-      @t.neo_node_properties[:name].should == @t.name
-      @t.neo_node_properties[:slug].should == "#{@t.id}-#{@t.name.underscore}"
-    end
-
-    it 'saves to neo' do
-      @t.neo_node._id.should == @t.id
+      expect(topic.neo_node_properties[:_id]).to  eql topic.id
+      expect(topic.neo_node_properties[:name]).to eql topic.name
+      expect(topic.neo_node_properties[:slug]).to eql "#{topic.id}-#{topic.name.underscore}"
     end
 
-    it 'updates to neo after assigning attr and save OR update_attribute()' do
-      @t.name = 'MacBook'
-      @t.save
-      @t.neo_node.name.should == 'MacBook'
-      @t.neo_node._id.should == @t.id
-
-      @t.update_attribute(:name, 'Technology')
-      @t.neo_node.name.should == 'Technology'
-      @t.neo_node._id.should == @t.id
+    it 'has same values' do
+      expect(topic.neo_node._id).to  eql topic.id
+      expect(topic.neo_node.name).to eql topic.name
+      expect(topic.neo_node.slug).to eql "#{topic.id}-#{topic.name.underscore}"
     end
 
     it 'has 1 record' do
-      Topic.count.should == Neoon.db.q('MATCH n:Topic return n').data.count
-      Topic.count.should == 1
+      expect(Topic.count).to eql Neoon.db.q('MATCH n:Topic return n').data.count
+      expect(Topic.count).to eql 1
     end
   end
 
   context 'destroy' do
-    before do
-      @t1 = Topic.where(:name => 'Amr').first_or_create
+    it 'responds to .neo_destroy' do
+      expect(topic).to respond_to(:neo_destroy)
     end
 
-    after :all do
-      Topic.destroy_all
+    it 'doesn\'t exist in neo4j' do
+      topic.destroy
+      expect { topic.neo_node }.to raise_error Neoon::Error::NodeNotFoundException
     end
 
-    it 'responds to neo_destroy' do
-      @t1.respond_to?(:neo_destroy).should be_true
-    end
-
-    it 'has 2 records' do
-      topic = Topic.new name: 'Jo'
-      topic.save
-
-      Topic.count.should == Neoon.db.q('MATCH n:Topic return n').data.count
-      Topic.count.should == 2
+    it 'has 0 record' do
+      expect(Topic.count).to eql Neoon.db.q('MATCH n:Topic return n').data.count
+      expect(Topic.count).to eql 0
     end
   end
 

data/spec/neoon/model/schema_spec.rb

@@ -9,7 +9,7 @@ describe Neoon::Model::Schema do
 
   context 'list index' do
     context 'from model config' do
-      it 'responds to neo_schema_index_keys' do
+      it 'responds to .neo_schema_index_keys' do
         expect(Topic).to respond_to(:neo_schema_index_keys)
       end
       it 'returns all indexed properties' do
@@ -52,7 +52,7 @@ describe Neoon::Model::Schema do
     end
 
     context 'create index' do
-      it 'responds to neo_index_create' do
+      it 'responds to .neo_index_create' do
         expect(Topic).to respond_to(:neo_index_create)
       end
 
@@ -63,8 +63,8 @@ describe Neoon::Model::Schema do
         expect(Topic.neo_index_create(:slug)).to be_true
         expect(Topic.neo_index_list.keys).to eql [:name, :slug]
 
-        expect { Topic.neo_index_create(:name) }.to raise_error Neoon::Error::AlreadyIndexedException
-        expect { Topic.neo_index_create(:slug) }.to raise_error Neoon::Error::AlreadyConstrainedException
+        expect(Topic.neo_index_create(:name).result[:error].class).to eq Neoon::Error::AlreadyIndexedException
+        expect(Topic.neo_index_create(:slug).result[:error].class).to eq Neoon::Error::AlreadyConstrainedException
       end
 
     end
@@ -75,7 +75,7 @@ describe Neoon::Model::Schema do
         Topic.neo_index_create(:slug)
       end
 
-      it 'responds to neo_index_drop' do
+      it 'responds to .neo_index_drop' do
         expect(Topic).to respond_to(:neo_index_drop)
       end
 
@@ -86,8 +86,8 @@ describe Neoon::Model::Schema do
         expect(Topic.neo_index_drop(:slug)).to be_true
         expect(Topic.neo_index_list.keys).to eql []
 
-        expect { Topic.neo_index_drop(:name) }.to raise_error Neoon::Error::DropIndexFailureException
-        expect { Topic.neo_index_drop(:slug) }.to raise_error Neoon::Error::DropIndexFailureException
+        expect(Topic.neo_index_drop(:name).result[:error].class).to eq Neoon::Error::DropIndexFailureException
+        expect(Topic.neo_index_drop(:slug).result[:error].class).to eq Neoon::Error::DropIndexFailureException
       end
     end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neoon
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Amr Tamimi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-28 00:00:00.000000000 Z
+date: 2013-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -157,6 +157,7 @@ files:
 - lib/neoon/config.rb
 - lib/neoon/cypher/handler.rb
 - lib/neoon/cypher/instance_query.rb
+- lib/neoon/cypher/node/operations.rb
 - lib/neoon/cypher/query.rb
 - lib/neoon/cypher/schema/constraints.rb
 - lib/neoon/cypher/schema/indexes.rb