inesita 0.2.3 → 0.3.0

data/lib/inesita/minify.rb

@@ -0,0 +1,34 @@
+module Inesita
+  module Minify
+    module_function
+
+    def html(source)
+      if defined?(HtmlCompressor) && defined?(HtmlCompressor::Compressor)
+        HtmlCompressor::Compressor.new.compress(source)
+      else
+        source
+      end
+    end
+
+    def js(source)
+      if defined?(Uglifier)
+        Uglifier.compile(source)
+      else
+        source
+      end
+    end
+
+    def css(source)
+      if defined?(Sass) && defined?(Sass::Engine)
+        Sass::Engine.new(source,
+                         syntax:     :scss,
+                         cache:      false,
+                         read_cache: false,
+                         style:      :compressed
+                        ).render
+      else
+        source
+      end
+    end
+  end
+end

data/lib/inesita/server.rb

@@ -1,74 +1,81 @@
 require 'rack/rewrite'
 
 module Inesita
-  module Server
-    SOURCE_MAP_PREFIX = '/__OPAL_MAPS__'
-    ASSETS_PREFIX = '/__ASSETS__'
+  module SprocketsContext
+    def asset_path(path, _options = {})
+      path
+    end
+  end
+
+  class Server
+    attr_reader :assets_app
+
+    def initialize
+      @assets_app = create_assets_app
+      @source_maps_app = create_source_maps_app
+      @app = create_app
+      Inesita.assets_code = assets_code
+    end
 
-    module_function
+    def assets_code
+      assets_prefix = Inesita.env == :development ? Config::ASSETS_PREFIX : nil
+      %(
+        <link rel="stylesheet" type="text/css" href="#{assets_prefix}/stylesheet.css">
+        #{Opal::Sprockets.javascript_include_tag('application', sprockets: @assets_app, prefix: assets_prefix, debug: Inesita.env == :development)}
+       )
+    end
+
+    def create_app
+      assets_app = @assets_app
+      source_maps_app = @source_maps_app
+
+      Rack::Builder.new do
+        use Rack::Static, :urls => [Config::STATIC_DIR]
 
-    def assets
-      Sprockets::Environment.new.tap do |s|
-        # register engines
-        s.register_engine '.slim', Slim::Template
-        s.register_engine '.rb', Opal::Processor
+        use Rack::Rewrite do
+          rewrite(/^(?!#{Config::ASSETS_PREFIX}|#{Config::SOURCE_MAP_PREFIX}).*/, Config::ASSETS_PREFIX)
+        end
+
+        map Config::ASSETS_PREFIX do
+          run assets_app
+        end
+
+        map Config::SOURCE_MAP_PREFIX do
+          run source_maps_app
+        end
+      end
+    end
 
-        # add folders
-        s.append_path 'app'
+    def create_assets_app
+      Opal::Server.new do |s|
+        s.append_path Config::APP_DIR
 
-        # add paths from opal
         Opal.paths.each do |p|
           s.append_path p
         end
 
-        # add paths from rails-assets
         RailsAssets.load_paths.each do |p|
           s.append_path p
         end if defined?(RailsAssets)
 
-        s.context_class.class_eval do
-          def asset_path(path, options = {})
-            $DEVELOPMENT_MODE ? "#{ASSETS_PREFIX}/#{path}" : path
-          end
-        end
-      end
+        configure_sprockets(s.sprockets)
+      end.sprockets
     end
 
-    def set_global_vars(assets, debug = false)
-      $LOAD_ASSETS_CODE = Opal::Processor.load_asset_code(assets, 'application.js')
-      if $DEVELOPMENT_MODE
-        $SCRIPT_FILES = (assets['application.js'].dependencies + [assets['application.self.js']]).map(&:logical_path)
+    def configure_sprockets(sprockets)
+      sprockets.register_engine '.slim', Slim::Template
+      sprockets.context_class.class_eval do
+        include SprocketsContext
       end
     end
 
-    def source_maps(sprockets)
-      ::Opal::Sprockets::SourceMapHeaderPatch.inject!(SOURCE_MAP_PREFIX)
-      Opal::SourceMapServer.new(sprockets, SOURCE_MAP_PREFIX)
+    def create_source_maps_app
+      ::Opal::Sprockets::SourceMapHeaderPatch.inject!(Config::SOURCE_MAP_PREFIX)
+      Opal::SourceMapServer.new(@assets_app, Config::SOURCE_MAP_PREFIX)
     end
 
-    def development_mode
-      $DEVELOPMENT_MODE = ENV['DEVELOPMENT_MODE'] || true
-    end
-
-    def create
-      development_mode
-      assets_app = assets
-      source_maps_app = source_maps(assets_app)
-      set_global_vars(assets_app, true)
-
-      Rack::Builder.new do
-        use Rack::Rewrite do
-          rewrite %r[^(?!#{ASSETS_PREFIX}|#{SOURCE_MAP_PREFIX}).*], ASSETS_PREFIX
-        end
-
-        map ASSETS_PREFIX do
-          run assets_app
-        end
-
-        map SOURCE_MAP_PREFIX do
-          run source_maps_app
-        end
-      end
+    def call(env)
+      @app.call(env)
     end
   end
 end

data/lib/rubame.rb

@@ -0,0 +1,156 @@
+require 'websocket'
+require 'socket'
+
+module Rubame
+  class Server
+    def initialize(host, port)
+      Socket.do_not_reverse_lookup
+      @hostname = host
+      @port = port
+
+      @reading = []
+      @writing = []
+
+      @clients = {} # Socket as key, and Client as value
+
+      @socket = TCPServer.new(@hostname, @port)
+      @reading.push @socket
+    end
+
+    def accept
+      socket = @socket.accept_nonblock
+      @reading.push socket
+      handshake = WebSocket::Handshake::Server.new
+      client = Rubame::Client.new(socket, handshake, self)
+
+      while line = socket.gets
+        client.handshake << line
+        break if client.handshake.finished?
+      end
+      if client.handshake.valid?
+        @clients[socket] = client
+        client.write handshake.to_s
+        client.opened = true
+        return client
+      else
+        close(client)
+      end
+      return nil
+    end
+
+    def read(client)
+
+      pairs = client.socket.recvfrom(2000)
+      messages = []
+
+      if pairs[0].length == 0
+        close(client)
+      else
+        client.frame << pairs[0]
+
+        while f = client.frame.next
+          if (f.type == :close)
+            close(client)
+            return messages
+          else
+            messages.push f
+          end
+        end
+
+      end
+
+      return messages
+
+    end
+
+    def close(client)
+      @reading.delete client.socket
+      @clients.delete client.socket
+      begin
+        client.socket.close
+      ensure
+        client.closed = true
+      end
+    end
+
+    def run(&blk)
+      readable, _writable = IO.select(@reading, @writing)
+
+      if readable
+        readable.each do |socket|
+          client = @clients[socket]
+          if socket == @socket
+            client = accept
+          else
+            msg = read(client)
+            client.messaged = msg
+          end
+
+          blk.call(client) if client and blk
+        end
+      end
+    end
+
+    def stop
+      @socket.close
+    end
+  end
+
+  class Client
+    attr_accessor :socket, :handshake, :frame, :opened, :messaged, :closed
+
+    def initialize(socket, handshake, server)
+      @socket = socket
+      @handshake = handshake
+      @frame = WebSocket::Frame::Incoming::Server.new(:version => @handshake.version)
+      @opened = false
+      @messaged = []
+      @closed = false
+      @server = server
+    end
+
+    def write(data)
+      @socket.write data
+    end
+
+    def send(data)
+      frame = WebSocket::Frame::Outgoing::Server.new(:version => @handshake.version, :data => data, :type => :text)
+      begin
+        @socket.write frame
+        @socket.flush
+      rescue
+        @server.close(self) unless @closed
+      end
+    end
+
+    def onopen(&blk)
+      if @opened
+        begin
+          blk.call
+        ensure
+          @opened = false
+        end
+      end
+    end
+
+    def onmessage(&blk)
+      if @messaged.size > 0
+        begin
+          @messaged.each do |x|
+            blk.call(x.to_s)
+          end
+        ensure
+          @messaged = []
+        end
+      end
+    end
+
+    def onclose(&blk)
+      if @closed
+        begin
+          blk.call
+        end
+      end
+    end
+  end
+end

data/opal/inesita.rb

@@ -1,6 +1,16 @@
+require 'opal'
+require 'js'
+require 'console'
+
+require 'browser'
+require 'browser/history'
+require 'browser/animation_frame'
+
 require 'virtual_dom'
-require 'inesita/js_helpers'
-require 'inesita/component_withs'
+
+require 'inesita/error'
+require 'inesita/component_virtual_dom_extension'
+require 'inesita/component_properties'
 require 'inesita/component'
 require 'inesita/routes'
 require 'inesita/router'

data/opal/inesita/application.rb

@@ -2,27 +2,49 @@ module Inesita
   class Application
     include Inesita::Component
 
-    attr_reader :root
+    def initialize(options = {})
+      setup_router(options[:router])
+      setup_layout(options[:layout])
+      setup_root
+      setup_store(options[:store])
+    end
 
-    def initialize(options)
-      router = options[:router]
-      layout = options[:layout]
-      store  = options[:store]
+    def render
+      component @root
+    end
 
-      raise 'Router missing' unless router
-      raise "Invalid #{router} class, should mixin Inesita::Router" unless router.include?(Inesita::Router)
-      raise "Invalid #{layout} class, should mixin Inesita::Layout" unless layout.include?(Inesita::Layout)
-      raise "Invalid #{store} class, should mixin Inesita::Store" unless store.include?(Inesita::Store)
+    private
 
-      @router = router.new
-      @layout = layout.new if layout
+    def setup_router(router)
+      if router
+        fail Error, "Invalid #{router} class, should mixin Inesita::Router" unless router.include?(Inesita::Router)
+        @router = router.new
+      else
+        @router = Class.new { define_method(:method_missing) { fail 'Router missing' } }.new
+      end
+    end
 
-      @root   = @layout ? @layout : @router
-      @store  = store.new.with_root_component(@root).store if store
+    def setup_layout(layout)
+      if layout
+        fail Error, "Invalid #{layout} class, should mixin Inesita::Layout" unless layout.include?(Inesita::Layout)
+        @layout = layout.new
+      end
     end
 
-    def render
-      component root
+    def setup_root
+      if @layout
+        @root = @layout
+      elsif @router
+        @root = @router
+      else
+        fail Error, 'Router or Layout not found!'
+      end
+    end
+
+    def setup_store(store)
+      return unless store
+      fail Error, "Invalid #{store} class, should mixin Inesita::Store" unless store.include?(Inesita::Store)
+      @store = store.new.with_root_component(@root).store
     end
   end
 end

data/opal/inesita/component.rb

@@ -1,36 +1,64 @@
 module Inesita
   module Component
     include VirtualDOM::DOM
-    include ComponentWiths
+    include ComponentProperties
+    include ComponentVirtualDomExtension
+
+    def render
+      fail Error, "Implement #render in #{self.class} component"
+    end
 
     def mount_to(element)
+      fail Error, "Can't mount #{self.class}, target element not found!" unless element
       @root_component = self
       @virtual_dom = render_virtual_dom
       @root_node = VirtualDOM.create(@virtual_dom)
       element.inner_dom = @root_node
+      @root_component.call_after_render
+      self
     end
 
     def render_if_root
-      if @virtual_dom && @root_node
-        new_virtual_dom = render_virtual_dom
-        diff = VirtualDOM.diff(@virtual_dom, new_virtual_dom)
-        VirtualDOM.patch(@root_node, diff)
-        @virtual_dom = new_virtual_dom
-      end
+      return unless @virtual_dom && @root_node
+      new_virtual_dom = render_virtual_dom
+      diff = VirtualDOM.diff(@virtual_dom, new_virtual_dom)
+      VirtualDOM.patch(@root_node, diff)
+      @virtual_dom = new_virtual_dom
     end
 
     def render_virtual_dom
+      @after_render_callbacks = []
+      @root_component.add_after_render(method(:after_render)) if respond_to?(:after_render)
+      @cache_component_counter = 0
       @__virtual_nodes__ = []
       render
       if @__virtual_nodes__.length == 1
         @__virtual_nodes__.first
       else
-        VirtualDOM::VirtualNode.new('div', {}, @__virtual_nodes__).vnode
+        VirtualDOM::VirtualNode.new('div', {}, @__virtual_nodes__).to_n
       end
     end
 
+    def add_after_render(block)
+      @after_render_callbacks << block
+    end
+
+    def call_after_render
+      @after_render_callbacks.reverse_each(&:call)
+    end
+
     def update_dom
-      @root_component.render_if_root
+      $console.warn "Use 'render!' instead of 'update_dom'"
+      render!
+    end
+
+    def render!
+      animation_frame do
+        if @root_component
+          @root_component.render_if_root
+          @root_component.call_after_render
+        end
+      end
     end
 
     def cache_component(component, &block)
@@ -39,32 +67,5 @@ module Inesita
       @cache_component_counter += 1
       @cache_component["#{component}-#{@cache_component_counter}"] || @cache_component["#{component}-#{@cache_component_counter}"] = block.call
     end
-
-    def a(params, &block)
-      params = { onclick: -> { @router.handle_link(params[:href]) } }.merge(params) if params[:href] && @router
-      @__virtual_nodes__ ||= []
-      if block
-        current = @__virtual_nodes__
-        @__virtual_nodes__ = []
-        result = block.call
-        vnode = VirtualDOM::VirtualNode.new('a', process_params(params), @__virtual_nodes__.count == 0 ? result : @__virtual_nodes__).vnode
-        @__virtual_nodes__ = current
-      else
-        vnode = VirtualDOM::VirtualNode.new('a', process_params(params), []).vnode
-      end
-      @__virtual_nodes__ << vnode
-      vnode
-    end
-
-    def component(comp, opts = {})
-      fail "Component is nil in #{self.class} class" if comp.nil?
-      @__virtual_nodes__ ||= []
-      @__virtual_nodes__ << cache_component(comp) do
-        (comp.is_a?(Class) ? comp.new : comp)
-          .with_root_component(@root_component)
-          .with_router(@router)
-          .with_store(@store)
-      end.with_props(opts[:props] || {}).render_virtual_dom
-    end
   end
 end