neoon 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08ac0ff644d4961a328938854c086db4a7d35689
-  data.tar.gz: 54aa3709453cecc5d1533036418812868547affe
+  metadata.gz: b1ff7ac30436f19194698ede55cfe68529918122
+  data.tar.gz: 3b62de2caf2e48745e2f67d9705490b5cfe43e48
 SHA512:
-  metadata.gz: 84a8aaca5d0e2a78c120517f29aba0ad0a63d9b8c4e818a4e5a9fbb5239f02d0611ce2d5d92a544e1fc7b99e41fbc8d2f8c6e55378394b191f818f81a8621494
-  data.tar.gz: 50662379431fe64b80fbd9d64930060d1a582adb737a52bddb92f9135b2c9880d53d3f0cff493f80492fafdfe29e0d60bb479799f25193f7389c9e3362c6070e
+  metadata.gz: a5baa0e81c289446fee6744879834a45a878b976d265c10c871b0b666bdcc9c69f581108a665c1959533e0f73ae9241a2247da2d822043ac5ff8d084e708b0ed
+  data.tar.gz: dcb1ea83f6b94370962a93f9a829833f2a1e1f6f882e1ea4458b530f56f8776b078644433bce4090b99b56b683743fae9e444ad645db6234a0be490497ee1026

data/.gitignore

@@ -16,3 +16,4 @@ test/tmp
 test/version_tmp
 tmp
 .ruby-version
+neo4j

data/.travis.yml

@@ -4,6 +4,9 @@ rvm:
   - 2.0.0
   - jruby
 jdk:
+  - oraclejdk7
   - openjdk7
-services:
-  - neo4j
+before_script:
+  - bundle exec rake neo4j:server:install neo4j:server:start
+after_script:
+  - bundle exec rake neo4j:server:stop

data/README.md

@@ -4,7 +4,7 @@
 
 A simple Ruby wrapper for Neo4j with focus on Cypher and the features of Neo4j 2.0
 
-#### Inspired by [Neoid](https://github.com/elado/neoid)
+---
 
 ## Installation
 
@@ -22,6 +22,22 @@ Or install it yourself as:
 
 ## Usage
 
+You can easily install Neo4j in your application path:
+
+```ruby
+bundle exec rake neo4j:server:install
+```
+
+Then start(stop/restart) the Neo4j server by:
+
+```ruby
+bundle exec rake neo4j:server:start
+
+bundle exec rake neo4j:server:stop
+
+bundle exec rake neo4j:server:restart
+```
+
 First you have to initialize  a client:
 
 ```ruby
@@ -34,17 +50,17 @@ Set configuration:
 
 ```ruby
 Neoon.configure do |config|
-  config.preload_models = true # (default: false) This will load your models — so to update the indexes at the (Rails) boot
+  config.preload_models = true # This will load your models — helps updating the indexed nodes at the (Rails) boot (default: false)
 end
 ```
 
 To query using Cypher:
 
 ```ruby
-$neo.q("START node=node(*) RETURN node")
+$neo.q('START node=node(*) RETURN node')
 ```
 
-To your ActiveRecord model, initialize Neoon like so (with example of using properties/index):
+With ActiveRecord models, initialize Neoon like so (with example of using properties/index):
 
 ```ruby
 class Topic < ActiveRecord::Base
@@ -52,45 +68,88 @@ class Topic < ActiveRecord::Base
   include Neoon::Node
 
   neoon do |c|
-    c.property :name
-    c.property :slug, :index => true do
+    c.property :name, :index => true
+    c.property :slug, :index => :unique do
       "#{self.id}-#{self.name.underscore}"
     end
+    c.property :created_at
   end
 
 end
 ```
 
-### Indexing
+#### Indexing
 
-This will be used internally to auto indexing the model depends on what described in the neoon model config.
+This will be used internally to auto index models nodes.
 
 ```ruby
-Neoon.db.list 'Topic' #=> ["slug"]
+Topic.neo_index_list #=> [:name, :slug]
+
+#
+# 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]
+```
 
-Neoon.db.create 'Topic', [:name, ...]
+---
 
-Neoon.db.drop 'Topic' [:name, ...]
+### Neoon::Cypher::Query
 
-# Alternativly
+`Neoon::Cypher::InstanceQuery` should be initialized with an Class name or `label`. You can use `Neoon::Cypher::Query` to manually create indexes, constraints, etc.
 
-Topic.neo_index_list #=> ["slug"]
+```ruby
+l = Neoon::Cypher::Query.new('Person') #=> #<Neoon::Cypher::Query:0x007fe8926d2068 @label="Person">
 
-Topic.neo_index_create [:name, ...]
+l.create_index(:name).run
+# l.drop_index(:name).run
 
-Topic.neo_index_drop [:name, ...]
+l.create_constraint(:username).run
+# l.drop_constraint(:username).run
 
-# Sync the indexes you described in 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_index_update #=> ["slug"]
+l.list_indexes                         #=> { :name => true, :username => "UNIQUENESS" }
+```
+
+---
+
+### Neoon::Cypher::InstanceQuery
+
+`Neoon::Cypher::InstanceQuery` should be initialized with an object that respond to `id`, `class.name` as it will represent the `label` and `neo_node_properties` as it will represent the `args`.
+
+You can use `Neoon::Cypher::InstanceQuery` to manually create operations on nodes related to an object, etc.
+
+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"}>
+
+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
+```
+
+Note that the key of finding nodes in Neo4j is `id` as saved in Neo4j with key `db_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.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
 ```
 
+---
+
 **The gem is still at heavy development. More to come!**
 
 ## TODO
 
-1. ADD TESTS
-2. ..
+1. Add inline docs
+2. ADD TESTS!!!
 
 ## Contributing
 

data/Rakefile

@@ -2,6 +2,8 @@ require 'rubygems'
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
+load 'neoon/tasks/server.rake'
+
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec

data/lib/faraday/neoon/raise_error.rb

@@ -0,0 +1,26 @@
+module Faraday
+  module Neoon
+    class RaiseError < Faraday::Response::Middleware
+
+      def call(env)
+        @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]}"
+          when (500..599)
+            raise 'Something went error with Neo4j server.'
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/neoon/client/connection.rb

@@ -12,7 +12,6 @@ module Neoon
       end
 
       include Request
-      include Indexing
 
     private
 
@@ -36,6 +35,7 @@ module Neoon
           builder.use FaradayMiddleware::EncodeJson
           builder.use FaradayMiddleware::Mashify
           builder.use FaradayMiddleware::ParseJson, :content_type => /\bjson$/
+          builder.use Faraday::Neoon::RaiseError
 
           builder.adapter Faraday.default_adapter
         end

data/lib/neoon/client/request.rb

@@ -1,5 +1,3 @@
-require 'faraday_middleware'
-
 module Neoon
   module Client
     module Request

data/lib/neoon/cypher/handler.rb

@@ -0,0 +1,36 @@
+module Neoon
+  module Cypher
+    class Handler
+
+      attr_reader :query, :args
+
+      def initialize(hash)
+        @query = hash[:query]
+        @args  = hash[:args]
+      end
+
+      def to_cypher
+        if query.is_a?(Array)
+          query.map { |q| q.gsub(/\s+/, ' ').strip }
+        else
+          query.gsub(/\s+/, ' ').strip
+        end
+      end
+
+      def run
+        if query.is_a?(Array)
+          query.each { |q| make_cypher_request(q, args) }
+        else
+          make_cypher_request(query, args)
+        end
+      end
+
+    protected
+
+      def make_cypher_request(query, args = nil)
+        Neoon.db.cypher(query, args)
+      end
+
+    end
+  end
+end

data/lib/neoon/cypher/instance_query.rb

@@ -0,0 +1,50 @@
+module Neoon
+  module Cypher
+    class InstanceQuery
+
+      attr_reader :id, :label, :args
+
+      def initialize(object)
+        @id     = object.id
+        @label  = object.class.name
+        @args   = object.neo_node_properties
+      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
+
+    protected
+
+      def cypherable(query)
+        Cypher::Handler.new(query)
+      end
+
+    end
+  end
+end

data/lib/neoon/cypher/query.rb

@@ -0,0 +1,22 @@
+module Neoon
+  module Cypher
+    class Query
+
+      attr_reader :label
+
+      def initialize(klass)
+        @label  = klass.is_a?(String) ? klass : klass.name
+      end
+
+      include Neoon::Cypher::Schema::Indexes
+      include Neoon::Cypher::Schema::Constraints
+
+    protected
+
+      def cypherable(query)
+        Cypher::Handler.new(query)
+      end
+
+    end
+  end
+end

data/lib/neoon/cypher/schema/constraints.rb

@@ -0,0 +1,19 @@
+module Neoon
+  module Cypher
+    module Schema
+      module Constraints
+
+        def create_constraint(key)
+          cypher_query = "CREATE CONSTRAINT ON (node:#{label}) ASSERT node.#{key.to_s.downcase} IS UNIQUE"
+          cypherable(:query => cypher_query)
+        end
+
+        def drop_constraint(key)
+          cypher_query = "DROP CONSTRAINT ON (node:#{label}) ASSERT node.#{key.to_s.downcase} IS UNIQUE"
+          cypherable(:query => cypher_query)
+        end
+
+      end
+    end
+  end
+end

data/lib/neoon/cypher/schema/indexes.rb

@@ -0,0 +1,25 @@
+module Neoon
+  module Cypher
+    module Schema
+      module Indexes
+
+        def list_indexes
+          # The only none Cypher query
+          idx_keys = Neoon.db.get("/schema/index/#{label}") + Neoon.db.get("/schema/constraint/#{label}")
+          idx_keys.reduce({}) { |k, v| k[v.send('property-keys').first.to_sym] = v.type || true; k }
+        end
+
+        def create_index(key)
+          cypher_query = "CREATE INDEX ON :#{label}(#{key.to_s.downcase})"
+          cypherable(:query => cypher_query)
+        end
+
+        def drop_index(key)
+          cypher_query = "DROP INDEX ON :#{label}(#{key.to_s.downcase})"
+          cypherable(:query => cypher_query)
+        end
+
+      end
+    end
+  end
+end

data/lib/neoon/error.rb

@@ -0,0 +1,71 @@
+module Neoon
+  module Error
+
+    class Exception < StandardError; end
+    class IndexException < Exception; end
+    class SchemaException < Exception; end
+    class CypherException < Exception; end
+
+    # org.neo4j.kernel.api.exceptions
+    class BeginTransactionFailureException < Exception; end
+    class ConstraintCreationException < Exception; end
+    class EntityNotFoundException < Exception; end
+    class KernelException < Exception; end
+    class LabelNotFoundKernelException < Exception; end
+    class PropertyKeyIdNotFoundKernelException < Exception; end
+    class PropertyKeyNotFoundException < Exception; end
+    class PropertyNotFoundException < Exception; end
+    class RelationshipTypeIdNotFoundKernelException < Exception; end
+    class TransactionalException < Exception; end
+    class TransactionFailureException < Exception; end
+
+    # org.neo4j.kernel.api.exceptions.index
+    class ExceptionDuringFlipKernelException < IndexException; end
+    class FlipFailedKernelException < IndexException; end
+    class IndexNotFoundKernelException < IndexException; end
+    class IndexPopulationFailedKernelException < IndexException; end
+    class IndexProxyAlreadyClosedKernelException < IndexException; end
+
+    # org.neo4j.kernel.api.exceptions.schema
+    class AddIndexFailureException < SchemaException; end
+    class AlreadyConstrainedException < SchemaException; end
+    class AlreadyIndexedException < SchemaException; end
+    class CreateConstraintFailureException < SchemaException; end
+    class DropConstraintFailureException < SchemaException; end
+    class DropIndexFailureException < SchemaException; end
+    class IllegalTokenNameException < SchemaException; end
+    class IndexBelongsToConstraintException < SchemaException; end
+    class IndexBrokenKernelException < SchemaException; end
+    class MalformedSchemaRuleException < SchemaException; end
+    class NoSuchConstraintException < SchemaException; end
+    class NoSuchIndexException < SchemaException; end
+    class SchemaAndDataModificationInSameTransactionException < SchemaException; end
+    class SchemaKernelException < SchemaException; end
+    class SchemaRuleNotFoundException < SchemaException; end
+    class TooManyLabelsException < SchemaException; end
+
+    # org.neo4j.cypher.CypherException
+    class CypherExecutionException < CypherException; end
+    class UniquePathNotUniqueException < CypherException; end
+    # class EntityNotFoundException < CypherException; end
+    class CypherTypeException < CypherException; end
+    class IterableRequiredException < CypherException; end
+    class ParameterNotFoundException < CypherException; end
+    class ParameterWrongTypeException < CypherException; end
+    class PatternException < CypherException; end
+    class InternalException < CypherException; end
+    class MissingIndexException < CypherException; end
+    class MissingConstraintException < CypherException; end
+    class InvalidAggregateException < CypherException; end
+    class NodeStillHasRelationshipsException < CypherException; end
+    class ProfilerStatisticsNotReadyException < CypherException; end
+    class UnknownLabelException < CypherException; end
+    class IndexHintException < CypherException; end
+    class LabelScanHintException < CypherException; end
+    class UnableToPickStartPointException < CypherException; end
+    class InvalidSemanticsException < CypherException; end
+    class OutOfBoundsException < CypherException; end
+    class MergeConstraintConflictException < CypherException; end
+
+  end
+end

data/lib/neoon/model/node.rb

@@ -0,0 +1,44 @@
+module Neoon
+  module Model
+    module Node
+
+      def neo_node
+        _cypher_query.find_node.run.data.first.first.data
+      end
+
+      def neo_create
+        _cypher_query.create_node.run.data
+      end
+      alias_method :neo_save,   :neo_create
+      alias_method :neo_update, :neo_create
+
+      def neo_destroy
+        _cypher_query.delete_node.run.data
+      end
+
+      def neo_node_properties
+        _neo_node.merge({ :_id => self.id })
+      end
+
+    protected
+
+      def _cypher_query
+        Neoon::Cypher::InstanceQuery.new(self)
+      end
+
+      def _neo_node
+        return {} unless self.class.neo_model_config.properties
+        hash = self.class.neo_model_config.properties.inject({}) do |all, (field, block)|
+          all[field] = if block[:block]
+            instance_eval(&block[:block])
+          else
+            self.send(field) rescue (raise "No field #{field} for #{self.class.name}")
+          end
+          all
+        end
+        hash.reject { |k, v| v.nil? }
+      end
+
+    end
+  end
+end

data/lib/neoon/model/schema.rb

@@ -3,37 +3,59 @@ module Neoon
     module Schema
 
       def neo_index_list
-        Neoon.db.list self.name
+        _cypher_query.list_indexes
       end
 
-      def neo_index_create keys = []
-        Neoon.db.create self.name, keys
+      def neo_index_create key
+        if neo_schema_index_keys.select { |k,v| v == 'UNIQUENESS' }.include? key
+          _cypher_query.create_constraint(key).run
+        else
+          _cypher_query.create_index(key).run
+        end
+        true
       end
 
-      def neo_index_drop keys = []
-        Neoon.db.drop self.name, keys
+      def neo_index_drop key
+        if neo_index_list[key] == 'UNIQUENESS'
+          _cypher_query.drop_constraint(key).run
+        else
+          _cypher_query.drop_index(key).run
+        end
+        true
+      end
+
+      def neo_index_drop_all
+        neo_index_list.each { |k, _| neo_index_drop(k) }
       end
 
       def neo_index_update
-        cl = neo_index_list
-        ck = neo_node_keys_to_index
-        return cl if (cl) == (ck)
+        cl, ck = neo_index_list.to_a, neo_schema_index_keys.to_a
+        return cl if cl == ck
+        return neo_index_drop_all if ck.empty?
 
-        neo_index_create(ck - cl) unless (ck - cl).empty?
-        neo_index_drop(cl - ck) unless (cl - ck).empty?
-        neo_index_list
+        (cl - ck).each{ |k| neo_index_drop(k.first) } unless (cl - ck).empty?
+        (ck - cl).each{ |k| neo_index_create(k.first) } unless (ck - cl).empty?
       end
 
-    private
+      def neo_schema_update
+        neo_index_update
+        neo_index_list
+      end
 
-      def neo_model_props
-        self.neo_model_config.properties
+      def neo_schema_index_keys
+        neo_model_config.properties.inject({}) do |all, (k, v)|
+          all[k] = true if v[:index]
+          all[k] = 'UNIQUENESS' if v[:index] == :unique
+          all
+        end
       end
 
-      def neo_node_keys_to_index
-        neo_model_props.select{ |k, v| v[:index]==true }.keys.map(&:to_s).sort
+    protected
+
+      def _cypher_query
+        Neoon::Cypher::Query.new(self)
       end
 
     end
   end
-end
+end

data/lib/neoon/node.rb

@@ -2,15 +2,30 @@ module Neoon
   module Node
 
     module ClassMethods
-    end
+      attr_reader :neo_model_config
+
+      def neo_model_config
+        @neo_model_config ||= Model::Config.new(self)
+      end
+
+      def neoon(opts = {})
+        yield(neo_model_config) if block_given?
 
-    module InstanceMethods
+        opts.each do |key, value|
+          raise "No such option #{key} for #{self.name} model" unless neo_model_config.respond_to?("#{key}=")
+          neo_model_config.send("#{key}=", value)
+        end
+      end
     end
 
     def self.included(receiver)
-      receiver.send :include, Model::Service
+      receiver.send :include, Model::Node
+      receiver.extend         Model::Schema
       receiver.extend         ClassMethods
-      receiver.send :include, InstanceMethods
+
+      receiver.after_save    :neo_save
+      receiver.after_destroy :neo_destroy
+
       Neoon.config.models << receiver
     end
 

data/lib/neoon/railtie.rb

@@ -6,16 +6,17 @@ module Rails
     class Railtie < ::Rails::Railtie
 
       rake_tasks do
-        load "neoon/railties/database.rake"
+        load 'neoon/tasks/server.rake'
+        load 'neoon/tasks/database.rake'
       end
 
-      initializer "neoon.neo_index_update" do
+      initializer 'neoon.neo_schema_update' do
         config.after_initialize do
-          ::Neoon.config.models.each(&:neo_index_update)
+          ::Neoon.config.models.each(&:neo_schema_update)
         end
       end
 
-      initializer "neoon.preload_models" do |app|
+      initializer 'neoon.preload_models' do |app|
         config.to_prepare do
           Rails::Neoon.preload_models(app)
         end

data/lib/neoon/tasks/database.rake

@@ -0,0 +1,15 @@
+namespace :neo4j do
+  namespace :db do
+
+    namespace :index do
+      desc 'Index/reindex the nodes'
+      task :build do
+      end
+
+      desc 'Remove nodes indexing'
+      task :destroy do
+      end
+    end
+
+  end
+end

data/lib/neoon/tasks/server.rake

@@ -0,0 +1,35 @@
+namespace :neo4j do
+  namespace :server do
+
+    # Taken from https://github.com/maxdemarzi/neography/blob/master/lib/neography/tasks.rb (Unix)
+    desc 'Install Neo4j server'
+    task :install, :edition, :version do |t, args|
+      args.with_defaults(:edition => 'community', :version => '2.0.0-M05')
+      puts "Installing Neo4j-#{args[:edition]}-#{args[:version]}..."
+      %x[curl -O http://dist.neo4j.org/neo4j-#{args[:edition]}-#{args[:version]}-unix.tar.gz]
+      %x[tar -xvzf neo4j-#{args[:edition]}-#{args[:version]}-unix.tar.gz]
+      %x[mv neo4j-#{args[:edition]}-#{args[:version]} neo4j]
+      %x[rm neo4j-#{args[:edition]}-#{args[:version]}-unix.tar.gz]
+      puts 'Neo4j Installed in to neo4j directory.'
+    end
+
+    desc 'Start Neo4j server'
+    task :start do
+      puts 'Starting Neo4j...'
+      %x[neo4j/bin/neo4j start]
+    end
+
+    desc 'Stop Neo4j server'
+    task :stop do
+      puts 'Stopping Neo4j...'
+      %x[neo4j/bin/neo4j stop]
+    end
+
+    desc 'Restart Neo4j server'
+    task :restart do
+      puts 'Restarting Neo4j...'
+      %x[neo4j/bin/neo4j restart]
+    end
+
+  end
+end

data/lib/neoon/version.rb

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

data/lib/neoon.rb

@@ -1,16 +1,28 @@
 require 'multi_json'
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday/neoon/raise_error'
 
 require 'neoon/version'
 require 'neoon/config'
+require 'neoon/error'
+
 require 'neoon/client/request'
-require 'neoon/client/indexing'
 require 'neoon/client/connection'
 
+require 'neoon/cypher/handler'
+require 'neoon/cypher/schema/indexes'
+require 'neoon/cypher/schema/constraints'
+require 'neoon/cypher/query'
+require 'neoon/cypher/instance_query'
+
 require 'neoon/model/config'
 require 'neoon/model/schema'
-require 'neoon/model/service'
+require 'neoon/model/node'
+
 require 'neoon/node'
 
+
 if defined?(Rails)
   require 'neoon/railtie'
 end

data/lib/rails/neoon.rb

@@ -6,13 +6,13 @@ module Rails
       models.each do |path|
         files = Dir.glob("#{path}/**/*.rb")
         files.sort.each do |file|
-          load_model(file.gsub("#{path}/" , "").gsub(".rb", ""))
+          load_model(file.gsub("#{path}/" , '').gsub('.rb', ''))
         end
       end
     end
 
     def preload_models(app)
-      models = app.config.paths["app/models"]
+      models = app.config.paths['app/models']
       load_models(models) if ::Neoon.config.preload_models
     end
 

data/neoon.gemspec

@@ -19,10 +19,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.required_ruby_version     = ">= 1.9"
+  spec.required_ruby_version     = '>= 1.9'
 
   spec.add_runtime_dependency 'faraday'
   spec.add_runtime_dependency 'faraday_middleware'
+  spec.add_runtime_dependency 'activesupport'
   spec.add_runtime_dependency 'multi_json'
   spec.add_runtime_dependency 'hashie'
 

data/spec/app/models/topic.rb

@@ -2,10 +2,11 @@ class Topic < ActiveRecord::Base
   include Neoon::Node
 
   neoon do |c|
-    c.property :name
-    c.property :slug, :index => true do
+    c.property :name, :index => true
+    c.property :slug, :index => :unique do
       "#{self.id}-#{self.name.underscore}"
     end
+    c.property :created_at
   end
 
 end

data/spec/neoon/config_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Neoon::Config do
+
+  context 'no block given' do
+    it 'returns the config singleton' do
+      expect(Neoon.config.class).to eq Neoon::Config
+    end
+
+    it 'returns config.preload_models false' do
+      expect(Neoon.config.preload_models).to be_false
+    end
+
+    it 'should have no model' do
+      expect(Neoon.config.models).to be_empty
+    end
+  end
+
+  context 'with block given' do
+    before do
+      Neoon.configure do |c|
+        c.preload_models = true
+      end
+      require 'app/models/topic' # fake loading a model
+    end
+
+    after do
+      Neoon.configure do |c|
+        c.preload_models = false
+      end
+    end
+
+    it 'returns config.preload_models true' do
+      expect(Neoon.config.preload_models).to be_true
+    end
+
+    it 'should have models' do
+      expect(Neoon.config.models).not_to be_empty
+    end
+  end
+
+end

data/spec/neoon/model/config_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Neoon::Model::Config do
+
+  before do
+    require 'app/models/topic'
+  end
+
+  it 'returns the model config singleton' do
+    expect(Topic.neo_model_config.class).to eq Neoon::Model::Config
+  end
+
+  context 'properties' do
+    it 'stores them' do
+      expect(Topic.neo_model_config.properties).not_to be_nil
+      expect(Topic.neo_model_config.properties.keys).to eql [ :name, :slug, :created_at ]
+    end
+
+    it 'has block' do
+      expect(Topic.neo_model_config.properties[:slug][:block]).to be_a(Proc)
+    end
+
+    it 'has index' do
+      expect(Topic.neo_model_config.properties[:name][:index]).to be_true
+    end
+
+    it 'has unique index' do
+      expect(Topic.neo_model_config.properties[:slug][:index]).to eql :unique
+    end
+  end
+
+end

data/spec/neoon/model/node_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Neoon::Model::Node do
+
+  before :each do
+    require 'app/models/topic'
+    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
+  end
+
+  context 'save' do
+    before do
+      @t = Topic.where(:name => 'Apple').first_or_create
+    end
+
+    after :all do
+      Topic.destroy_all
+    end
+
+    it 'responds to neo_save' do
+      @t.respond_to?(:neo_save).should be_true
+    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
+    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
+    end
+
+    it 'has 1 record' do
+      Topic.count.should == Neoon.db.q('MATCH n:Topic return n').data.count
+      Topic.count.should == 1
+    end
+  end
+
+  context 'destroy' do
+    before do
+      @t1 = Topic.where(:name => 'Amr').first_or_create
+    end
+
+    after :all do
+      Topic.destroy_all
+    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
+    end
+  end
+
+end

data/spec/neoon/model/schema_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Neoon::Model::Schema do
+
+  before do
+    require 'app/models/topic'
+    Topic.neo_schema_update
+  end
+
+  context 'list index' do
+    context 'from model config' 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
+        expect(Topic.neo_schema_index_keys.keys).to eql [:name, :slug]
+      end
+      it 'returns indexed properties' do
+        expect(Topic.neo_schema_index_keys.select{|_, v| v == true}.keys).to eql [:name]
+      end
+      it 'returns unique indexed properties' do
+        expect(Topic.neo_schema_index_keys.select{|_, v| v == 'UNIQUENESS'}.keys).to eql [:slug]
+      end
+
+    end
+
+    context 'from Neo4j' do
+      it 'returns all indexed properties' do
+        expect(Topic.neo_index_list.keys).to eql [:name, :slug]
+      end
+      it 'returns indexed properties' do
+        expect(Topic.neo_index_list.select{|_, v| v == true}.keys).to eql [:name]
+      end
+      it 'returns unique indexed properties' do
+        expect(Topic.neo_index_list.select{|_, v| v == 'UNIQUENESS'}.keys).to eql [:slug]
+      end
+    end
+  end
+
+  context 'index operation' do
+    before :each do
+      begin
+        Topic.neo_index_drop(:name)
+        Topic.neo_index_drop(:slug)
+      rescue
+
+      end
+    end
+
+    it 'no indexes in Neo4j' do
+      expect(Topic.neo_index_list.keys).to eql []
+    end
+
+    context 'create index' do
+      it 'responds to neo_index_create' do
+        expect(Topic).to respond_to(:neo_index_create)
+      end
+
+      it 'creates indexes for properties' do
+        expect(Topic.neo_index_create(:name)).to be_true
+        expect(Topic.neo_index_list.keys).to eql [:name]
+
+        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
+      end
+
+    end
+
+    context 'drop index' do
+      before do
+        Topic.neo_index_create(:name)
+        Topic.neo_index_create(:slug)
+      end
+
+      it 'responds to neo_index_drop' do
+        expect(Topic).to respond_to(:neo_index_drop)
+      end
+
+      it 'drops indexes for properties' do
+        expect(Topic.neo_index_drop(:name)).to be_true
+        expect(Topic.neo_index_list.keys).to eql [:slug]
+
+        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
+      end
+    end
+
+    context 'update index' do
+      before do
+        Topic.neo_schema_update
+      end
+
+      it 'updates index as in model config' do
+        Topic.neo_index_list.keys.should == [:name, :slug]
+      end
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neoon
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Amr Tamimi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-23 00:00:00.000000000 Z
+date: 2013-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -38,6 +38,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
@@ -136,22 +150,32 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/faraday/neoon/raise_error.rb
 - lib/neoon.rb
 - lib/neoon/client/connection.rb
-- lib/neoon/client/indexing.rb
 - lib/neoon/client/request.rb
 - lib/neoon/config.rb
+- lib/neoon/cypher/handler.rb
+- lib/neoon/cypher/instance_query.rb
+- lib/neoon/cypher/query.rb
+- lib/neoon/cypher/schema/constraints.rb
+- lib/neoon/cypher/schema/indexes.rb
+- lib/neoon/error.rb
 - lib/neoon/model/config.rb
+- lib/neoon/model/node.rb
 - lib/neoon/model/schema.rb
-- lib/neoon/model/service.rb
 - lib/neoon/node.rb
 - lib/neoon/railtie.rb
-- lib/neoon/railties/database.rake
+- lib/neoon/tasks/database.rake
+- lib/neoon/tasks/server.rake
 - lib/neoon/version.rb
 - lib/rails/neoon.rb
 - neoon.gemspec
 - spec/app/models/topic.rb
-- spec/neoon_spec.rb
+- spec/neoon/config_spec.rb
+- spec/neoon/model/config_spec.rb
+- spec/neoon/model/node_spec.rb
+- spec/neoon/model/schema_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.yml
 - spec/support/schema.rb
@@ -181,7 +205,10 @@ specification_version: 4
 summary: A simple Ruby wrapper for Neo4j with focus on Cypher
 test_files:
 - spec/app/models/topic.rb
-- spec/neoon_spec.rb
+- spec/neoon/config_spec.rb
+- spec/neoon/model/config_spec.rb
+- spec/neoon/model/node_spec.rb
+- spec/neoon/model/schema_spec.rb
 - spec/spec_helper.rb
 - spec/support/database.yml
 - spec/support/schema.rb

data/lib/neoon/client/indexing.rb

@@ -1,25 +0,0 @@
-module Neoon
-  module Client
-    module Indexing
-
-      def list(label)
-        Neoon.db.get("/schema/index/#{label}")
-          .map{|f| f.send("property-keys")}.flatten.map(&:to_s).sort
-      end
-
-      def create(label, keys = [])
-        keys.each do |key|
-          Neoon.db.cypher("CREATE INDEX ON :#{label}(#{key.to_s.downcase})")
-        end
-      end
-
-      def drop(label, keys = [])
-        keys.each do |key|
-          Neoon.db.cypher("DROP INDEX ON :#{label}(#{key.to_s.downcase})")
-        end
-        neo_index_list
-      end
-
-    end
-  end
-end

data/lib/neoon/model/service.rb

@@ -1,69 +0,0 @@
-module Neoon
-  module Model
-    module Service
-
-      module ClassMethods
-        attr_reader :neo_model_config
-
-        def neo_model_config
-          @neo_model_config ||= Neoon::Model::Config.new(self)
-        end
-
-        def neoon(opts = {})
-          yield(neo_model_config) if block_given?
-
-          opts.each do |key, value|
-            raise "No such option #{key} for #{self.name} model" unless neo_model_config.respond_to?("#{key}=")
-            neo_model_config.send("#{key}=", value)
-          end
-        end
-      end
-
-      module InstanceMethods
-        def neo_node_props
-          neo_node.merge({ :db_id => self.id })
-        end
-
-        def neo_save
-          cypher_query = <<-CYPHER
-            MERGE (node:#{self.class.name} { db_id: #{self.id} })
-            ON CREATE node SET node = {props}
-            ON MATCH node SET node = {props}
-            RETURN node
-          CYPHER
-          Neoon.db.q(cypher_query, { :props => neo_node_props })
-        end
-
-        def neo_destroy
-          cypher_query = <<-CYPHER
-          CYPHER
-          Neoon.db.q(cypher_query)
-        end
-
-      protected
-
-        def neo_node
-          return {} unless self.class.neo_model_props
-          hash = self.class.neo_model_props.inject({}) do |all, (field, block)|
-            all[field] = if block[:block]
-              instance_eval(&block[:block])
-            else
-              self.send(field) rescue (raise "No field #{field} for #{self.class.name}")
-            end
-            all
-          end
-          hash.reject { |k, v| v.nil? }
-        end
-      end
-
-      def self.included(receiver)
-        receiver.extend         ClassMethods
-        receiver.extend         Schema
-        receiver.send :include, InstanceMethods
-
-        receiver.after_save :neo_save
-      end
-
-    end
-  end
-end

data/lib/neoon/railties/database.rake

@@ -1,2 +0,0 @@
-namespace :db do
-end

data/spec/neoon_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Neoon do
-
-  describe ".config" do
-
-    context "no block given" do
-      it "returns the config singleton" do
-        Neoon.config.should eq Neoon::config
-      end
-
-      it "returns config.preload_models false" do
-        Neoon.config.preload_models.should be_false
-      end
-
-      it "should have no model" do
-        Neoon.config.models.should be_empty
-      end
-    end
-
-    context "with block given" do
-      before do
-        Neoon.configure do |c|
-          c.preload_models = true
-        end
-        require 'app/models/topic' # fake loading a model
-      end
-
-      after do
-        Neoon.configure do |c|
-          c.preload_models = false
-        end
-      end
-
-      it "returns config.preload_models true" do
-        Neoon.config.preload_models.should be_true
-      end
-
-      it "should have models" do
-        Neoon.config.models.should_not be_empty
-      end
-    end
-
-  end
-end