klear 0.0.1 → 0.1.0

data/spec/lib/klear/choreography_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe Klear::Choreography do
+
+  context 'with test.kle fixture' do
+    let(:test_kle_path) { "#{RSpec.configuration.fixtures}/test.kle" }
+    let(:choreography) { Klear::Choreography.load(test_kle_path) }
+
+    it 'reads kle files' do
+      choreography.should be_kind_of(Klear::Choreography)
+    end
+    
+    it 'knows details about kle files when read' do
+      choreography.framecount.should eq(264)
+      choreography.framesize.should eq(14*11)
+      choreography.geometry.should eq({:columns => 14, :rows => 11})
+      choreography.fps.should eq(25)
+      choreography.gamma.should eq(1.0)
+      
+      frame = choreography.frame(0)
+      frame.should be_kind_of(Klear::Frame)
+      frame.data.size.should eq(14*11)
+    end
+    
+    it 'raises on out of bound frame numbers' do
+      high = choreography.framecount # frames go from [0; framecount[
+      expect { choreography.frame(high) }.to raise_error /bound.*#{high}/
+    end
+
+    it 'raises on negative frame numbers' do
+      expect { choreography.frame(-1) }.to raise_error /negative.*#{-1}/
+    end
+
+    it 'knows about rows' do
+      frame = choreography.frame(0)
+      
+      frame.row(0).should eq([
+        27009, 38885, 47331, 51027, 51233, 49789, 47645,
+        45039, 41857, 38387, 35095, 32101, 29395, 27007])
+      total_size = 0
+      frame.rows {|row| total_size += row.size }
+      total_size.should eq(frame.data.size)
+    
+      total_size = 0
+      frame.rows {|row| total_size += row.size }
+      total_size.should eq(frame.data.size)
+      
+      frame.rows.should be_kind_of(Array)
+      frame.rows[choreography.geometry[:rows] - 1].should eq([
+        33761, 48607, 59165, 63785, 64043, 62237, 59557,
+        56301, 52323, 47985, 43869, 40127, 36745, 33759
+      ])
+    end
+    
+    it 'knows about columns' do
+      frame = choreography.frame(0)
+      
+      frame.column(0).should eq([
+        27009, 63689, 64223, 64219, 63417,
+        61537, 58347, 53747, 47923, 41223, 33761
+      ])
+      
+      total_size = 0
+      frame.columns { |col| total_size += col.size }
+      total_size.should eq(frame.data.size)
+      
+      total_size = 0
+      frame.columns { |col| total_size += col.size }
+      total_size.should eq(frame.data.size)
+      
+      frame.columns.should be_kind_of(Array)
+      frame.columns[choreography.geometry[:columns] - 1].should eq([
+        27007, 24163, 25097, 26035, 26997,
+        27991, 29027, 30111, 31259, 32473, 33759])
+    end
+    
+    it 'knows about blades (the same as columns)' do
+      frame = choreography.frame(0)
+      
+      frame.blade(0).should eq([
+        27009, 63689, 64223, 64219, 63417,
+        61537, 58347, 53747, 47923, 41223, 33761])
+      frame.blade(0).should eq([
+        27009, 63689, 64223, 64219, 63417,
+        61537, 58347, 53747, 47923, 41223, 33761])
+      
+=begin
+      total_size = 0
+      frame.blades { |col| total_size += col.size }
+      total_size.should eq(frame.data.size)
+      
+      frame.blades.should be_kind_of(Hash)
+      frame.blades[choreography.geometry[:columns] - 1].should eq([
+        27007, 24163, 25097, 26035, 26997,
+        27991, 29027, 30111, 31259, 32473, 33759
+      ])
+=end
+    end
+
+    pending 'has direct col/row access to the buffer' do
+      frame = choreography.frame(0)
+      frame.cell(2,5).should eq(frame.column(2)[5])
+      frame.cell(1,7).should eq(frame.row(7)[1])
+      # frame.cell(1,15).should eq(nil)
+      # frame.cell(12,1).should eq(nil)
+    end
+  end
+  
+  ##it 'should just work dammit' do
+  ##  choreography = Kleac::Choreography.load("#{RSpec.configuration.fixtures}/black_to_white_linear.kle")
+  ##  puts "framesize #{choreography.framesize}"
+  ##  puts "framecount #{choreography.framecount}"
+  ##  #puts choreography.frame(0).dump
+  ##  choreography.each_frame { |frame, idx|
+  ##    puts "Frame #{idx}"
+  ##    puts frame.dump
+  ##    puts "\n"
+  ##    #puts "#{idx} => #{frame.row(0)[0]}"
+  ##  }
+  ##end
+  
+  context 'with test.kle fixture' do
+    let(:path) { "#{RSpec.configuration.fixtures}/test_without_gamma_and_fps.kle" }
+    let(:choreography) { Klear::Choreography.load(path) }
+    
+    it 'produces defaults for missing gamma and fps' do
+      choreography.fps.should eq(25)
+      choreography.gamma.should eq(1.0)
+    end
+  end
+  
+end

data/spec/lib/klear/file_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Klear::File do 
+  it 'exists' do
+    Klear::File.should be_kind_of(Class)
+  end
+
+  context 'with test.kle fixture' do
+    let(:path) { "#{RSpec.configuration.fixtures}/test.kle" }
+    let(:klear) { Klear::File.new path }
+
+    it 'calculates playtimes from the number of frames in the zipfile' do
+      klear.frame_count.should eq(264)
+    end
+
+    it 'reads info' do
+      klear.info.should be_kind_of(Hash)
+    end
+
+    it 'knows the dimensions' do
+      klear.dimensions.should eq({:columns => 14, :rows => 11})
+    end
+
+    it 'reads frames' do
+      (frames = klear.frames).should_not be(nil)
+      frames.columns.should eq(14)
+      frames.rows.should eq(11)
+    end
+
+    it 'reads motors' do
+      (motors = klear.motors).should_not be(nil)
+      motors.should be_kind_of(Klear::Motors)
+      motors.count.should eq(14)
+      motors.blade_count.should eq(motors.count)
+      motors.frame_count.should eq(264)
+    end
+  end
+
+  context 'default config' do
+    let(:klear) { Klear::File.new }
+
+    it 'info raises no path exception' do 
+      expect { klear.info }.to raise_error /path not specified/
+    end
+  end
+end

data/spec/lib/klear/filters_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Klear::Filters do 
+  it 'exists' do
+    Klear::Filters.should be_kind_of(Module)
+  end
+
+  it 'projects values to range' do
+    Klear::Filters.project([0, 0x8000, 0xffff], 10, 14).should eq([10, 12, 14])
+  end
+
+  it 'provides JJ/F14 sampling' do
+    Klear::Filters.f14jj((0...90)).should eq([0,30,60])
+  end
+end

data/spec/lib/klear/frame_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Klear::Frame do 
+  context 'loaded frames fixture' do
+    let(:path) { "#{RSpec.configuration.fixtures}/test.kle" }
+    let(:data) { Zip::ZipFile.new(path).read("cache/frames.bin") }
+    let(:frames) { Klear::Frames.new(14, 11, data) }
+
+    context 'with frame zero from test fixture' do
+      let(:frame) { frames.get(0) }
+
+      it 'has row, column and size' do
+        frame.row_count.should eq(11)
+        frame.column_count.should eq(14)
+        frame.size.should eq(11 * 14)
+      end
+    end
+  end
+end

data/spec/lib/klear/frames_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Klear::Frames do 
+  it 'exists' do
+    Klear::Frames.should be_kind_of(Class)
+  end
+
+  context 'with test.kle fixture' do
+    let(:path) { "#{RSpec.configuration.fixtures}/test.kle" }
+    let(:data) { Zip::ZipFile.new(path).read("cache/frames.bin") }
+
+    it 'initializes with data' do 
+      expect { Klear::Frames.new(14, 11, data) }.to_not raise_error
+    end
+
+    it 'load from binary string' do
+      expect { Klear::Frames.new(14, 11).load(data) }.to_not raise_error
+    end
+
+    context 'loaded frames fixture' do
+      let(:frames) { Klear::Frames.new(14, 11, data) }
+
+      it 'knows the frames cell count' do
+        frames.framesize.should eq(14 * 11)
+      end
+
+      it 'knows the frame count' do 
+        frames.count.should eq(264)
+      end
+
+      it 'gets me all frames' do
+        (all = frames.all).should be_kind_of(Array)
+        all.size.should eq(264)
+      end
+
+      it 'gets me any frame' do
+        frames.get(0).should be_kind_of(Klear::Frame)
+      end
+
+      it 'raises on out of bound frame numbers' do
+        high = frames.count # frames go from [0; framecount[
+        expect { frames.get(high) }.to raise_error /bound.*#{high}/
+      end
+
+      it 'raises on negative frame numbers' do
+        expect { frames.get(-1) }.to raise_error /negative.*#{-1}/
+      end
+    end
+  end
+end

data/spec/lib/klear/motors_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Klear::Motors do 
+  it 'exists' do
+    Klear::Motors.should be_kind_of(Class)
+  end
+
+  it 'initializes blade_count data' do 
+    Klear::Motors.new(7).blade_count.should eq(7)
+  end
+
+  context 'with three blades, four frames data' do
+    let(:data) { 
+      [[1, 2, 3], [10, 20, 30], [100, 200, 300], [1000, 2000, 3000]]
+    }
+
+    it 'initializes with blade data' do 
+      expect { motors = Klear::Motors.new(3, data) }.to_not raise_error
+    end
+
+    context 'with motors from three blades, four frames data' do
+      let(:motors) { Klear::Motors.new(3, data) }
+
+      it 'knows the frame count' do
+        motors.frame_count.should eq(4)
+      end
+
+      it 'gets me the second frame values (frames are null based!!!!)' do
+        motors.frame(2).should eq([100, 200, 300])
+      end
+
+      it 'gets me any motor sequence (motors are one based!!!!)' do
+        motors.get(2).should eq([2, 20, 200, 2000])
+      end
+
+      it 'gets works with strings and integer args' do 
+        motors.get(2).should eq(motors.get('2'))
+      end
+
+      it 'raises on to high motor numbers' do
+        max = motors.blade_count
+        expect { motors.get(max+1) }.to raise_error /bound.*#{max+1}/
+      end
+
+      it 'raises on to low motor numbers' do
+        expect { motors.get(0) }.to raise_error /invalid motor no.*#{0}/
+      end
+    end
+  end
+end
+
+__END__
+
+  context 'with kle file fixture' do
+    #let(:path) { "#{RSpec.configuration.fixtures}/motors_test.kle" }
+    #let(:data) { Zip::ZipFile.new(path).read("cache/motors.bin") }
+
+    it 'initializes with data' do 
+      expect { Klear::Motors.new(14, data) }.should_not raise_error
+    end
+
+    it 'load from binary string' do
+      expect { Klear::Motors.new(14).load(data) }.should_not raise_error
+    end
+
+    context 'with loaded motors fixture' do
+      let(:motors) { Klear::Motors.new(14, data) }
+
+      it 'calculated the frame count' do 
+        motors.frame_count.should eq(264)
+      end
+
+      it 'gets me a for any frame a array with a one value per blade motor' do
+        (a = motors.get(7)).should be_kind_of(Array)
+        a.size.should eq(a.blade_count)
+      end
+    end
+  end
+end

data/spec/lib/klear/version_spec.rb

@@ -0,0 +1,6 @@
+describe Klear::VERSION do 
+  it 'defines a VERSION' do 
+    Klear::VERSION.should be_kind_of(String)
+    Klear::VERSION.should match(/\d\.\d\.\d/)
+  end
+end