neo4j-cypher 1.0.0.rc2 → 1.0.0

data/lib/neo4j-cypher/start.rb

@@ -2,16 +2,19 @@ module Neo4j
   module Cypher
     class Start
       include Clause
-      include Referenceable
 
-      attr_accessor :entities # TODO CHECK  if needed
-
-      def initialize(clause_list)
+      def initialize(clause_list, rvalue)
         super(clause_list, :start, EvalContext)
+        @rvalue = rvalue
+      end
+
+      def entity_list(entity_type, entities)
+        list = entities.map { |n| n.respond_to?(:neo_id) ? n.neo_id : n }.join(',')
+        "#{entity_type}(#{list})"
       end
 
-      def initialize_entities(entities)
-        @entities = entities.map { |n| n.respond_to?(:neo_id) ? n.neo_id : n }
+      def to_cypher
+        "#{var_name}=#{@rvalue}"
       end
 
       class EvalContext
@@ -30,63 +33,56 @@ module Neo4j
     class StartNode < Start
 
       def initialize(clause_list, nodes)
-        super(clause_list)
-        initialize_entities(nodes)
-      end
-
-      def to_cypher
-        "#{var_name}=node(#{entities.join(',')})"
+        super(clause_list, entity_list('node', nodes))
       end
-
     end
 
 
     # Can be created from a <tt>rel</tt> dsl method.
     class StartRel < Start
       def initialize(clause_list, rels)
-        super(clause_list)
-        initialize_entities(rels)
+        super(clause_list, entity_list('relationship', rels))
       end
+    end
 
-      def to_cypher
-        "#{var_name}=relationship(#{entities.join(',')})"
+    class LuceneQuery < Start
+      def initialize(clause_list, query, type)
+        super(clause_list, "#{type}:#{query}")
+      end
+
+      def self._lookup_params(index_class, key, value)
+        %Q[#{_index_name_for_key(index_class, key)}(#{key}="#{value}")]
       end
-    end
 
-    class NodeQuery < Start
-      attr_reader :index_name, :query
+      def self.lookup_node_by_class(clause_list, index_class, key, value)
+        LuceneQuery.new(clause_list, _lookup_params(index_class, key, value), 'node')
+      end
 
-      def initialize(clause_list, index_class, query, index_type)
-        super(clause_list)
-        @index_name = index_class.index_name_for_type(index_type)
-        @query = query
+      def self.query_node_by_class(clause_list, index_class, query, index_type)
+        LuceneQuery.new(clause_list, "#{_index_name_for_type(index_class, index_type)}(#{query})", 'node')
       end
 
-      def to_cypher
-        "#{var_name}=node:#{index_name}(#{query})"
+      def self.lookup_rel_by_class(clause_list, index_class, key, value)
+        LuceneQuery.new(clause_list, _lookup_params(index_class, key, value), 'relationship')
+      end
+
+      def self.query_rel_by_class(clause_list, index_class, query, index_type)
+        LuceneQuery.new(clause_list, "#{_index_name_for_type(index_class, index_type)}(#{query})", 'relationship')
       end
-    end
 
-    class NodeLookup < Start
-      attr_reader :index_name, :query
+      def self._index_name_for_type(index_class , index_type)
+        index_class.respond_to?(:index_name_for_type) ? index_class.index_name_for_type(index_type) : index_class.to_s
+      end
 
-      def initialize(clause_list, index_class, key, value)
-        super(clause_list)
+      def self._index_name_for_key(index_class, key)
         if index_class.respond_to?(:index_type)
           index_type = index_class.index_type(key.to_s)
           raise "No index on #{index_class} property #{key}" unless index_type
-          @index_name = index_class.index_name_for_type(index_type)
+          index_class.index_name_for_type(index_type)
         else
-          @index_name = index_class
+          index_class.to_s
         end
-
-        @query = %Q[#{key}="#{value}"]
-      end
-
-      def to_cypher
-        %Q[#{var_name}=node:#{index_name}(#{query})]
       end
-
     end
 
   end

data/lib/neo4j-cypher/version.rb

@@ -1,5 +1,5 @@
 module Neo4j
   module Cypher
-    VERSION = '1.0.0.rc2'
+    VERSION = '1.0.0'
   end
-end
+end

data/lib/neo4j-cypher/where.rb

@@ -3,13 +3,26 @@ module Neo4j
     class Where
       include Clause
 
-      def initialize(clause_list, where_statement = nil)
+      def initialize(clause_list, context, where_statement = nil, &block)
         super(clause_list, :where)
-        @where_statement = where_statement
+
+        if where_statement
+          @where_statement = where_statement
+        else
+          clause_list.push
+          RootClause::EvalContext.new(context).instance_exec(context, &block)
+          @where_statement = clause_list.to_cypher
+          clause_list.pop
+        end
+
+      end
+
+      def neg!
+        @where_statement = "not(#{@where_statement})"
       end
 
       def to_cypher
-        @where_statement.to_s
+        @where_statement
       end
     end
   end

data/lib/neo4j-cypher/with.rb

@@ -12,12 +12,10 @@ module Neo4j
 
         @args = create_clause_args_for(args)
         @arg_list = @args.map { |a| a.return_value }.join(',')
-        @where_or_match = where_or_match
         arg_exec = @args.map(&:eval_context)
 
         RootClause::EvalContext.new(self).instance_exec(*arg_exec, &cypher_dsl)
-
-        @body = "#{@where_or_match.to_s.upcase} #{clause_list.to_cypher}"
+        @body = "#{where_or_match.to_s.upcase} #{clause_list.to_cypher}"
         clause_list.pop
       end
 

data/lib/tasks/analyzer.rake

@@ -0,0 +1,54 @@
+require 'rubygems'
+#require 'term/ansicolor'
+require 'reek/rake/task'
+
+# Stolen rake task from https://github.com/andywenk/ruby_code_analyzer_rake_tasks/blob/master/lib/tasks/analyzer.rake
+
+Reek::Rake::Task.new do |t|
+  t.source_files = "app"
+  t.verbose = false
+  t.fail_on_error = false
+end
+
+SOURCE_DIR = 'lib/neo4j-cypher/*.rb'
+
+namespace :analyzer do
+  desc "run all code analyzing tools (reek, rails_best_practices, flog, flay)"
+  task :all => [:reek, :flog, :flay] do
+    message(:info, 'have been running all code analyzing tools')
+  end
+
+  desc "run reek and find code smells"
+  task :reek do
+    message(:info, 'Running reek and find code smells')
+    Rake::Task['reek'].invoke
+  end
+
+  desc "run flog and find the most tortured code"
+  task :flog do
+    message(:info, 'Running flog and find the most tortured code')
+    sh "flog -ca #{SOURCE_DIR}"
+  end
+
+  desc "run flay and analyze code for structural similarities"
+  task :flay do
+    message(:info, 'Running flay and and analyze code for structural similarities')
+    sh "flay #{SOURCE_DIR}"
+  end
+end
+
+def message(type, message)
+  set_color(type)
+  puts message
+  reset_color
+end
+
+def set_color(type)
+  term = Term::ANSIColor
+  colors = {info: term.green, error: term.red}
+  puts colors[type]
+end
+
+def reset_color
+  puts Term::ANSIColor.reset
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: neo4j-cypher
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc2
-  prerelease: 6
+  version: 1.0.0
+  prerelease: 
 platform: ruby
 authors:
 - Andreas Ronge
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-21 00:00:00.000000000 Z
+date: 2012-10-02 00:00:00.000000000 Z
 dependencies: []
 description: ! 'This gem is used in the JRuby neo4j gem but should work on any Ruby
   implementation since it simply
@@ -23,13 +23,16 @@ extensions: []
 extra_rdoc_files:
 - README.rdoc
 files:
+- lib/neo4j-cypher/abstract_filter.rb
 - lib/neo4j-cypher/argument.rb
 - lib/neo4j-cypher/clause.rb
 - lib/neo4j-cypher/clause_list.rb
+- lib/neo4j-cypher/collection.rb
 - lib/neo4j-cypher/context.rb
 - lib/neo4j-cypher/create.rb
+- lib/neo4j-cypher/foreach.rb
 - lib/neo4j-cypher/match.rb
-- lib/neo4j-cypher/mixins.rb
+- lib/neo4j-cypher/neography.rb
 - lib/neo4j-cypher/node_var.rb
 - lib/neo4j-cypher/operator.rb
 - lib/neo4j-cypher/predicate.rb
@@ -44,6 +47,7 @@ files:
 - lib/neo4j-cypher/where.rb
 - lib/neo4j-cypher/with.rb
 - lib/neo4j-cypher.rb
+- lib/tasks/analyzer.rake
 - README.rdoc
 - Gemfile
 - neo4j-cypher.gemspec
@@ -69,9 +73,12 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
+      segments:
+      - 0
+      hash: -2728689632116511744
 requirements: []
 rubyforge_project: neo4j-cypher
 rubygems_version: 1.8.24

data/lib/neo4j-cypher/mixins.rb

@@ -1,47 +0,0 @@
-module Neo4j
-  module Cypher
-    module Referenceable
-      def var_name
-        @var_name ||= @clause_list.create_variable(self)
-      end
-
-      def var_name=(new_name)
-        @var_name = new_name.to_sym
-      end
-
-      def referenced?
-        !!@referenced
-      end
-
-      def referenced!
-        @referenced = true
-      end
-
-      def as_alias(new_name)
-        @alias = new_name
-        self.var_name = new_name
-      end
-
-      def alias_name
-        @alias
-      end
-
-      def as_alias?
-        !!@alias && var_name != return_value
-      end
-
-    end
-
-    module ToPropString
-      def to_prop_string(props)
-        key_values = props.keys.map do |key|
-          raw = key.to_s[0, 1] == '_'
-          val = props[key].is_a?(String) && !raw ? "'#{props[key]}'" : props[key]
-          "#{raw ? key.to_s[1..-1] : key} : #{val}"
-        end
-        "{#{key_values.join(', ')}}"
-      end
-    end
-
-  end
-end