hari 0.0.3 → 0.0.4

data/lib/hari/keys/string.rb

@@ -0,0 +1,81 @@
+module Hari
+  module Keys
+    class String < Key
+
+     def string(name)
+        @name = name
+        self
+      end
+
+      def string!(name)
+        @name = name
+        to_s
+      end
+
+      def to_s
+        Hari.redis.get key
+      end
+
+      def set(value)
+        Hari.redis.set key, value
+      end
+
+      def length
+        Hari.redis.strlen key
+      end
+
+      alias :size :length
+
+      def range(start = nil, stop = nil)
+        start ||= 0
+        stop ||= -1
+        Hari.redis.getrange key, start, stop
+      end
+
+      def at(index)
+        Hari.redis.getrange key, index, index
+      end
+
+      def [](*args)
+        arg = args.first
+
+        if args.size == 2
+          range *args
+        elsif arg.kind_of? Integer
+          at arg
+        elsif arg.kind_of? Range
+          range arg.first, arg.last
+        end
+      end
+
+      def <<(value)
+        Hari.redis.append key, value
+      end
+
+      def +(i)
+        Hari.redis.incrby key, i
+        self
+      end
+
+      def -(i)
+        Hari.redis.decrby key, i
+        self
+      end
+
+      def bitcount(start = nil, stop = nil)
+        start ||= 0
+        stop ||= -1
+        Hari.redis.bitcount key, start, stop
+      end
+
+      def getbit(offset)
+        Hari.redis.getbit key, offset
+      end
+
+      def setbit(offset, value)
+        Hari.redis.setbit key, offset, value
+      end
+
+    end
+  end
+end

data/lib/hari/keys.rb

@@ -0,0 +1,9 @@
+module Hari
+  module Keys
+    autoload :Key,       'hari/keys/key'
+    autoload :List,      'hari/keys/list'
+    autoload :Set,       'hari/keys/set'
+    autoload :SortedSet, 'hari/keys/sorted_set'
+    autoload :String,    'hari/keys/string'
+  end
+end

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

@@ -10,10 +10,14 @@ class Hari::Node::Queries::Relation
 
       def fetch_relations_ids(set, options)
         from, limit = options.values_at(:from, :limit)
+        limit = limit.try(:to_i)
 
-        if from.present?
-          set.range_by_score from, '+inf', desc: true, limit: [0, limit]
+        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
@@ -35,7 +39,7 @@ class Hari::Node::Queries::Relation
       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)
+        limit     = options.fetch(:limit, -1).try :to_i
 
         nodes_ids.each_with_index do |node_id, index|
           prune, stop = true, options.fetch(:step, 5)
@@ -50,7 +54,13 @@ class Hari::Node::Queries::Relation
             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])
+              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

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

@@ -12,6 +12,8 @@ module Hari
 
         attr_reader :parent, :direction, :relation, :level, :options
 
+        alias :name :relation
+
         def initialize(parent, direction, relation, *args)
           @parent, @direction, @relation = parent, direction, relation
           @level = parent.level + 1
@@ -26,24 +28,22 @@ module Hari
         end
 
         def calculate_limit
-          options[:limit] ? (options[:limit].to_i - 1) : -1
+          options[:limit] || -1
         end
 
-        %w(limit from step).each do |method|
+        %w(limit 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
+        def from(score, direction = nil)
+          direction ||= :up
+          options[:from] = { score: score, direction: direction.to_s }
           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
@@ -60,6 +60,12 @@ module Hari
         alias :rel_ids :relations_ids
         alias :rids    :relations_ids
 
+        def type(name)
+          fail 'type not supported for chained queries' if level > 1
+
+          Type.new self, name
+        end
+
         def count
           options[:result_type] = :count
           result

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

@@ -0,0 +1,62 @@
+module Hari
+  class Node < Entity
+    module Queries
+      class Type
+
+        attr_reader :relation, :name
+
+        def initialize(relation, name)
+          @relation, @name = relation, name
+        end
+
+        def intersect_count(type)
+          intersect_key = interstore(type)
+
+          Hari.redis.zcard(intersect_key).tap do
+            Hari.redis.del intersect_key
+          end
+        end
+
+        def intersect(type, start = nil, stop = nil)
+          start ||= 0
+          stop  ||= -1
+
+          intersect_key = interstore(type)
+
+          Hari.redis.zrevrange(intersect_key, start, stop).tap do
+            Hari.redis.del intersect_key
+          end
+        end
+
+        def sort_by(type, offset = nil, count = nil, order = nil)
+          offset ||= 0
+          count  ||= Hari.redis.zcard(key)
+          order  = 'desc' unless order.to_s == 'asc'
+
+          Hari.redis.sort key, by: type.sort_key, order: "#{order} alpha", limit: [offset, count]
+        end
+
+        def interstore(type)
+          intersect_key(type).tap do |destination|
+            Hari.redis.zinterstore destination, [key, type.key]
+          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}#*"
+        end
+
+        def intersect_key(type)
+          "inter:#{key}:#{type.key}"
+        end
+
+      end
+    end
+  end
+end

data/lib/hari/node/queries.rb

@@ -1,30 +1,32 @@
-require 'hari/node/queries/list'
-require 'hari/node/queries/set'
-require 'hari/node/queries/sorted_set'
-require 'hari/node/queries/relation'
-
 module Hari
   class Node < Entity
     module Queries
+      autoload :Relation, 'hari/node/queries/relation'
+      autoload :Type,     'hari/node/queries/type'
 
       delegate :in, :out, to: :relation_query
 
       delegate :set,        :set!,        to: :set_query
       delegate :sorted_set, :sorted_set!, to: :sorted_set_query
       delegate :list,       :list!,       to: :list_query
+      delegate :string,     :string!,     to: :string_query
 
       private
 
       def set_query
-        Queries::Set.new query_node
+        Keys::Set.new query_node
       end
 
       def sorted_set_query
-        Queries::SortedSet.new query_node
+        Keys::SortedSet.new query_node
       end
 
       def list_query
-        Queries::List.new query_node
+        Keys::List.new query_node
+      end
+
+      def string_query
+        Keys::String.new query_node
       end
 
       def relation_query

data/lib/hari/relation/sorted_set.rb

@@ -3,12 +3,41 @@ module Hari
     module SortedSet
       extend self
 
-      def create(rel)
-        Relation::DIRECTIONS.each { |d| Hari.redis.zadd rel.key(d), rel.weight(d), rel.id }
+      def create(relation)
+        Relation::DIRECTIONS.each do |direction|
+          key    = relation.key(direction)
+          weight = relation.weight(direction)
+
+          Hari.redis.zadd key, weight, relation.id
+          Hari.redis.zadd type_key(relation, direction), weight, type_id(relation, direction)
+        end
+      end
+
+      def delete(relation)
+        Relation::DIRECTIONS.each do |direction|
+          key = relation.key(direction)
+
+          Hari.redis.zrem key, relation.id
+          Hari.redis.zrem type_key(relation, direction), type_id(relation, direction)
+        end
+      end
+
+      private
+
+      def type_key(relation, direction)
+        case direction.to_s
+        when 'out'
+          "#{relation.start_node_id}:#{relation.label}:out:#{Hari.node_type(relation.end_node_id)}"
+        when 'in'
+          "#{relation.end_node_id}:#{relation.label}:in:#{Hari.node_type(relation.start_node_id)}"
+        end
       end
 
-      def delete(rel)
-        Relation::DIRECTIONS.each { |d| Hari.redis.zrem rel.key(d), rel.id }
+      def type_id(relation, direction)
+        case direction.to_s
+        when 'in'  then Hari.node_id(relation.start_node_id)
+        when 'out' then Hari.node_id(relation.end_node_id)
+        end
       end
 
     end

data/lib/hari/relation.rb

@@ -1,4 +1,3 @@
-require 'hari/relation/linked_list'
 require 'hari/relation/sorted_set'
 
 module Hari
@@ -54,8 +53,6 @@ module Hari
       ::Time.now.to_f
     end
 
-    private
-
     def create
       super
       backend.create self

data/lib/hari/version.rb

@@ -1,3 +1,3 @@
 module Hari
-  VERSION = '0.0.3'
+  VERSION = '0.0.4'
 end

data/lib/hari.rb

@@ -12,12 +12,15 @@ require 'ostruct'
 require 'hari/version'
 require 'hari/configuration'
 require 'hari/errors'
-require 'hari/entity'
-require 'hari/node'
-require 'hari/relation'
 
 module Hari
   extend self
+
+  autoload :Entity,   'hari/entity'
+  autoload :Keys,     'hari/keys'
+  autoload :Node,     'hari/node'
+  autoload :Relation, 'hari/relation'
+
   extend Configuration
   extend Hari::Node::Queries
 
@@ -68,6 +71,10 @@ module Hari
     Relation.create type, from, target
   end
 
+  def remove_relation!(type, from, target)
+    relation!(type, from, target).delete
+  end
+
 end
 
 def Hari(arg)

data/spec/hari/keys/key_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Hari::Keys::Key do
+
+  let(:node) { Hari.node user: 10 }
+  subject    { node.list :friends }
+
+  specify { subject.instance_of? Hari::Keys::Key }
+
+  before { subject.add 1 }
+
+  specify '#exists? + #delete!' do
+    subject.exists?.should be_true
+
+    subject.delete!
+
+    subject.exists?.should be_false
+  end
+
+  specify '#type' do
+    subject.type.should eq('list')
+  end
+
+  specify '#expire + #persist + #ttl' do
+    subject.expire 80 # ms
+    (subject.ttl.to_i < 80).should be_true
+
+    sleep 0.1
+
+    subject.exists?.should be_false
+
+    subject.add 12
+    subject.expire 100
+    subject.persist
+
+    sleep 0.2
+
+    subject.exists?.should be_true
+  end
+
+end

data/spec/hari/{node → keys}/lists_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Hari::Node::Queries::List do
+describe Hari::Keys::List do
 
   let(:node) { Hari.node user: 10 }
   subject    { node.list :friends }

data/spec/hari/{node → keys}/sets_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Hari::Node::Queries::Set do
+describe Hari::Keys::Set do
 
   let(:node) { Hari.node user: 10 }
   subject    { node.set :friends }

data/spec/hari/{node → keys}/sorted_sets_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Hari::Node::Queries::SortedSet do
+describe Hari::Keys::SortedSet do
 
   let(:node) { Hari.node user: 10 }
   subject    { node.sorted_set :friends }

data/spec/hari/keys/string_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Hari::Keys::String do
+
+  let(:node) { Hari.node user: 10 }
+  subject    { node.string :bio }
+
+  specify '#string! + #to_s + #set' do
+    subject.set 'lol'
+    node.string!(:bio).should eq('lol')
+
+    subject.to_s.should eq('lol')
+  end
+
+  specify '#length' do
+    subject.set 'lol'
+    subject.length.should eq(3)
+    subject.size.should eq(3)
+  end
+
+  specify '#at + #range + #[]' do
+    subject.set 'de his omnibus non cogitavi'
+
+    subject.at(7).should eq('o')
+    subject[7].should eq('o')
+
+    subject.range(7, 13).should eq('omnibus')
+    subject[7, 13].should eq('omnibus')
+    subject[7..13].should eq('omnibus')
+  end
+
+  specify '#<<' do
+    subject.set 'lol'
+    subject << 'omg'
+    subject << 'bbq'
+
+    subject.to_s.should eq('lolomgbbq')
+  end
+
+  specify '#+ + #-' do
+    subject.set 1
+    subject + 4
+    subject.to_s.should eq('5')
+
+    subject - 7
+    subject.to_s.should eq('-2')
+  end
+
+  specify '#bitcount + #getbit + #setbit' do
+    subject.set 'lol'
+    subject.bitcount.should eq(14)
+    subject.getbit(3).should eq(0)
+    subject.setbit(4, 1)
+    subject.getbit(4).should eq(1)
+  end
+
+end

data/spec/hari/node_spec.rb

@@ -65,6 +65,12 @@ describe Hari::Node do
     it 'paginates queries' do
       following = joao.out(:follow).from(15.minutes.ago.to_f).to_a
       following.map(&:id).sort.should eq [teresa, raimundo].map(&:id).sort
+
+      following = joao.out(:follow).from(15.minutes.ago.to_f, 'down').to_a
+      following.map(&:id).sort.should eq [maria, joaquim, lili].map(&:id).sort
+
+      following = joao.out(:follow).limit(1).from(15.minutes.ago.to_f, 'down').to_a
+      following.map(&:id).sort.should eq [maria.id]
     end
 
     it 'paginates chained queries' do
@@ -73,6 +79,45 @@ describe Hari::Node do
       following = teresa.out(:follow).out(:follow).from(15.minutes.ago.to_f)
       following.to_a.map(&:id).sort.should eq [teresa, raimundo].map(&:id).sort
       following.nodes!.map(&:id).sort.should eq [teresa, raimundo].map(&:id).sort
+
+      following = teresa.out(:follow).out(:follow).from(15.minutes.ago.to_f, 'down')
+      following.to_a.map(&:id).sort.should eq [maria, joaquim, lili].map(&:id).sort
+
+      following = teresa.out(:follow).out(:follow).limit(1).from(15.minutes.ago.to_f, 'down')
+      following.to_a.map(&:id).sort.should eq [maria.id]
+    end
+  end
+
+  describe 'queries by type' do
+    before do
+      Hari.relation! :follow, 'user#1', 'celeb#x'
+      Hari.relation! :follow, 'user#2', 'user#1'
+    end
+
+    it 'can intersect type queries' do
+      friends = Hari('user#2').out(:follow).type(:user)
+      fans    = Hari('celeb#x').in(:follow).type(:user)
+
+      fans.intersect_count(friends).should eq(1)
+      friends.intersect_count(fans).should eq(1)
+
+      fans.intersect(friends).should eq %w(1)
+
+      Hari.relation! :follow, 'user#3', 'celeb#x'
+      Hari.relation! :follow, 'user#4', 'celeb#x'
+      Hari.relation! :follow, 'user#5', 'celeb#x'
+      Hari.relation! :follow, 'user#6', 'celeb#x'
+      Hari.relation! :follow, 'user#7', 'celeb#x'
+      Hari.relation! :follow, 'user#8', 'celeb#x'
+
+      Hari.relation! :follow, 'user#2', 'user#4'
+      Hari.relation! :follow, 'user#2', 'user#5'
+      Hari.relation! :follow, 'user#2', 'user#6'
+      Hari.relation! :follow, 'user#2', 'user#7'
+
+      fans.intersect(friends, 1, 3).should eq %w(6 5 4)
+
+      fans.sort_by(friends).take(5).should eq %w(7 6 5 4 1)
     end
   end
 

data/spec/hari_spec.rb

@@ -34,4 +34,17 @@ describe Hari do
     node.node_type.should eq('user')
   end
 
+  specify '.relation!' do
+    Hari.relation! :follow, 'user#1', 'user#2'
+
+    Hari(user: 1).out(:follow).nodes_ids!.should eq %w(user#2)
+  end
+
+  specify '.remove_relation!' do
+    Hari.relation! :follow, 'user#6', 'user#9'
+    Hari.remove_relation! :follow, 'user#6', 'user#9'
+
+    Hari(user: 1).out(:follow).nodes_ids!.should be_empty
+  end
+
 end