hyperstack-config 0.1

data/lib/hyperstack/context.rb

@@ -0,0 +1,36 @@
+module Hyperstack
+  # Allows interactive systems to reset context to the state at boot. Any
+  # modules or classes that set context instance variables to hold things like
+  # call backs should use Hyperstack::Context.set_var(self, :@var_name) { .... }
+  # the provided block will be rerun and the instance variable re-initialized
+  # when the reset! method is called
+  module Context
+    # Replace @foo ||= ... with
+    # Context.set_var(self, :@foo) { ... }
+    # If reset! has been called then the instance variable will be record, and
+    # will be reset on the next call to reset!
+    # If you want to record the current value of the instance variable then set
+    # force to true.
+    def self.set_var(ctx, var, force: nil)
+      inst_value_b4 = ctx.instance_variable_get(var)
+      if @context && !@context[ctx].key?(var) && (force || !inst_value_b4)
+        @context[ctx][var] = (inst_value_b4 && inst_value_b4.dup)
+      end
+      inst_value_b4 || ctx.instance_variable_set(var, yield)
+    end
+
+    def self.reset!(reboot = true)
+      # if @context is already initialized then reset all the instance
+      # vars using their corresponding blocks.  Otherwise initialize
+      # @context.
+      if @context
+        @context.each do |ctx, vars|
+          vars.each { |var, init| ctx.instance_variable_set(var, init.dup) }
+        end
+        Hyperstack::Application::Boot.run if reboot
+      else
+        @context = Hash.new { |h, k| h[k] = {} }
+      end
+    end
+  end
+end

data/lib/hyperstack/deprecation_warning.rb

@@ -0,0 +1,10 @@
+module Hyperstack
+  def self.deprecation_warning(name, message)
+    return if env.production?
+    @deprecation_messages ||= []
+    message = "Warning: Deprecated feature used in #{name}. #{message}"
+    return if @deprecation_messages.include? message
+    @deprecation_messages << message
+    `console.warn.apply(console, [message])`
+  end
+end

data/lib/hyperstack/env.rb

@@ -0,0 +1,10 @@
+module Hyperstack
+  def self.env
+    @environment ||= begin
+      env = Rails.env if defined? Rails
+      env ||= ENV['RACK_ENV']
+      env = 'development' unless %w[development production test staging].include? env
+      ActiveSupport::StringInquirer.new(env)
+    end
+  end
+end

data/lib/hyperstack/environment/development/hyperstack_env.rb

@@ -0,0 +1,5 @@
+module Hyperstack
+  def self.env
+    @environment ||= ActiveSupport::StringInquirer.new('development')
+  end
+end

data/lib/hyperstack/environment/production/hyperstack_env.rb

@@ -0,0 +1,5 @@
+module Hyperstack
+  def self.env
+    @environment ||= ActiveSupport::StringInquirer.new('production')
+  end
+end

data/lib/hyperstack/environment/staging/hyperstack_env.rb

@@ -0,0 +1,5 @@
+module Hyperstack
+  def self.env
+    @environment ||= ActiveSupport::StringInquirer.new('staging')
+  end
+end

data/lib/hyperstack/environment/test/hyperstack_env.rb

@@ -0,0 +1,5 @@
+module Hyperstack
+  def self.env
+    @environment ||= ActiveSupport::StringInquirer.new('test')
+  end
+end

data/lib/hyperstack/hotloader.rb

@@ -0,0 +1,129 @@
+require 'hyperstack/hotloader/add_error_boundry'
+require 'hyperstack/hotloader/stack-trace.js'
+require 'hyperstack/hotloader/css_reloader'
+require 'opal-parser' # gives me 'eval', for hot-loading code
+
+require 'json'
+require 'hyperstack/hotloader/short_cut.js'
+
+# Opal client to support hot reloading
+$eval_proc = proc do |file_name, s|
+  $_hyperstack_reloader_file_name = file_name
+  eval s
+end
+
+module Hyperstack
+
+  class Hotloader
+    def self.callbackmaps
+      @@callbackmaps ||= Hash.new { |h, k| h[k] = Hash.new { |h1, k1| h1[k1] = Hash.new { |h2, k2| h2[k2] = Array.new }}}
+    end
+
+    def self.record(klass, instance_var, depth, *items)
+      if $_hyperstack_reloader_file_name
+        callbackmaps[$_hyperstack_reloader_file_name][klass][instance_var].concat items
+      else
+        callback = lambda do |stack_frames|
+          file_name = `#{stack_frames[depth]}.fileName`
+          match = /^(.+\/assets\/)(.+\/)\2/.match(file_name)
+          if match
+            file_name = file_name.gsub(match[1]+match[2], '')
+            callbackmaps[file_name][klass][instance_var].concat items
+          end
+        end
+        error = lambda do |err|
+          `console.error(#{"hyperstack hot loader could not find source file for callback: #{err}"})`
+        end
+        `StackTrace.get().then(#{callback}).catch(#{error})`
+       end
+    end
+
+    def self.remove(file_name)
+      callbackmaps[file_name].each do |klass, instance_vars|
+        instance_vars.each do |instance_var, items|
+          klass.instance_variable_get(instance_var).reject! { |item| items.include? item }
+        end
+      end
+    end
+
+    def connect_to_websocket(port)
+      host = `window.location.host`.sub(/:\d+/, '')
+      host = '127.0.0.1' if host == ''
+      protocol = `window.location.protocol` == 'https:' ? 'wss:' : 'ws:'
+      ws_url = "#{host}:#{port}"
+      puts "Hot-Reloader connecting to #{ws_url}"
+      ws = `new WebSocket(#{protocol} + '//' + #{ws_url})`
+      `#{ws}.onmessage = #{lambda { |e| reload(e) }}`
+      `setInterval(function() { #{ws}.send('') }, #{@ping * 1000})` if @ping
+    end
+
+    def notify_error(reload_request)
+      msg = "Hotloader #{reload_request[:filename]} RELOAD ERROR:\n\n#{$!}"
+      puts msg
+      alert msg if use_alert?
+    end
+
+    @@USE_ALERT = true
+    def self.alerts_on!
+      @@USE_ALERT = true
+    end
+
+    def self.alerts_off!
+      @@USE_ALERT = false
+    end
+
+    def use_alert?
+      @@USE_ALERT
+    end
+
+    def reload(e)
+      reload_request = JSON.parse(`e.data`)
+      if reload_request[:type] == "ruby"
+        puts "Reloading #{reload_request[:filename]} (asset_path: #{reload_request[:asset_path]})"
+        begin
+          #Hyperstack::Context.reset! false
+          file_name = reload_request[:asset_path] #.gsub(/.+hyperstack\//, '')
+          Hotloader.remove(file_name)
+          $eval_proc.call file_name, reload_request[:source_code]
+        rescue
+          notify_error(reload_request)
+        end
+        if @reload_post_callback
+          @reload_post_callback.call
+        else
+          puts "no reloading callback to call"
+        end
+      end
+      if reload_request[:type] == "css"
+        @css_reloader.reload(reload_request, `document`)
+      end
+    end
+
+    # @param port [Integer] opal hot reloader port to connect to
+    # @param reload_post_callback [Proc] optional callback to be called after re evaluating a file for example in react.rb files we want to do a React::Component.force_update!
+    def initialize(port=25222, ping=nil, &reload_post_callback)
+      @port = port
+      @reload_post_callback  = reload_post_callback
+      @css_reloader = CssReloader.new
+      @ping = ping
+    end
+    # Opens a websocket connection that evaluates new files and runs the optional @reload_post_callback
+    def listen
+      connect_to_websocket(@port)
+    end
+
+    def self.listen(port=25222, ping=nil)
+      ::Hyperstack::Internal::Component::TopLevelRailsComponent.include AddErrorBoundry
+      @server = Hotloader.new(port, ping) do
+        # TODO: check this out when Operations are integrated
+        # if defined?(Hyperloop::Internal::Operation::ClientDrivers) &&
+        #    Hyperloop::ClientDrivers.respond_to?(:initialize_client_drivers_on_boot)
+        #   Hyperloop::ClientDrivers.initialize_client_drivers_on_boot
+        # end
+        Hyperstack::Component.force_update!
+      end
+      @server.listen
+    end
+
+  end
+end

data/lib/hyperstack/hotloader/add_error_boundry.rb

@@ -0,0 +1,31 @@
+module Hyperstack
+  class Hotloader
+    module AddErrorBoundry
+      def self.included(base)
+        base.after_error do |*err|
+          @err = err
+          Hyperstack::Component.force_update!
+        end
+        base.define_method :render do
+          @err ? parse_display_and_clear_error : top_level_render
+        end
+      end
+
+      def parse_display_and_clear_error
+        e = @err[0]
+        component_stack = @err[1]['componentStack'].split("\n ")
+        @err = nil
+        display_error(e, component_stack)
+      end
+
+      def display_error(e, component_stack)
+        DIV do
+          DIV { "Uncaught error: #{e}" }
+          component_stack.each do |line|
+            DIV { line }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/hyperstack/hotloader/css_reloader.rb

@@ -0,0 +1,41 @@
+require 'native'
+module Hyperstack
+  class Hotloader
+    class CssReloader
+
+      def reload(reload_request, document)
+        url = reload_request[:url]
+        puts "Reloading CSS: #{url}"
+        to_append = "t_hot_reload=#{Time.now.to_i}"
+        links = Native(`document.getElementsByTagName("link")`)
+        (0..links.length-1).each { |i|
+          link = links[i]
+          if link.rel == 'stylesheet' && is_matching_stylesheet?(link.href, url)
+            if  link.href !~ /\?/
+              link.href += "?#{to_append}"
+            else
+              if link.href !~ /t_hot_reload/
+                link.href += "&#{to_append}"
+              else
+                link.href = link.href.sub(/t_hot_reload=\d+/, to_append)
+              end
+            end
+          end
+        }
+      end
+
+      def is_matching_stylesheet?(href, url)
+        # straight match, like in Rack::Sass::Plugin
+        if href.index(url)
+          true
+        else
+          # Rails asset pipeline match
+          url_base = File.basename(url).sub(/\.s?css+/, '').sub(/\.s?css+/, '')
+          href_base = File.basename(href).sub(/\.self-?.*.css.+/, '')
+          url_base == href_base
+        end
+
+      end
+    end
+  end
+end

data/lib/hyperstack/hotloader/server.rb

@@ -0,0 +1,296 @@
+require 'websocket'
+require 'socket'
+require 'fiber'
+require 'listen'
+require 'optparse'
+require 'json'
+
+module Hyperstack
+  class Hotloader
+    # Most of this lifted from https://github.com/saward/Rubame
+    class Server
+
+      attr_reader :directories
+      def initialize(options)
+        Socket.do_not_reverse_lookup
+        @hostname = '0.0.0.0'
+        @port = options[:port]
+        setup_directories(options)
+
+        @reading = []
+        @writing = []
+
+        @clients = {} # Socket as key, and Client as value
+
+        @socket = TCPServer.new(@hostname, @port)
+        @reading.push @socket
+      end
+
+      # adds known directories automatically if they exist
+      # - rails js app/assets/javascripts app/assets/stylesheets
+      # - reactrb rails defaults app/views/components
+      # - you tell me and I'll add them
+      def setup_directories(options)
+        @directories = options[:directories] || []
+        [
+          'app/assets/javascripts',
+          'app/assets/stylesheets',
+          'app/views/components'
+        ].each { |known_dir|
+          if !@directories.include?(known_dir) && File.exists?(known_dir)
+            @directories << known_dir
+          end
+        }
+      end
+
+      def accept
+        socket = @socket.accept_nonblock
+        @reading.push socket
+        handshake = WebSocket::Handshake::Server.new
+        client = 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 send_updated_file(modified_file)
+        if modified_file =~ /\.rb(\.erb)?$/
+          if File.exist?(modified_file)
+            file_contents = File.read(modified_file).force_encoding(Encoding::UTF_8)
+          end
+          relative_path = Pathname.new(modified_file).relative_path_from(Pathname.new(Dir.pwd)).to_s
+          asset_path = nil
+          @directories.each do |directory|
+            next unless relative_path =~ /^#{directory}/
+            asset_path = relative_path.gsub("#{directory}/", '')
+          end
+          update = {
+            type: 'ruby',
+            filename: modified_file,
+            asset_path: asset_path,
+            source_code: file_contents || ''
+          }.to_json
+        end
+        if modified_file =~ /\.s?[ac]ss$/ && File.exist?(modified_file)
+          # Don't know how to remove css definitions at the moment
+          # TODO: Switch from hard-wired path assumptions to using SASS/sprockets config
+          relative_path = Pathname.new(modified_file).relative_path_from(Pathname.new(Dir.pwd))
+          url = relative_path.to_s
+            .sub('public/','')
+            .sub('/sass/','/')
+            .sub(/\.s[ac]ss/, '.css')
+          update = {
+            type: 'css',
+            filename: modified_file,
+            url: url
+          }.to_json
+        end
+        if update
+          @clients.each { |socket, client| client.send(update) }
+        end
+      end
+
+      PROGRAM = 'opal-hot-reloader'
+      def loop
+        listener = Listen.to(*@directories, only: %r{\.(rb(\.erb)?|s?[ac]ss)$}) do |modified, added, removed|
+          (removed + modified + added).each { |file| send_updated_file(file) }
+          puts "removed absolute path: #{removed}"
+          puts "modified absolute path: #{modified}"
+          puts "added absolute path: #{added}"
+        end
+        listener.start
+
+        puts "#{PROGRAM}: starting..."
+        while (!$quit)
+          run do |client|
+            client.onopen do
+              puts "#{PROGRAM}:  client open"
+            end
+            client.onmessage do |mess|
+              puts "PROGRAM:  message received: #{mess}" unless mess == ''
+            end
+            client.onclose do
+              puts "#{PROGRAM}:  client closed"
+            end
+          end
+          sleep 0.2
+        end
+      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
+    rescue
+    end
+    client.closed = true
+  end
+
+  def run(time = 0, &blk)
+    readable, writable = IO.select(@reading, @writing, nil, 0)
+
+    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
+
+    # Check for lazy send items
+    timer_start = Time.now
+    time_passed = 0
+    begin
+      @clients.each do |s, c|
+        c.send_some_lazy(5)
+      end
+      time_passed = Time.now - timer_start
+    end while time_passed < time
+  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 = []
+      @lazy_queue = []
+      @lazy_current_queue = nil
+      @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 lazy_send(data)
+      @lazy_queue.push data
+    end
+
+    def get_lazy_fiber
+      # Create the fiber if needed
+      if @lazy_fiber == nil or !@lazy_fiber.alive?
+        @lazy_fiber = Fiber.new do
+          @lazy_current_queue.each do |data|
+            send(data)
+            Fiber.yield unless @lazy_current_queue[-1] == data
+          end
+        end
+      end
+
+      return @lazy_fiber
+    end
+
+    def send_some_lazy(count)
+      # To save on cpu cycles, we don't want to be chopping and changing arrays, which could get quite large.  Instead,
+      # we iterate over an array which we are sure won't change out from underneath us.
+      unless @lazy_current_queue
+        @lazy_current_queue = @lazy_queue
+        @lazy_queue = []
+      end
+
+      completed = 0
+      begin
+        get_lazy_fiber.resume
+        completed += 1
+      end while (@lazy_queue.count > 0 or @lazy_current_queue.count > 0) and completed < count
+
+    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
+        ensure
+        end
+      end
+    end
+  end
+
+  line = 0
+  end
+end