bigbertha 0.0.1

data/lib/bigbertha/snapshot.rb

@@ -0,0 +1,99 @@
+module Bigbertha
+  class Snapshot
+      
+    class Node
+      attr_accessor :priority, :name, :parent, :children, :value
+    
+      def initialize( name )
+        @name     = name
+        @priority = nil
+        @children = []
+        @value    = nil
+        @parent   = nil
+      end
+    
+      def add_child( child )
+        child.parent = self
+        children << child
+      end
+      
+      def to_map
+        map = Map.new
+        order( map )
+        map
+      end
+        
+      def dump
+        puts "#{'  '*level}#{name} [#{priority.inspect}] --#{value.inspect}"  
+        children.sort_by do |c|
+          if c.priority and c.priority.is_a? Integer
+            "b_#{c.priority}_#{c.name}"
+          elsif c.priority
+            "z_#{c.priority}_#{c.name}"
+          else
+            "a_#{c.name}"
+          end
+        end.each do |c|
+          c.dump
+        end
+      end
+      
+      private
+      
+      def order( map )
+        map[name] = children.empty? ? value : Map.new
+        children.sort_by do |c|
+          if c.priority and c.priority.is_a? Numeric
+            "b_#{'%05.2f' % c.priority}_#{c.name}"
+          elsif c.priority
+            "z_#{c.priority}_#{c.name}"
+          else
+            "a_#{c.name}"
+          end
+        end.each do |c|
+          c.send( :order, map[name] )
+        end
+      end
+             
+      def level
+        level = 0
+        node  = self
+        while node.parent do
+          level +=1
+          node = node.parent
+        end
+        level
+      end
+    end
+  
+    def initialize( map )
+      @map = map
+      @root = Node.new( 'root' )
+      build( @map, @root )
+    end
+    
+    def to_map
+      @root.to_map.root
+    end
+    
+    def dump
+      @root.dump
+    end
+        
+    private
+  
+    def build( map, root )
+      map.each_pair do |k,v|
+        node = Node.new( k )
+        if v.is_a? Hash
+          priority = v.delete('.priority')
+          node.priority = priority if priority
+          build( v, node )
+        else
+          node.value = v.is_a?(String) ? v.to_val : v
+        end
+        root.add_child( node )
+      end
+    end
+  end
+end

data/lib/bigbertha/version.rb

@@ -0,0 +1,3 @@
+module Bigbertha
+  VERSION = "0.0.1"
+end

data/spec/bigbertha/core_ext/map_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Map do
+  describe '#diff' do
+    describe 'single vals' do
+      it "tracks value changes correctly" do
+        prev = Map(:a,1)
+        curr = Map(:a,2)
+        evts = prev.diff( curr )
+        evts.should have(1).item
+        evts.first.event_type.should == Bigbertha::Load.evt_value
+        evts.first.ref.should == 'a'
+      end    
+    
+      it "tracks adds correctly" do
+        prev = Map.new
+        curr = Map(:a,2)
+        evts = prev.diff( curr )
+        evts.should have(1).item
+        evts.first.event_type.should == Bigbertha::Load.evt_child_added
+        evts.first.ref.should == 'a'
+      end    
+    
+      it "tracks deletes correctly" do
+        prev = Map(:a,2)
+        curr = Map.new
+        evts = prev.diff( curr )
+        evts.should have(1).item
+        evts.first.event_type.should == Bigbertha::Load.evt_child_removed
+        evts.first.ref.should == 'a'
+      end
+    end
+    
+    describe 'multi vals' do
+      it 'tracks multi value changes correctly' do
+        prev = Map(:a,1)
+        curr = Map({a:{a_1:10, a_2:20}})
+        evts = prev.diff( curr )
+        evts.should have(1).item
+        evts.first.event_type.should == Bigbertha::Load.evt_value
+        evts.first.ref.should == 'a'
+      end
+    end
+  end
+end

data/spec/bigbertha/core_ext/string_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe String do
+  describe '#to_val' do
+    it "keep strings unchanged" do
+      "fred".to_val.should == "fred"
+    end
+    
+    it "converts an integer correctly" do
+      "10".to_val.should == 10
+    end
+    
+    it "converts an float correctly" do
+      "10.5".to_val.should == 10.5
+    end
+    
+    it "converts a boolean correctly" do
+      "true".to_val.should  == true
+      "false".to_val.should == false
+    end
+    
+    it 'converts null correctly' do
+      'null'.to_val.should == "null"
+    end
+  end
+end

data/spec/bigbertha/ref_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Bigbertha::Ref do
+  before :all do
+    @ref = Bigbertha::Load.new( ENV['fb_url'] )
+  end
+  
+  describe '#child?' do
+    it "retrieves complex values correctly" do
+      @ref.set( a:{b:{c:1, d:"hello"}} )
+      @ref.child?( :a ).should    == true
+      @ref.child?( 'a/b' ).should == true
+      @ref.child?( :z ).should    == false
+    end
+  end
+
+  describe '#children?' do
+    it "retrieves complex values correctly" do
+      @ref.set( a:{b:{c:1, d:"hello"}} )
+      @ref.child(:a).children?.should        == true
+      @ref.child('a/b').children?.should     == true
+      @ref.child( 'a/b/c' ).children?.should == false
+    end
+  end
+
+  describe '#num_children' do
+    it "retrieves complex values correctly" do
+      @ref.set( a:{b:{c:1, d:"hello"}} )
+      @ref.child(:a).num_children.should     == 1
+      @ref.child('a/b').num_children.should  == 2
+      @ref.child( 'a/b/c' ).num_children.should == 0
+    end
+  end
+  
+  describe '#val' do
+    it "retrieves simple value correctly" do
+      @ref.set( a:1 )
+      @ref.child( :a ).val.to_i.should == 1
+    end
+    
+    it "retrieves complex values correctly" do
+      @ref.set( a:{b:{c:1, d:"hello"}} )
+      @ref.child( :a ).val.should == {b:{c:1, d:"hello"}}
+    end
+  end
+  
+  describe '#child' do
+    it "creates a child ref correctly" do
+      child_ref = @ref.child( 'fred')
+      child_ref.name.should == 'fred'
+      child_ref.parent.to_s.should == ENV['fb_url']
+    end
+    
+    it "creates a deep child ref correctly" do
+      child_ref = @ref.child( 'fred/blee/duh')
+      child_ref.name.should == 'duh'
+      child_ref.parent.to_s.should == ENV['fb_url'] + '/fred/blee'
+    end    
+  end
+  
+  describe '#name' do
+    it "identifies / as the root name correctly" do
+      @ref.name.should be_nil
+    end
+    
+    it "identifies a url name correctly" do
+      ref = Bigbertha::Load.new( ENV['fb_url'] + '/fred/blee' )
+      ref.name.should == 'blee'
+    end    
+  end
+  
+  describe '#root' do
+    it "identifies / as root correctly" do
+      @ref.root.should == @ref
+    end    
+
+    it "identifies non root url correctly" do
+      ref = Bigbertha::Load.new( ENV['fb_url'] + '/fred/blee' )
+      ref.root.to_s.should == ENV['fb_url']
+    end        
+  end
+  
+  describe '#root?' do
+    it "identifies root correctly" do
+      @ref.should be_root
+    end
+    
+    it "identifies / as root correctly" do
+      ref = Bigbertha::Load.new( ENV['fb_url'] + '/' )
+      ref.should be_root
+    end
+    
+    it "identifies non root correctly" do
+      ref = Bigbertha::Load.new( ENV['fb_url'] + '/fred' )
+      ref.should_not be_root
+    end
+  end
+  
+  describe '#parent' do
+    it "identifies parent from root correctly" do
+      @ref.parent.should be_nil
+    end
+    
+    it "identifies a parent correctly" do
+      ref = Bigbertha::Load.new( ENV['fb_url'] + '/fred/blee' )
+      ref.parent.to_s.should == ENV['fb_url'] + '/fred'
+    end
+  end
+end

data/spec/bigbertha/root_spec.rb

@@ -0,0 +1,301 @@
+require 'spec_helper'
+
+describe Bigbertha::Load do  
+  before :all do
+    @url = ENV['fb_url']
+    @fb = Bigbertha::Load.new( @url )
+  end
+    
+  describe '#inc' do
+    before :all do
+      @fb.remove      
+      @fb.set( 
+        {
+          a: {
+           a_1: 1,
+          },
+          b: {
+           b_1: 1.5
+          },
+          c: {
+           c_1: "fred" 
+          }
+        }
+      )
+    end
+    
+    it "increases an integer value correctly" do
+       @fb.child( :a ).inc( :a_1 )
+       @fb.child( 'a/a_1' ).read.should == 2
+    end
+    
+    it "increases an float value correctly" do
+       @fb.child( :b ).inc( :b_1 )
+       @fb.child( 'b/b_1' ).read.should == 2.5
+    end
+    
+    it "set the value to zero is the data does not exist" do
+      @fb.child( :b ).inc( :b_2 )
+      @fb.child( 'b/b_2' ).read.should == 0
+    end
+      
+    it "fails if the field is non numeric" do
+      lambda { @fb.child( :c ).inc( :c_1 ) }.should raise_error( Bigbertha::Load::NonNumericFieldError )
+    end    
+  end
+
+  describe '#dec' do
+    before :all do
+      @fb.remove      
+      @fb.set( 
+        {
+          a: {
+           a_1: 2,
+          },
+          b: {
+           b_1: 1.5
+          },
+          c: {
+           c_1: "fred" 
+          }
+        }
+      )
+    end
+    
+    it "decreases an integer value correctly" do
+       @fb.child( :a ).dec( :a_1 )
+       @fb.child( 'a/a_1' ).read.should == 1
+    end
+    
+    it "decreases an float value correctly" do
+       @fb.child( :b ).dec( :b_1 )
+       @fb.child( 'b/b_1' ).read.should == 0.5
+    end
+
+    it "set the value to zero is the data does not exist" do
+      @fb.child( :b ).dec( :b_2 )
+      @fb.child( 'b/b_2' ).read.should == 0
+    end
+    
+    it "fails if the field is non numeric" do
+      lambda { @fb.child( :c ).dec( :c_1 ) }.should raise_error( Bigbertha::Load::NonNumericFieldError )
+    end    
+  end
+  
+  describe '#set_rules' do
+    before :each do
+      @auth_fb = Bigbertha::Load.new( @url, ENV['fb_auth_token'] )
+    end
+      
+    after :each do
+      @auth_fb.set_rules( { '.read' => true, '.write' => true } )
+    end
+    
+    it "fetch security rules correctly" do      
+      @auth_fb.set( tmp: { a: 0, b: 1 } )
+      @auth_fb.set_rules( 
+        { '.read' => true, '.write' => false, 
+           "tmp"  => { '.read' => true, '.write' => false }
+      })
+      res= @auth_fb.get_rules
+      res.rules.tmp['.read'].should be_true
+      res.rules.tmp['.write'].should be_false
+      
+      res = @fb.child(:tmp).read
+      res.should == { a: 0, b: 1 }
+
+      lambda { @fb.set( tmp: { d: 0 } ) }.should raise_error Bigbertha::Load::PermissionDeniedError
+    end
+  end
+  
+  describe "#read" do
+    before :all do
+      @fb.remove
+      @fb.set( { 
+        test_1: { 
+          test_1_1: {
+            key_1: 'Hello',
+            key_2: 'World'             
+           },
+           test_1_2: {
+             key_1: 10,
+             key_2: [10,20,30],
+             key_3: {
+               test_1_2_1: {
+                 key_1: 50
+               }                
+             }
+           }
+         },
+         test_2: 10,
+         test_3: :Blee,
+         test_4: %w[hello world],
+         test_5: [{a:1,b:2}, {c:3,d:4}]
+        }
+      )
+    end
+
+    it "reads a simple number correctly" do
+      @fb.child( :test_2 ).read.to_i.should == 10
+    end
+    
+    it "reads a string correctly" do
+      @fb.child( :test_3 ).read.should == "Blee"
+    end
+    
+    it "reads a simple array correctly" do
+      @fb.child( :test_4 ).read.should == %w[hello world]
+    end    
+    
+    it "reads an array of hash correctly" do
+      @fb.child( 'test_5/0' ).read.a.should == 1
+    end   
+    
+    it "reads a deeply nested hash correctly" do
+      @fb.child( 'test_1/test_1_2/key_3').read.test_1_2_1.key_1.should == 50
+    end     
+  end
+
+  describe '#push' do
+    before :each do
+      @fb.remove
+    end
+    
+    it "makes up an empty ref if no data" do
+      resp = @fb.push()
+      resp.name.should_not be_nil
+    end
+    
+    it "builds a list with values" do
+      resp = @fb.push( {a:1,b:2} )
+      resp.name.should_not be_nil
+      @fb.child( resp.name ).read.a.should == 1
+      @fb.child( resp.name ).read.b.should == 2
+    end
+  end
+  
+  describe 'priority' do
+    before :each do
+      @fb.remove
+    end
+    
+    it "sets priority with complex data correctly" do
+      @fb.set( c:{d:1} )
+      ref = @fb.child( :c )
+      ref.set_priority( 2.0 )
+      ref.get_priority.to_i.should == 2.0
+    end
+
+    it "unsets priority correctly" do
+      @fb.set( c:{d:1} )
+      ref = @fb.child( :c )
+      ref.set_priority( 2.0 )
+      ref.get_priority.to_i.should == 2.0
+      ref.set_priority( nil )
+      ref.get_priority.should == nil
+    end
+
+    it "sets priority for lists correctly" do
+      a_ref = @fb.push( {b:1, a:2} )
+      b_ref = @fb.push( {e:1, d:2} )
+      a_ref.set_priority( 20 )
+      b_ref.set_priority( 10 )      
+      a_ref.get_priority.to_i.should == 20
+      b_ref.get_priority.to_i.should == 10
+      res = a_ref.parent.read
+      keys  = [b_ref.name, a_ref.name]
+      index = 0
+      res.each_pair do |k,v|
+        k.should == keys[index]
+        index += 1
+      end
+    end
+    
+    it "sets priority for lists correctly" do
+      a_ref = @fb.push
+      a1_ref = a_ref.push( a:1 )
+      a2_ref = a_ref.push( b:1 )
+      b_ref = @fb.push
+      b1_ref = b_ref.push( c:1 )
+      b2_ref = b_ref.push( d:1 )
+      
+      a_ref.set_priority( 20 )
+      a1_ref.set_priority( 50 )
+      a2_ref.set_priority( 30 )
+      b_ref.set_priority( 10 )
+      b1_ref.set_priority( 50 )
+      b2_ref.set_priority( 30 )      
+      
+      a1_ref.get_priority.to_i.should == 50
+      a2_ref.get_priority.to_i.should == 30
+      b1_ref.get_priority.to_i.should == 50
+      b2_ref.get_priority.to_i.should == 30
+      
+      res = a_ref.parent.read
+      keys  = [b_ref.name, a_ref.name]
+      index = 0
+      res.each_pair do |k,v|
+        k.should == keys[index]
+        index += 1
+      end
+    end
+    
+  end
+  
+  it "reads a simple number correctly" do
+    @fb.update( {test_1: 20 } )
+    @fb.child( :test_1 ).read.to_i.should == 20
+  end
+    
+  describe '#remove' do
+    before :each do
+      @fb.remove
+    end
+    
+    it "removes data correctly" do
+      @fb.set( {fred: 10} )
+      @fb.child( :fred ).remove
+      lambda { @fb.child( :fred ).read }.should raise_error( /No data/ )
+    end
+  end
+  
+  describe '#update' do
+    before :all do
+      @fb.remove
+      @fb.set( a:{b:1,c:2} )      
+      @a_ref = @fb.child( :a )
+    end
+
+    describe 'oneshot' do    
+      it "updates an integer correctly" do
+        @a_ref.update( c:5 )
+        @a_ref.child( :c ).read.should == 5
+      end
+      
+      it "updates a float correctly" do
+        @a_ref.update( c:5.0 )
+        @a_ref.child( :c ).read.should == 5.0
+      end
+
+      it "updates a boolean correctly" do
+        @a_ref.update( c:true )
+        @a_ref.child( :c ).read.should be_true
+      end
+
+      it "updates a boolean correctly" do
+        @a_ref.update( c:true )
+        @a_ref.child( :c ).read.should be_true
+      end
+
+      it "updates an object correctly" do
+        @a_ref.update( c:{fred:'Hello', blee:'World'} )
+        @a_ref.child( :c ).read.should == {fred:'Hello', blee:'World'}
+      end 
+      
+      it "updates an array correctly" do
+        @a_ref.update( c:%w[Hello World] )
+        @a_ref.child( :c ).read.should == %w[Hello World]
+      end
+    end
+  end  
+end