rustle 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a832c77bff50413388dc4b5e7930c623a8807c5e
-  data.tar.gz: 4565b1dfd7ed5ddae95fe044b3419a3dfa850224
+  metadata.gz: 5471958598d61f4dc25f459bdad141ada82b1bd0
+  data.tar.gz: 9f0f17ec4a82206000b729e697bffd7778848d68
 SHA512:
-  metadata.gz: ab2b36845325b8f6ad07c9c78ffbb83c6372b7c167c213d1444ffb1f3c9c18c7ba0fb42f5726c023a04cc2384b450ccf5596129764d41741a0d402bcf56a4774
-  data.tar.gz: 5eeea99ff6e98b0e7d310aa55f5a0b603a5feffa132dc915d6e2d2870c820dd8cc4a010aea53cdfd53a64d1e3dae4cb6f37106573e98d91cf0900a7c8b92bf32
+  metadata.gz: 6744cbf1557218443148fc94c02f3728af062d97320202323d234e2251415a8696fb2369b2ec9d9401519e4cb5250b621a8a982ff153337f8f317847b6e240b7
+  data.tar.gz: 41a86f55fa7681a319da9853a3dcd3c06aa392daeac3cc91dadbb5cada709ae7a298e6c4d90e6dd3e4e5850b6907a45c45229b13aceb2314fc4f33bab1648368

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Rustle Changelog
 
+## 0.1.2
+
+#### New
+
+* Much more spec coverage.
+* Invalid data handling
+* **Debug mode**: to make specs easier, Receiver objects can be set to debug mode, in which no actual data will be sent to the Arduino, and instead will be returned as arrays.
+
+#### Deprecated
+
+* The old DSL-style Receiver instantiation syntax. See the documentation for Receiver#initialize because the syntax is now quite different.
+
 ## 0.1.1
 
 #### New

data/lib/rustle/debug_port.rb

@@ -0,0 +1,18 @@
+module Rustle
+  # = DebugPort
+  #
+  # This class's purpose is simply to provide a mock serial port for debugging
+  # purposes. Instead of writing to an actual TTY connection, it simply
+  # deserializes and returns the values passed into it. It's convenient because
+  # it allows one to test without requiring a physical Arduino.
+  class DebugPort
+    # @param [String] string the string of chars to be written to the mock
+    #   serial port
+    #
+    # @return [Array<Fixnum>] an array containing the deserialized values found
+    #   in +string+
+    def write(string)
+      string.chars.map(&:ord)
+    end
+  end
+end

data/lib/rustle/exceptions.rb

@@ -7,4 +7,13 @@ module Rustle
 
   # Raised when a user provides an invalid hexadecimal color
   class InvalidHexColorCode < Error; end
+
+  # Raised when a user does not provide a receiver when instantiating a strip
+  class ReceiverNotFound < Error; end
+
+  # Raised when a user does not specify the number of LEDs for a strip
+  class NumLEDsInvalid < Error; end
+
+  # Raised when a user tries to provide data that is not an array of {Color} objects
+  class InvalidLEDArray < Error; end
 end

data/lib/rustle/frame.rb

@@ -28,6 +28,8 @@ module Rustle
     # @param [Array] leds n array of {Color} objects, whose length is the same
     #   as the number of LEDs connected to the strip.
     def initialize(leds)
+      validate_leds(leds)
+
       @leds = leds
     end
 
@@ -38,5 +40,11 @@ module Rustle
     def serialize
       @leds.map(&:serialize).join + 255.chr
     end
+
+    private
+
+      def validate_leds(arr)
+        raise InvalidLEDArray unless arr.all? { |l| l.is_a? Color }
+      end
   end
 end

data/lib/rustle/receiver.rb

@@ -11,10 +11,7 @@ module Rustle
   #
   # The Receiver class is initialized using a block.
   #
-  #   bedroom_arduino = Rustle::Receiver.new do
-  #     port_file "/dev/[PORT_FILE]"
-  #     num_leds 30
-  #   end
+  #   bedroom_arduino = Rustle::Receiver.new("/dev/[PORT_FILE]")
   #
   # Your port file can be found using the Arduino IDE.
   class Receiver
@@ -23,29 +20,33 @@ module Rustle
     # @return [Strip] the strip associated with the Receiver
     attr_reader :strip
 
-    # Initializes a new receiver.
+    # Initializes a new receiver. 
     #
     # @example
-    #   kitchen_arduino = Rustle::Receiver.new do
-    #     port_file "/dev/tty.usbmodem411" # replace this
-    #     num_leds 60
-    #   end
+    #   kitchen_arduino = Rustle::Receiver.new("/deb/tty.usbmodem411", 
+    #     num_leds: 30, baud: 921_600, debug: false)
     #
-    # @yieldparam [String] port_file the location of serial port file. It can be
+    # @param [String] port_file the location of serial port file. It can be
     #   found in the Arduino IDE (or via Ino).
-    # @yieldparam [Fixnum] baud (optional) the serial baud rate (make sure it matches the one in
+    # @param [Fixnum] baud the serial baud rate (make sure it matches the one in
     #   your sketch)
-    # @yieldparam [Fixnum] num_leds (optional) the total number of LEDs connected to your 
+    # @param [Fixnum] num_leds the total number of LEDs connected to your 
     #   receiver. Note that this attribute only affects how the {Strip} object
     #   is instantiated; the number of LEDs is not actually stored in the
     #   Receiver object.
-    def initialize(&block)
-      # Default value
-      @baud = 921_600
-
-      instance_eval &block
+    # @param [Boolean] debug whether or not to enable debug mode. See
+    #   {DebugPort}.
+    def initialize(port_file = nil, baud: 921_600, num_leds: 30, debug: false)
+      @port_file = port_file
+      @baud = baud
+      @debug = debug
+      @strip = Strip.new(self, num_leds)
 
       init_serialport
+
+      # Sending a blank frame upon initialization seems to fix all timing 
+      # constraint problems.
+      @strip.off!
     end
 
     # Serializes +frame+ and sends it off to the the serial port. +push_frame+
@@ -58,16 +59,14 @@ module Rustle
 
     private
 
-      # instance_eval-specific methods for our DSL
-      def port_file(file); @port_file = file; end
-      def baud(int);       @baud = int;       end
-      def num_leds(count)
-        @strip = Strip.new(self, count)
-      end
-
-      # Instantiates a new serial port
+      # Instantiates a new port
       def init_serialport
-        @port = SerialPort.new @port_file, @baud, 8, 1, SerialPort::NONE
+        if @debug
+          @port = DebugPort.new
+        else
+          raise PortFileNotSpecified if @debug == false
+          @port = SerialPort.new @port_file, @baud, 8, 1, SerialPort::NONE
+        end
       end
   end
 end

data/lib/rustle/strip.rb

@@ -3,7 +3,7 @@ require 'active_support/inflector'
 module Rustle
   # = Strips
   # 
-  # The Strip class' purpose is to respond to requests to change the color of
+  # The Strip class's purpose is to respond to requests to change the color of
   # the physical strip, and send changes to the {Receiver} when appropriate.
   # All Strip objects also have a buffer, which is simply an array of {Frame} 
   # objects. Calling any method which advances to the next frame causes the 
@@ -27,6 +27,9 @@ module Rustle
       @receiver = receiver
       @num_leds = num_leds
       @queue = []
+
+      raise ReceiverNotFound unless receiver.is_a? Receiver
+      raise NumLEDsInvalid   unless @num_leds && @num_leds > 0
     end
 
     # @return [Frame] the next frame in the buffer. If the buffer only has one
@@ -56,6 +59,7 @@ module Rustle
 
     # Turns off all LEDs on the strip
     def off!
+      sleep 0.0025
       @queue << Frame.new([Color.new(0,0,0)] * @num_leds)
       next_frame!
     end
@@ -64,6 +68,7 @@ module Rustle
     #
     # @param [Color] color 
     def to(color)
+      sleep 0.0025
       @queue << Frame.new([color] * @num_leds)
       next_frame!
     end
@@ -89,7 +94,7 @@ module Rustle
       # :fade_to => FadeToTransition
       klass = "#{klass.to_s.camelize}Transition".constantize
       
-      klass.new(self, duration, opts).frames
+      klass.new(self, duration, opts)
     end
   end
 end

data/lib/rustle/version.rb

@@ -1,3 +1,3 @@
 module Rustle
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/rustle.rb

@@ -4,10 +4,13 @@ require "rustle/receiver"
 require "rustle/strip"
 require "rustle/color"
 require "rustle/frame"
+
 require "rustle/transition"
 require "rustle/transitions/wipe_to_transition"
 require "rustle/transitions/fade_to_transition"
+
 require "rustle/exceptions"
+require "rustle/debug_port"
 
 module Rustle
   FRAME_RATE = 60

data/spec/color_spec.rb

@@ -8,49 +8,38 @@ describe Rustle::Color do
     let(:color_with_invalid_params) { Rustle::Color.new(-100,1000,0) }
 
     it "corrects negative rgb values to zero" do
-      (color_with_invalid_params.r).should eq(0)
+      expect(color_with_invalid_params.r).to eq(0)
     end
 
     it "corrects very large rgb values to 255" do
-      (color_with_invalid_params.g).should eq(255)
+      expect(color_with_invalid_params.g).to eq(255)
     end
 
     it "makes no changes to rgb values between 0 and 255" do
       color1 = Rustle::Color.new(0,0,0)
-      (color1.r).should eq(0)
-      (color1.g).should eq(0)
-      (color1.b).should eq(0)
+      expect(color1.r).to eq(0)
+      expect(color1.g).to eq(0)
+      expect(color1.b).to eq(0)
 
       color2 = Rustle::Color.new(255,255,255)
-      (color2.r).should eq(255)
-      (color2.g).should eq(255)
-      (color2.b).should eq(255)
+      expect(color2.r).to eq(255)
+      expect(color2.g).to eq(255)
+      expect(color2.b).to eq(255)
     end
   end
 
   describe "#to_a" do
     it "returns an array" do
-      (color.to_a).should be_a(Array)
+      expect(color.to_a).to be_a(Array)
     end
 
     it "the array has the correct [r,g,b] values" do
-      (color.to_a).should eq([128,128,128])
+      expect(color.to_a).to eq([128,128,128])
     end
 
     it "rounds decimal values down to the nearest whole number" do
       fractional_rgbs = Rustle::Color.rgb(0.5,10.7,99.9)
-      (fractional_rgbs.to_a).should eq([0, 10, 99])
-    end
-  end
-
-  describe "#to_s" do
-    it "returns a string with information about the color" do
-      (color.to_s).should eq("rgb(128, 128, 128)")
-    end
-
-    it "pads strings so that even small rgb values align properly" do
-      other_color = Rustle::Color.rgb(0,1,2)
-      (other_color.to_s).should eq("rgb(  0,   1,   2)")
+      expect(fractional_rgbs.to_a).to eq([0, 10, 99])
     end
   end
 
@@ -60,11 +49,11 @@ describe Rustle::Color do
     let(:colorB) { Rustle::Color.rgb(0, 0, 0) }
 
     it "returns true if the reciever and parameter objects hold equivalent rgb values" do
-      (colorA.eql?(another_colorA)).should be_true
+      expect(colorA.eql?(another_colorA)).to be_true
     end
 
     it "returns false if the reciever and parameter objects differ in rgb values" do
-      (colorA.eql?(colorB)).should be_false
+      expect(colorA.eql?(colorB)).to be_false
     end
   end
 
@@ -75,11 +64,11 @@ describe Rustle::Color do
       let (:badass) { Rustle::Color.hex "BADA55" }
 
       it "creates a color object" do
-        (badass).should be_a(Rustle::Color)
+        expect(badass).to be_a(Rustle::Color)
       end
 
       it "has the proper rgb values" do
-        (badass).should eql(badass_rgb)
+        expect(badass).to eql(badass_rgb)
       end
     end
 
@@ -87,11 +76,11 @@ describe Rustle::Color do
       let(:badass) { Rustle::Color.hex "#BADA55" }
 
       it "creates a color object" do
-        (badass).should be_a(Rustle::Color)
+        expect(badass).to be_a(Rustle::Color)
       end
 
       it "has the right rgb values" do
-        (badass).should eql(badass_rgb)
+        expect(badass).to eql(badass_rgb)
       end
     end
 
@@ -100,18 +89,18 @@ describe Rustle::Color do
       let(:bad_rgb) { Rustle::Color.rgb 187, 170, 221 }
 
       it "creates a color object" do
-        (bad_hex).should be_a(Rustle::Color)
+        expect(bad_hex).to be_a(Rustle::Color)
       end
 
       it "should have the correct rgb values" do
-        (bad_hex).should eql(bad_rgb)
+        expect(bad_hex).to eql(bad_rgb)
       end
     end
 
     it "is case insensitive" do
       first_badass = Rustle::Color.hex "#BADa55"
       second_badass = Rustle::Color.hex "#badA55"
-      (first_badass).should eql(second_badass)
+      expect(first_badass).to eql(second_badass)
     end
 
     it "raises an error when given an invalid color code string" do
@@ -127,14 +116,14 @@ describe Rustle::Color do
     # HSV: 260 (260), saturation: 23 (23.0769), value: 87 (86.6667)
 
     it "produces a color object" do
-      hsb.should be_a(Rustle::Color)
+      expect(hsb).to be_a(Rustle::Color)
     end
 
     it "has the correct rgb properties" do
       # Use be_within to give some allowance for rounting errors
-      (hsb.r).should be_within(3).of(rgb.r)
-      (hsb.g).should be_within(3).of(rgb.g)
-      (hsb.b).should be_within(3).of(rgb.b)
+      expect(hsb.r).to be_within(3).of(rgb.r)
+      expect(hsb.g).to be_within(3).of(rgb.g)
+      expect(hsb.b).to be_within(3).of(rgb.b)
     end
   end
 
@@ -142,14 +131,14 @@ describe Rustle::Color do
     let(:hsb) { Rustle::Color.hsb 180, 0.5, 0.8 }
 
     it "returns an array of [h,s,v] coordinates" do
-      color.to_hsb.should be_a(Array)
+      expect(color.to_hsb).to be_a(Array)
     end
 
     it "should have the (approximate) [h,s,v] coordinates" do
       hsb_arr = hsb.to_hsb
-      hsb_arr[0].should be_within(1).of(180)
-      hsb_arr[1].should be_within(0.1).of(0.5)
-      hsb_arr[2].should be_within(0.1).of(0.8)
+      expect(hsb_arr[0]).to be_within(1).of(180)
+      expect(hsb_arr[1]).to be_within(0.1).of(0.5)
+      expect(hsb_arr[2]).to be_within(0.1).of(0.8)
     end
 
   end

data/spec/frame_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Rustle::Frame do
+  describe "initialization" do
+    it "should require a valid array of LEDs" do
+      valid = [Rustle::Color.rgb(255, 0, 0)] * 5
+      invalid = ["poop"] * 5
+
+      expect { Rustle::Frame.new(invalid) }
+        .to raise_error(Rustle::InvalidLEDArray)
+        
+      expect { Rustle::Frame.new(valid) }
+        .not_to raise_error
+    end
+  end
+end

data/spec/receiver_spec.rb

@@ -1,5 +1,32 @@
 require 'spec_helper'
 
 describe Rustle::Receiver do
-  it "does nothing"
+  describe "#initialize" do
+    let(:receiver) do
+      Rustle::Receiver.new(nil, num_leds: 30, debug: true)
+    end
+
+    it "should intantiate a Strip with the appropriate number of LEDs" do
+      expect(receiver.strip).to be_a(Rustle::Strip)
+      expect(receiver.strip.num_leds).to eq(30)
+    end
+
+    it "should only require a portfile when not in debug mode" do
+      expect { Rustle::Receiver.new(nil, debug: false) }
+        .to raise_error(Rustle::PortFileNotSpecified)
+      expect { Rustle::Receiver.new(nil, debug: true) }
+        .not_to raise_error
+    end
+  end
+
+  describe "#push_frame" do
+    let(:receiver) do
+      Rustle::Receiver.new(nil, num_leds: 30, debug: true)
+    end
+
+    it "should send a frame to the port" do
+      frame = Rustle::Frame.new([Rustle::Color.new(0,0,0)] * 30)
+      expect(receiver.push_frame(frame)).to have(91).items
+    end
+  end
 end

data/spec/strip_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Rustle::Strip do
+  context "when initializing" do
+    it "should require a receiver" do
+      expect { Rustle::Strip.new(nil, 30) }.to raise_error(Rustle::ReceiverNotFound)
+    end
+
+    it "should require an LED count" do
+      receiver = Rustle::Receiver.new(nil, debug: true)
+      expect { Rustle::Strip.new(receiver, nil) }.to raise_error(Rustle::NumLEDsInvalid)
+    end
+  end
+
+  describe "queue" do
+    let(:strip) { Rustle::Receiver.new(nil, num_leds: 5, debug: true).strip }
+
+    it "should be initialized with a black frame" do
+      expect(strip.current_frame).to_not be_nil
+    end
+
+    it "should be initialized with a black frame" do
+      frame = Rustle::Frame.new [Rustle::Color.new(255, 0, 0)] * 5
+
+      strip.queue_frames [frame]
+      expect(strip.next_frame).to_not be_nil
+
+      # After advancing to the next frame, there shouldn't be a next_frame
+      strip.next_frame!
+      expect(strip.next_frame).to eq(strip.current_frame)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rustle
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Andrew Hamon
@@ -117,6 +117,7 @@ files:
 - Rakefile
 - lib/rustle.rb
 - lib/rustle/color.rb
+- lib/rustle/debug_port.rb
 - lib/rustle/exceptions.rb
 - lib/rustle/frame.rb
 - lib/rustle/receiver.rb
@@ -129,8 +130,10 @@ files:
 - rustle_logo.png
 - sketches/basic.ino
 - spec/color_spec.rb
+- spec/frame_spec.rb
 - spec/receiver_spec.rb
 - spec/spec_helper.rb
+- spec/strip_spec.rb
 homepage: ''
 licenses:
 - MIT
@@ -158,6 +161,8 @@ specification_version: 4
 summary: Control an individually-addressable RGB LED strip in Ruby.
 test_files:
 - spec/color_spec.rb
+- spec/frame_spec.rb
 - spec/receiver_spec.rb
 - spec/spec_helper.rb
+- spec/strip_spec.rb
 has_rdoc: