hari 0.0.4 → 0.0.5

data/lib/hari/node/queries/relation.rb

@@ -28,7 +28,7 @@ module Hari
         end
 
         def calculate_limit
-          options[:limit] || -1
+          (options[:limit].presence || -1).to_i
         end
 
         %w(limit step).each do |method|
@@ -66,6 +66,10 @@ module Hari
           Type.new self, name
         end
 
+        def first
+          limit(1).to_a.first
+        end
+
         def count
           options[:result_type] = :count
           result
@@ -75,6 +79,14 @@ module Hari
           level == 1 ? parent.node : parent.start_node
         end
 
+        def <<(nodes)
+          fail 'cannot create relation for chained queries' if level > 1
+
+          Array(nodes).each do |node|
+            Hari.relation! relation, parent.node, Hari(node)
+          end
+        end
+
         def call(final = true)
           if level == 1
             backend.fetch parent.node, call_args(final)
@@ -87,6 +99,7 @@ module Hari
           {
             relation:  relation,
             direction: direction,
+            position:  direction == :in ? 0 : 2,
             limit:     calculate_limit,
             from:      options[:from],
             step:      options[:step],

data/lib/hari/node/queries/relation/backend/sorted_set.rb

@@ -1,105 +1,56 @@
-class Hari::Node::Queries::Relation
-  module Backend
-    module SortedSet
-      extend self
-
-      def fetch(node, options = {})
-        set = node.sorted_set set_name(options)
-        send "fetch_#{options[:result]}", set, options
-      end
-
-      def fetch_relations_ids(set, options)
-        from, limit = options.values_at(:from, :limit)
-        limit = limit.try(:to_i)
-
-        if from.present? && from[:direction] == 'up'
-          set.range_by_score from[:score], '+inf', desc: true, limit: [0, limit]
-        elsif from.present? && from[:direction] == 'down'
-          set.range_by_score '-inf', from[:score], desc: true, limit: [0, limit]
-        else
-          limit -= 1 unless limit <= 0
-          set.range from, limit, desc: true
+require 'hari/node/queries/relation/backend/sorted_set/node_step'
+require 'hari/node/queries/relation/backend/sorted_set/count_step'
+
+module Hari::Node::Queries
+  class Relation
+    module Backend
+      module SortedSet
+        extend self
+        extend SortedSet::NodeStep
+        extend SortedSet::CountStep
+
+        def fetch(node, options = {})
+          set = node.sorted_set set_name(options)
+          send "fetch_#{options[:result]}", set, options
         end
-      end
-
-      def fetch_nodes_ids(set, options)
-        index = set.name =~ /in$/ ? 0 : 2
-        fetch_relations_ids(set, options).map { |r| r.split(':')[index] }
-      end
 
-      def fetch_nodes(set, options)
-        nodes_ids = fetch_nodes_ids(set, options)
-        nodes_ids.empty? ? [] : Hari.redis.mget(nodes_ids)
-      end
-
-      def fetch_count(set, options)
-        set.count
-      end
-
-      def step(start_node, nodes_ids, options = {})
-        stream    = start_node.sorted_set("stream:#{SecureRandom.hex(6)}")
-        direction = options[:direction] == :in ? 0 : 2
-        limit     = options.fetch(:limit, -1).try :to_i
-
-        nodes_ids.each_with_index do |node_id, index|
-          prune, stop = true, options.fetch(:step, 5)
-
-          if limit == -1 || stream.count < limit
-            prune, stop = false, limit
+        def fetch_relations_ids(set, options)
+          from, limit = options.values_at(:from, :limit)
+          limit = limit.try(:to_i)
+
+          if from.present? && from[:direction] == 'up'
+            set.range_by_score from[:score], '+inf', desc: true, limit: [0, limit]
+          elsif from.present? && from[:direction] == 'down'
+            set.range_by_score '-inf', from[:score], desc: true, limit: [0, limit]
+          else
+            limit -= 1 unless limit <= 0
+            set.range from, limit, desc: true
           end
+        end
 
-          start, digg = 0, true
-
-          while digg
-            set = Hari(node_id).sorted_set set_name(options)
-
-            if from = options[:from].presence
-              args = { desc: true, with_scores: true, limit: [start, stop] }
-
-              if from[:direction] == 'up'
-                scored_relations_ids = set.range_by_score(from[:score], '+inf', args)
-              elsif from[:direction] == 'down'
-                scored_relations_ids = set.range_by_score('-inf', from[:score], args)
-              end
-            else
-              scored_relations_ids = set.range(start, stop, desc: true, with_scores: true)
-            end
-
-            break if scored_relations_ids.empty?
-
-            scored_nodes_ids = scored_relations_ids.map { |(r, s)| [s, r.split(':')[direction]] }.flatten
-            stream.add *scored_nodes_ids
-
-            last_node_id = scored_nodes_ids.last
-
-            if prune
-              stream.trim_by_rank 0, stop
+        def fetch_nodes_ids(set, options)
+          index = set.name =~ /in$/ ? 0 : 2
+          fetch_relations_ids(set, options).map { |r| r.split(':')[index] }
+        end
 
-              unless stream.include? last_node_id
-                digg = false
-                start += stop + 1
-              end
-            else
-              digg = false
-            end
-          end
+        def fetch_nodes(set, options)
+          nodes_ids = fetch_nodes_ids(set, options)
+          nodes_ids.empty? ? [] : Hari.redis.mget(nodes_ids)
         end
 
-        nodes_ids = stream.revrange
+        def fetch_count(set, options)
+          set.count
+        end
 
-        if nodes_ids.any? && options[:result] == :nodes
-          Hari.redis.mget nodes_ids
-        else
-          nodes_ids
+        def step(start_node, nodes_ids, options)
+          send "step_#{options[:result]}", start_node, nodes_ids, options
         end
-      end
 
-      private
+        def set_name(options)
+          "#{options[:relation]}:#{options[:direction]}"
+        end
 
-      def set_name(options)
-        "#{options[:relation]}:#{options[:direction]}"
       end
-
     end
   end
 end

data/lib/hari/node/queries/relation/backend/sorted_set/count_step.rb

@@ -0,0 +1,16 @@
+module Hari::Node::Queries
+  class Relation
+    module Backend
+      module SortedSet
+        module CountStep
+
+          def step_count(start_node, nodes_ids, options)
+            # CONSIDER LIMIT AND FROM
+            nodes_ids.inject(0) { |b, n| b + Hari(n).sorted_set(set_name(options)).count }
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/hari/node/queries/relation/backend/sorted_set/node_step.rb

@@ -0,0 +1,91 @@
+module Hari::Node::Queries
+  class Relation
+    module Backend
+      module SortedSet
+        module NodeStep
+
+          def step_nodes(start_node, nodes_ids, options)
+            stream = start_node.sorted_set("stream:#{SecureRandom.hex(6)}")
+
+            nodes_ids.each { |node_id| step_node node_id, stream, options }
+
+            ids = stream.revrange
+
+            stream.delete!
+
+            case options[:result]
+            when :nodes_ids
+              ids
+            when :nodes
+              ids.any? ? Hari.redis.mget(ids) : []
+            end
+          end
+
+          alias :step_nodes_ids :step_nodes
+
+          def step_node(node_id, stream, options)
+            set = Hari(node_id).sorted_set set_name(options)
+
+            start = 0
+            stop = calculate_stop(stream, options)
+            prune = stream.count > options[:limit] && options[:limit] != -1
+
+            digg = true
+
+            while digg
+              if from = options[:from].presence
+                args = { desc: true, with_scores: true, limit: [start, stop] }
+
+                if from[:direction] == 'up'
+                  scored_relations_ids = set.range_by_score(from[:score], '+inf', args)
+                elsif from[:direction] == 'down'
+                  scored_relations_ids = set.range_by_score('-inf', from[:score], args)
+                end
+              else
+                scored_relations_ids = set.range(start, stop, desc: true, with_scores: true)
+              end
+
+              break if scored_relations_ids.empty?
+
+              scored_nodes_ids = scored_relations_ids.map { |(r, s)| [s, r.split(':')[options[:position]]] }.flatten
+              stream.add *scored_nodes_ids
+
+              last_node_id = scored_nodes_ids.last
+
+              if prune
+                stream.trim_by_rank 0, stop
+
+                unless stream.include? last_node_id
+                  digg = false
+                  start += stop + 1
+                end
+              else
+                digg = false
+              end
+            end
+
+            stream_count = stream.count
+
+            if options[:limit] != -1 && stream_count > options[:limit]
+              trim_stop = stream_count - options[:limit] - 1
+              stream.trim_by_rank 0, trim_stop
+            end
+          end
+
+          def calculate_stop(stream, options)
+            return options[:step].to_i if options[:step].present?
+            return options[:limit] if stream.count < options[:limit]
+
+            case options[:limit]
+            when -1, 1...5
+              options[:limit]
+            else
+              5
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/hari/node/queries/type.rb

@@ -3,10 +3,11 @@ module Hari
     module Queries
       class Type
 
-        attr_reader :relation, :name
+        attr_reader :relation, :name, :options
 
         def initialize(relation, name)
           @relation, @name = relation, name
+          @options = {}
         end
 
         def intersect_count(type)
@@ -42,20 +43,84 @@ module Hari
           end
         end
 
+        def count
+          Hari.redis.zcard key
+        end
+
+        def ids
+          start = options[:start] || 0
+          stop  = options[:stop]  || -1
+
+          Hari.redis.zrevrange key, start, stop
+        end
+
+        def nodes_ids
+          ids.map { |id| "#{name}##{id}" }
+        end
+
+        alias :nodes_ids! :nodes_ids
+        alias :n_ids      :nodes_ids
+        alias :nids       :nodes_ids
+
+        def nodes
+          if ids = nodes_ids.presence
+            Hari.redis.mget(ids).map &Hari::Node.method(:from_source)
+          end
+        end
+
+        alias :nodes! :nodes
+        alias :to_a   :nodes
+
+        def relations_ids
+          ids.map &method(:relation_key)
+        end
+
+        alias :relations_ids! :relations_ids
+        alias :rids           :relations_ids
+        alias :rel_ids        :relations_ids
+
+        def limit(start, stop)
+          options.merge! start: start, stop: stop
+
+          self
+        end
+
+        def <<(ids)
+          Array(ids).each do |id|
+            Hari.relation! relation.name, relation.parent.node, Hari(name => id)
+          end
+        end
+
+        def where(conditions = {})
+          type_class.where(conditions).tap do |index|
+            index.indexes << self
+          end
+        end
+
         def key
-          start_key = Hari.node_key(relation.parent.node)
           "#{start_key}:#{relation.name}:#{relation.direction}:#{name}"
         end
 
         def sort_key
-          start_key = Hari.node_key(relation.parent.node)
-          "#{start_key}:#{relation.name}:#{name}#*"
+          relation_key '*'
+        end
+
+        def relation_key(id)
+          "#{start_key}:#{relation.name}:#{name}##{id}"
         end
 
         def intersect_key(type)
           "inter:#{key}:#{type.key}"
         end
 
+        def start_key
+          Hari.node_key relation.parent.node
+        end
+
+        def type_class
+          name.to_s.camelize.constantize
+        end
+
       end
     end
   end

data/lib/hari/node/repository.rb

@@ -3,6 +3,27 @@ module Hari
     module Repository
       extend ActiveSupport::Concern
 
+      def reindex(options = {})
+        self.class.indexed_properties.each do |property|
+          if change = previous_changes[property.name]
+            previous, current = change
+
+            Index.new(property, previous).delete self
+            Index.new(property, current).add self
+          elsif options[:force_index]
+            value = send(property.name)
+            Index.new(property, value).add self
+          end
+        end
+      end
+
+      def remove_from_indexes
+        self.class.indexed_properties.each do |property|
+          value = send(property.name)
+          Index.new(property, value).delete self
+        end
+      end
+
       module ClassMethods
 
         def find_one(id, options = {})
@@ -18,6 +39,21 @@ module Hari
           super ids, options
         end
 
+        def find_by(name, value)
+          if property = indexed_properties.find { |p| p.name.to_s == name.to_s }
+            Index.new property, value
+          else
+            fail "missing index for key #{name}"
+          end
+        end
+
+        def where(conditions = {})
+          conditions.inject(nil) do |index, (key, value)|
+            query = find_by(key, value)
+            index ? index.append(query) : query
+          end
+        end
+
       end
     end
   end

data/lib/hari/node/serialization.rb

@@ -5,18 +5,19 @@ module Hari
       def from_source(source)
         return if source.blank?
 
-        hash = Yajl::Parser.parse(source)
-        klass = hash['id'].split('#').first.camelize.constantize
-
-        attrs = hash.inject({}) do |buffer, (key, value)|
-          if prop = klass.properties.find { |p| p.name == key }
-            buffer[key] = prop.desserialize(value)
-          end
-
-          buffer
+        case source
+        when ::String
+          hash = Yajl::Parser.parse(source)
+          source_class(hash).from_hash hash
+        when ::Hash
+          source_class(source).from_hash source
         end
+      end
+
+      private
 
-        klass.new attrs
+      def source_class(source)
+        source['id'].split('#').first.camelize.constantize
       end
 
     end