clearwater 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e0dbe512477a239908316a57e35d45ee6071a644
+  data.tar.gz: 1a1e20bb5da838c0e7abd7cb8f43394fde474763
+SHA512:
+  metadata.gz: 974c1f2fba54d8cf8b0467fcaaae1ebfa4e92ad1ce419be6096dbe0869044ed402b24bf8fbb557b9ab44fa37ea0ed388f443bbddb97f1a6c0dcc60b8a4e5321a
+  data.tar.gz: ff9e1f46a84c517f5984b0a7854add9ec298ef00dbbc206cede4b29866898b0b80d4c268e42d6af987bca27a3d565d4bf79330bd0e9fdf37c2df6f6587fa4edf

data/lib/clearwater.rb

@@ -0,0 +1,7 @@
+require "opal"
+
+module Clearwater
+  require_relative "clearwater/version"
+end
+
+Opal.append_path(File.expand_path(File.join("..", "..", "opal"), __FILE__).untaint)

data/lib/clearwater/version.rb

@@ -0,0 +1,3 @@
+module Clearwater
+  VERSION = "0.1.0"
+end

data/opal/clearwater.rb

@@ -0,0 +1,4 @@
+require 'browser'
+require 'clearwater/component'
+require 'clearwater/link'
+require 'clearwater/application'

data/opal/clearwater/api_client.rb

@@ -0,0 +1,90 @@
+require "clearwater/cgi"
+require "browser/http"
+
+module Clearwater
+  class APIClient
+    ResponseNotFinished = Class.new(RuntimeError)
+
+    attr_reader :base_url
+
+    def initialize attributes={}
+      @base_url = attributes.fetch(:base_url) { nil }
+    end
+
+    def fetch resource, id, params
+      response = Browser::HTTP.get(path_for_resource(resource, id, params))
+      Response.new(response)
+    end
+
+    def store resource, id, data={}
+      path = case id
+             when String, Numeric
+               path_for_resource(resource, id)
+             when Hash
+               data.merge! id
+               path_for_resource(resource)
+             end
+
+      response = Browser::HTTP.post(path, data)
+      Response.new(response)
+    end
+
+    def update resource, id, data
+      response = Browser::HTTP.patch path_for_resource(resource, id), data: data
+      Response.new(response)
+    end
+
+    def delete resource, id
+      response = Browser::HTTP.delete path_for_resource(resource, id)
+      Response.new(response)
+    end
+
+    private
+
+    def path_for_resource resource, id, params={}
+      path = "#{base_url}/#{resource}"
+      case id
+      when String, Numeric
+        path += "/#{id}"
+      when Hash
+        params.merge! id
+      end
+
+      if params.any?
+        path += "?#{query_string(params)}"
+      end
+
+      path
+    end
+
+    def query_string params
+      query_params = params.map { |key, value|
+        "#{CGI.escape(key)}=#{CGI.escape(value)}"
+      }.join("&")
+    end
+
+    class Response
+      attr_reader :response
+
+      def initialize response
+        @response = response
+      end
+
+      def then
+        response.then do |r|
+          yield self.class.new(r)
+        end
+      end
+
+      def fail
+        response.fail do |r|
+          yield self.class.new(r)
+        end
+      end
+
+      def json
+        response.json
+      end
+    end
+  end
+end

data/opal/clearwater/application.rb

@@ -0,0 +1,128 @@
+require 'clearwater/router'
+require 'clearwater/application_registry'
+require 'browser/delay'
+require 'browser/event/pop_state'
+
+module Clearwater
+  class Application
+    RENDER_FPS = 60
+    AppRegistry = ApplicationRegistry.new
+
+    attr_reader :store, :router, :component, :api_client, :on_render
+
+    def self.render
+      AppRegistry.render_all
+    end
+
+    def initialize options={}
+      @store      = options.fetch(:store)      { nil }
+      @router     = options.fetch(:router)     { Router.new }
+      @component  = options.fetch(:component)  { nil }
+      @api_client = options.fetch(:api_client) { nil }
+      @element    = options.fetch(:element)    { nil }
+      @on_render  = []
+
+      router.application = self
+      component.router = router
+
+      $document.on 'visibilitychange' do
+        if @render_on_visibility_change
+          @render_on_visibility_change = false
+          render
+        end
+      end
+    end
+
+    def call
+      AppRegistry << self
+      render_current_url
+      watch_url
+    end
+
+    def watch_url
+      unless @watching_url
+        @watching_url = true
+        $window.on('popstate') { render_current_url }
+      end
+    end
+
+    def render_current_url &block
+      router.set_outlets
+      render &block
+    end
+
+    def render &block
+      on_render << block if block
+
+      # If the app isn't being shown, wait to render until it is.
+      if `document.hidden`
+        @render_on_visibility_change = true
+        return
+      end
+
+      delay_render
+
+      nil
+    end
+
+    def element
+      @element ||= begin
+                     if `document.body != null` || `document.body != undefined`
+                       $document.body
+                     else
+                       nil
+                     end
+                   end
+    end
+
+    def benchmark message
+      if debug?
+        start = Time.now
+        result = yield
+        finish = Time.now
+        puts "#{message} in #{(finish - start) * 1000}ms"
+        result
+      else
+        yield
+      end
+    end
+
+    def debug?
+      false
+    end
+
+    def delay_render
+      # Throttle rendering
+      unless @next_render
+        @next_render = last_render + time_between_renders
+        now = Time.now
+        after [@next_render - now, time_between_renders].max do
+          perform_render
+          @next_render = nil
+        end
+      end
+    end
+
+    def perform_render
+      if element.nil?
+        raise TypeError, "Cannot render to a non-existent element. Make sure the document ready event has been triggered before invoking the application."
+      end
+
+      @_virtual_dom ||= VirtualDOM::Document.new(element)
+
+      rendered = benchmark('Generated virtual DOM') { component.render }
+      benchmark('Rendered to actual DOM') { @_virtual_dom.render rendered }
+      @last_render = Time.now
+      on_render.each(&:call)
+      on_render.clear
+    end
+
+    def last_render
+      @last_render ||= Time.now - 10
+    end
+
+    def time_between_renders
+      1 / RENDER_FPS
+    end
+  end
+end

data/opal/clearwater/application_registry.rb

@@ -0,0 +1,23 @@
+require 'set'
+
+module Clearwater
+  class ApplicationRegistry
+    def initialize
+      @apps = Set.new
+    end
+
+    def << app
+      @apps << app
+    end
+
+    def render_all &block
+      @apps.each do |app|
+        app.render_current_url &block
+      end
+    end
+
+    def delete app
+      @apps.delete app
+    end
+  end
+end

data/opal/clearwater/cached_render.rb

@@ -0,0 +1,15 @@
+module Clearwater
+  module CachedRender
+    def cached_render
+      if !@cached_render || should_render?
+        @cached_render = sanitize_content(render)
+      else
+        @cached_render
+      end
+    end
+
+    def should_render?
+      false
+    end
+  end
+end

data/opal/clearwater/cgi.rb

@@ -0,0 +1,14 @@
+module Clearwater
+  class CGI
+    def self.escape string
+      # string.gsub(/([^ a-zA-Z0-9_.-]+)/) do |ch|
+      string.chars.map do |ch|
+        if ch =~ /([^ a-zA-Z0-9_.-]+)/
+          "%#{ch.ord.to_s(16).upcase}"
+        else
+          ch
+        end
+      end.join.tr(" ", "+")
+    end
+  end
+end

data/opal/clearwater/component.rb

@@ -0,0 +1,205 @@
+require 'clearwater/virtual_dom'
+require 'set'
+
+module Clearwater
+  module Component
+    attr_accessor :router, :outlet
+
+    def self.included(klass)
+      def klass.attributes(*attrs)
+        attrs.each do |attr|
+          ivar = "@#{attr}"
+          define_method(attr) { instance_variable_get(ivar) }
+          define_method("#{attr}=") do |value|
+            instance_variable_set ivar, value
+            call
+          end
+        end
+      end
+    end
+
+    def render
+    end
+
+    HTML_TAGS = %w(
+      a
+      abbr
+      address
+      area
+      article
+      aside
+      audio
+      b
+      base
+      bdi
+      bdo
+      blockquote
+      body
+      br
+      button
+      canvas
+      caption
+      cite
+      code
+      col
+      colgroup
+      command
+      data
+      datalist
+      dd
+      del
+      details
+      dfn
+      dialog
+      div
+      dl
+      dt
+      em
+      embed
+      fieldset
+      figcaption
+      figure
+      footer
+      form
+      h1
+      h2
+      h3
+      h4
+      h5
+      h6
+      head
+      header
+      hgroup
+      hr
+      html
+      i
+      iframe
+      img
+      input
+      ins
+      kbd
+      keygen
+      label
+      legend
+      li
+      link
+      map
+      mark
+      menu
+      meta
+      meter
+      nav
+      noscript
+      object
+      ol
+      optgroup
+      option
+      output
+      p
+      param
+      pre
+      progress
+      q
+      rp
+      rt
+      ruby
+      s
+      samp
+      script
+      section
+      select
+      small
+      source
+      span
+      strong
+      style
+      sub
+      summary
+      sup
+      table
+      tbody
+      td
+      textarea
+      tfoot
+      th
+      thead
+      time
+      title
+      tr
+      track
+      u
+      ul
+      var
+      video
+      wbr
+    )
+
+    HTML_TAGS.each do |tag_name|
+      define_method(tag_name) do |attributes, content|
+        tag(tag_name, attributes, content)
+      end
+    end
+
+    def tag tag_name, attributes=nil, content=nil
+      VirtualDOM.node(
+        tag_name,
+        sanitize_attributes(attributes),
+        sanitize_content(content)
+      )
+    end
+
+    def params
+      router.params_for_path(router.current_path)
+    end
+
+    def param(key)
+      params[key]
+    end
+
+    def sanitize_attributes attributes
+      return nil if attributes.nil?
+
+      # Allow specifying `class` instead of `class_name`.
+      # Note: `class_name` is still allowed
+      if attributes.key? :class
+        if attributes.key? :class_name
+          warn "You have both `class` and `class_name` attributes for this " +
+            "element. `class` takes precedence: #{attributes}"
+        end
+
+        attributes[:class_name] = attributes.delete(:class)
+      end
+
+      attributes.each do |key, handler|
+        if key.start_with? 'on'
+          attributes[key] = proc do |event|
+            handler.call(Browser::Event.new(event))
+          end
+        end
+      end
+
+      attributes
+    end
+
+    def sanitize_content content
+      case content
+      when Numeric, String
+        content.to_s
+      when Array
+        content.map { |c| sanitize_content(c) }.compact
+      else
+        if content.respond_to? :cached_render
+          content.cached_render
+        elsif content.respond_to? :render
+          sanitize_content content.render
+        else
+          content
+        end
+      end
+    end
+
+    def call &block
+      Clearwater::Application::AppRegistry.render_all(&block)
+    end
+  end
+end