active_node 2.2.6 → 2.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3416059b31793c6207482121cf2f34de2d24b11f
-  data.tar.gz: 8286a0af63a32878cfaa64902877c1290899744c
+  metadata.gz: 1b61a35ae17f4598504c8840a398430f85c0a6a3
+  data.tar.gz: 4ee34af5defc7d4e94f201ffac233ff0ab30344b
 SHA512:
-  metadata.gz: 7af0ea851c7d6b59474a3a67eb739c2c76edf424fd7ada60eac28302ca438cacc20a6863f74ed60fc0bf84242af505a905da495d1e5e4996aa595891abe1e41b
-  data.tar.gz: bfe66442b9408ab7f09946e48813c1741b0158fd73add2b4d0c29144a4f00ef5f13f4a8a81d39b209ca75105e7545ac6d6bdd856bb81792e6d236a68bc25a8ea
+  metadata.gz: 1f100b6302c72bc460b5f8149adaaf5bf179bb3dd6b2a84ad5db8bacb12db160ae4ad366243c19bb20a1bee3f90b20b0b11515f9fbd5d97f8c117bc52d5710fd
+  data.tar.gz: 7547f7c6a17f49dc5ad264843b16007cd17a1dc28b8f785c9fdb1fb519770eee51ff73a7a4e0b15e82b1ba889a6f4efd3facb3a60bc3d159ba483fae97409c2b

data/lib/active_node/graph.rb

@@ -1,8 +1,8 @@
 module ActiveNode
   class Graph
-    MULTI_VALUE_METHODS  = [:includes, :eager_load, :preload, :select, :group,
-                            :order, :joins, :where, :having, :bind, :references,
-                            :extending, :unscope]
+    MULTI_VALUE_METHODS = [:includes, :eager_load, :preload, :select, :group,
+                           :order, :joins, :where, :having, :bind, :references,
+                           :extending, :unscope]
 
     SINGLE_VALUE_METHODS = [:limit, :offset, :lock, :readonly, :from, :reordering,
                             :reverse_order, :distinct, :create_with, :uniq]
@@ -15,6 +15,8 @@ module ActiveNode
     attr_reader :reflections, :matches, :klass, :loaded
     alias :loaded? :loaded
 
+    delegate :data, :extract_id, to: ActiveNode::Base
+
     def initialize klass, *includes
       @klass = klass if klass < ActiveNode::Base
       @matches = []
@@ -51,7 +53,7 @@ module ActiveNode
     end
 
     def load
-      parse_results execute unless loaded?
+      parse_results execute['data'] unless loaded?
       self
     end
 
@@ -159,30 +161,27 @@ module ActiveNode
     end
 
     def sanitize_where
-      @where.each { |key, value| @where[key] = extract_id(value) if key.to_s == 'id'}
+      @where.each { |key, value| @where[key] = extract_id(value) if key.to_s == 'id' }
     end
 
     def to_cypher
       [initial_match, conditions, "with n0", order_list, skip_cond, limit_cond, query, 'return', list_with_rel(@reflections.size), order_list_with_defaults].compact.join ' '
     end
 
-    def parse_results results
-      records = Set.new
-      results['data'].each do |record|
-        records << wrap(record.first, @klass)
+    def parse_results data
+      @records = data.reduce(Set.new) { |set, record| set << wrap(record.first, @klass) }.to_a
+      alternate_cells(data, 2) { |node, reflection| wrap node, reflection.klass }
+      alternate_cells(data, 1) { |rel, reflection| wrap_rel [rel].flatten.last, reflection }
+      @loaded = true
+    end
+
+    def alternate_cells data, shift
+      data.each do |row|
         @reflections.each_with_index do |reflection, index|
-          node_rel = record[2*index+1]
-          node_rel = node_rel.last if node_rel.is_a? Array
-          next unless node_rel
-          owner = @object_cache[owner_id node_rel, reflection.direction]
-          node = wrap record[2*index + 2], reflection.klass
-          rel = reflection.klass.create_rel node_rel, node
-          assoc = owner.association(reflection.name)
-          assoc.rels_writer((assoc.rel_target || []) << rel) unless previously_loaded?(assoc)
+          cell = row[2*index + shift]
+          yield cell, reflection if cell
         end
       end
-      @loaded = true
-      @records = records.to_a
     end
 
     def previously_loaded?(assoc)
@@ -194,8 +193,19 @@ module ActiveNode
       @object_cache[extract_id record] ||= ActiveNode::Base.wrap(record, klass)
     end
 
-    def owner_id relationship, direction
-      extract_id relationship[direction == :incoming ? 'end' : 'start']
+    def wrap_rel(rel, reflection)
+      @relationship_cache[extract_id rel] ||= create_rel(rel, reflection)
+    end
+
+    def create_rel(rel, reflection)
+      ActiveNode::Relationship.new(@object_cache[node_id rel, reflection, :other], data(rel)).tap do |relationship|
+        assoc = @object_cache[node_id rel, reflection, :owner].association(reflection.name)
+        assoc.rels_writer((assoc.rel_target || []) << relationship) unless previously_loaded?(assoc)
+      end
+    end
+
+    def node_id relationship, reflection, side
+      extract_id relationship[reflection.direction == {owner: :outgoing, other: :incoming}[side] ? 'start' : 'end']
     end
 
     def parse_paths as, klass, includes
@@ -256,18 +266,5 @@ module ActiveNode
       end
       "order by #{build_order(:n0)}"
     end
-
-    def extract_id(id)
-      case id
-        when Array
-          id.map { |i| extract_id(i) }
-        when ActiveNode::Base
-          id.id
-        else
-          get_id(id).to_i
-      end
-    end
-
-
   end
 end

data/lib/active_node/persistence.rb

@@ -31,14 +31,6 @@ module ActiveNode
         node.is_a?(Array) ? new_instances(node, klass) : new_instance(node, klass)
       end
 
-      def wrap_rel rel, node, klass
-        create_rel rel, wrap(node, klass)
-      end
-
-      def create_rel rel, node
-        ActiveNode::Relationship.new node, rel['data'].merge(id: get_id(rel).to_i)
-      end
-
       def active_node_class(class_name, default_klass=nil)
         klass = Module.const_get(class_name) rescue nil
         klass && klass < ActiveNode::Base && klass || default_klass
@@ -48,15 +40,26 @@ module ActiveNode
         ActiveNode::Graph.new(self)
       end
 
+      def data hash
+        hash['data'].merge(id: extract_id(hash))
+      end
+
+      def extract_id(id)
+        case id
+          when Array
+            id.map { |i| extract_id(i) }
+          when ActiveNode::Base
+            id.id
+          else
+            get_id(id).to_i
+        end
+      end
+
       private
       def new_instance node, klass=nil
         node && (klass || find_suitable_class(Neo.db.get_node_labels(node))).try(:new, data(node), :declared?)
       end
 
-      def data hash
-        hash['data'].merge(id: get_id(hash).to_i)
-      end
-
       def new_instances nodes, klass=nil
         nodes.map { |node| new_instance(node, klass) }.compact
       end
@@ -203,7 +206,7 @@ module ActiveNode
     end
 
     def create_node_with_label
-      self.id = get_id(Neo.db.create_node(all_attributes)).to_i
+      self.id = self.class.extract_id(Neo.db.create_node(all_attributes))
       Neo.db.set_label(id, self.class.label)
     end
 

data/lib/active_node/version.rb

@@ -1,3 +1,3 @@
 module ActiveNode
-  VERSION = "2.2.6"
+  VERSION = "2.2.7"
 end

data/lib/ext/rails/generators/generated_attribute.rb

@@ -0,0 +1,9 @@
+module Rails
+  module Generators
+    class GeneratedAttribute
+      def type_class
+        type.to_s.camelcase
+      end
+    end
+  end
+end

data/lib/generators/active_node/model/USAGE

@@ -0,0 +1,55 @@
+Description:
+    Creates a new ActiveNode model, using the given NAME.  Similar to with
+    active_record, pass the model name, either CamelCased or under_scored, and
+    an optional list of attribute pairs as arguments.
+
+    Attribute pairs are attribute:type arguments specifying the model's
+    attributes. The +timestamps+ call is added by default, so you don't have to
+    a) specify them as explicit attributes, nor b) add the +timestamps+ call
+    yourself.  You can, however, turn this off by using the +--no-timestamps+
+    option.
+
+    This generator invokes your configured test framework and will, thus,
+    create tests for your generated model.
+
+
+Available field types:
+
+    Just after the field name you can specify a type like String or boolean.
+    It will generate the property key with the associated Neo4J value type. You
+    can use the following types:
+
+    * big_decimal
+    * boolean
+    * date
+    * date_time
+    * float
+    * integer
+    * object
+    * string
+
+Examples:
+
+    `rails generate active_node:model Car`
+
+        Creates:
+
+            Model: +app/models/car.rb+
+            Test:  +test/models/car_test.rb+
+
+    `rails generate active_node:model Car make engine_displacement`
+
+        This will...
+
+            ...create app/models/car.rb
+            ...add ActiveNode attributes +make+ and +engine_displacement+,
+            without specifying the attribute type.
+
+    `rails generate active_node:model Car make:string engine_displacement:short`
+
+        This will...
+
+            * ...app/models/car.rb
+            * ...add ActiveNode attributes +make+ as type String, and
+              +engine_displacement+ as type short.
+

data/lib/generators/active_node/model/model_generator.rb

@@ -0,0 +1,25 @@
+require_relative '../../../ext/rails/generators/generated_attribute'
+
+module ActiveNode
+  class ModelGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path('../templates', __FILE__)
+    check_class_collision
+
+    class_option :timestamps,
+      type: :boolean,
+      default: true
+
+    hook_for :test_framework,
+      as: :model,
+      aliases: '-t'
+
+    argument :attributes,
+      type: :array,
+      default: [],
+      banner: 'attribute[:type] attribute[:type]'
+
+    def create_model_file
+      template 'model.rb.erb', File.join('app/models', class_path, "#{file_name}.rb")
+    end
+  end
+end

data/lib/generators/active_node/model/templates/model.rb.erb

@@ -0,0 +1,10 @@
+<% module_namespacing do -%>
+class <%= class_name %> < ActiveNode::Base
+<% attributes.reject(&:reference?).each do |attribute| -%>
+  attribute :<%= attribute.name %>, type: <%= attribute.type_class %>
+<% end -%>
+<% if options[:timestamps] -%>
+  timestamps
+<% end -%>
+end
+<% end -%>

data/spec/functional/graph_spec.rb

@@ -50,5 +50,13 @@ describe ActiveNode::Graph do
       p = Person.create! father: Person.create!
       Person.where(id: p.id).includes(:father).first.should == p
     end
+
+    it "should return correct associated objects" do
+      child1 = Person.create! children: [Person.create!, Person.create!]
+      person = Person.create! children: [child1]
+      Person.includes(children: :children).find(person.id).children.should == [child1]
+      Person.includes(children: 2).find(person.id).children.should == [child1]
+      Person.includes(children: '*').find(person.id).children.should == [child1]
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_node
 version: !ruby/object:Gem::Version
-  version: 2.2.6
+  version: 2.2.7
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-17 00:00:00.000000000 Z
+date: 2014-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_attr
@@ -180,6 +180,10 @@ files:
 - lib/active_node/validations.rb
 - lib/active_node/validations/uniqueness.rb
 - lib/active_node/version.rb
+- lib/ext/rails/generators/generated_attribute.rb
+- lib/generators/active_node/model/USAGE
+- lib/generators/active_node/model/model_generator.rb
+- lib/generators/active_node/model/templates/model.rb.erb
 - spec/functional/associations_spec.rb
 - spec/functional/base_spec.rb
 - spec/functional/graph/query_methods_spec.rb