clearwater 0.1.0

data/opal/clearwater/link.rb

@@ -0,0 +1,122 @@
+require 'clearwater/component'
+require 'browser/history'
+
+# TODO: Remove this once opal-browser supports coordinates natively
+# for touch events.
+module Browser
+  class Event
+    class Touch
+      def x
+        `#@native.pageX`
+      end
+
+      def y
+        `#@native.pageY`
+      end
+    end
+  end
+end
+
+class Link
+  include Clearwater::Component
+
+  attr_reader :attributes, :content
+
+  def initialize(attributes={}, content=nil)
+    # Augment the onclick passed in by the user, don't replace it.
+    @onclick = attributes.dup.delete(:onclick)
+    @attributes = attributes.merge(
+      onclick: method(:handle_click),
+      ontouchstart: method(:handle_touch),
+      key: attributes[:href]
+    )
+
+    check_active attributes[:href]
+
+    @content = content
+  end
+
+  def handle_click event
+    if @onclick
+      @onclick.call event
+    end
+
+    if touch?
+      event.prevent
+      return
+    end
+
+    if event.prevented?
+      warn "You are preventing the default behavior of a `Link` component. " +
+           "In this case, you could just use an `a` element."
+    else
+      navigate event
+    end
+  end
+
+  def handle_touch event
+    # All links will treat this as touch because this is a touch device
+    @@touch = true
+    moved = false
+    x_start = event.x
+    y_start = event.y
+
+    touch_move_handler = proc do |event|
+      x_now = event.x
+      y_now = event.y
+
+      # Count this gesture as a non-click if user moves over 30px
+      if ((x_now - x_start) ** 2 + (y_now - y_start) ** 2) ** 0.5 > 30
+        moved = true
+      end
+    end
+
+    touch_end_handler = proc do
+      unless moved
+        @onclick.call event if @onclick
+        navigate event
+      end
+
+      $document.off 'touchmove', &touch_move_handler
+      $document.off 'touchend', &touch_end_handler
+    end
+
+    $document.on 'touchmove', &touch_move_handler
+    $document.on 'touchend', &touch_end_handler
+  end
+
+  def navigate event
+    unless event.meta? || event.shift? || event.ctrl? || event.alt?
+      event.prevent
+      if href != $window.location.path
+        $window.history.push href
+        call
+        $window.scroll.to x: 0, y: 0
+      end
+    end
+  end
+
+  def href
+    attributes[:href]
+  end
+
+  def render
+    a(attributes, content)
+  end
+
+  def touch?
+    !!@@touch
+  end
+
+  def check_active href
+    if $window.location.path == href
+      class_name = (
+        @attributes.delete(:class_name) ||
+        @attributes.delete(:class) ||
+        @attributes.delete(:className)
+      ).to_s
+
+      @attributes[:className] = "#{class_name} active"
+    end
+  end
+end

data/opal/clearwater/model.rb

@@ -0,0 +1,33 @@
+require "clearwater/binding"
+
+module Clearwater
+  class Model
+    def initialize attributes={}
+      @_bindings = Hash.new { |h,k| h[k] = [] }
+      self.class.attributes.each do |attr|
+        public_send "#{attr}=", attributes[attr]
+      end
+    end
+
+    def add_binding attribute, &block
+      binding = Binding.new(self, attribute, &block)
+      @_bindings[attribute].delete_if(&:dead?)
+      @_bindings[attribute] << binding
+      binding
+    end
+
+    def self.attributes *args
+      @attributes ||= []
+      args.each do |attr|
+        attr_reader attr
+
+        define_method "#{attr}=" do |value|
+          instance_variable_set "@#{attr}", value
+          @_bindings[attr].each(&:call)
+          @_bindings[attr].delete_if(&:dead?)
+        end
+      end
+      @attributes.concat args
+    end
+  end
+end

data/opal/clearwater/router.rb

@@ -0,0 +1,98 @@
+require "clearwater/router/route_collection"
+
+module Clearwater
+  class Router
+    attr_reader :window, :location, :history
+    attr_accessor :application
+
+    def initialize options={}, &block
+      @window   = options.fetch(:window)   { Native(`window`)  }
+      @location = options.fetch(:location) { window[:location] }
+      @history  = options.fetch(:history)  { window[:history]  }
+      @routes   = RouteCollection.new(self)
+      @application = options[:application]
+
+      add_routes(&block) if block_given?
+    end
+
+    def add_routes &block
+      @routes.instance_exec(&block)
+    end
+
+    def routes_for_path path
+      parts = path.split("/").reject(&:empty?)
+      @routes[parts]
+    end
+
+    def canonical_path_for_path path
+      routes_for_path(path).map { |r| "/#{r.key}" }.join
+    end
+
+    def targets_for_path path
+      routes_for_path(path).map(&:target)
+    end
+
+    def params_for_path path
+      path_parts = path.split("/").reject(&:empty?)
+      canonical_parts = canonical_path_for_path(path).split("/").reject(&:empty?)
+      params = {}
+      canonical_parts.each_with_object(params)
+                     .each_with_index { |(part, params), index|
+        if part.start_with? ":"
+          param = part[1..-1].to_sym
+          params[param] = path_parts[index]
+        end
+      }
+      params
+    end
+
+    def canonical_path
+    end
+
+    def current_path
+      location[:pathname]
+    end
+
+    def navigate_to path
+      push_state path
+      set_outlets
+      render_application
+    end
+
+    def navigate_to_remote path
+      location[:href] = path
+    end
+
+    def current_url
+      location[:href]
+    end
+
+    def back
+      history.back
+    end
+
+    def set_outlets targets=targets_for_path(current_path)
+      if targets.any?
+        (targets.count).times do |index|
+          targets[index].outlet = targets[index + 1]
+        end
+
+        application && application.component.outlet = targets.first
+      else
+        application && application.component.outlet = nil
+      end
+    end
+
+    private
+
+    def push_state path
+      history.pushState({}, nil, path)
+    end
+
+    def render_application
+      if application && application.component
+        application.component.call
+      end
+    end
+  end
+end

data/opal/clearwater/router/route.rb

@@ -0,0 +1,43 @@
+require "clearwater/router/route_collection"
+
+module Clearwater
+  class Router
+    class Route
+      attr_reader :target, :key, :parent
+
+      def initialize options={}
+        @key = options.fetch(:key)
+        @target = options.fetch(:target)
+        @parent = options.fetch(:parent)
+      end
+
+      def route *args, &block
+        nested_routes.route *args, &block
+      end
+
+      def canonical_path
+        @canonical_path ||= "#{parent.canonical_path}/#{key}".gsub("//", "/")
+      end
+
+      def match key, other_parts=[]
+        if key && (key == self.key || param_key?)
+          if Array(other_parts).any?
+            [self, nested_routes[other_parts]]
+          else
+            self
+          end
+        end
+      end
+
+      private
+
+      def param_key?
+        @param_key ||= key.start_with? ":"
+      end
+
+      def nested_routes
+        @nested_routes ||= RouteCollection.new(self)
+      end
+    end
+  end
+end

data/opal/clearwater/router/route_collection.rb

@@ -0,0 +1,52 @@
+require "clearwater/router/route"
+
+module Clearwater
+  class Router
+    class RouteCollection
+      attr_reader :router
+
+      def initialize parent
+        @routes = []
+        @parent = parent
+        @router = loop do
+          break parent if parent.is_a? Router
+          parent = parent.parent
+        end
+      end
+
+      def route route_options, &block
+        route_key = route_options.keys.first.to_s
+        target = route_options.delete(route_key)
+        target.router = router
+        options = {
+          key: route_key,
+          target: target,
+          parent: parent,
+        }.merge(route_options)
+        route = Route.new(options)
+        route.instance_exec(&block) if block_given?
+        @routes << route
+      end
+
+      def namespace path
+        @namespace = path
+      end
+
+      def [] route_names
+        if route_names.any? && route_names.first == @namespace
+          route_names = route_names[1..-1]
+        end
+        routes = @routes.map { |r|
+          r.match route_names.first, route_names[1..-1]
+        }
+        routes.compact!
+        routes.flatten!
+        routes
+      end
+
+      private
+
+      attr_reader :parent
+    end
+  end
+end

data/opal/clearwater/store.rb

@@ -0,0 +1,99 @@
+require "json"
+
+module Clearwater
+  class Store
+    attr_reader :mapping, :identity_map
+
+    def initialize options={}
+      @url = options.fetch(:url) { "/api/:model/:id" }
+      @mapping = Mapping.new(options.fetch(:mapping) { {} })
+      @protocol = options.fetch(:protocol) { HTTP }
+      @identity_map = IdentityMap.new
+    end
+
+    def all klass
+      deserialized = api(:get, url_for(klass)).body
+      models = JSON.parse(deserialized).map do |attributes|
+        deserialize(klass, attributes)
+      end
+    end
+
+    def find klass, id
+      identity_map.fetch(klass, id) do
+        serialized = api(:get, url_for(klass, id)).body
+        identity_map[klass][id] = deserialize(klass, JSON.parse(serialized))
+      end
+    end
+
+    def save model
+      method = persisted?(model) ? :patch : :post
+      response = api method, url_for_model(model)
+      if method == :post && response.ok
+        attributes = JSON.parse(response.body)
+        model.instance_variable_set :@id, attributes[:id]
+      end
+    end
+
+    def delete model
+      api :delete, url_for_model(model)
+    end
+
+    def persisted? model
+      !!model.id
+    end
+
+    private
+
+    def api method, url
+      @protocol.public_send method, url
+    end
+
+    def url_for klass, id=nil
+      @url.gsub(":model", mapping[klass])
+          .gsub(":id", id.to_s)
+    end
+
+    def url_for_model model
+      url_for(model.class, model.id)
+    end
+
+    def url_for_class klass, id
+      url_for(klass, nil)
+    end
+
+    def deserialize klass, attributes
+      model = klass.allocate
+      attributes.each do |attr, value|
+        model.instance_variable_set "@#{attr}", value
+      end
+
+      model
+    end
+  end
+
+  class Mapping
+    def initialize mappings={}
+      @custom_mappings = mappings
+    end
+
+    def [] klass
+      @custom_mappings.fetch(klass) { |*args|
+        klass.name.downcase.gsub("::", "/") + "s"
+      }
+    end
+  end
+
+  class IdentityMap
+    def initialize
+      @map = Hash.new { |h, k| h[k] = {} }
+    end
+
+    def [] key
+      @map[key]
+    end
+
+    def fetch(klass, id, &block)
+      self[klass].fetch(id, &block)
+    end
+  end
+end