fron 0.1.4 → 0.2.0rc1

data/opal/fron/utils/drag.rb

@@ -0,0 +1,135 @@
+require 'fron/utils/point'
+
+module Fron
+  # Class for dragging with pointer events.
+  class Drag
+    include Fron::Eventable
+    extend  Fron::Eventable
+
+    # @return [DOM::Element] The base of the drag
+    attr_reader :base
+
+    # @return [DOM::Element] The documents body
+    attr_reader :body
+
+    IS_TOUCH = `'ontouchstart' in window  && !window._phantom`
+
+    if IS_TOUCH
+      EVENTS = {
+        down: 'touchstart',
+        move: 'touchmove',
+        up:   'touchend'
+      }
+    else
+      EVENTS = {
+        down: 'mousedown',
+        move: 'mousemove',
+        up:   'mouseup'
+      }
+    end
+
+    # Creates a new drag instance.
+    #
+    # @param base [DOM::Element] The element to monitor
+    def initialize(base)
+      reset
+      @base = base
+      @body = DOM::Document.body
+
+      @base.on EVENTS[:down] do |event| start(event) end
+    end
+
+    # Returns the current difference position
+    # from the start position.
+    #
+    # @return [Fron::Point] The difference
+    def diff
+      @start_position - @position
+    end
+
+    private
+
+    # Runs when dragging starts.
+    #
+    # @param event [Event] The event
+    def start(event)
+      return stop if IS_TOUCH && `#{event.touches}.length != 1`
+
+      off if @pos_method
+
+      @position       = position(event)
+      @target         = event.target
+      @start_position = @position
+      @mouse_is_down  = true
+
+      @pos_method = @body.on! EVENTS[:move] do |evt| pos(evt) end
+      @up_method  = @body.on! EVENTS[:up]   do |evt| up(evt)  end
+
+      request_animation_frame do move end
+    end
+
+    # Runs when the pointer moves starts.
+    #
+    # @param event [Event] The event
+    def pos(event)
+      @position = position(event)
+      if diff.distance > 7 && !@started
+        @started = true
+        trigger 'start', @target
+      end
+      event.stop
+    end
+
+    # Stops the drag
+    def stop
+      off
+      reset
+    end
+
+    # Runs when pointer releases.
+    #
+    # @param event [Event] The event
+    def up(event)
+      off
+      trigger 'end' if @started
+      reset
+      return unless @started
+      event.preventDefault
+      event.stop
+    end
+
+    # Runs on animation frame when the mouse is down.
+    def move
+      request_animation_frame { move } if @mouse_is_down
+      return if !@position || !@started
+      trigger 'move', @position
+    end
+
+    # Removes event listeners
+    def off
+      @body.off EVENTS[:move], @pos_method
+      @body.off EVENTS[:up],   @up_method
+    end
+
+    # Resets the drag
+    def reset
+      @started         = false
+      @target          = nil
+      @position        = nil
+      @start_position  = nil
+      @mouse_is_down   = false
+    end
+
+    # Gets the position from the given event.
+    # @param event [Event] The event
+    #
+    # @return [Fron::Point] A point from the event.
+    def position(event)
+      if IS_TOUCH && event.touches
+        Point.new `#{event.touches}[0].pageX`, `#{event.touches}[0].pageY`
+      else
+        Point.new event.pageX, event.pageY
+      end
+    end
+  end
+end

data/opal/fron/utils/keyboard.rb

@@ -0,0 +1,70 @@
+module Fron
+  # Keyboard class that handles matcing keyp presses to shortcuts.
+  class Keyboard
+    class << self
+      # @return [Array] The data for the shortcuts
+      attr_reader :shortcuts
+
+      # Delimeters to separate shortcut parts
+      DELIMETERS = /-|\+|:|_/
+
+      # Defines a shortcut. If a block given it will run that block on a match
+      # and not the action. Otherwise it will run the action named method on
+      # the instance.
+      #
+      # The shortcut order is not relevant, and it can have many delimiters.
+      #
+      # Exmaple shortcuts:
+      # * ctrl+click
+      # * ctrl:up
+      # * ctrl-down
+      # * ctrl-shift_up
+      #
+      # @param shortcut [String] The shortcut
+      # @param action [Symbol] The action to run
+      # @param block [Proc] The block to run
+      def sc(shortcut, action = nil, &block)
+        @shortcuts ||= []
+        @shortcuts << { parts: shortcut.split(DELIMETERS), action: action, block: block }
+      end
+    end
+
+    # Create a new instance
+    def initialize
+      DOM::Document.body.on 'keydown' do |event| keydown event end
+    end
+
+    # Handles keydown event, and shortcut matching.
+    #
+    # @param event [DOM::Event] The event
+    def keydown(event)
+      return if DOM::Document.active_element
+      combo = [event.key]
+      combo << 'ctrl'  if event.ctrl?
+      combo << 'shift' if event.shift?
+      combo << 'alt'   if event.alt?
+      combo.uniq!
+
+      self.class.shortcuts.each do |shortcut|
+        next unless shortcut[:parts].sort == combo.sort
+        handle_shortcut shortcut
+        event.stop
+        break
+      end
+    end
+
+    # Handles the shortcut.
+    #
+    # @param shortcut [Hash] The shortcut
+    def handle_shortcut(shortcut)
+      action = shortcut[:action]
+      if shortcut[:block]
+        instance_exec(&shortcut[:block])
+      elsif respond_to? action
+        send action
+      else
+        warn self.class.name + " - shortcut #{shortcut[:parts].join('+')}:#{action} is not implemented!"
+      end
+    end
+  end
+end

data/opal/fron/utils/point.rb

@@ -0,0 +1,78 @@
+# rubocop:disable VariableName
+require 'math'
+
+module Fron
+  # Simple class for point with x and y coordinates.
+  class Point
+    # Sets / gets the x portion of the point
+    #
+    # @param value [Numeric] The value
+    # @return [Numeric] The value
+    attr_accessor :x
+
+    # Sets / gets the y portion of the point
+    #
+    # @param value [Numeric] The value
+    # @return [Numeric] The value
+    attr_accessor :y
+
+    # Creates a new instance
+    #
+    # @param x [Float] The x coordiante
+    # @param y [Float] The y coordiante
+    def initialize(x = 0, y = 0)
+      @x, @y = x, y
+    end
+
+    # Returns the difference from an other point.
+    #
+    # @param other [Core::Point] The point to caluclate the difference from
+    #
+    # @return [Core::Point] The difference
+    def -(other)
+      self.class.new x - other.x, y - other.y
+    end
+
+    # Adds two points together
+    #
+    # @param other [Core::Point] The other point
+    #
+    # @return [Core::Point] The result
+    def +(other)
+      self.class.new x + other.x, y + other.y
+    end
+
+    # Multiplies the point by given scalar value
+    #
+    # @param other [Numeric] The scalar value
+    #
+    # @return [Core::Point] The result
+    def *(other)
+      self.class.new x * other, y * other
+    end
+
+    # Divides the point by given scalar value
+    #
+    # @param other [Numeric] The scalar value
+    #
+    # @return [Core::Point] The result
+    def /(other)
+      self.class.new x / other, y / other
+    end
+
+    # Returns the distance between
+    # this point and 0, 0
+    #
+    # @return [Numeric] The distance
+    def distance
+      Math.sqrt(@x**2 + @y**2)
+    end
+
+    # Returns the string representation of the point
+    #
+    # @return [String] The representation
+    def to_s
+      "[#{x}, #{y}]"
+    end
+  end
+end

data/opal/fron/utils/render_proc.rb

@@ -0,0 +1,27 @@
+module Fron
+  # Render Proc for rendering efficiently, it uses requestAnimationFrame
+  # to limit the number of cycles.
+  class RenderProc
+    # Initializes a render proc
+    #
+    # @param method [Method] The method
+    # @param verbose [Boolean] Whether or not to log render time
+    def initialize(method, verbose)
+      @running = false
+      @method  = method
+      @verbose = verbose
+    end
+
+    # Runs the proc
+    def call
+      return if @running
+      @running = true
+      request_animation_frame do
+        time = Time.now
+        @method.call
+        logger.info "Rendered #{@method.owner} in #{(Time.now - time) * 1000}ms" if @verbose
+        @running = false
+      end
+    end
+  end
+end

data/spec/core-ext/array_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Array do
+  subject { %w(a b) }
+
+  describe '#reverse_each_with_index' do
+    it 'should run in reverse' do
+      array = []
+      subject.reverse_each_with_index do |item, index|
+        array << [item, index]
+      end
+      array.should eq [['b', 1], ['a', 0]]
+    end
+  end
+end

data/spec/core-ext/date_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Date do
+  context 'Class' do
+    subject { described_class }
+
+    describe '#this_week' do
+      it 'should return this week' do
+        week = subject.this_week
+        week.should be_a Range
+        week.count.should eq 7
+      end
+    end
+
+    describe '#last_week' do
+      it 'should return last week' do
+        week = subject.last_week
+        week.should be_a Range
+        week.count.should eq 7
+      end
+    end
+
+    describe '#monday' do
+      it 'should return monday' do
+        monday = subject.monday
+        monday.strftime('%A').should eq 'Monday'
+      end
+    end
+
+    describe '#week' do
+      it 'should return a week' do
+        week = subject.week
+        week.should be_a Range
+        week.count.should eq 7
+      end
+    end
+  end
+
+  subject { described_class.new 1987, 05, 28 }
+
+  describe '#beginning_of_month' do
+    it 'should return the beginning of the month' do
+      date = subject.beginning_of_month
+      date.to_s.should eq '1987-05-01'
+    end
+  end
+
+  describe '#end_of_month' do
+    it 'should return the end of the month' do
+      date = subject.end_of_month
+      date.to_s.should eq '1987-05-31'
+    end
+  end
+end

data/spec/core-ext/hash_spec.rb

@@ -1,10 +1,13 @@
-require 'fron/core-ext/hash'
+require 'spec_helper'
 
 describe Hash do
+  let(:base)  { { a: 'test', b: 'asd', c: { test: 'asd' } } }
+  let(:other) { { a: 'test', b: 'user', c: { test: 'wtf' } } }
+  let(:diff)  { { b: %w(asd user), c: { test: %w(asd wtf) } } }
 
   subject { { a: 'test', b: 'user' } }
 
-  describe "#to_query_string" do
+  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
@@ -15,4 +18,17 @@ describe Hash do
       `#{subject.to_form_data} instanceof FormData`.should be true
     end
   end
+
+  describe '#deep_diff' do
+    it 'should return a diff of the two objects' do
+      base.deep_diff(other).should eq diff
+    end
+  end
+
+  describe '#difference' do
+    it 'should return the difference of the two objects' do
+      (base - other).should eq b: 'asd', c: { test: 'asd' }
+      (other - base).should eq b: 'user', c: { test: 'wtf' }
+    end
+  end
 end

data/spec/core-ext/kernel_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Kernel do
+  describe '#request_animation_frame' do
+    it 'should return nil if no block given' do
+      request_animation_frame.should eq nil
+    end
+
+    it 'should run the block inside requestAnimationFrame' do
+      value = nil
+      request_animation_frame do
+        value = true
+      end
+      value.should eq true
+    end
+  end
+
+  describe '#timeout' do
+    it 'should run the provided block' do
+      value = nil
+      timeout do
+        value = true
+      end
+      value.should eq true
+    end
+  end
+
+  describe '#prompt' do
+    it 'should show the window' do
+      prompt('test', 'value').should eq 'value'
+    end
+  end
+
+  describe '#alert' do
+    it 'should show the window' do
+      alert('test').should eq 'alert'
+    end
+  end
+
+  describe '#confirm' do
+    it 'should show the window' do
+      confirm('test').should eq true
+    end
+  end
+
+  describe '#clear_timeout' do
+    it 'should clear the timeout' do
+      clear_timeout(0).should eq true
+    end
+  end
+
+  describe '#logger' do
+    it 'should return logger' do
+      logger.should be_a Fron::Logger
+    end
+  end
+end