fron 0.1.0 → 0.1.1

data/opal/fron/dom/fragment.rb

@@ -1,7 +1,5 @@
 module DOM
-  class Fragment
-    include Node
-
+  class Fragment < NODE
     def initialize
       @el = `document.createDocumentFragment()`
     end

data/opal/fron/dom/modules/classlist.rb

@@ -16,8 +16,8 @@ module DOM
       `#{@el}.classList.contains(#{cls})`
     end
 
-    def toggleClass(cls,value)
-      if value
+    def toggleClass(cls,value = nil)
+      if value || (value == nil && !hasClass(cls))
         addClass cls
       else
         removeClass cls

data/opal/fron/dom/modules/dimensions.rb

@@ -4,34 +4,33 @@ module DOM
   module Dimensions
 
     def top
-      clientRect[:top] + Window.scrollY
+      `#{clientRect}.top` + Window.scrollY
     end
 
     def left
-      clientRect[:left] + Window.scrollX
+      `#{clientRect}.left` + Window.scrollX
     end
 
     def right
-      clientRect[:right] + Window.scrollX
+      `#{clientRect}.right` + Window.scrollX
     end
 
     def bottom
-      clientRect[:bottom] + Window.scrollY
+      `#{clientRect}.bottom` + Window.scrollY
     end
 
     def width
-      clientRect[:width]
+      `#{clientRect}.width`
     end
 
     def height
-
-      clientRect[:height]
+      `#{clientRect}.height`
     end
 
     private
 
     def clientRect
-      Hash.new `JSON.parse(JSON.stringify(#{@el}.getBoundingClientRect()))`
+      `#{@el}.getBoundingClientRect()`
     end
   end
 end

data/opal/fron/dom/modules/events.rb

@@ -1,19 +1,64 @@
 module DOM
   module Events
-    def on(event, &listener)
-    `#{@el}.addEventListener(#{event},function(e){#{ listener.call Event.new(`e`)}})`
-    self
-    end
-
-    def delegate(event,selector, &listener)
+    def trigger(type, data = {})
       %x{
-        #{@el}.addEventListener(#{event},function(e){
-          if(e.target.webkitMatchesSelector(#{selector})){
-            #{ listener.call Event.new(`e`)}
-          }
-        },true)
+        event = document.createEvent("HTMLEvents");
+        event.initEvent(#{type}, true, true);
+        for (key in #{data}) {
+          value = #{data}[key];
+          event[key] = value;
+        }
+        #{@el}.dispatchEvent(event);
       }
-      self
+    end
+
+    def on(type, &listener)
+      klass = if defined? self.class::EVENT_TARGET_CLASS
+        self.class::EVENT_TARGET_CLASS
+      else
+        Hash
+      end
+      method = `function(e){#{ listener.call Event.new(`e`,klass)}}`
+
+      @listeners       ||= {}
+      @listeners[type] ||= []
+      @listeners[type] << method
+
+      `#{@el}.addEventListener(#{type},#{method})`
+      method
+    end
+
+    def off(type = nil, method = nil)
+      return unless @listeners
+
+      if type == nil
+        @listeners.keys.each do |type|
+          removeListeners type
+        end
+      elsif method == nil
+        removeListeners type
+      else
+        return unless @listeners[type].index(method)
+        @listeners[type].delete method
+        `#{@el}.removeEventListener(#{type},#{method})`
+      end
+    end
+
+    def delegate(type,selector, &listener)
+      on type do |event|
+        if event.target.matches selector
+          listener.call event
+        end
+      end
+    end
+
+    private
+
+    def removeListeners(type)
+      @listeners[type].each do |method|
+        @listeners[type].delete method
+        `#{@el}.removeEventListener(#{type},#{method})`
+      end
     end
   end
 end

data/opal/fron/dom/node.rb

@@ -1,6 +1,17 @@
+require 'native'
+
 module DOM
-  module Node
+  class NODE
+    EVENT_TARGET_CLASS = self
+
     include Events
+    include Comparable
+
+    def initialize(node = nil)
+      raise "A node must be provided!" unless node
+      raise "Not a HTML Node given!" unless `#{node} instanceof Node`
+      @el = node
+    end
 
     # Cloning
     # ---------------------------------------
@@ -15,11 +26,13 @@ module DOM
     # Hierarchy
     # ---------------------------------------
     def parentNode
-      DOM::Node.new `#{@el}.parentNode`
+      el = `#{@el}.parentNode || false`
+      el ? DOM::NODE.new(el) : nil
     end
 
     def parent
-      DOM::Node.new `#{@el}.parentElement`
+      el = `#{@el}.parentElement || false`
+      el ? DOM::NODE.new(el) : nil
     end
 
     def empty?
@@ -27,13 +40,13 @@ module DOM
     end
 
     def children
-      `Array.prototype.slice.call(#{@el}.childNodes)`
+      NodeList.new `Array.prototype.slice.call(#{@el}.childNodes)`
     end
 
     # Remove
     # ---------------------------------------
     def remove(el)
-      `#{@el}.removeChild(#{getEl el})`
+      `#{@el}.removeChild(#{NODE.getElement el})`
     end
 
     def remove!
@@ -44,12 +57,11 @@ module DOM
     # Hierarchy Manipulation
     # ---------------------------------------
     def << el
-      `#{@el}.appendChild(#{getEl el})`
-      self
+      `#{@el}.appendChild(#{NODE.getElement el})`
     end
 
     def >> el
-      `#{getEl el}.appendChild(#{@el})`
+      `#{NODE.getElement el}.appendChild(#{@el})`
     end
 
     def insertBefore(what,where)
@@ -66,14 +78,36 @@ module DOM
       `#{@el}.textContent = #{text}`
     end
 
-    def normalize
+    def normalize!
       `#{@el}.normalize()`
     end
 
+    # Comparabe methods
+    # ---------------------------------------
+    def ==(obj)
+      `#{NODE.getElement(obj)} === #{@el}`
+    end
+
+    def <=>(obj)
+      if obj == self then return 0 end
+      if obj.parent != parent then raise 'Nodes not Comparable!' end
+      obj.index <=> index
+    end
+
+    def index
+      parent.children.index self
+    end
+
     private
 
-    def getEl(obj)
-      obj.is_a?(Node) ? obj.instance_variable_get('@el') : obj
+    def self.getElement(obj)
+      if `#{obj} instanceof Node`
+        obj
+      elsif obj.is_a?(NODE)
+        obj.instance_variable_get('@el')
+      else
+        nil
+      end
     end
   end
 end

data/opal/fron/dom/nodelist.rb

@@ -0,0 +1,14 @@
+require 'forwardable'
+
+module DOM
+  class NodeList
+    include Enumerable
+    extend Forwardable
+
+    def_delegators :@nodes, :length, :include?, :each, :index, :[]
+
+    def initialize(nodes)
+      @nodes = nodes.map { |node| DOM::NODE.new node }
+    end
+  end
+end

data/opal/fron/dom/style.rb

@@ -1,21 +1,23 @@
-class Style
-  def initialize(el)
-    @el = el
-  end
+module DOM
+  class Style
+    def initialize(el)
+      @el = el
+    end
 
-  def method_missing(name,value)
-    if name =~ /\=$/
-      self[name[0..-2]] = value
-    else
-      self[name]
+    def method_missing(name,value)
+      if name =~ /\=$/
+        self[name[0..-2]] = value
+      else
+        self[name]
+      end
     end
-  end
 
-  def [](prop)
-    `#{@el}.style[#{prop}]`
-  end
+    def [](prop)
+      `#{@el}.style[#{prop}]`
+    end
 
-  def []=(prop,value)
-    `#{@el}.style[#{prop}] = #{value}`
+    def []=(prop,value)
+      `#{@el}.style[#{prop}] = #{value}`
+    end
   end
 end

data/opal/fron/dom/text.rb

@@ -1,9 +1,7 @@
 module DOM
-  class Text
-  	include Node
-
+  class Text < NODE
     def initialize(data)
-    	@el = `typeof #{data} === 'string'` ? `document.createTextNode(#{data})` : data
+      @el = `typeof #{data} === 'string'` ? `document.createTextNode(#{data})` : data
     end
   end
 end

data/opal/fron/dom/window.rb

@@ -1,8 +1,7 @@
 module DOM
   module Window
-    def self.on(event, &listener)
-      `window.addEventListener(#{event},#{listener})`
-    end
+    extend Events
+    @el = `window`
 
     def self.hash
       `window.location.hash.slice(1)`

data/opal/fron/request/request.rb

@@ -11,26 +11,16 @@ module Fron
       self
     end
 
-    def handle_state_change
-      if ready_state == 4
-        response = Response.new `#{@request}.status`, `#{@request}.response`, `#{@request}.getAllResponseHeaders()`
-        @callback.call response
-      end
-    end
-
-    def ready_state
-      `#{@request}.readyState`
-    end
-
-    def request( method = 'GET',data = nil, &callback)
+    def request( method = 'GET', data = nil, &callback)
       if ready_state == 0 or ready_state == 4
+        @callback = callback
         if method.upcase == "GET" && data
           `#{@request}.open(#{method},#{@url+"?"+data.to_query_string})`
+          `#{@request}.send()`
         else
           `#{@request}.open(#{method},#{@url})`
+          `#{@request}.send(#{data.to_form_data if data})`
         end
-        @callback = callback
-        `#{@request}.send(#{data.to_form_data if data})`
       else
         raise "The request is already running!"
       end
@@ -47,5 +37,18 @@ module Fron
     def put(data, &callback)
       request 'PUT', data, &callback
     end
+
+    private
+
+    def ready_state
+      `#{@request}.readyState`
+    end
+
+    def handle_state_change
+      if ready_state == 4
+        response = Response.new `#{@request}.status`, `#{@request}.response`, `#{@request}.getAllResponseHeaders()`
+        @callback.call response if @callback
+      end
+    end
   end
 end

data/opal/fron/storage/local-storage.rb

@@ -1,18 +1,34 @@
-module LocalStorage
-  def self.get(key)
-    value = `window.localStorage.getItem(#{key}) || false`
-    value ? JSON.parse(value) : nil
-  end
+module Fron
+  module Storage
+    module LocalStorage
+      def self.get(key)
+        value = `window.localStorage.getItem(#{key}) || false`
+        value ? JSON.parse(value) : nil
+      end
 
-  def self.set(key, data)
-    `window.localStorage.setItem(#{key},#{data.to_json})`
-  end
+      def self.set(key, data)
+        `window.localStorage.setItem(#{key},#{data.to_json})`
+      end
 
-  def self.keys
-    `ret = []; for (var key in localStorage){ ret.push(key) }; return ret;`
-  end
+      def self.remove(key)
+        `window.localStorage.removeItem(#{key})`
+      end
+
+      def self.keys
+        %x{
+          ret = []
+          for (var key in localStorage){ ret.push(key) }
+          return ret
+        }
+      end
+
+      def self.all
+        self.keys.map{ |key| self.get key }
+      end
 
-  def self.all
-    self.keys.map{ |key| self.get key }
+      def self.clear
+        `window.localStorage.clear()`
+      end
+    end
   end
 end

data/spec/core-ext/hash_spec.rb

@@ -0,0 +1,18 @@
+require 'fron/core-ext/hash'
+
+describe Hash do
+
+  subject { { a: 'test', b: 'user' } }
+
+  describe "#to_query_string" do
+    it 'should return the hash in query string format' do
+      subject.to_query_string.should eq 'a=test&b=user'
+    end
+  end
+
+  describe '#to_form_data' do
+    it 'should return the hash in FormData format' do
+      `#{subject.to_form_data} instanceof FormData`.should be true
+    end
+  end
+end

data/spec/core/adapter/local_spec.rb

@@ -0,0 +1,65 @@
+require 'fron/storage'
+require 'fron/core'
+
+describe Fron::Adapters::LocalAdapter do
+
+  subject { described_class.new({fields: [:name]}) }
+  let(:proc) { Proc.new {} }
+
+  describe "#all" do
+    it "should call localStorage#all" do
+      Fron::Storage::LocalStorage.should receive(:all).once
+      subject.all &proc
+    end
+
+    it "should run the block" do
+      proc.should receive(:call)
+      subject.all &proc
+    end
+  end
+
+  describe "#get" do
+    it "should call localStorage#get" do
+      Fron::Storage::LocalStorage.should receive(:get).once
+      subject.get 0, &proc
+    end
+
+    it "should run the block" do
+      proc.should receive(:call)
+      subject.get 0, &proc
+    end
+  end
+
+  describe "#set" do
+    it "should call localStorage#set" do
+      Fron::Storage::LocalStorage.should receive(:set).once
+      subject.set 0, {name: 'test'}, &proc
+    end
+
+    it "should run the block with nil if there are no errors" do
+      proc.should receive(:call).with nil
+      subject.set 0, {name: 'test'}, &proc
+    end
+
+    it "should run the block with erros if ther are any" do
+      proc.should receive(:call).with({name: ["can't be blank"]})
+      subject.set 0, {name: ''}, &proc
+    end
+
+    it "should add id if there isn't any" do
+      result = subject.set nil, {name: ''}, &proc
+      result[:id].should_not be nil
+    end
+  end
+
+  describe "#validate" do
+    it "should return errors for undefined fields" do
+      subject.validate.should eq({name: ["can't be blank"]})
+    end
+
+    it "should return errors for empty fields" do
+      subject.validate({name: ''}).should eq({name: ["can't be blank"]})
+    end
+  end
+end
+