flms 0.0.3 → 0.1.0

data/spec/models/block_spec.rb

@@ -10,5 +10,23 @@ describe Flms::Block do
       expect(block.pages.first).to eql page_1
     end
   end
+
+  describe 'scroll_duration' do
+    let(:block) { create :block }
+    let!(:layer_1) { l = block.layers.build(name: 'abc').build_default_keyframes
+                     l.start_state_keyframe.scroll_start = 1
+                     l.save! }
+    let!(:layer_2) { l = block.layers.build(name: 'def').build_default_keyframes
+                     l.start_state_keyframe.scroll_start = 2
+                     l.save! }
+
+    it 'returns the total scroll duration for the block' do
+      expect(block.scroll_duration).to eql 302
+    end
+
+    it 'returns 0 when the block has no layers' do
+      expect(subject.scroll_duration).to eql 0
+    end
+  end
 end
 

data/spec/models/embed_layer_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Flms::EmbedLayer do
+  include NamedFactories
+
+  describe 'view_object' do
+    it 'provides a view object' do
+      expect(subject.view_object).to be_a Flms::EmbedLayerViewObject
+    end
+  end
+
+  describe 'validation' do
+    describe 'url' do
+      it 'does not permit null url' do
+        embed_layer_1a1.update_attribute(:embed_code, nil)
+        expect(embed_layer_1a1).to have(1).error_on(:embed_code)
+      end
+    end
+  end
+
+end

data/spec/models/end_state_keyframe_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Flms::EndStateKeyframe do
+  describe 'defaults' do
+    it 'initializes correct defaults for an end keyframe' do
+      k = Flms::EndStateKeyframe.new
+      expect(k.scroll_start).to be_nil
+      expect(k.scroll_duration).to eql 100
+      expect(k.width).to eql 1.0
+      expect(k.height).to eql 1.0
+      expect(k.position_x).to eql 0.5
+      expect(k.position_y).to eql 0.5
+      expect(k.opacity).to eql 0.0
+      expect(k.scale).to eql 1.0
+      expect(k.blur).to eql 0.0
+    end
+  end
+end

data/spec/models/image_layer_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Flms::ImageLayer do
+  include NamedFactories
+
+  describe 'view_object' do
+    it 'provides a view object' do
+      expect(Flms::ImageLayer.new.view_object.is_a?(Flms::ImageLayerViewObject)).to be_true
+    end
+  end
+
+  describe 'image attachments' do
+    let(:layer) { image_layer_1a1 }
+
+    it 'has an attachment' do
+      expect(layer.image.path).to match 'placeholder.png'
+    end
+  end
+end

data/spec/models/keyframe_spec.rb

@@ -0,0 +1,185 @@
+require 'spec_helper'
+
+describe Flms::Keyframe do
+  describe 'translation accessors' do
+    describe 'width_percent' do
+      it 'sets width correctly' do
+        expect(Flms::Keyframe.new(width_percent: 50).width).to eql 0.5
+      end
+
+      it 'gets width correctly' do
+        expect(Flms::Keyframe.new(width: 0.5).width_percent).to eql 50
+      end
+    end
+
+    describe 'height_percent' do
+      it 'sets height correctly' do
+        expect(Flms::Keyframe.new(height_percent: 50).height).to eql 0.5
+      end
+
+      it 'gets height correctly' do
+        expect(Flms::Keyframe.new(height: 0.5).height_percent).to eql 50
+      end
+    end
+
+    describe 'margin_left_percent' do
+      it 'sets margin_left correctly' do
+        expect(Flms::Keyframe.new(margin_left_percent: 50).margin_left).to eql 0.5
+      end
+
+      it 'gets margin_left correctly' do
+        expect(Flms::Keyframe.new(margin_left: 0.5).margin_left_percent).to eql 50
+      end
+    end
+
+    describe 'margin_top_percent' do
+      it 'sets margin_top correctly' do
+        expect(Flms::Keyframe.new(margin_top_percent: 50).margin_top).to eql 0.5
+      end
+
+      it 'gets margin_top correctly' do
+        expect(Flms::Keyframe.new(margin_top: 0.5).margin_top_percent).to eql 50
+      end
+    end
+
+    describe 'opacity_percent' do
+      it 'sets opacity correctly' do
+        expect(Flms::Keyframe.new(opacity_percent: 50).opacity).to eql 0.5
+      end
+
+      it 'gets opacity correctly' do
+        expect(Flms::Keyframe.new(opacity: 0.5).opacity_percent).to eql 50
+      end
+    end
+
+    describe 'scale_percent' do
+      it 'sets scale correctly' do
+        expect(Flms::Keyframe.new(scale_percent: 50).scale).to eql 0.5
+      end
+
+      it 'gets scale correctly' do
+        expect(Flms::Keyframe.new(scale: 0.5).scale_percent).to eql 50
+      end
+    end
+
+    describe 'blur_percent' do
+      it 'sets blur correctly' do
+        expect(Flms::Keyframe.new(blur_percent: 50).blur).to eql 0.5
+      end
+
+      it 'gets blur correctly' do
+        expect(Flms::Keyframe.new(blur: 0.5).blur_percent).to eql 50
+      end
+    end
+    
+    describe 'left_percent' do
+      it 'sets value correctly' do
+        expect(Flms::Keyframe.new(left_percent: 50).position_x).to eql 0.5
+      end
+
+      it 'gets value correctly' do
+        expect(Flms::Keyframe.new(position_x: 0.5).left_percent).to eql 50
+      end
+    end
+
+    describe 'top_percent' do
+      it 'sets value correctly' do
+        expect(Flms::Keyframe.new(top_percent: 50).position_y).to eql 0.5
+      end
+
+      it 'gets value correctly' do
+        expect(Flms::Keyframe.new(position_y: 0.5).top_percent).to eql 50
+      end
+    end
+
+    describe 'position_name' do
+      it 'sets position coordinates from name correctly' do
+        keyframe = Flms::Keyframe.new(position_name: 'top-right')
+        expect(keyframe.position_x).to eql 1.0
+        expect(keyframe.position_y).to eql 0.0
+      end
+
+      it 'gets position name from coordinates correctly' do
+        keyframe = Flms::Keyframe.new(position_x: 1.0, position_y: 0.0)
+        expect(keyframe.position_name).to eql 'top-right'
+      end
+    end
+  end
+
+  describe 'positions' do
+    let(:keyframe) { Flms::Keyframe.new }
+
+    describe 'position_name_valid?' do
+      it 'returns true for all valid position names' do
+        expect(keyframe.position_name_valid? 'center').to eql true
+        expect(keyframe.position_name_valid? 'top-left').to eql true
+        expect(keyframe.position_name_valid? 'top').to eql true
+        expect(keyframe.position_name_valid? 'top-right').to eql true
+        expect(keyframe.position_name_valid? 'right').to eql true
+        expect(keyframe.position_name_valid? 'bottom-right').to eql true
+        expect(keyframe.position_name_valid? 'bottom').to eql true
+        expect(keyframe.position_name_valid? 'bottom-left').to eql true
+        expect(keyframe.position_name_valid? 'left').to eql true
+      end
+
+      it 'returns false for a bad position name' do
+        expect(keyframe.position_name_valid? 'an unknown position name').to eql false
+      end
+    end
+    
+    describe 'position_coordiates_valid?' do
+      it 'returns true for all valid position coordinates' do
+        expect(keyframe.position_coordinates_valid? [0.5, 0.5]).to eql true
+        expect(keyframe.position_coordinates_valid? [0.0, 0.0]).to eql true
+        expect(keyframe.position_coordinates_valid? [0.5, 0.0]).to eql true
+        expect(keyframe.position_coordinates_valid? [1.0, 0.0]).to eql true
+        expect(keyframe.position_coordinates_valid? [1.0, 0.5]).to eql true
+        expect(keyframe.position_coordinates_valid? [1.0, 1.0]).to eql true
+        expect(keyframe.position_coordinates_valid? [0.5, 1.0]).to eql true
+        expect(keyframe.position_coordinates_valid? [0.0, 1.0]).to eql true
+        expect(keyframe.position_coordinates_valid? [0.0, 0.5]).to eql true
+      end
+      
+      it 'returns false for an unknown set of coordinates' do
+        expect(keyframe.position_coordinates_valid? 'an unknown set of coordinates').to eql false
+      end
+    end
+
+    describe 'position_name_to_coordinates' do
+      it 'provides correct x,y coordinates for valid position names' do
+        expect(keyframe.position_name_to_coordinates 'center').to eql [0.5, 0.5]
+        expect(keyframe.position_name_to_coordinates 'top-left').to eql [0.0, 0.0]
+        expect(keyframe.position_name_to_coordinates 'top').to eql [0.5, 0.0]
+        expect(keyframe.position_name_to_coordinates 'top-right').to eql [1.0, 0.0]
+        expect(keyframe.position_name_to_coordinates 'right').to eql [1.0, 0.5]
+        expect(keyframe.position_name_to_coordinates 'bottom-right').to eql [1.0, 1.0]
+        expect(keyframe.position_name_to_coordinates 'bottom').to eql [0.5, 1.0]
+        expect(keyframe.position_name_to_coordinates 'bottom-left').to eql [0.0, 1.0]
+        expect(keyframe.position_name_to_coordinates 'left').to eql [0.0, 0.5]
+      end
+
+      it 'raises an error when given an invalid position name' do
+        expect { keyframe.position_name_to_coordinates 'an invalid position name' }.to raise_error
+      end
+    end
+
+    describe 'position_coordinates_to_name' do
+      it 'provides correct name from x,y coordinates' do
+        expect(keyframe.position_coordinates_to_name [0.5, 0.5]).to eql 'center'
+        expect(keyframe.position_coordinates_to_name [0.0, 0.0]).to eql 'top-left'
+        expect(keyframe.position_coordinates_to_name [0.5, 0.0]).to eql 'top'
+        expect(keyframe.position_coordinates_to_name [1.0, 0.0]).to eql 'top-right'
+        expect(keyframe.position_coordinates_to_name [1.0, 0.5]).to eql 'right'
+        expect(keyframe.position_coordinates_to_name [1.0, 1.0]).to eql 'bottom-right'
+        expect(keyframe.position_coordinates_to_name [0.5, 1.0]).to eql 'bottom'
+        expect(keyframe.position_coordinates_to_name [0.0, 1.0]).to eql 'bottom-left'
+        expect(keyframe.position_coordinates_to_name [0.0, 0.5]).to eql 'left'
+      end
+
+      it 'raises an error when given coordinates that do not correspond to a known position' do
+        expect { keyframe.position_coordinates_to_name [-1.0, -1.0] }.to raise_error
+      end
+    end
+  end
+
+end

data/spec/models/layer_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe Flms::Layer do
+  include NamedFactories
+
+  describe 'scroll position autocalculation' do
+    let(:layer) { build :layer }
+
+    it 'correctly calculates scroll positions on save' do
+      expect(layer.start_state_keyframe.scroll_start).to eql 0
+      expect(layer.target_state_keyframe.scroll_start).to be_nil
+      expect(layer.end_state_keyframe.scroll_start).to be_nil
+      layer.save!
+      expect(layer.start_state_keyframe.scroll_start).to eql 0
+      expect(layer.target_state_keyframe.scroll_start).to eql 100
+      expect(layer.end_state_keyframe.scroll_start).to eql 200
+    end
+  end
+
+  describe 'scopes' do
+    describe 'ordered_by_scroll_start' do
+      def builder pos
+        create :layer, block: block_1a,
+               start_state_keyframe_attributes: { scroll_start: pos },
+               target_state_keyframe_attributes: {},
+               end_state_keyframe_attributes: {}
+      end
+
+      let!(:layer_0) { builder(3) }
+      let!(:layer_1) { builder(2) }
+      let!(:layer_2) { builder(1) }
+
+      it 'returns layers ordered by the scroll start of their start keyframe' do
+        layers = block_1a.layers.ordered_by_scroll_start
+        expect(layers[0]).to eql layer_2
+        expect(layers[1]).to eql layer_1
+        expect(layers[2]).to eql layer_0
+      end
+    end
+
+    describe 'is_active' do
+      let!(:active_layer) { create :layer, block: block_1a, active: true }
+      let!(:inactive_layer) { create :layer, block: block_1a, active: false }
+
+      it 'only filters out inactive layers' do
+        layers = block_1a.layers.is_active
+        expect(layers).not_to include inactive_layer
+        expect(layers).to include active_layer
+      end
+    end
+  end
+
+  describe 'view_object' do
+    it 'provides a view object' do
+      expect(Flms::Layer.new.view_object.is_a?(Flms::LayerViewObject)).to be_true
+    end
+  end
+
+  describe 'build_default_keyframes' do
+    let(:layer) { Flms::Layer.new(name: 'abc').build_default_keyframes }
+
+    it 'creates valid associations' do
+      expect(layer.start_state_keyframe.layer).to eql layer
+      expect(layer.target_state_keyframe.layer).to eql layer
+      expect(layer.end_state_keyframe.layer).to eql layer
+    end
+
+    it 'preserves the associations through save/reload' do
+      layer.save!
+      layer.reload
+      expect(layer.start_state_keyframe.layer).to eql layer
+      expect(layer.target_state_keyframe.layer).to eql layer
+      expect(layer.end_state_keyframe.layer).to eql layer
+    end
+  end
+
+  describe 'validations' do
+    let(:layer) { Flms::Layer.new.build_default_keyframes }
+
+    describe 'for name' do
+      describe 'uniqueness' do
+        it 'validates uniqueness on block' do
+          layer_1a1
+          layer_1a2
+          layer_1a2.update_attributes name: layer_1a1.name
+          expect(layer_1a2).to have(1).error_on(:name)
+        end
+      end
+    end
+
+    describe 'for keyframes' do
+      it 'requires all keyframes to be properly associated' do
+        expect { Flms::Layer.create! }.to raise_error ActiveRecord::RecordInvalid
+      end
+    end
+  end
+
+  describe 'keyframes' do
+    let(:layer) { Flms::Layer.new.build_default_keyframes }
+
+    it 'returns an array containing start, target, and end keyframes' do
+      result = layer.keyframes
+      expect(result[0]).to eql layer.start_state_keyframe
+      expect(result[1]).to eql layer.target_state_keyframe
+      expect(result[2]).to eql layer.end_state_keyframe
+    end
+  end
+
+  describe 'scroll start and end' do
+    let(:layer) { l = Flms::Layer.new.build_default_keyframes; l.start_state_keyframe.scroll_start = 1; l }
+
+    describe 'scroll_start' do
+      it 'returns scroll start of initial state' do
+        expect(layer.scroll_start).to eql 1
+      end
+    end
+
+    describe 'scroll_end' do
+      it 'returns scroll start of initial state plus durations of target and end states' do
+        expect(layer.scroll_end).to eql 301
+      end
+    end
+  end
+
+  describe 'translation accessors' do
+    describe 'width_percent' do
+      it 'sets width correctly' do
+        expect(Flms::Layer.new(width_percent: 50).width).to eql 0.5
+      end
+
+      it 'gets width correctly' do
+        expect(Flms::Layer.new(width: 0.5).width_percent).to eql 50
+      end
+    end
+
+    describe 'height_percent' do
+      it 'sets height correctly' do
+        expect(Flms::Layer.new(height_percent: 50).height).to eql 0.5
+      end
+
+      it 'gets height correctly' do
+        expect(Flms::Layer.new(height: 0.5).height_percent).to eql 50
+      end
+    end
+  end
+
+end

data/spec/models/page_spec.rb

@@ -4,19 +4,51 @@ describe Flms::Page do
   include NamedFactories
 
   subject { create :page }
-  let(:subject_with_block) { subject.blocks << block ; subject }
+  let(:subject_with_block) { subject.blocks << block; subject }
 
   describe 'associations' do
-    it 'has blocks' do
-      expect(subject_with_block).to have(1).blocks
-      expect(subject_with_block.blocks.first).to eql block
+    describe 'blocks' do
+      it 'has blocks' do
+        expect(subject_with_block).to have(1).blocks
+        expect(subject_with_block.blocks.first).to eql block
+      end
+    end
+
+    describe 'active_blocks' do
+      let(:result) { page_1.active_blocks }
+
+      before do
+        block_1c
+        block_1b_inactive
+        block_1a
+      end
+
+      it 'orders blocks by ordering' do
+        expect(result[0]).to eql block_1a
+        expect(result[1]).to eql block_1c
+      end
+
+      it 'lists only active blocks' do
+        result = page_1.active_blocks
+        expect(result.count).to eql 2
+        expect(result).not_to include block_1b_inactive
+      end
+    end
+
+    describe 'active blocks pages' do
+      it 'lists only blocks_pages that link to active blocks' do
+        block_1c
+        block_1b_inactive
+        block_1a
+        result = page_1.blocks_pages.ordered.is_active
+        expect(result.count).to eql 2
+      end
     end
   end
 
   describe 'ordered_blocks_pages' do
-
     it 'returns the blocks_pages for the page, ordered by "ordering"' do
-      block_1b
+      block_1b_inactive
       block_1a
 
       result = page_1.ordered_blocks_pages
@@ -24,7 +56,7 @@ describe Flms::Page do
       expect(result[0].ordering).to eql 1
       expect(result[1].ordering).to eql 2
       expect(result[0].block).to eq block_1a
-      expect(result[1].block).to eq block_1b
+      expect(result[1].block).to eq block_1b_inactive
     end
   end
 
@@ -35,5 +67,23 @@ describe Flms::Page do
       expect(result.block).to eq block
     end
   end
+
+  describe 'blocks_to_display_with_offsets' do
+    it 'returns active, ordered blocks with correct scroll offsets' do
+      image_layer_1a1
+      image_layer_1b1_inactive
+      image_layer_1c1
+      result = page_1.blocks_to_display_with_offsets
+
+      expect(result.length).to eql 2
+
+      expected_scroll_offset = 0
+      result.each do |item|
+        expect(item[:block].class).to eql Flms::Block
+        expect(item[:scroll_offset]).to eql expected_scroll_offset
+        expected_scroll_offset += item[:block].scroll_duration
+      end
+    end
+  end
 end