active_node 2.2.3 → 2.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f1e0b745f51b5a1c58f9053bb5fe9b0d94b24bec
-  data.tar.gz: f83ca71aed4249ee3f7eff3f9a69b00b5b6ad7e5
+  metadata.gz: f099f7600aea945cfd5006b737360b8d5403909c
+  data.tar.gz: b2505371bcbc5ed36a5692fc6720aab6bff55985
 SHA512:
-  metadata.gz: ced0ba488ef4173804f1dbd6cc96ba567ef76f796ed7e3b093e901df80b0228309ba1dfbfb3da6fb58f9ccd73303f002642c693b353542f2f6085a64f58ae271
-  data.tar.gz: 20b2b8337a2fc1577fa9f943a5dc1ab4476138b1e3bb87255ed67963085252cf2d505e5bcd68bf9f57584ea706e1e8da9c1a47c84b83f56ecea8f2e77689f319
+  metadata.gz: 52822ad900508188e43d78788179768eb0dcde8cbbb4e543fc28c63cb1d259913dbbaeb0f50a3e6af29e4977fb063f5b8f4f57864d00778e2d0ea94cf981314a
+  data.tar.gz: aa4ca077908e7d79375059bfe776291bb4d3267d1b088e80515c6127ca8293e86c94c49945c55a39e216a40543ac5e22d9fae22da335c8b06d8447b19ca164d2

data/lib/active_node/graph.rb

@@ -1,5 +1,14 @@
 module ActiveNode
   class Graph
+    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]
+
+    VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
+
     include Neography::Rest::Helpers
     include FinderMethods, QueryMethods, Delegation
 
@@ -15,6 +24,7 @@ module ActiveNode
       @loaded_assoc_cache = {}
       @where = {}
       @includes = includes
+      @values = {}
       @offsets = {}
     end
 
@@ -36,11 +46,6 @@ module ActiveNode
       self
     end
 
-    def limit count
-      @limit = count
-      self
-    end
-
     def build *objects
       find objects.map { |o| o.is_a?(ActiveNode::Base) ? o.id.tap { |id| @object_cache[id]=o } : extract_id(o) }
     end
@@ -138,7 +143,11 @@ module ActiveNode
     end
 
     def limit_cond
-      "limit #{@limit}" if @limit
+      "limit #{limit_value}" if limit_value
+    end
+
+    def skip_cond
+      "skip #{offset_value}" if offset_value
     end
 
     def initial_match
@@ -154,7 +163,7 @@ module ActiveNode
     end
 
     def to_cypher
-      [initial_match, conditions, "with n0", limit_cond, query, 'return', list_with_rel(@reflections.size), 'order by', created_at_list(@reflections.size)].compact.join ' '
+      [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
@@ -229,15 +238,23 @@ module ActiveNode
     end
 
     def list_with_rel num
-      comma_sep_list(num) { |i| [("r#{i}" if i>0), "n#{i}"] }
+      comma_sep_list(0, num) { |i| [("r#{i}" if i>0), "n#{i}"] }
     end
 
-    def comma_sep_list num, &block
+    def comma_sep_list start, num, &block
       (0..num).map(&block).flatten.compact.join(', ')
     end
 
-    def created_at_list num
-      comma_sep_list(num) { |i| "n#{i}.created_at" }
+    def order_list_with_defaults
+      "#{order_list}, #{comma_sep_list(1, @reflections.size) { |i| "n#{i}.created_at" }}"
+    end
+
+    def order_list
+      if order_values.empty?
+        order(:created_at) if @klass.respond_to? :created_at
+        order(:id)
+      end
+      "order by #{build_order(:n0)}"
     end
 
     def extract_id(id)
@@ -250,5 +267,7 @@ module ActiveNode
           get_id(id).to_i
       end
     end
+
+
   end
 end

data/lib/active_node/graph/query_methods.rb

@@ -1,28 +1,218 @@
 module ActiveNode
   module QueryMethods
-    def order(*args)
+    Graph::MULTI_VALUE_METHODS.each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}_values                   # def select_values
+          @values[:#{name}] || []            #   @values[:select] || []
+        end                                  # end
+                                             #
+        def #{name}_values=(values)          # def select_values=(values)
+          raise ImmutableGraph if @loaded    #   raise ImmutableGraph if @loaded
+          @values[:#{name}] = values         #   @values[:select] = values
+        end                                  # end
+      CODE
+    end
+
+    (Graph::SINGLE_VALUE_METHODS - [:create_with]).each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}_value                    # def readonly_value
+          @values[:#{name}]                  #   @values[:readonly]
+        end                                  # end
+      CODE
+    end
+
+    Graph::SINGLE_VALUE_METHODS.each do |name|
+      class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def #{name}_value=(value)            # def readonly_value=(value)
+          raise ImmutableGraph if @loaded    #   raise ImmutableGraph if @loaded
+          @values[:#{name}] = value          #   @values[:readonly] = value
+        end                                  # end
+      CODE
+    end
+
+    # Specifies a limit for the number of records to retrieve.
+    #
+    #   User.limit(10) # generated SQL has 'LIMIT 10'
+    #
+    #   User.limit(10).limit(20) # generated SQL has 'LIMIT 20'
+    def limit(value)
+      spawn.limit!(value)
+    end
+
+    def limit!(value) # :nodoc:
+      self.limit_value = value
       self
     end
 
+    # Specifies the number of rows to skip before returning rows.
+    #
+    #   User.offset(10) # generated SQL has "OFFSET 10"
+    #
+    # Should be used with order.
+    #
+    #   User.offset(10).order("name ASC")
     def offset(value)
+      spawn.offset!(value)
+    end
+
+    def offset!(value) # :nodoc:
+      self.offset_value = value
+      self
+    end
+
+
+    # Allows to specify an order attribute:
+    #
+    #   User.order('name')
+    #   => SELECT "users".* FROM "users" ORDER BY name
+    #
+    #   User.order('name DESC')
+    #   => SELECT "users".* FROM "users" ORDER BY name DESC
+    #
+    #   User.order('name DESC, email')
+    #   => SELECT "users".* FROM "users" ORDER BY name DESC, email
+    #
+    #   User.order(:name)
+    #   => SELECT "users".* FROM "users" ORDER BY "users"."name" ASC
+    #
+    #   User.order(email: :desc)
+    #   => SELECT "users".* FROM "users" ORDER BY "users"."email" DESC
+    #
+    #   User.order(:name, email: :desc)
+    #   => SELECT "users".* FROM "users" ORDER BY "users"."name" ASC, "users"."email" DESC
+    def order(*args)
+      check_if_method_has_arguments!(:order, args)
+      spawn.order!(*args)
+    end
+
+    def order!(*args) # :nodoc:
+      preprocess_order_args(args)
+
+      self.order_values += args
+      self
+    end
+
+    # Replaces any existing order defined on the relation with the specified order.
+    #
+    #   User.order('email DESC').reorder('id ASC') # generated SQL has 'ORDER BY id ASC'
+    #
+    # Subsequent calls to order on the same relation will be appended. For example:
+    #
+    #   User.order('email DESC').reorder('id ASC').order('name ASC')
+    #
+    # generates a query with 'ORDER BY id ASC, name ASC'.
+    def reorder(*args)
+      check_if_method_has_arguments!(:reorder, args)
+      spawn.reorder!(*args)
+    end
+
+    def reorder!(*args) # :nodoc:
+      preprocess_order_args(args)
+
+      self.reordering_value = true
+      self.order_values = args
       self
     end
 
+    # Reverse the existing order clause on the relation.
+    #
+    #   User.order('name ASC').reverse_order # generated SQL has 'ORDER BY name DESC'
     def reverse_order
+      spawn.reverse_order!
+    end
+
+    def reverse_order! # :nodoc:
+      self.reverse_order_value = !reverse_order_value
       self
     end
 
-    #TODO temporary stubbing
-    def offset_value
-      0
+    private
+
+    def build_order(prefix)
+      orders = order_values.uniq
+      orders.reject!(&:blank?)
+      orders = reverse_sql_order(orders) if reverse_order_value
+
+      orders.map {|o| "#{prefix}.#{o}"}.join(', ')
+    end
+
+    def reverse_sql_order(order_query)
+      # order_query = ["#{quoted_table_name}.#{quoted_primary_key} ASC"] if order_query.empty?
+
+      order_query.flat_map do |o|
+        case o
+          when String
+            split_order(o).map! do |s|
+              s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
+            end
+          else
+            o
+        end
+      end
+    end
+
+    def spawn
+      clone
+    end
+
+    def split_order s
+      s.to_s.split(',').map! &:strip
+    end
+
+    def preprocess_order_args(order_args)
+      order_args.flatten!
+      validate_order_args(order_args)
+
+      # references = order_args.grep(String)
+      # references.map! { |arg| arg =~ /^([a-zA-Z]\w*)\.(\w+)/ && $1 }.compact!
+      # references!(references) if references.any?
+
+      order_args.map! do |arg|
+        case arg
+          when Symbol
+            arg = klass.attribute_alias(arg) if klass.try :attribute_alias?, arg
+            arg.to_s
+          when Hash
+            arg.map { |field, dir|
+              field = klass.attribute_alias(field) if klass.try :attribute_alias?, arg
+              "#{field} #{dir}"
+            }
+          when String
+            split_order(arg)
+          else
+            arg
+        end
+      end.flatten!
     end
 
-    def order_values
-      []
+    # Checks to make sure that the arguments are not blank. Note that if some
+    # blank-like object were initially passed into the query method, then this
+    # method will not raise an error.
+    #
+    # Example:
+    #
+    #    Post.references()   # => raises an error
+    #    Post.references([]) # => does not raise an error
+    #
+    # This particular method should be called with a method_name and the args
+    # passed into that method as an input. For example:
+    #
+    # def references(*args)
+    #   check_if_method_has_arguments!("references", args)
+    #   ...
+    # end
+    def check_if_method_has_arguments!(method_name, args)
+      if args.blank?
+        raise ArgumentError, "The method .#{method_name}() must contain arguments."
+      end
     end
 
-    def limit_value
-      nil
+    def validate_order_args(args)
+      args.grep(Hash) do |h|
+        unless (h.values - [:asc, :desc]).empty?
+          raise ArgumentError, 'Direction should be :asc or :desc'
+        end
+      end
     end
   end
-end
+end

data/lib/active_node/version.rb

@@ -1,3 +1,3 @@
 module ActiveNode
-  VERSION = "2.2.3"
+  VERSION = "2.2.4"
 end

data/spec/functional/graph/query_methods_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe ActiveNode::QueryMethods do
+  describe "#order" do
+    it "should order" do
+      p1=Person.create!(name: 'abc')
+      p2=Person.create!(name: 'def')
+      Person.order(:name).should == [p1, p2]
+      Person.order(name: :desc).should == [p2, p1]
+      Person.order('name asc').reverse_order.should == [p2, p1]
+    end
+  end
+
+  describe "#limit" do
+    it "should limt" do
+      p1=Person.create!(name: 'abc')
+      p2=Person.create!(name: 'def')
+      Person.limit(1).should == [p1]
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_node
 version: !ruby/object:Gem::Version
-  version: 2.2.3
+  version: 2.2.4
 platform: ruby
 authors:
 - Heinrich Klobuczek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-13 00:00:00.000000000 Z
+date: 2014-05-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_attr
@@ -182,6 +182,7 @@ files:
 - lib/active_node/version.rb
 - spec/functional/associations_spec.rb
 - spec/functional/base_spec.rb
+- spec/functional/graph/query_methods_spec.rb
 - spec/functional/graph_spec.rb
 - spec/functional/persistence_spec.rb
 - spec/functional/validations_spec.rb
@@ -218,6 +219,7 @@ summary: ActiveRecord style Object Graph Mapping for neo4j
 test_files:
 - spec/functional/associations_spec.rb
 - spec/functional/base_spec.rb
+- spec/functional/graph/query_methods_spec.rb
 - spec/functional/graph_spec.rb
 - spec/functional/persistence_spec.rb
 - spec/functional/validations_spec.rb