flammarion_rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 15f7d10ed9788e61ebd810c34eeb3d67bf63ef9c
+  data.tar.gz: 6396f3d2703750b5026fd5e560b2b0ff9dd4265e
+SHA512:
+  metadata.gz: 99e21f6996bf87be7d1db17b57ecc6e9349403953ab039c85ed7dd73814f183163c104d71bb603518fdd88dedfce99114853f64f9020da06e14bdeef361bb110
+  data.tar.gz: 5c8b6fb0b2a96475dd74d278e513eeb548d55553eabdd477cd9dca47036a90a35916860c6aa6b0f0149f3a0ee11bf3084b0d4d053a3c873c8e37846dfc0f6f00

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Patrice Lebel
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+# FlammarionRails
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,26 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'FlammarionRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+require 'bundler/gem_tasks'
+

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/lib/flammarion/engraving.rb

@@ -0,0 +1,95 @@
+module Flammarion
+  class Engraving
+    include Revelator
+
+    attr_accessor :on_disconnect, :on_connect, :sockets
+
+    # Creates a new Engraving (i.e., a new display window)
+    # @option options [Proc] :on_connect Called when the display window is
+    #  connected (i.e., displayed)
+    # @option options [Proc] :on_disconnect Called when the display windows is
+    #  disconnected (i.e., closed)
+    # @option options [Boolean] :exit_on_disconnect (false) Will call +exit+
+    #  when the widow is closed if this option is true.
+    # @option options [Boolean] :close_on_exit (false) Will close the window
+    #  when the process exits if this is true. Otherwise, it will just stay
+    #  around, but not actually be interactive.
+    # @raise {SetupError} if neither chrome is set up correctly and
+    #  and Flammarion is unable to display the engraving.
+    def initialize(**options)
+      @chrome = OpenStruct.new
+      @sockets = []
+      @on_connect = options[:on_connect]
+      @on_disconnect = options[:on_disconnect]
+      @exit_on_disconnect = options.fetch(:exit_on_disconnect, false)
+
+      start_server
+      @window_id = @@server.register_window(self)
+      open_a_window(options) unless options[:no_window]
+      wait_for_a_connection unless options[:no_wait]
+
+      at_exit {close if window_open?} if options.fetch(:close_on_exit, true)
+    end
+
+    # Blocks the current thread until the window has been closed. All user
+    # interactions and callbacks will continue in other threads.
+    def wait_until_closed
+      sleep 1 until @sockets.empty?
+    end
+
+    # Is this Engraving displayed on the screen.
+    def window_open?
+      !@sockets.empty?
+    end
+
+    def disconnect(ws)
+      @sockets.delete ws
+      exit 0 if @exit_on_disconnect
+      @on_disconnect.call if @on_disconnect
+    end
+
+    def process_message(msg)
+      result = dispatch(JSON.parse(msg).with_indifferent_access)
+
+      send_json(document: result.last.body)
+
+    rescue JSON::ParserError
+      Rails.logger.debug "Invalid JSON String #{msg}"
+    end
+
+    def dispatch(params)
+      http_method = params.delete(:method) || :get
+      mapping = Rails.application.routes.recognize_path(params.delete(:url), method: http_method, **params)
+
+      unless mapping.key?(:controller)
+        Rails.logger.debug "Path not found"
+        return ActionDispatch::Request::PASS_NOT_FOUND
+      end
+
+      controller_name = "#{mapping[:controller].underscore.camelize}Controller"
+      controller      = ActiveSupport::Dependencies.constantize(controller_name)
+      action          = mapping[:action] || 'index'
+      request         = ActionDispatch::Request.new('rack.input' => '', 'REQUEST_METHOD' => http_method.to_s.upcase!)
+      response        = controller.make_response! request
+
+      controller.dispatch(action, request, response)
+    end
+
+    def start_server
+      @@server ||= Server.new
+    end
+
+    def server
+      @@server
+    end
+
+    def send_json(val)
+      if @sockets.empty?
+        open_a_window
+        wait_for_a_connection
+      end
+      @sockets.each{ |ws| ws.send val.to_json }
+      nil
+    end
+  end
+end

data/lib/flammarion/revelator.rb

@@ -0,0 +1,88 @@
+module Flammarion
+  class SetupError < StandardError; end
+
+  module Revelator
+    CHROME_PATH = ENV["FLAMMARION_REVELATOR_PATH"] || 'C:\Program Files (x86)\Google\Chrome\Application\chrome.exe'
+
+    def open_a_window(**options)
+      index_path = FlammarionRails::Engine.root.join('public', 'index.html')
+      index_path = `cygpath -w '#{index_path}'`.strip if RbConfig::CONFIG["host_os"] == "cygwin"
+
+      url = "file://#{index_path}?" + { port: server.port, path: @window_id, boot: FlammarionRails.config.boot_path }.to_query
+      @browser_options = options.merge(url: url)
+      @requested_browser = ENV["FLAMMARION_BROWSER"] || options[:browser]
+
+      @browser = @@browsers.find do |browser|
+        next if @requested_browser and browser.name.to_s != @requested_browser
+        begin
+          send(browser.name, @browser_options)
+        rescue Exception
+          next
+        end
+      end
+
+      raise SetupError.new("You must have google-chrome installed and accesible via your path.") unless @browser
+    end
+
+    def wait_for_a_connection
+       Timeout.timeout(20) { sleep 0.5 while @sockets.empty? }
+     rescue Timeout::Error
+       raise SetupError.new("Timed out while waiting for a connecting using #{@browser.name}.")
+    end
+
+    private
+
+    @@browsers = []
+
+    def self.browser(name, &block)
+      @@browsers << OpenStruct.new(name: name, method:define_method(name, block))
+    end
+
+    browser :osx do |options|
+      return false unless RbConfig::CONFIG["host_os"] =~ /darwin|mac os/
+      executable = "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+      @chrome.in, @chrome.out, @chrome.err, @chrome.thread = Open3.popen3("'#{executable}' --app='#{options[:url]}'")
+      true if @chrome.in
+    end
+
+    browser :chrome_windows do |options|
+      return false unless RbConfig::CONFIG["host_os"] =~ /cygwin|mswin|mingw/
+      file_path = File.absolute_path(File.join(File.dirname(__FILE__), ".."))
+      file_path = `cygpath -w '#{file_path}'`.strip if RbConfig::CONFIG["host_os"] == "cygwin"
+      resource = %[file\://#{file_path}/html/build/index.html]
+      resource = "http://localhost:4567/" if options[:development_mode]
+      chrome_path = CHROME_PATH
+      chrome_path = `cygpath -u '#{CHROME_PATH}'`.strip if RbConfig::CONFIG["host_os"] == "cygwin"
+      return false unless File.exist?(chrome_path)
+      Process.detach(spawn(chrome_path, %[--app=#{resource}?path=#{@window_id}&port=#{server.port}]))
+    end
+
+    browser :chrome do |options|
+      %w[google-chrome google-chrome-stable chromium chromium-browser chrome].each do |executable|
+        next unless which(executable)
+        @chrome.in, @chrome.out, @chrome.err, @chrome.thread = Open3.popen3("#{executable} --app='#{options[:url]}'")
+        return true if @chrome.in
+      end
+      false
+    end
+
+    browser :www do |options|
+      # Last ditch effort to display something
+      Launchy.open(options[:url].gsub(/\s/, "%20")) do |error|
+        return false
+      end
+      true
+    end
+
+    def which(cmd)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable?(exe) && !File.directory?(exe)
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/flammarion/server.rb

@@ -0,0 +1,88 @@
+module Flammarion
+  class Server
+    attr_accessor :port
+
+    def initialize
+      @windows = {}
+      @socket_paths = {}
+      @started = false
+      @launch_thread = Thread.current
+      @server_thread = Thread.new do
+        begin
+          start_server_internal
+        rescue StandardError => e
+          handle_exception(e)
+        end
+      end
+      sleep 0.5 until @started
+    end
+
+    def start_server_internal
+      self.port =
+        if Gem.win_platform?
+          rand(65000 - 1024) + 1024
+        else
+          7870
+        end
+      begin
+        @server = Rubame::Server.new("0.0.0.0", port)
+        loop do
+          @started = true
+          @server.run do |ws|
+            ws.onopen {
+              log "Connection open"
+              if @windows.include?(ws.handshake.path)
+                @windows[ws.handshake.path].sockets << ws
+                @windows[ws.handshake.path].on_connect.call if @windows[ws.handshake.path].on_connect
+                @socket_paths[ws] = ws.handshake.path
+              else
+                log "No such window: #{handshake.path}"
+              end
+            }
+
+            ws.onclose do
+              log "Connection closed"
+              @windows[@socket_paths[ws]].disconnect(ws) if @windows[@socket_paths[ws]]
+            end
+
+            ws.onmessage { |msg|
+              Thread.new do
+                begin
+                  @windows[@socket_paths[ws]].process_message(msg)
+                rescue StandardError => e
+                  handle_exception(e)
+                end
+              end
+            }
+          end
+        end
+      rescue RuntimeError, Errno::EADDRINUSE => e
+        if e.message == "no acceptor (port is in use or requires root privileges)" || e.is_a?(Errno::EADDRINUSE)
+          self.port = rand(65000 - 1024) + 1024
+          retry
+        else
+          raise
+        end
+      end
+      @started = true
+    end
+
+    def stop
+    end
+
+    def log(str)
+      Rails.logger.debug str
+    end
+
+    def handle_exception(e)
+      @launch_thread.raise(e)
+    end
+
+    def register_window(window)
+      @new_path ||= 0
+      @new_path += 1
+      @windows["/w#{@new_path}"] = window
+      "w#{@new_path}"
+    end
+  end
+end

data/lib/flammarion_rails.rb

@@ -0,0 +1,5 @@
+require "flammarion_rails/engine"
+
+module FlammarionRails
+  # Your code goes here...
+end

data/lib/flammarion_rails/configuration.rb

@@ -0,0 +1,25 @@
+module FlammarionRails
+  @@config = nil
+
+  def self.configure
+    @@config ||= Configuration.new
+
+    if block_given?
+      yield config
+    end
+
+    config
+  end
+
+  def self.config
+    @@config || configure
+  end
+
+  class Configuration
+    attr_accessor :boot_path
+
+    def boot_path
+      @boot_path ||= '/'
+    end
+  end
+end

data/lib/flammarion_rails/engine.rb

@@ -0,0 +1,28 @@
+require "flammarion_rails/configuration"
+
+require 'open3'
+require "rubame/server"
+require "flammarion/server"
+require "flammarion/revelator"
+require "flammarion/engraving"
+
+module FlammarionRails
+  class Engine < ::Rails::Engine
+    # Initialize engine dependencies on wrapper application
+    Gem.loaded_specs["flammarion_rails"].dependencies.each do |d|
+      begin
+        require d.name
+      rescue LoadError => e
+        # Put exceptions here.
+      end
+    end
+    # Uncomment if migrations need to be shared
+    # initializer :append_migrations do |app|
+    #   unless app.root.to_s.match root.to_s
+    #     config.paths["db/migrate"].expanded.each do |expanded_path|
+    #       app.config.paths["db/migrate"] << expanded_path
+    #     end
+    #   end
+    # end
+  end
+end

data/lib/flammarion_rails/version.rb

@@ -0,0 +1,3 @@
+module FlammarionRails
+  VERSION = '0.1.0'
+end

data/lib/rubame/server.rb

@@ -0,0 +1,172 @@
+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
+
+      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
+
+      messages
+    end
+
+    def close(client)
+      @reading.delete client.socket
+      @clients.delete client.socket
+      begin
+        client.socket.close
+      rescue
+        # do nothing
+      end
+      client.closed = true
+    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 && 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
+        ensure
+          # do nothing
+        end
+      end
+    end
+  end
+end
+
+if __FILE__==$0
+  server = Rubame::Server.new("0.0.0.0", 25222)
+  while !$quit
+    server.run do |client|
+      client.onopen do
+        puts "Server reports:  client open"
+      end
+      client.onmessage do |mess|
+        puts "Server reports:  message received: #{mess}"
+      end
+      client.onclose do
+        puts "Server reports:  client closed"
+      end
+    end
+  end
+end