fron 0.1.0

data/opal/fron/core/controller.rb

@@ -0,0 +1,41 @@
+module Fron
+  class Controller
+    class << self
+      attr_accessor :baseComponent, :routes, :beforeFilters, :events
+
+      def base(component)
+        @baseComponent = component
+      end
+
+      def route(*args)
+        @routes ||= []
+        @routes << Router.map(*args)
+      end
+
+      def on(name,action)
+        @events ||= []
+        @events << {name: name, action: action}
+      end
+
+      def beforeFilter(method,actions)
+        @beforeFilters ||= []
+        @beforeFilters << {method: method, actions: actions}
+      end
+    end
+
+    attr_reader :base
+
+    def initialize
+      if self.class.baseComponent
+        @base = self.class.baseComponent.new
+      else
+        @base = DOM::Element.new 'div'
+      end
+
+      return unless self.class.events
+      self.class.events.each do |event|
+        Eventable.on event[:name] do self.send(event[:action]) end
+      end
+    end
+  end
+end

data/opal/fron/core/eventable.rb

@@ -0,0 +1,31 @@
+module Fron
+  module Eventable
+    extend self
+
+    def on(event, &block)
+      @events ||= {}
+      @events[event] ||= []
+      @events[event] << block
+    end
+
+    def trigger(event, triggerGlobal = true)
+      Eventable.trigger event, false if triggerGlobal
+      return unless @events
+      return unless @events[event]
+      @events[event].each do |block|
+        block.call
+      end
+    end
+
+    def off(event = nil, &block)
+      return unless @events
+      if block_given?
+        @events[event].delete block
+      elsif event
+        @events[event] = []
+      else
+        @events = {}
+      end
+    end
+  end
+end

data/opal/fron/core/logger.rb

@@ -0,0 +1,8 @@
+module Fron
+  class Logger
+    def info(message)
+      return if ENV == 'test'
+      puts Time.now.strftime("[%H:%M] ") + message
+    end
+  end
+end

data/opal/fron/core/model.rb

@@ -0,0 +1,68 @@
+module Fron
+  class Model
+    include Eventable
+    attr_reader :errors
+
+    class << self
+      attr_accessor :fields
+      attr_accessor :adapter
+
+      def adapter(adapter, options = {})
+        options.merge! fields: @fields
+        @adapter = adapter.new options
+      end
+
+      def field(name)
+        @fields ||= []
+        @fields << name
+        define_method(name) do
+          @data[name]
+        end
+        define_method(name+"=") do |value|
+          @data[name] = value
+          trigger 'change'
+        end
+      end
+
+      def all(&block)
+        @adapter.all do |items|
+          block.call items.map{ |item| self.new item }
+        end
+      end
+
+      def find(id, &block)
+        user = self.new
+        @adapter.get id do |data|
+          user.merge data
+          block.call user
+        end
+        user
+      end
+    end
+
+    def initialize(data = {})
+      @data  = data
+    end
+
+    def update(attributes, &block)
+      data = @data.dup.merge! attributes
+      self.class.instance_variable_get("@adapter").set id, data do |errors|
+        @errors = errors
+        merge data
+        block.call if block_given?
+      end
+    end
+
+    def dirty?
+      !self.id
+    end
+
+    private
+
+    def merge(data)
+      data.each_pair do |key,value|
+        self.send(key+"=", value) if self.respond_to?(key+"=")
+      end
+    end
+  end
+end

data/opal/fron/core/router.rb

@@ -0,0 +1,81 @@
+module Fron
+  class Router
+    def initialize(routes,config)
+      @config = config
+      @routes = routes
+
+      DOM::Window.on 'load' do
+        route
+      end
+      DOM::Window.on 'hashchange' do
+        route
+      end
+    end
+
+    def self.map(*args)
+      data = case args.length
+      when 1
+        action = args[0]
+        {path: "*"}
+      when 2
+        action = args[1]
+        {path: Router.pathToRegexp(args[0]) }
+      end
+      if action.is_a? Class
+        data[:controller] = action.new
+      else
+        data[:action] = action.to_s
+      end
+      data
+    end
+
+    def self.pathToRegexp(path)
+      return path if path == "*"
+      {regexp: Regexp.new('^'+path.gsub(/:(.+)/, '(.+)')), map: path.match(/:(.+)/).to_a[1..-1] }
+    end
+
+    def route(hash = DOM::Window.hash, controller = nil)
+      routes = controller ? controller.class.routes : @routes
+      routes.each do |r|
+        if r[:path] == '*'
+          if r[:controller]
+            break route(hash,r[:controller])
+          else
+            break applyRoute(controller,r)
+          end
+        else
+          matches = hash.match(r[:path][:regexp]).to_a[1..-1]
+          if matches
+            params = {}
+            if r[:path][:map]
+              r[:path][:map].each_with_index do |key, index|
+                params[key.to_sym] = matches[index]
+              end
+            end
+            if r[:action]
+              break applyRoute(controller,r,params)
+            else
+              break route hash.gsub(r[:path][:regexp],''), r[:controller]
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    def applyRoute(controller,route, params = {})
+      if controller.class.beforeFilters
+        controller.class.beforeFilters.each do |filter|
+          if filter[:actions].include?(route[:action])
+            controller.send(filter[:method], params)
+          end
+        end
+      end
+      controller.send(route[:action], params)
+      @config.logger.info "Navigate >> #{controller.class}##{route[:action]} with params #{params}"
+      @config.main.empty
+      @config.main << controller.base
+    end
+  end
+end

data/opal/fron/dom.rb

@@ -0,0 +1,11 @@
+require './dom/modules/events'
+require './dom/modules/classlist'
+require './dom/modules/dimensions'
+require './dom/style'
+require './dom/node'
+require './dom/text'
+require './dom/element'
+require './dom/fragment'
+require './dom/document'
+require './dom/window'
+require './dom/event'

data/opal/fron/dom/document.rb

@@ -0,0 +1,20 @@
+module DOM
+  module Document
+    def self.head
+      find 'head'
+    end
+
+    def self.body
+      find 'body'
+    end
+
+    def self.title=(value)
+      `document.title = #{value}`
+    end
+
+    def self.find(selector)
+      value = `document.querySelector(#{selector}) || false`
+      value ? DOM::Element.new(value) : nil
+    end
+  end
+end

data/opal/fron/dom/element.rb

@@ -0,0 +1,102 @@
+module DOM
+  class Element
+    include Node
+    include ClassList
+    include Dimensions
+
+    attr_reader :style
+
+    ATTRIBUTE_REGEXP = /\[(.*?)=(.*?)\]/
+    TAG_REGEXP       = /(^[A-Za-z_\-0-9]+)(.*)/
+    MODIFIER_REGEXP  = /(#|\.)(.+?)(?=#|\.| |$)/
+
+    def initialize(data)
+      if `typeof #{data} === 'string'`
+        match, tag, rest = data.match(TAG_REGEXP).to_a
+        @el = `document.createElement(#{tag})`
+        rest = rest.gsub ATTRIBUTE_REGEXP do |match|
+          m,key,value = match.match(ATTRIBUTE_REGEXP).to_a
+          self[key] = value
+          ''
+        end
+        rest = rest.gsub MODIFIER_REGEXP do |match|
+          m,type,value = match.match(MODIFIER_REGEXP).to_a
+          case type
+          when "#"
+            self['id'] = value
+          when "."
+            addClass value
+          end
+          ''
+        end
+        if (m = rest.match /\s(.+)$/)
+          self.text = m[0].strip
+        end
+      else
+        @el = data
+      end
+      @style = Style.new @el
+    end
+
+    # Visiblity
+    # --------------------------------
+    def hide
+      @style.display = 'none'
+    end
+
+    def show
+      @style.display = 'block'
+    end
+
+    # Attribute access
+    # --------------------------------
+    def [](name)
+      `#{@el}.getAttribute(#{name})`
+    end
+
+    def []=(name,value)
+      `#{@el}.setAttribute(#{name},#{value})`
+    end
+
+    # Traversing
+    # --------------------------------
+    def find(selector)
+      value = `#{@el}.querySelector(#{selector}) || false`
+      value ? DOM::Element.new(value) : nil
+    end
+
+    # HTML Modification
+    # --------------------------------
+    def html
+      `#{@el}.innerHTML`
+    end
+
+    def html=(value)
+      `#{@el}.innerHTML = #{value}`
+    end
+
+    def empty
+      self.html = ''
+    end
+
+    def value
+      `#{@el}.value`
+    end
+
+    def value=(value)
+      `#{@el}.value = #{value}`
+    end
+
+    def checked
+      `!!#{@el}.checked`
+    end
+
+    def checked=(value)
+      `#{@el}.checked = #{value}`
+    end
+
+    def tag
+      `#{@el}.tagName`.downcase
+    end
+  end
+end

data/opal/fron/dom/event.rb

@@ -0,0 +1,70 @@
+class Event
+  def initialize(e)
+    @e = e
+  end
+
+  def target
+    `#{@e}.target`
+  end
+
+  def charCode
+    `#{@e}.charCode`
+  end
+
+  def keyCode
+    `#{@e}.keyCode`
+  end
+
+  def stop
+    preventDefault
+    stopPropagation
+  end
+
+  def preventDefault
+    `#{@e}.preventDefault()`
+  end
+
+  def stopPropagation
+    `#{@e}.stopPropagation()`
+  end
+
+  def pageX
+    `#{@e}.pageX`
+  end
+
+  def pageY
+    `#{@e}.pageY`
+  end
+
+  def screenX
+    `#{@e}.screenX`
+  end
+
+  def screenY
+    `#{@e}.screenY`
+  end
+
+  def clientX
+    `#{@e}.clientX`
+  end
+
+  def clientY
+    `#{@e}.clientY`
+  end
+
+  def alt?
+    `#{@e}.altkey`
+  end
+
+  def shift?
+    `#{@e}.shiftkey`
+  end
+
+  def ctrl?
+    `#{@e}.ctrlkey`
+  end
+
+  def meta?
+    `#{@e}.metakey`
+  end
+end

data/opal/fron/dom/fragment.rb

@@ -0,0 +1,9 @@
+module DOM
+  class Fragment
+    include Node
+
+    def initialize
+      @el = `document.createDocumentFragment()`
+    end
+  end
+end