hari 0.0.1 → 0.0.3

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

@@ -0,0 +1,100 @@
+require 'hari/node/queries/relation/step'
+require 'hari/node/queries/relation/start'
+require 'hari/node/queries/relation/runnable'
+require 'hari/node/queries/relation/backend/sorted_set'
+
+module Hari
+  class Node < Entity
+    module Queries
+      class Relation
+        include Relation::Step
+        include Relation::Runnable
+
+        attr_reader :parent, :direction, :relation, :level, :options
+
+        def initialize(parent, direction, relation, *args)
+          @parent, @direction, @relation = parent, direction, relation
+          @level = parent.level + 1
+          @options = {}
+          args.extract_options!.each { |k, v| send k, v }
+
+          @options[:backend] = args.first.presence || Backend::SortedSet
+        end
+
+        def backend
+          options[:backend]
+        end
+
+        def calculate_limit
+          options[:limit] ? (options[:limit].to_i - 1) : -1
+        end
+
+        %w(limit from step).each do |method|
+          define_method method do |value|
+            options[method.to_sym] = value
+            self
+          end
+        end
+
+        # TODO for later, filter by node type
+        def types(*types)
+          options[:types] = types
+          self
+        end
+
+        alias :type :types
+
+        %w(nodes_ids relations_ids nodes).each do |result_type|
+          define_method result_type do
+            options[:result_type] = result_type.to_sym
+            self
+          end
+
+          define_method "#{result_type}!" do
+            send result_type
+            result
+          end
+        end
+
+        alias :nids    :nodes_ids
+        alias :rel_ids :relations_ids
+        alias :rids    :relations_ids
+
+        def count
+          options[:result_type] = :count
+          result
+        end
+
+        def start_node
+          level == 1 ? parent.node : parent.start_node
+        end
+
+        def call(final = true)
+          if level == 1
+            backend.fetch parent.node, call_args(final)
+          else
+            backend.step start_node, parent.call(false), call_args(final)
+          end
+        end
+
+        def call_args(final = true)
+          {
+            relation:  relation,
+            direction: direction,
+            limit:     calculate_limit,
+            from:      options[:from],
+            step:      options[:step],
+            result:    result_type(final)
+          }
+        end
+
+        def result_type(final = false)
+          return :nodes_ids unless final
+
+          options.fetch :result_type, :nodes
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Hari::Node::Queries::Relation
+  module Backend
+    module List
+      extend self
+
+      def fetch(node, options = {})
+        list = node.list list_name(options)
+        send "fetch_#{options[:result]}", list, options
+      end
+
+      def fetch_relations_ids(list, options = {})
+        start = options.fetch(:from, 0)
+        stop  = options.limit(:limit, -1)
+
+        list.range start, stop
+      end
+
+      def fetch_nodes_ids(list, options)
+        index = list.name =~ /in$/ ? 1 : 2
+        fetch_relations_ids(list, options).map { |r| r.split(':')[index] }
+      end
+
+      def fetch_count(list, options)
+        list.count
+      end
+
+      private
+
+      def list_name(options)
+        "#{options[:relation]}:#{options[:direction]}"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+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)
+
+        if from.present?
+          set.range_by_score from, '+inf', desc: true, limit: [0, limit]
+        else
+          set.range from, limit, desc: true
+        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)
+
+        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
+          end
+
+          start, digg = 0, true
+
+          while digg
+            set = Hari(node_id).sorted_set set_name(options)
+
+            if from = options[:from].presence
+              scored_relations_ids = set.range_by_score(from, '+inf', desc: true, with_scores: true, limit: [start, stop])
+            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
+
+              unless stream.include? last_node_id
+                digg = false
+                start += stop + 1
+              end
+            else
+              digg = false
+            end
+          end
+        end
+
+        nodes_ids = stream.revrange
+
+        if nodes_ids.any? && options[:result] == :nodes
+          Hari.redis.mget nodes_ids
+        else
+          nodes_ids
+        end
+      end
+
+      private
+
+      def set_name(options)
+        "#{options[:relation]}:#{options[:direction]}"
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+module Hari
+  class Node < Entity
+    module Queries
+      class Relation
+        module Runnable
+
+          def result
+            result = call(true)
+
+            case result_type(true)
+            when :nodes
+              result.map &Hari::Node.method(:from_source)
+            else
+              result
+            end
+          end
+
+          alias :to_a :result
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Hari
+  class Node < Entity
+    module Queries
+      class Relation
+        class Start
+          include Relation::Step
+
+          attr_reader :node, :level
+
+          def initialize(node)
+            @node = node
+            @level = 0
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Hari
+  class Node < Entity
+    module Queries
+      class Relation
+        module Step
+
+          %w(in out).each do |direction|
+            define_method direction do |*args|
+              Relation.new self, direction, *args
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+module Hari
+  class Node < Entity
+    module Queries
+      class Set
+
+        attr_reader :node, :name
+
+        def initialize(node = nil)
+          @node = node
+        end
+
+        def key
+          @key ||= begin
+            prefix = node ? "#{Hari.node_key(node)}:" : ''
+            prefix + name.to_s
+          end
+        end
+
+        def set(name)
+          @name = name
+          self
+        end
+
+        def set!(name)
+          @name = name
+          members
+        end
+
+        def members
+          Hari.redis.smembers key
+        end
+
+        def rand(count = 1)
+          Hari.redis.srandmember key, count
+        end
+
+        def count
+          Hari.redis.scard key
+        end
+
+        alias :size :count
+        alias :length :count
+
+        def empty?
+          count == 0
+        end
+
+        def one?
+          count == 1
+        end
+
+        def many?
+          count > 1
+        end
+
+        def include?(member)
+          Hari.redis.sismember key, member
+        end
+
+        alias :member? :include?
+
+        def add(*members)
+          Hari.redis.sadd key, members
+        end
+
+        def <<(member)
+          add member
+        end
+
+        def delete(*members)
+          Hari.redis.srem key, members
+        end
+
+        def pop
+          Hari.redis.spop key
+        end
+
+        def intersect(*set_queries)
+          Hari.redis.sinter key, set_query_keys(set_queries)
+        end
+
+        def &(other_set_query)
+          intersect other_set_query
+        end
+
+        def diff(*set_queries)
+          Hari.redis.sdiff key, set_query_keys(set_queries)
+        end
+
+        def -(other_set_query)
+          diff other_set_query
+        end
+
+        private
+
+        def set_query_keys(set_queries)
+          keys = set_queries.map do |query|
+            ensure_set_query! query
+            query.key
+          end
+
+          fail 'no query keys' if keys.empty?
+
+          keys
+        end
+
+        def ensure_set_query!(query)
+          unless query.kind_of?(Hari::Node::Queries::Set)
+            fail 'not a set query'
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,130 @@
+module Hari
+  class Node < Entity
+    module Queries
+      class SortedSet
+
+        attr_reader :node, :name
+
+        def initialize(node = nil)
+          @node = node
+        end
+
+        def key
+          @key ||= begin
+            prefix = node ? "#{Hari.node_key(node)}:" : ''
+            prefix + name.to_s
+          end
+        end
+
+        def sorted_set(name)
+          @name = name
+          self
+        end
+
+        def sorted_set!(name)
+          @name = name
+          members
+        end
+
+        def range(start = 0, stop = -1, options = {})
+          return revrange(start, stop, options) if options[:desc]
+
+          Hari.redis.zrange key, start, stop, options.slice(:with_scores)
+        end
+
+        alias :members :range
+
+        def range_with_scores
+          range 0, -1, with_scores: true
+        end
+
+        def revrange(start = 0, stop = -1, options = {})
+          Hari.redis.zrevrange key, start, stop, options.slice(:with_scores)
+        end
+
+        alias :reverse_range :revrange
+        alias :desc_range    :revrange
+
+        def revrange_with_scores
+          revrange 0, -1, with_scores: true
+        end
+
+        def range_by_score(min, max, options = {})
+          return revrange_by_score(min, max, options) if options[:desc]
+
+          Hari.redis.zrangebyscore key, min, max, options.slice(:with_scores, :limit)
+        end
+
+        def revrange_by_score(min, max, options = {})
+          Hari.redis.zrevrangebyscore key, max, min, options.slice(:with_scores, :limit)
+        end
+
+        def rank(member, options = {})
+          return revrank(member, options) if options[:desc]
+
+          Hari.redis.zrank key, member
+        end
+
+        alias :ranking  :rank
+        alias :position :rank
+
+        def revrank(member)
+          Hari.redis.zrevrank key, member
+        end
+
+        alias :reverse_ranking  :revrank
+        alias :reverse_position :revrank
+
+        def count
+          Hari.redis.zcard key
+        end
+
+        alias :size :count
+        alias :length :count
+
+        def empty?
+          count == 0
+        end
+
+        def one?
+          count == 1
+        end
+
+        def many?
+          count > 1
+        end
+
+        def include?(member)
+          score(member).present?
+        end
+
+        alias :member? :include?
+
+        def score(member)
+          Hari.redis.zscore key, member
+        end
+
+        def add(*score_members)
+          Hari.redis.zadd key, score_members.to_a.flatten
+        end
+
+        def <<(*score_members)
+          add score_members
+        end
+
+        def delete(*members)
+          Hari.redis.zrem key, members
+        end
+
+        def trim_by_rank(start, stop)
+          Hari.redis.zremrangebyrank key, start, stop
+        end
+
+        def trim_by_score(min, max)
+          Hari.redis.zremrangebyscore key, min, max
+        end
+
+      end
+    end
+  end
+end