chawk 0.1.10

data/lib/paddr.rb

@@ -0,0 +1,45 @@
+require 'store'
+
+module Chawk
+	class Paddr
+
+		include Chawk::Store
+
+		def model
+			Chawk::Models::Point
+		end
+
+		def coll
+			@node.points
+		end
+
+		def stored_type
+			Integer
+		end
+
+		def +(other = 1)
+			raise ArgumentError unless other.is_a?(Numeric) && other.integer?
+			int = (self.last.value.to_i + other.to_i)
+			self << int
+		end  
+
+		def -(other = 1)
+			raise ArgumentError unless other.is_a?(Numeric) && other.integer?
+			self + (-other)
+		end  
+
+		  def length
+			coll.length
+		end
+
+		def max
+			coll.max(:value)
+		end
+
+		def min
+			coll.min(:value)
+		end
+
+	end
+
+end

data/lib/quantizer.rb

@@ -0,0 +1,36 @@
+module Chawk
+	module Quantizer
+		def starting_step(x,step_width)
+			if (x % step_width) == 0
+				step = x
+			else
+				step = x - (x % step_width) + step_width
+			end
+		end
+
+		def ending_step(x,step_width)
+			if (x % step_width) == 0
+				step = x
+			else
+				step = x - (x % step_width)
+			end
+		end
+
+		def quantize(ary,step_width,steps=nil)
+			# TODO: Needs lots more testing, then faster implementation
+			# with caching (probaby at data add point)
+			#puts "#{ary.length}"
+			step = starting_step(ary[0][1],step_width)
+			end_step = ending_step(ary[-1][1], step_width)
+			out = [ary[0]]
+			while (step > end_step) do
+				step -= step_width
+				next_step = step - step_width
+				data = ary[0]
+				data = ary.reverse.detect{|a|a[1] > next_step} || data#(ary[-1])
+				out << [data[0],step]
+			end
+			out
+		end
+	end
+end

data/lib/store.rb

@@ -0,0 +1,71 @@
+module Chawk
+	module Store
+
+		def initialize(addr)
+			@addr = addr
+			@node = addr.node
+		end
+
+		def _insert(val,ts,options={})
+			#DataMapper.logger.debug "PREINSERT #{val} -- #{ts.to_f}"
+
+			values = {value:val,observed_at:ts.to_f,agent:@addr.agent}
+			values[:meta] = options[:meta] if options[:meta]
+
+			coll.create(values)
+		end
+
+		def clear_history!
+			model.all(node_id:@node.id).destroy
+		end
+
+		def length
+			coll.length
+		end
+
+		def <<(args,options={})
+			dt = Time.now
+			if args.is_a?(Array)
+				args.each do |arg|
+					if arg.is_a?(stored_type)
+						self._insert(arg,dt,options)
+					else
+						raise ArgumentError
+					end
+				end
+			else
+				if args.is_a?(stored_type)
+					_insert(args,dt,options)
+				else
+					raise ArgumentError
+				end
+			end
+			self.last
+		end
+
+	  def last(count=1)
+	  	if count == 1
+	  		if coll.length > 0
+	  			coll.last
+		  		#PPoint.new(self, coll.last)
+		  	else
+		  		nil
+		  	end
+		else
+			vals = coll.all(limit:count,order:[:observed_at.asc, :id.asc])
+			#last_items = vals #.each.collect{|val|PPoint.new(self, val)}
+		end
+	  end
+
+	  def range(dt_from, dt_to,options={})
+		vals = coll.all(:observed_at.gte => dt_from, :observed_at.lte =>dt_to, limit:1000,order:[:observed_at.asc, :id.asc])
+		return vals
+	  end
+
+	  def since(dt_from)
+	  	self.range(dt_from,Time.now)
+	  end
+
+	end
+end
+

data/lib/vaddr.rb

@@ -0,0 +1,21 @@
+require 'store'
+
+module Chawk
+	class Vaddr
+
+		include Chawk::Store
+
+		def coll
+			@node.values
+		end
+
+		def model
+			Chawk::Models::Value
+		end
+
+		def stored_type
+			String
+		end
+	end
+
+end

data/test/lib/addr_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+require 'json'
+
+describe Chawk::Addr do
+  before do
+    Chawk.clear_all_data!
+    @agent =  Chawk::Models::Agent.first || Chawk::Models::Agent.create(:name=>"Test User")
+    @addr = Chawk.addr(@agent,'a/b')
+  end
+
+  it "has path" do
+   @addr.must_respond_to(:path)
+  end
+
+  it "has address" do
+    @addr.must_respond_to(:address)
+  end
+
+  it "address is a/b" do
+    @addr.address.must_equal("a/b")
+    Chawk.addr(@agent,'a/b').address.must_equal("a/b")
+    Chawk.addr(@agent,'0/x/z').address.must_equal("0/x/z")
+  end
+
+  it "rejects invalid paths" do
+    lambda {Chawk.addr(@agent,['A'])}.must_raise(ArgumentError)
+    lambda {Chawk.addr(@agent,0)}.must_raise(ArgumentError)
+    lambda {Chawk.addr(@agent,:a)}.must_raise(ArgumentError)
+    lambda {Chawk.addr(@agent,Object.new)}.must_raise(ArgumentError)
+    lambda {Chawk.addr(@agent,String.new)}.must_raise(ArgumentError)
+    lambda {Chawk.addr(@agent,"")}.must_raise(ArgumentError)
+  end
+
+  it "stops unauthorized access" do
+    agent2 = Chawk::Models::Agent.first(name:"Steve Austin") || Chawk::Models::Agent.create(name:"Steve Austin")
+    lambda{@addr = Chawk.addr(agent2,'a/b')}.must_raise SecurityError
+    @addr.public_read=true
+    Chawk.addr(agent2,'a/b').address.must_equal "a/b"
+    @addr.public_read=false
+    lambda{@addr = Chawk.addr(agent2,'a/b')}.must_raise SecurityError
+    @addr.set_permissions(agent2,true,false,false)
+    Chawk.addr(agent2,'a/b').address.must_equal "a/b"
+    @addr.set_permissions(agent2,false,false,false)
+    lambda{@addr = Chawk.addr(agent2,'a/b')}.must_raise SecurityError
+    @addr.set_permissions(agent2,false,false,true)
+    Chawk.addr(agent2,'a/b').address.must_equal "a/b"
+  end
+
+end

data/test/lib/paddr_test.rb

@@ -0,0 +1,212 @@
+require 'test_helper'
+
+describe Chawk::Paddr do
+  before do
+    #@board = Chawk::Board.new()
+    @agent =  Chawk::Models::Agent.first || Chawk::Models::Agent.create(:name=>"Test User")
+    @addr = Chawk.addr(@agent,'a/b')
+    @addr.points.clear_history!
+  end
+
+ 	it "has length" do
+  		@addr.points.must_respond_to(:length)
+ 	end
+
+ 	it "calculates length" do
+ 		@addr.points.clear_history!
+ 		@addr.points.length.must_equal(0)
+ 		@addr.points << 2
+ 		@addr.points.length.must_equal(1)
+ 		@addr.points << 2
+ 		@addr.points.length.must_equal(2)
+ 		@addr.points << 2
+ 		@addr.points.length.must_equal(3)
+ 		@addr.points << [1,2,3,4]
+ 		@addr.points.length.must_equal(7)
+ 	end
+
+ 	it "has clear_history!" do
+  		@addr.points.must_respond_to(:clear_history!)
+ 	end
+
+ 	it "clears history" do
+ 		@addr.points.clear_history!
+ 		@addr.points.length.must_equal(0)
+ 	end
+
+ 	it "accepts _insert" do
+ 		@addr.points._insert(100,Time.now)
+ 		@addr.points.length.must_equal(1)
+ 	end
+
+ 	it "accepts <<" do
+ 		@addr.points.must_respond_to(:"<<")
+ 	end
+
+ 	it "accepts integers" do
+ 		@addr.points << 10
+ 		@addr.points.length.must_equal(1)
+ 		@addr.points << 0
+ 		@addr.points.length.must_equal(2)
+ 		@addr.points << 190
+ 		@addr.points << 10002
+ 		@addr.points << [10,0,190,100]
+ 	end
+
+ 	it "does +" do
+ 		@addr.points.must_respond_to(:"+")
+ 		@addr.points << 10
+ 		@addr.points + 100
+ 		@addr.points.last.value.must_equal(110)
+ 		@addr.points + -10
+ 		@addr.points.last.value.must_equal(100)
+		@addr.points.+ 
+ 		@addr.points.last.value.must_equal(101)
+ 	end
+
+ 	it "should only + integers" do
+ 		lambda {@addr.points + 'A'}.must_raise(ArgumentError)
+ 		lambda {@addr.points + nil}.must_raise(ArgumentError)
+ 	end
+
+ 	it "does -" do
+ 		@addr.points.must_respond_to(:"-")
+ 		@addr.points << 10
+ 		@addr.points - 100
+ 		@addr.points.last.value.must_equal(-90)
+ 		@addr.points - -10
+ 		@addr.points.last.value.must_equal(-80)
+ 		@addr.points.- 
+ 		@addr.points.last.value.must_equal(-81)
+ 	end
+
+ 	it "should only - integers" do
+ 		lambda {@addr.points - 'A'}.must_raise(ArgumentError)
+ 		lambda {@addr.points - nil}.must_raise(ArgumentError)
+ 	end
+
+ 	it "only accepts integers" do
+ 		lambda {@addr.points << 10.0}.must_raise(ArgumentError)
+ 		lambda {@addr.points << nil}.must_raise(ArgumentError)
+    lambda {@addr.points << [10.0,:x]}.must_raise(ArgumentError)
+ 	end
+
+ 	it "has last()" do
+  		@addr.points.must_respond_to(:last)
+ 	end
+
+ 	it "remembers last value" do
+ 		@addr.points << 10
+  		@addr.points.last.value.must_equal(10)
+ 		@addr.points << 1000
+  		@addr.points.last.value.must_equal(1000)
+ 		@addr.points << 99
+  		@addr.points.last.value.must_equal(99)
+ 		@addr.points << [10,0,190,100]
+  		@addr.points.last.value.must_equal(100)
+ 	end
+
+ 	it "returns ordinal last" do
+ 		@addr.points << [10,9,8,7,6,5,4,3,2,1,0]
+  	@addr.points.last(5).length.must_equal(5)
+ 	end
+
+ 	it "has max()" do
+  		@addr.points.must_respond_to(:max)
+ 	end
+
+ 	it "does max()" do
+ 		@addr.points.clear_history!
+ 		@addr.points << [1,2,3,4,5]
+ 		@addr.points.max.must_equal(5)
+ 		@addr.points << 100
+ 		@addr.points.max.must_equal(100)
+ 		@addr.points << 100
+ 		@addr.points.max.must_equal(100)
+ 		@addr.points << 99
+ 		@addr.points.max.must_equal(100)
+ 		@addr.points << 0
+ 		@addr.points.max.must_equal(100)
+ 	end
+
+ 	it "does min()" do
+ 		@addr.points << [11,12,13,14,15]
+ 		@addr.points.min.must_equal(11)
+ 		@addr.points << 100
+ 		@addr.points.min.must_equal(11)
+ 		@addr.points << 10
+ 		@addr.points.min.must_equal(10)
+ 		@addr.points << 99
+ 		@addr.points.min.must_equal(10)
+ 		@addr.points << 0
+ 		@addr.points.min.must_equal(0)
+ 	end
+
+ 	it :does_range do
+  		@addr.points.must_respond_to(:range)
+
+  		ts = Time.now
+
+  		@addr.points._insert(0,ts-1000)
+  		@addr.points._insert(1,ts-1000)
+  		@addr.points._insert(2,ts-1000)
+  		@addr.points._insert(3,ts-1000)
+  		@addr.points._insert(4,ts-1000)
+  		@addr.points._insert(5,ts-800)
+  		@addr.points._insert(6,ts-800)
+  		@addr.points._insert(7,ts-800)
+  		@addr.points._insert(8,ts-200)
+  		@addr.points._insert(9,ts-10)
+  		@addr.points._insert(10,ts-5)
+ 	  	@addr.points.range(ts-1000,ts).length.must_equal 11 
+ 	  	@addr.points.range(ts-800,ts).length.must_equal 6 
+ 	  	@addr.points.range(ts-200,ts).length.must_equal 3 
+	  	@addr.points.range(ts-10,ts).length.must_equal 2 
+	  	@addr.points.range(ts-5,ts).length.must_equal 1 
+	  	@addr.points.range(ts-200,ts-11).length.must_equal 1 
+	  	@addr.points.range(ts-1000,ts-1000).length.must_equal 5
+
+ 		@addr.points._insert(0,ts-100)
+	  	@addr.points.range(ts-200,ts).length.must_equal 4 
+	end
+
+	it "does since" do
+ 		ts = Time.now
+
+ 		@addr.points._insert(0,ts-1000)
+ 		@addr.points._insert(7,ts-800)
+ 		@addr.points._insert(8,ts-200)
+ 		@addr.points._insert(10,ts-5)
+ 		@addr.points.must_respond_to(:since)
+  	@addr.points.since(ts-1000).length.must_equal(4) 
+  	@addr.points.since(ts-300).length.must_equal(2) 
+	end
+
+  # it :acts_like_an_integer do
+  #   @addr.points << 36878
+  #   last = @addr.points.last
+  #   last.to_i.must_equal 36878
+  # end
+
+	# it "does mq" do
+	# 	@board.flush_notification_queue
+	# 	@board.notification_queue_length.must_equal (0)
+
+	# 	pointers = []
+	#    	pointers << @board.paddr(['0','1','2'])
+	#    	pointers << @board.paddr(['0','1','3'])
+	#    	pointers << @board.paddr(['0','1','4'])
+	#    	pointers << @board.paddr(['0','1','5'])
+
+	#    	pointers.each{|p|p<<10}
+
+	# 	@board.notification_queue_length.must_equal (4)
+	# 	x = @board.pop_from_notification_queue
+	# 	x.length.must_equal(3)
+	# 	@board.notification_queue_length.must_equal (3)
+	# 	x = @board.pop_from_notification_queue
+	# 	x = @board.pop_from_notification_queue
+	# 	@board.notification_queue_length.must_equal (1)
+	# 	x.length.must_equal(3)
+	# end
+end

data/test/lib/quantizer_test.rb

@@ -0,0 +1,63 @@
+#require 'minitest'
+#require 'minitest/autorun'
+#require 'chawk'
+require 'test_helper'
+
+
+ts1 = [['A',100],['B',99],['C',95],['D',50],['E',45],['F',30],['G',29],['H',28]]
+ts2 = [['A',100],['B',85],['C',80],['D',71],['E',70],['F',30],['G',29],['H',28]]
+
+class Qharness
+	include Chawk::Quantizer
+	attr_accessor :datum
+	def initialize()
+		@datum = datum
+	end
+end
+
+describe Chawk::Quantizer do
+	before do
+		@qh = Qharness.new()
+	end
+
+    it "does quantize" do
+        @qh.must_respond_to "quantize"
+ 		@qh.quantize(ts1,10).must_equal (
+			[["A", 100], ["C", 90], ["C", 80], ["C", 70], ["C", 60], ["E", 50], ["E", 40], ["H", 30], ["H", 20]]
+ 		)
+ 		@qh.quantize(ts2,10).must_equal(
+			[["A", 100], ["B", 90], ["D", 80], ["E", 70], ["E", 60], ["E", 50], ["E", 40], ["H", 30], ["H", 20]]
+ 		)
+ 		@qh.quantize(ts2,5).must_equal(
+            [["A", 100], ["A", 95], ["A", 90], ["B", 85], ["C", 80], ["D", 75], ["E", 70], ["E", 65], ["E", 60], ["E", 55], ["E", 50], ["E", 45], ["E", 40], ["E", 35], ["H", 30], ["H", 25]] 		)
+    end
+
+    it "picks first step" do
+    	@qh.starting_step(101,10).must_equal(110)
+    	@qh.starting_step(111,10).must_equal(120)
+    	@qh.starting_step(100,10).must_equal(100)
+    	@qh.starting_step(99,10).must_equal(100)
+    	@qh.starting_step(92,10).must_equal(100)
+    	@qh.starting_step(91,10).must_equal(100)
+    	@qh.starting_step(90,10).must_equal(90)
+    	@qh.starting_step(1,10).must_equal(10)
+    	@qh.starting_step(3,10).must_equal(10)
+    	@qh.starting_step(7,10).must_equal(10)
+    	@qh.starting_step(10,10).must_equal(10)
+    	@qh.starting_step(101,5).must_equal(105)
+    	@qh.starting_step(102,5).must_equal(105)
+    	@qh.starting_step(105,5).must_equal(105)
+    	@qh.starting_step(107,5).must_equal(110)
+    end
+
+    it "picks last step" do
+    	@qh.ending_step(101,10).must_equal(100)
+    	@qh.ending_step(111,10).must_equal(110)
+    	@qh.ending_step(100,10).must_equal(100)
+    	@qh.ending_step(101,5).must_equal(100)
+    	@qh.ending_step(106,5).must_equal(105)
+    	@qh.ending_step(100,5).must_equal(100)
+    end
+
+
+end