fron 0.1.4 → 0.2.0rc1

data/opal/fron/dom/nodelist.rb

@@ -1,14 +1,21 @@
 require 'forwardable'
 
 module DOM
+  # Node List
   class NodeList
     include Enumerable
     extend Forwardable
 
-    def_delegators :@nodes, :length, :include?, :each, :index, :[]
+    # @return [Array] The nodes
+    attr_reader :nodes
 
+    def_delegators :@nodes, :length, :include?, :each, :index, :[], :to_a, :last, :empty?
+
+    # Initializes the node list
+    #
+    # @param nodes [Array] Array of nodes
     def initialize(nodes)
-      @nodes = nodes.map { |node| DOM::NODE.new node }
+      @nodes = nodes.map { |node| DOM::Element.from_node node }
     end
   end
 end

data/opal/fron/dom/style.rb

@@ -1,10 +1,22 @@
+# rubocop:disable MethodName
+
 module DOM
+  # Style
   class Style
+    # Initializes the style
+    #
+    # @param el [DOM::Element] The element
     def initialize(el)
       @el = el
     end
 
-    def method_missing(name,value)
+    # Sets or gets a given CSS property
+    #
+    # @param name [String] The property
+    # @param value [String] The value
+    #
+    # @return [String] The value of the property
+    def method_missing(name, value)
       if name =~ /\=$/
         self[name[0..-2]] = value
       else
@@ -12,11 +24,20 @@ module DOM
       end
     end
 
+    # Gets a CSS property value
+    #
+    # @param prop [String] The property
+    #
+    # @return [String] The value of the property
     def [](prop)
       `#{@el}.style[#{prop}]`
     end
 
-    def []=(prop,value)
+    # Sets the given CSS property with the given value
+    #
+    # @param prop [String] The property
+    # @param value [String] The value
+    def []=(prop, value)
       `#{@el}.style[#{prop}] = #{value}`
     end
   end

data/opal/fron/dom/text.rb

@@ -1,5 +1,9 @@
 module DOM
+  # Text
   class Text < NODE
+    # Initializes the text node with the given data
+    #
+    # @param data [String] The value of the node
     def initialize(data)
       @el = `typeof #{data} === 'string'` ? `document.createTextNode(#{data})` : data
     end

data/opal/fron/dom/window.rb

@@ -1,21 +1,50 @@
 module DOM
+  # Window
   module Window
     extend Events
     @el = `window`
 
+    # Sets the url via pushState
+    #
+    # @param url [String] The url
+    def self.state=(url)
+      return if url == state
+      `window.history.pushState({},'',#{url})`
+      timeout { trigger 'popstate' }
+    end
+
+    # Returns the locations pathname as state
+    #
+    # @return [String] The pathname
+    def self.state
+      `window.location.pathname`
+    end
+
+    # Returns the locations hash
+    #
+    # @return [String] The hash
     def self.hash
       `window.location.hash.slice(1)`
     end
 
+    # Sets the locations hash with the given value
+    #
+    # @param value [String] The value
     def self.hash=(value)
       `window.location.hash = #{value}`
     end
 
-    def self.scrollY
+    # Returns the Y scroll position of the window
+    #
+    # @return [Numeric] The position
+    def self.scroll_y
       `window.scrollY || document.documentElement.scrollTop`
     end
 
-    def self.scrollX
+    # Returns the X scroll position of the window
+    #
+    # @return [Numeric] The position
+    def self.scroll_x
       `window.scrollX || document.documentElement.scrollTop`
     end
   end

data/opal/fron/event_mock.rb

@@ -0,0 +1,54 @@
+require 'fron/js/syntetic_event'
+
+# Event Mock module for mocking events
+module EventMock
+  class << self
+    # Sets / gets the whether or not
+    # log event triggers
+    #
+    # @param value [Boolean] The verbosity
+    # @return [Boolean] The verbosity
+    attr_accessor :verbose
+
+    # Triggers a syntetic event.
+    #
+    # @param element [DOM::Element] The element
+    # @param type [String] Event type
+    # @param data [Hash] The data for the event
+    def trigger_event(element, type, data = {})
+      event = `new SynteticEvent(#{element.instance_variable_get('@el')}, #{data.to_n})`
+      dispath_event element, event, type
+    end
+
+    # Dispatches a sytetic event
+    #
+    # @param element [DOM::Element] The element
+    # @param event [SynteticEvent] The event
+    # @param type [String] Event type
+    #
+    # @return [type] [description]
+    def dispath_event(element, event, type)
+      if `#{element.listeners} || Opal.nil`
+        element.listeners[type].to_a.each do |method|
+          break unless `#{event}.immediatePropagate`
+          method.call event
+        end
+      end
+      return unless `#{event}.propagate`
+      return unless element.parent
+      dispath_event element.parent, event, type
+    end
+
+    # Mocks triggers on DOM::Events
+    def mock_events
+      DOM::Events.alias_method :old_trigger, :trigger
+      DOM::Events.define_method :trigger do |type, data = {}|
+        puts "Triggered syntetic event \"#{type}\" for \"#{path}\"" if EventMock.verbose
+        EventMock.trigger_event self, type, data
+      end
+      yield
+    ensure
+      DOM::Events.alias_method :trigger, :old_trigger
+    end
+  end
+end

data/opal/fron/js/syntetic_event.js

@@ -0,0 +1,16 @@
+SynteticEvent = function(target, data){
+  this.target = target
+  this.defaultPrevented = false
+  this.immediatePropagate = true
+  this.propagate = true
+  this.data = data
+}
+SynteticEvent.prototype.stopImmediatePropagation = function(){
+  this.immediatePropagate = false
+}
+SynteticEvent.prototype.stopPropagation = function(){
+  this.propagate = false
+}
+SynteticEvent.prototype.preventDefault = function(){
+  this.defaultPrevented = true
+}

data/opal/fron/request.rb

@@ -1,2 +1,2 @@
-require './request/response'
-require './request/request'
+require 'fron/request/response'
+require 'fron/request/request'

data/opal/fron/request/request.rb

@@ -1,9 +1,29 @@
 require 'json'
 
 module Fron
+  # Request
   class Request
-    attr_accessor :url, :headers
+    extend Eventable
+    extend Forwardable
 
+    # Sets / gets the URL
+    #
+    # @param value [String] The URL
+    # @return [String] The URL
+    attr_accessor :url
+
+    # Sets / gets the headers for the request
+    #
+    # @param value [Hash] The headers
+    # @return [Hash] The headers
+    attr_accessor :headers
+
+    def_delegators :class, :trigger
+
+    # Initialies the request
+    #
+    # @param url [String] The url
+    # @param headers [Hash] The headers
     def initialize(url, headers = {})
       @url = url
       @headers = headers
@@ -12,50 +32,93 @@ module Fron
       self
     end
 
-    def request( method = 'GET', data = nil, &callback)
-      if ready_state == 0 or ready_state == 4
+    # Runs a request
+    #
+    # @param method [String] The method
+    # @param data [Hash] The data
+    #
+    # @yieldparam response [Response] The response
+    def request(method = 'GET', data = nil, &callback)
+      if ready_state == 0 || ready_state == 4
         @callback = callback
-        if method.upcase == "GET" && data
-          `#{@request}.open(#{method},#{@url+"?"+data.to_query_string})`
-          setHeaders
-          `#{@request}.send()`
+        if method.upcase == 'UPLOAD'
+          send 'POST', @url, data.to_form_data
+        elsif method.upcase == 'GET' && data
+          send method, @url + '?' + data.to_query_string.to_s, nil
         else
-          `#{@request}.open(#{method},#{@url})`
-          setHeaders
-          `#{@request}.send(#{data.to_json if data})`
+          data = data.to_json if data
+          send method, @url, data
         end
+        trigger :loading
       else
-        raise "The request is already running!"
+        fail 'The request is already running!'
       end
     end
 
+    # Runs a GET request
+    #
+    # @param data [Hash] The data
+    #
+    # @yieldparam response [Response] The response
     def get(data, &callback)
       request 'GET', data, &callback
     end
 
+    # Runs a POST request
+    #
+    # @param data [Hash] The data
+    #
+    # @yieldparam response [Response] The response
     def post(data, &callback)
       request 'POST', data, &callback
     end
 
+    # Runs a PUT request
+    #
+    # @param data [Hash] The data
+    #
+    # @yieldparam response [Response] The response
     def put(data, &callback)
       request 'PUT', data, &callback
     end
 
     private
-    def setHeaders
-      @headers.each_pair do |header,value|
+
+    # Sends the given data to the given URL
+    # with the given method
+    #
+    # @param method [String] The method
+    # @param url [String] The URL
+    # @param data [*] The data
+    def send(method, url, data)
+      `#{@request}.open(#{method}, #{url})`
+      `#{@request}.withCredentials = true`
+      set_headers
+      `#{@request}.send(#{data})`
+    end
+
+    # Sets the headers
+    def set_headers
+      @headers.each_pair do |header, value|
         `#{@request}.setRequestHeader(#{header},#{value})`
       end
     end
 
+    # Returns the ready state of the request
+    #
+    # @return [Numeric] The ready state
     def ready_state
       `#{@request}.readyState`
     end
 
+    # Handles the hash change
     def handle_state_change
-      if ready_state == 4
+      return unless ready_state == 4
+      begin
         response = Response.new `#{@request}.status`, `#{@request}.response`, `#{@request}.getAllResponseHeaders()`
         @callback.call response if @callback
+      ensure
+        trigger :loaded
       end
     end
   end

data/opal/fron/request/response.rb

@@ -1,7 +1,22 @@
 module Fron
+  # Response
   class Response
-    attr_reader :body, :headers, :status
+    # @return [String] The response body
+    attr_reader :body
 
+    # @return [Hash] The response headers
+    attr_reader :headers
+
+    # @return [Numeric] The response status code
+    attr_reader :status
+
+    # Initializes the response
+    #
+    # @param status [Numeric] The status
+    # @param body [String] The response body
+    # @param headers [Hash] The headers
+    #
+    # @return [type] [description]
     def initialize(status, body, headers)
       @body    = body
       @status  = status
@@ -13,24 +28,36 @@ module Fron
       end
     end
 
+    # Returns the content type of the response
+    #
+    # @return [String] The content type
     def content_type
       @headers['Content-Type']
     end
 
+    # Returns whether the request was successfull
+    #
+    # @return [Boolean] True if it was false if not
     def ok?
       @status == 200
     end
 
+    # Returns the response body as json
+    #
+    # @return [Hash] The body
     def json
       JSON.parse @body
     end
 
+    # Returns the response body as DOM::Fragment
+    #
+    # @return [DOM::Fragment] The body
     def dom
-      d = DOM::Element.new 'div'
-      d.html = @body
-      f = DOM::Fragment.new()
-      f << d
-      f
+      div = DOM::Element.new 'div'
+      div.html = @body
+      fragment = DOM::Fragment.new
+      fragment << div
+      fragment
     end
   end
 end

data/opal/fron/storage.rb

@@ -1 +1 @@
-require './storage/local-storage'
+require 'fron/storage/local_storage'

data/opal/fron/storage/local_storage.rb

@@ -0,0 +1,54 @@
+module Fron
+  module Storage
+    # Local Storage wrapper and adapter
+    module LocalStorage
+      # Gets a value from local storage with the given key
+      #
+      # @param key [String] The key
+      #
+      # @return [Object] The value
+      def self.get(key)
+        value = `window.localStorage.getItem(#{key}) || false`
+        value ? JSON.parse(value) : nil
+      end
+
+      # Sets a value to local storage with the given key
+      #
+      # @param key [String] The key
+      # @param data [Object] The value
+      def self.set(key, data)
+        `window.localStorage.setItem(#{key},#{data.to_json})`
+      end
+
+      # Removes a value from local storage with the given key
+      #
+      # @param key [String] The key
+      def self.remove(key)
+        `window.localStorage.removeItem(#{key})`
+      end
+
+      # Returns the all keys present in local storage
+      #
+      # @return [Array] Array of keys
+      def self.keys
+        %x{
+          ret = []
+          for (var key in localStorage){ ret.push(key) }
+          return ret
+        }
+      end
+
+      # Returns all values from local storage
+      #
+      # @return [Array] Array of values
+      def self.all
+        keys.map { |key| get key }
+      end
+
+      # Clears local storage removeing all values
+      def self.clear
+        `window.localStorage.clear()`
+      end
+    end
+  end
+end