fron 0.1.4 → 0.2.0rc1

data/opal/fron/core/component.rb

@@ -1,110 +1,84 @@
+require 'fron/core/behaviors/components'
+require 'fron/core/behaviors/events'
+require 'fron/core/behaviors/routes'
+
 module Fron
+  # Component
   class Component < DOM::Element
-    attr_reader :model
-
     class << self
-      attr_reader :events
+      # @return [String] The tagname of the component
       attr_reader :tagname
-      attr_reader :components
-      attr_reader :delegates
 
-      def inherited(subclass)
-        [:components,:events,:delegates].each do |type|
-          if (var = instance_variable_get("@#{type}"))
-            inst_var = subclass.instance_variable_get('@#{type}')
-            subclass.instance_variable_set("@#{type}", []) unless inst_var
-            subclass.send(type).concat var
-          end
-        end
-      end
-
-      def tag(tag)
-        @tagname = tag
+      # @return [Hash] The hash of behaviors
+      attr_reader :behaviors
+
+      # Creates a new class with the specific tag
+      #
+      # @param tag [String] The tag
+      #
+      # @return [Fron::Component] The new component
+      def create(tag)
+        klass = Class.new self
+        klass.tag tag
+        klass
       end
 
-      def on(*args)
-        @events ||= []
-        @events << args
-      end
-
-      def component(*args,&block)
-        attr_reader args[0]
-        @components ||= []
-        @components << ( args << block )
-      end
-
-      def delegate(*args)
-        @delegates ||= []
-        @delegates << args
-      end
-    end
-
-    def initialize(*args)
-      case args.length
-      when 1
-        @model = args[0]
-      when 2
-        tag, @model = args
-      when 3
-        tag, options, @model = args
+      # Register a behavior
+      #
+      # @param behavior [Module] The behavior
+      # @param methods [Array] The methods to register
+      def register(behavior, methods)
+        @behaviors ||= {}
+        @behaviors[behavior] = methods
+
+        methods.each do |name|
+          instance_variable_set "@#{name}", []
+          meta_def name do |*args, &block|
+            args << block if block_given?
+            instance_variable_get("@#{name}") << args
+          end
+        end
       end
 
-      super tag || self.class.tagname || self.class.name.split("::").last
-
-      applyEvents
-      createComponents
-      applyDelegates
-
-      if options
-        options.each do |method,value|
-          self.send(method+"=",value) if self.respond_to?(method+"=")
+      # Handles inheritance
+      #
+      # @param subclass [Class] The subclass
+      def inherited(subclass)
+        # Copy behaviours
+        subclass.instance_variable_set '@behaviors', @behaviors.dup
+
+        # Copy registries
+        @behaviors.values.reduce(&:+).each do |type|
+          next unless (var = instance_variable_get("@#{type}"))
+          inst_var = subclass.instance_variable_get("@#{type}") || []
+          subclass.instance_variable_set("@#{type}", inst_var.concat(var))
         end
       end
 
-      return if !respond_to?(:render) || !@model
-      @model.on 'change' do render end
-      render
-    end
-
-    def component(name,comp,options,&block)
-      c = comp.is_a?(Class) ? comp.new(nil,options,@model) : Component.new(comp, options, @model)
-      c.instance_eval(&block) if block
-      self << c
-      self.instance_variable_set "@#{name}", c
-    end
-
-    private
-
-    def createComponents
-      return unless self.class.components
-      self.class.components.each do |args|
-        arguments = args.dup
-        block = arguments.last.is_a?(Proc) ? arguments.pop : nil
-        component *arguments, &block
+      # Sets the tag name of the component
+      #
+      # @param tag [String] The tag name
+      def tag(tag)
+        @tagname = tag
       end
     end
 
-    def applyDelegates
-      return unless self.class.delegates
-      self.class.delegates.each do |args|
-        method, target = args
-        self.class.define_method(method) do
-          instance_variable_get("@#{target}").send(method)
-        end
+    include Behaviors::Components
+    include Behaviors::Events
 
-        self.class.define_method(method+"=") do |value|
-          instance_variable_get("@#{target}").send(method+"=",value)
-        end
-      end
-    end
+    # Initalizs the component
+    #
+    # @param tag [String] The tagname
+    def initialize(tag = nil)
+      klass = self.class
+
+      super tag || klass.tagname || klass.name.split('::').last
 
-    def applyEvents
-      return unless self.class.events
-      self.class.events.each do |args|
-        if args.length == 3
-          delegate(args[0], args[1]) { |e| self.method(args[2]).call e }
-        else
-          on(args[0]) { |e| self.method(args[1]).call e }
+      klass.behaviors.each do |mod, methods|
+        methods.each do |name|
+          next unless mod.respond_to?(name)
+          registry = self.class.instance_variable_get("@#{name}")
+          instance_exec registry, &mod.method(name)
         end
       end
     end

data/opal/fron/core/eventable.rb

@@ -1,7 +1,16 @@
+# rubocop:disable ModuleFunction
+
 module Fron
+  # Eventable
   module Eventable
     extend self
 
+    # Add an event listener
+    #
+    # @param event [String] The type of the event
+    # @param block [Proc] The listener body
+    #
+    # @return [Proc] The block
     def on(event, &block)
       @events ||= {}
       @events[event] ||= []
@@ -9,6 +18,11 @@ module Fron
       block
     end
 
+    # Triggers an event
+    #
+    # @param event [String] The type of the event
+    # @param data = {} [type] The data
+    # @param triggerGlobal [Boolean] Whether or not to trigger a global event
     def trigger(event, data = {}, triggerGlobal = true)
       return unless @events
       return unless @events[event]
@@ -18,6 +32,10 @@ module Fron
       end
     end
 
+    # Removes event listeners
+    #
+    # @param event [String] The type of the event
+    # @param block [Proc] The listener body
     def off(event = nil, &block)
       return unless @events
       if block_given?

data/opal/fron/core/logger.rb

@@ -1,15 +1,24 @@
 module Fron
+  # Logger
   class Logger
+    # Sets / gets the log level
+    #
+    # @param value [Symbol] The level
+    # @return [Symbol] The level
     attr_accessor :level
 
+    # Initailizes the logger
     def initialize
       @level = :info
     end
 
+    # Logs the given message
+    #
+    # @param message [String] The message
     def info(message)
       return if ENV == 'test'
       return if @level == :error
-      puts Time.now.strftime("[%H:%M] ") + message
+      puts Time.now.strftime('[%H:%M] ') + message
     end
   end
 end

data/opal/fron/core_ext.rb

@@ -0,0 +1,9 @@
+require 'fron/core_ext/hash'
+require 'fron/core_ext/kernel'
+require 'fron/core_ext/numeric'
+require 'fron/core_ext/proc'
+require 'fron/core_ext/string'
+require 'fron/core_ext/object'
+require 'fron/core_ext/nil'
+require 'fron/core_ext/date'
+require 'fron/core_ext/array'

data/opal/fron/core_ext/array.rb

@@ -0,0 +1,12 @@
+# Array extensions
+class Array
+  # Runs through the elements
+  # form the back with index
+  #
+  # @yieldreturn [*] The item and index
+  def reverse_each_with_index
+    (0...length).reverse_each do |i|
+      yield self[i], i
+    end
+  end
+end

data/opal/fron/core_ext/date.rb

@@ -0,0 +1,57 @@
+require 'date'
+
+# Methods for date class
+class Date
+  class << self
+    # Returns a range for this week
+    #
+    # @return [Range] The days as range
+    def this_week
+      Date.week(Date.today)
+    end
+
+    # Returns a range for last week
+    #
+    # @return [Range] The days as range
+    def last_week
+      Date.week(Date.today - 7)
+    end
+
+    # Returns the monday of the current week
+    #
+    # @return [Date] The date
+    def monday(date = Date.today)
+      today = date
+      day = today.wday
+      diff = case day
+             when 0
+               6
+             when 1..6
+               day - 1
+             end
+      today - diff
+    end
+
+    # Returns the week days in the current week
+    #
+    # @return [Range] The days as range
+    def week(date = Date.today)
+      day = monday(date)
+      (day..day + 6)
+    end
+  end
+
+  # Returns the begging of the month
+  #
+  # @return [Date] The date
+  def beginning_of_month
+    self.class.new year, month, 1
+  end
+
+  # Returns the end of the month
+  #
+  # @return [Date] The date
+  def end_of_month
+    self.class.new year, month + 1, 0
+  end
+end

data/opal/fron/core_ext/hash.rb

@@ -0,0 +1,52 @@
+# Hash
+class Hash
+  # Returns the difference from the other object
+  #
+  # @param other [Hash] The other hash
+  #
+  # @return [Hash] The difference
+  def difference(other)
+    Hash[to_a - other.to_a]
+  end
+
+  alias_method :-, :difference
+
+  # Converts the hash into an url encoded query string
+  #
+  # @return [String] the query string
+  def to_query_string
+    map do |key, value|
+      `encodeURIComponent(#{key})+"="+encodeURIComponent(#{value})`
+    end.join '&'
+  end
+
+  # Converts the hash into a form data object
+  #
+  # @return [FormData] The native form data object
+  def to_form_data
+    form_data = `new FormData()`
+    each do |key, value|
+      `#{form_data}.append(#{key},#{value})`
+    end
+    form_data
+  end
+
+  # Produces a diff hash from self and the other hash
+  #
+  # @param other [Hash] The other hash
+  #
+  # @return [Hash] The difference from the other hash
+  def deep_diff(other)
+    (keys + other.keys).uniq.each_with_object({}) do |key, diff|
+      self_key  = self[key]
+      other_key = other[key]
+      next if self_key == other_key
+      if self_key.respond_to?(:deep_diff) && other_key.respond_to?(:deep_diff)
+        diff[key] = self_key.deep_diff(other_key)
+      else
+        diff[key] = [self_key, other_key]
+      end
+      diff
+    end
+  end
+end

data/opal/fron/core_ext/kernel.rb

@@ -0,0 +1,57 @@
+# Kernel
+module Kernel
+  # Requests an animation frame from the browser
+  # and runs the givel block if given.
+  def request_animation_frame
+    return unless block_given?
+    return unless `!!window.requestAnimationFrame`
+    `window.requestAnimationFrame(function(){ #{yield} })`
+  end
+
+  # Runs the given block after the given number of milliseconds.
+  #
+  # @param ms [Integer] The milliseconds
+  def timeout(ms = 0)
+    `setTimeout(function(){#{yield}},#{ms})`
+  end
+
+  # Shows a prompt window with text and value
+  #
+  # @param text [String] The text
+  # @param value [String] The value
+  #
+  # @return [String] The user input
+  def prompt(text, value)
+    `prompt(#{text}, #{value})`
+  end
+
+  # Shows an alert window with the given text
+  #
+  # @param text [String] the text
+  def alert(text)
+    `alert(#{text})`
+  end
+
+  # Shows an confirm window with the given text
+  #
+  # @param text [String] the text
+  #
+  # @return [Boolean] True of false depending on user input
+  def confirm(text)
+    `confirm(#{text})`
+  end
+
+  # Clears the timeout with the given ID
+  #
+  # @param id [Numeric] The ID
+  def clear_timeout(id)
+    `clearTimeout(#{id})`
+  end
+
+  # Returns the logger for the application
+  #
+  # @return [Fron::Logger] The logger
+  def logger
+    @logger ||= Fron::Logger.new
+  end
+end

data/opal/fron/core_ext/nil.rb

@@ -0,0 +1,7 @@
+# Nil
+class NilClass
+  # Returns true for empty?
+  def empty?
+    true
+  end
+end

data/opal/fron/core_ext/numeric.rb

@@ -0,0 +1,19 @@
+# Numeric
+class Numeric
+  # Clamps itself between two values
+  #
+  # @param min [Numeric] The minimum value
+  # @param max [Numeric] The maximum value
+  #
+  # @return [Numeric] The clamped value
+  def clamp(min, max)
+    [[self, max].min, min].max
+  end
+
+  # Returns the px representation
+  #
+  # @return [String] The px
+  def px
+    "#{round}px"
+  end
+end