fron 0.1.4 → 0.2.0rc1

data/spec/dom/text_spec.rb

@@ -1,9 +1,10 @@
-describe DOM::Text do
+require 'spec_helper'
 
+describe DOM::Text do
   subject { described_class.new('test') }
-  let(:el) { subject.instance_variable_get("@el") }
+  let(:el) { subject.instance_variable_get('@el') }
 
-  describe "#initailize" do
+  describe '#initailize' do
     it 'should create textNode with given value' do
       subject.text.should eq 'test'
       `#{el} instanceof Text`.should be true

data/spec/dom/window_spec.rb

@@ -1,30 +1,45 @@
-describe DOM::Window do
+require 'spec_helper'
 
+describe DOM::Window do
   subject { described_class }
 
-  describe "#hash" do
+  describe '#state' do
+    it 'should return the pathname' do
+      subject.state.should eq '/'
+    end
+  end
+
+  describe '#state=' do
+    it 'should set the state' do
+      subject.should receive(:trigger).with 'popstate'
+      subject.state = '/test'
+      subject.state.should eq '/test'
+    end
+  end
+
+  describe '#hash' do
     it 'should return the hash of the url' do
       `window.location.hash = 'test'`
       subject.hash.should eq 'test'
     end
   end
 
-  describe "#hash=" do
+  describe '#hash=' do
     it 'should set the hash of the url' do
-      subject.hash = 'test'
-      `window.location.hash.slice(1)`.should eq 'test'
+      subject.hash = 'test2'
+      `window.location.hash.slice(1)`.should eq 'test2'
     end
   end
 
-  describe "scrollY" do
+  describe 'scrollY' do
     it 'should return the vertical scroll position' do
-      subject.scrollY.should eq 0
+      subject.scroll_y.should eq 0
     end
   end
 
-  describe "scrollX" do
+  describe 'scrollX' do
     it 'should return the horizontal scroll position' do
-      subject.scrollX.should eq 0
+      subject.scroll_x.should eq 0
     end
   end
 end

data/spec/js/mocks.js

@@ -0,0 +1,14 @@
+window.requestAnimationFrame = function(callback){ callback() }
+window.setTimeout = function(callback) { callback() }
+window.clearTimeout = function() { return true }
+window.alert = function(text) { return 'alert' }
+window.confirm = function(text) { return true }
+window.prompt = function(text, value) { return value }
+
+window.FileReader = function(){}
+window.FileReader.prototype.readAsDataURL = function(){
+  return 'data:image/gif;base64,R0lGODlhyAAiALM...DfD0QAADs='
+}
+
+window.throttle = function(fn){ return fn }
+window.debounce = function(fn){ return fn }

data/spec/request/request_spec.rb

@@ -1,23 +1,26 @@
-require 'fron/request'
+require 'spec_helper'
 
 describe Fron::Request do
-
-  subject { described_class.new 'url' }
-  let(:request) {%x{
-    return { readyState: 0,
-    open: function(){this.opened = true},
-    send: function(){this.sent = true}}
-  }}
-  let(:data) { double :data, to_query_string: '', to_form_data: true }
+  subject { described_class.new 'url', 'Content-Type' => 'application/json' }
+  let(:request) {
+    %x{
+      return { readyState: 0,
+      open: function(){this.opened = true},
+      send: function(){this.sent = true},
+      setRequestHeader: function(){},
+      getAllResponseHeaders: function(){return ''}}
+    }
+  }
+  let(:data) { Hash.new }
 
   before do
-    subject.instance_variable_set("@request", request)
+    subject.instance_variable_set('@request', request)
   end
 
-  describe "#request" do
+  describe '#request' do
     it 'should raise if the rquest is already running' do
       allow(subject).to receive(:ready_state).and_return 1
-      expect(Proc.new {subject.request} ).to raise_error
+      expect(proc { subject.request }).to raise_error
     end
 
     it 'should call #open on request' do
@@ -30,6 +33,11 @@ describe Fron::Request do
       expect(`#{request}.sent`).to be true
     end
 
+    it 'should call #to_form_data on data if it is an UPLOAD' do
+      expect(data).to receive(:to_form_data)
+      subject.request 'UPLOAD', data
+    end
+
     it 'should call #to_query_string on data if it is a GET' do
       expect(data).to receive(:to_query_string)
       expect(data).not_to receive(:to_json)
@@ -48,24 +56,35 @@ describe Fron::Request do
     end
   end
 
-  describe "#get" do
+  describe '#get' do
     it 'should call #request with GET' do
       expect(subject).to receive(:request).once
       subject.get
     end
   end
 
-  describe "#post" do
+  describe '#post' do
     it 'should call #request with POST' do
       expect(subject).to receive(:request).once
       subject.post
     end
   end
 
-  describe "#put" do
+  describe '#put' do
     it 'should call #request with PUT' do
       expect(subject).to receive(:request).once
       subject.put
     end
   end
+
+  describe '#handle_state_change' do
+    it 'should run callback' do
+      callback = proc {}
+      subject.instance_variable_set('@callback', callback)
+      callback.should receive(:call)
+      subject.should receive(:ready_state).and_return 4
+      subject.should receive(:trigger).with :loaded
+      subject.handle_state_change
+    end
+  end
 end

data/spec/request/response_spec.rb

@@ -1,14 +1,13 @@
-require 'fron/request'
+require 'spec_helper'
 
 describe Fron::Response do
-
-  let(:headers) { "Content-Type: application/json"}
+  let(:headers) { 'Content-Type: application/json' }
   let(:status)  { 200 }
-  let(:body)    {'<div></div>'}
+  let(:body)    { '<div></div>' }
   subject       { described_class.new status, body, headers }
 
-  describe "#json" do
-    let(:body) { {key: 'value'}.to_json }
+  describe '#json' do
+    let(:body) { { key: 'value' }.to_json }
 
     it 'should return the json body as a hash' do
       subject.json.class.should eq Hash
@@ -16,14 +15,14 @@ describe Fron::Response do
     end
   end
 
-  describe "#ok?" do
-    context "200" do
+  describe '#ok?' do
+    context '200' do
       it 'should return true if status is 200' do
         subject.ok?.should be true
       end
     end
 
-    context "404" do
+    context '404' do
       let(:status) { 404 }
       it 'should return false if status is not 200' do
         subject.ok?.should be false
@@ -31,7 +30,7 @@ describe Fron::Response do
     end
   end
 
-  describe "#dom" do
+  describe '#dom' do
     it 'should return with a Fragment' do
       subject.dom.class.should eq DOM::Fragment
       subject.dom.children[0].should_not be nil

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'rspec_coverage_helper'
+require 'js/mocks'
+require 'fron'
+require 'fron/event_mock'
+
+::RSpec.configure do |c|
+  c.after(:each) do
+    DOM::Document.body.off
+    DOM::Window.off
+  end
+end

data/spec/storage/{local-storage_spec.rb → local_storage_spec.rb}

@@ -1,15 +1,14 @@
-require 'fron/storage'
+require 'spec_helper'
 
 describe Fron::Storage::LocalStorage do
-
   subject { described_class }
 
   before do
     subject.clear
-    subject.set 'key', { data: 'value' }
+    subject.set 'key', data: 'value'
   end
 
-  describe "#get" do
+  describe '#get' do
     it 'should get the data for the key' do
       data = subject.get('key')
       data.class.should eq Hash
@@ -17,9 +16,9 @@ describe Fron::Storage::LocalStorage do
     end
   end
 
-  describe "#set" do
+  describe '#set' do
     it 'should set data for the key' do
-      subject.set 'key2', { data: 'value' }
+      subject.set 'key2', data: 'value'
       subject.keys.include?('key2').should be true
       subject.all.length.should be 2
     end
@@ -40,7 +39,7 @@ describe Fron::Storage::LocalStorage do
     end
   end
 
-  describe "#all" do
+  describe '#all' do
     it 'should get the data for all key' do
       data = subject.all[0]
       data.class.should eq Hash

data/spec/utils/drag_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+require 'fron/utils/drag'
+
+describe Fron::Drag do
+  let(:event)    { double(pageX: 0, pageY: 0, preventDefult: true, stop: true, target: true) }
+  let(:base)     { DOM::Element.new 'div'   }
+  let(:position) { double }
+
+  subject        { described_class.new base }
+
+  before do
+    allow(subject).to receive(:request_animation_frame)
+  end
+
+  around(:each) do |example|
+    EventMock.mock_events(&example)
+  end
+
+  describe 'Events' do
+    it 'should call start on mousedown' do
+      subject.should receive(:start)
+      subject.base.trigger 'mousedown'
+    end
+
+    it 'should call pos when mouse moves' do
+      subject.should receive(:pos)
+      subject.should receive(:request_animation_frame) do |&block|
+        subject.instance_variable_set('@mouse_is_down', false)
+        block.call
+      end
+      subject.start event
+      subject.body.trigger 'mousemove'
+    end
+
+    it 'should call up when mouse moves' do
+      subject.should receive(:up)
+      subject.start event
+      subject.body.trigger 'mouseup'
+    end
+  end
+
+  describe '#initialize' do
+    it 'should set the body' do
+      subject.body.should eq DOM::Document.body
+    end
+
+    it 'should add mousedown event listener to the base' do
+      subject.base.listeners['mousedown'].length.should eq 1
+    end
+  end
+
+  describe '#diff' do
+    it 'should diff start position and current position' do
+      subject.instance_variable_set('@start_position', position)
+      position.should receive(:-)
+      subject.diff
+    end
+  end
+
+  describe '#start' do
+    it 'should call request_animation_frame' do
+      subject.should receive(:request_animation_frame).once
+      subject.start event
+    end
+
+    it 'should remove events if the dragging not finished properly' do
+      subject.instance_variable_set('@pos_method', true)
+      subject.should receive(:off)
+      subject.start event
+    end
+  end
+
+  describe '#pos' do
+    it 'it should set position' do
+      event.should receive(:stop)
+      position.should receive(:distance).and_return 0
+      subject.should receive(:diff).and_return position
+      subject.should receive(:position).and_return position
+      subject.pos event
+      pos = subject.instance_variable_get('@position')
+      pos.should eq position
+    end
+  end
+
+  describe '#up' do
+    it 'should stop dragging and reset things' do
+      event.should receive(:stop)
+      event.should receive(:preventDefault)
+      subject.instance_variable_set('@started', true)
+      subject.should receive(:reset)
+      subject.should receive(:off)
+      subject.should receive(:trigger).with 'end'
+      subject.up event
+    end
+  end
+
+  describe '#move' do
+    it 'should call request_animation_frame if mouse is down' do
+      subject.instance_variable_set('@mouse_is_down', true)
+      subject.should receive(:request_animation_frame) do |&block|
+        subject.instance_variable_set('@mouse_is_down', false)
+        block.call
+      end
+      subject.move
+    end
+
+    it 'should trigger move if dragging' do
+      subject.instance_variable_set('@started', true)
+      subject.instance_variable_set('@position', position)
+      subject.should receive(:trigger).with 'move', position
+      subject.move
+    end
+
+    it 'should not trigger move if not dragging' do
+      subject.should_not receive(:trigger)
+      subject.should_not receive(:request_animation_frame)
+      subject.move
+    end
+  end
+
+  describe '#off' do
+    it 'should remove events' do
+      subject.body.should receive(:off).at_least(2).times
+      subject.off
+    end
+  end
+
+  describe '#position' do
+    it 'should return the current position' do
+      pos = subject.position event
+      pos.should be_a Fron::Point
+      pos.x.should eq 0
+      pos.y.should eq 0
+    end
+  end
+end

data/spec/utils/keyboard_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+require 'fron/utils/keyboard'
+
+# Test Keyboard Class
+class TestKeyboard < Fron::Keyboard
+  sc 'ctrl+up'
+end
+
+describe TestKeyboard do
+  let(:event) { DOM::Event.new `{ctrlKey: true, altKey: true, shiftKey: true, keyCode: 38}` }
+
+  describe Fron::Keyboard do
+    it 'should work on its own' do
+      Fron::Keyboard.new.should be_a Fron::Keyboard
+    end
+  end
+
+  describe 'DSL' do
+    subject { described_class }
+
+    describe '#sc' do
+      it 'should define a shortcut with action' do
+        subject.sc 'ctrl+down', :test
+        subject.shortcuts.last.should eq(
+          parts: %w(ctrl down),
+          action: :test,
+          block: nil
+        )
+      end
+
+      it 'should define a shortcut with block' do
+        sc = subject.shortcuts.first
+        sc[:parts].should eq %w(ctrl up)
+        sc[:action].should eq nil
+      end
+    end
+  end
+
+  describe 'Events' do
+    it 'should handle keydown' do
+      subject.should receive(:keydown)
+      DOM::Document.body.listeners[:keydown].count.should eq 1
+      DOM::Document.body.listeners[:keydown][0].call {}
+    end
+  end
+
+  describe '#keydown' do
+    let(:shortcut) { { parts: %w(ctrl alt shift up) } }
+
+    it 'should match shortcuts to the combo' do
+      described_class.instance_variable_set('@shortcuts', [{ parts: [] }, shortcut])
+      subject.should receive(:handle_shortcut).with shortcut
+      event.should receive(:stop)
+      subject.keydown event
+    end
+  end
+
+  describe 'handle_shortcut' do
+    it 'should run block if block given' do
+      sc = { block: proc {} }
+      subject.should receive(:instance_exec)
+      subject.handle_shortcut sc
+    end
+
+    it 'should call action method if given' do
+      subject.should receive(:test)
+      subject.handle_shortcut action: :test
+    end
+
+    it 'should warn if method is not exists' do
+      subject.should receive(:warn)
+      subject.handle_shortcut action: :test2, parts: %w(a b)
+    end
+  end
+end