inesita 0.3.5 → 0.4.0

data/lib/inesita/app_files_listener.rb

@@ -1,42 +0,0 @@
-module Inesita
-  class AppFilesListener
-    include Singleton
-    CURRENT_DIR = Dir.pwd
-
-    def initialize
-      @websockets = []
-      listener = Listen.to(Config::APP_DIR) do |modified, added, _removed|
-        (modified + added).each do |file|
-          @websockets.each do |ws|
-            ws.send transform_filename(file)
-          end
-        end
-      end
-      listener.start
-    end
-
-    def add_ws(ws)
-      @websockets << ws
-    end
-
-    def rm_ws(ws)
-      @websockets.delete(ws)
-    end
-
-    def transform_filename(filename)
-      filename.sub!(CURRENT_DIR, '')
-      path = filename.split('/')
-      path.delete('')
-      path.delete(Config::APP_DIR)
-      path = path.join('/').split('.')
-
-      prefix = Config::ASSETS_PREFIX
-      name = path.first
-      if path.include?('rb') || path.include?('js')
-        "#{prefix}|#{name}|js"
-      elsif path.include?('sass') || path.include?('css')
-        "#{prefix}|stylesheet|css"
-      end
-    end
-  end
-end

data/lib/inesita/live_reload.rb

@@ -1,47 +0,0 @@
-require 'rubame'
-
-module Inesita
-  class LiveReload
-    INJECT_CODE = Opal.compile(File.read(File.expand_path('../../../opal/inesita/live_reload.rb', __FILE__)))
-
-    def initialize(app, _options = {})
-      @app = app
-      Thread.new do
-        begin
-          init_live_reload
-        rescue => e
-          puts e
-        end
-      end
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      if status == 200
-        new_body = inject_script(body)
-        headers['Content-Length'] = new_body.bytesize.to_s
-        [status, headers, [new_body]]
-      else
-        [status, headers, body]
-      end
-    end
-
-    def inject_script(body)
-      new_body = ''
-      body.each { |line| new_body += line.to_s }
-      new_body.gsub('{ Opal.loaded', "{ #{INJECT_CODE} Opal.loaded")
-    end
-
-    def init_live_reload
-      AppFilesListener.instance
-      server = Rubame::Server.new('0.0.0.0', 23654)
-      loop do
-        server.run do |ws|
-          ws.onopen    { AppFilesListener.instance.add_ws(ws) }
-          ws.onclose   { AppFilesListener.instance.rm_ws(ws) }
-          ws.onmessage { |msg| ws.send 'pong' if msg == 'ping' }
-        end
-      end
-    end
-  end
-end

data/lib/rubame.rb

@@ -1,156 +0,0 @@
-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/live_reload.rb

@@ -1,79 +0,0 @@
-require 'inesita'
-
-module Inesita
-  WebSocket = JS.global.JS[:WebSocket]
-  Document = JS.global.JS[:document]
-  Head = Document.JS[:head]
-  Window = JS.global
-
-  module Component
-    alias_method :old_mount_to, :mount_to
-    def mount_to(element)
-      Window.JS.addEventListener('inesita:refresh', -> { render! }, false)
-      old_mount_to(element)
-    end
-  end
-
-  class LiveReload
-    def initialize
-      connect
-    end
-
-    def connect
-      ws = `new WebSocket('ws://0.0.0.0:23654')`
-      ws.JS[:onmessage] = ->(e) { on_file_change(e.JS[:data]) }
-      ws.JS[:onclose] = -> { reconnect }
-    end
-
-    def reconnect
-      JS.setTimeout(-> { connect }, 1000)
-    end
-
-    def on_file_change(filename)
-      prefix, mod, ext = filename.split('|')
-      filename = "#{prefix}/#{mod}.self.#{ext}"
-      case ext
-      when 'js'
-        replace_js(filename, mod)
-      when 'css'
-        replace_css(filename)
-      else
-        fail Error, "Don't know how to reload #{ext} file!"
-      end
-    end
-
-    def replace_js(filename, mod)
-      s = create_element(:script, type: 'text/javascript', src: filename, onload: lambda do
-        Opal.load(mod)
-        Window.JS.dispatchEvent(`new Event('inesita:refresh')`)
-      end)
-      replace_or_append(s, 'script') { |t| t.JS[:src].match(filename) }
-    end
-
-    def replace_css(filename)
-      s = create_element(:link, rel: 'stylesheet', type: 'text/css', href: filename)
-      replace_or_append(s, 'link') { |t| t.JS[:href].match(filename) }
-    end
-
-    def create_element(name, attrs = {})
-      s = Document.JS.createElement(name)
-      s.JS[:onload] = attrs.delete(:onload)
-      attrs.each do |k, v|
-        s.JS.setAttribute(k, v)
-      end
-      s
-    end
-
-    def replace_or_append(tag, tags, &block)
-      tags = Document.JS.getElementsByTagName(tags)
-      tags.JS[:length].times do |i|
-        next unless block.call(tags.JS.item(i))
-        Head.JS.replaceChild(tag, tags.JS.item(i))
-        return
-      end
-      Head.JS.appendChild(tag)
-    end
-  end
-end
-
-Inesita::LiveReload.new