flammarion 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015 Zachary Capalbo
+
+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,74 @@
+# Flammarion GUI Toolkit
+
+## Overview
+
+Flammarion is an easy-to-use library for displaying information that you might
+normally display to the command line in a slightly easier-to-access way.
+
+It is not intended to be a full fledged application development toolkit. It is
+intended instead for small scripts where you just want to show some information
+without going through too much trouble.
+
+## Documentation
+
+The easiest way to use Flammarion, is similar to how you might use STDOUT:
+
+```ruby
+require 'flammarion'
+f = Flammarion::Engraving.new
+f.puts "Hello World!"
+```
+
+It can even support standard console color codes: (Thanks to [ansi_up](http://github.com/drudru/ansi_up)!)
+
+```ruby
+require 'colorized'
+f.puts "This line will be red!".red
+f.puts "This #{"word".colorize(:green)} will not be blue."
+```
+
+However, you can also do more advanced things. Say you want to show a table. Easy!
+
+```ruby
+f.table(
+  [%w[Number Squared Sqrt].map{|h| h.light_magenta}] + # Make the header a different color
+  10.times.collect{|x| [x, x * x, Math.sqrt(x)]})
+```
+
+Or maybe you want to know where something is:
+
+```ruby
+f.map("Boston, MA")
+```
+
+Maybe you even want to see both of those things *at the same time*!
+
+```ruby
+f.pane("numberstuff").table([%w[Number Squared Sqrt].map{|h| h.light_magenta}] +
+  10.times.collect{|x| [x, x * x, Math.sqrt(x)]})
+f.pane("mapstuff").map("Big Ben")
+```
+
+If you need feedback, there's a simple callback mechanism for buttons and text
+boxes:
+
+```ruby
+f.button("Click Here!!!") {f.puts "You clicked the button!"}
+f.input("Placeholder > ") {|msg| f.puts "You wrote: #{msg['text'].light_magenta}"}
+```
+
+There's lots more, too. I'll write more documentation eventually.
+
+## Installation
+
+First you need to install [Google Chrome](https://www.google.com/chrome/browser/desktop/index.html)
+and make sure it's in your path. Then you can install the gem:
+
+`gem install flammarion`
+
+or add it to your Gemfile.
+
+## Behind the scenes
+
+Flammarion uses Chrome to display a simple html page, and WebSockets to communicate
+between the Javascript and ruby.

data/lib/flammarion.rb

@@ -0,0 +1,155 @@
+require 'monitor'
+require 'open3'
+require 'ostruct'
+require 'em-websocket'
+require 'json'
+require 'slim'
+require 'coffee-script'
+require 'sass'
+require 'colorize'
+require 'filewatcher'
+
+require_relative 'flammarion/writeable.rb'
+require_relative 'flammarion/pane.rb'
+require_relative 'flammarion/server.rb'
+
+module Flammarion
+  class Engraving
+    attr_reader :chrome
+    attr_accessor :callbacks, :sockets, :on_disconnect, :on_connect, :actions
+    include Writeable
+    def initialize(options = {})
+      @chrome = OpenStruct.new
+      @sockets = []
+      @actions = {}
+      @front_end = self
+      @pane_name = "default"
+      start_server
+      @window_id = @@server.register_window(self)
+      open_a_window unless options[:no_chrome]
+      @callbacks = {}
+      @exit_on_disconnect = options.fetch(:exit_on_disconnect, false)
+      wait_for_a_connection unless options[:no_wait]
+      @on_disconnect = options[:on_disconnect]
+      @ignore_old = options.fetch(:ignore_old, false)
+      @on_connect = options[:on_connect]
+    end
+
+    def disconnect(ws)
+      @sockets.delete ws
+      exit 0 if @exit_on_disconnect
+      @on_disconnect.call if @on_disconnect
+    end
+
+    def process_message(msg)
+      @last_msg = msg
+      m = {}
+      begin
+        m = JSON.parse(msg)
+      rescue JSON::ParserError
+        log "Invalid JSON String"
+        return
+      end
+
+      case m["action"]
+      when 'callback'
+        callback = @callbacks[m['id']]
+        unless callback.nil?
+          if callback.arity == 1
+            callback.call(m)
+          else
+            callback.call
+          end
+        end
+      end
+      @actions[m["action"]].call(m) if @actions.include?(m["action"])
+    end
+
+    def make_id
+      @id ||= 0
+      @id += 1
+      "i#{@id}"
+    end
+
+    def start_server
+      @@server ||= Server.new
+    end
+
+    def wait_for_a_connection
+      sleep 0.5 while @sockets.empty?
+    end
+
+    CHROME_PATH = 'C:\Program Files (x86)\Google\Chrome\Application\chrome.exe'
+    def open_a_window_on_windows
+      resource = %[file\://#{File.absolute_path(File.dirname(__FILE__))}/html/build/index.html]
+      spawn(CHROME_PATH, %[--app=#{resource}?path=#{@window_id}&port=#{@@server.port}])
+    end
+
+    def open_a_window
+      return open_a_window_on_windows if Gem.win_platform?
+      developmentMode = system("lsof -i:#{4567}", out: '/dev/null')
+      host = "file://#{File.dirname(File.absolute_path(__FILE__))}/html/build/index.html"
+      host = "http://localhost:4567/" if developmentMode
+
+      # data_dir = Dir.mktmpdir("flammarion")
+      # File.open("#{data_dir}/First\ Run", "w") {}
+
+      @expect_title = "Flammarion-#{rand.to_s[2..-1]}"
+
+      %w[google-chrome google-chrome-stable chromium chromium-browser chrome C:\Program\ Files\ (x86)\Google\Chrome\Application\chrome.exe].each do |executable|
+        @chrome.in, @chrome.out, @chrome.err, @chrome.thread = Open3.popen3("#{executable} --app='#{host}?path=#{@window_id}&port=#{@@server.port}&title=#{@expect_title}'")
+        break if @chrome.in
+      end
+
+      raise StandardError.new("Cannot launch any browser") unless @chrome.in
+    end
+
+    def window_open?
+      not @sockets.empty?
+    end
+
+    def send_json(val)
+      if @sockets.empty? then
+        open_a_window
+        wait_for_a_connection
+      end
+      @sockets.each{|ws| ws.send val.to_json}
+      nil
+    end
+
+    def pane(name)
+      return Pane.new(self, name)
+    end
+
+    def alert(text)
+      send_json(action:'alert', text:text)
+    end
+
+    def orientation=(orientation)
+      raise ArgumentError.new("Orientation must be :horizontal or :vertical") unless [:horizontal, :vertical].include?(orientation)
+      send_json({action:'reorient', orientation:orientation})
+    end
+
+    def title(str)
+      send_json({action:'title', title:str})
+    end
+
+    def layout(file)
+      data = Slim::Template.new(file).render
+      send_json({action:'layout', data:data})
+    end
+
+    def live_reload_layout(file)
+      layout(file); yield if block_given?
+      FileWatcher.new(file).watch {|file| layout(file); yield if block_given? }
+    end
+
+    def get_save_path
+      if Gem.win_platform?
+        `powershell "Add-Type -AssemblyName System.windows.forms|Out-Null;$f=New-Object System.Windows.Forms.SaveFileDialog;$f.InitialDirectory='%cd%';$f.Filter='All Files (*.*)|*.*';$f.showHelp=$true;$f.ShowDialog()|Out-Null;$f.FileName"`.strip
+      else
+        `zenity --file-selection --save --confirm-overwrite`.strip
+      end
+    end
+  end
+end

data/lib/flammarion/pane.rb

@@ -0,0 +1,12 @@
+require_relative 'writeable.rb'
+
+module Flammarion
+  class Pane
+    attr_reader :pane_name
+    include Writeable
+    def initialize(front_end, name)
+      @front_end = front_end
+      @pane_name = name
+    end
+  end
+end

data/lib/flammarion/server.rb

@@ -0,0 +1,103 @@
+module Flammarion
+  class Server
+    attr_reader :port
+    def initialize
+      @windows = {}
+      @socket_paths = {}
+      @started = false
+      Thread.new do
+        begin
+          start_server_internal
+        rescue SystemExit
+          raise
+        rescue Exception => e
+          if binding.respond_to? :pry
+            binding.pry
+          else
+            raise
+          end
+        end
+      end
+      sleep 0.5 while not @started
+    end
+    def start_server_internal
+      EM.run {
+      @port = 7870
+      @port = rand(65000 - 1024) + 1024 if Gem.win_platform?
+      begin
+        EM::WebSocket.run(:host => "0.0.0.0", :port => @port) do |ws|
+          ws.onopen { |handshake|
+            log "WebSocket connection open"
+            if @windows.include?(handshake.path)
+              @windows[handshake.path].sockets << ws
+              @windows[handshake.path].on_connect.call() if @windows[handshake.path].on_connect
+              @socket_paths[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 Exception => e
+                Kernel.puts "#{e.message.to_s.red}\n#{e.backtrace.join("\n").light_red}"
+                if binding.respond_to? :pry
+                  binding.pry
+                else
+                  raise
+                end
+              end
+            end
+          }
+
+          ws.onerror { |err|
+            if binding.respond_to? :pry
+              binding.pry
+            else
+              raise
+            end
+          }
+        end
+      rescue RuntimeError => e
+        if e.message == "no acceptor (port is in use or requires root privileges)"
+          @port = rand(65000 - 1024) + 1024
+          Kernel.puts "New port: #{port}"
+          retry
+        else
+          raise
+        end
+      end
+      @started = true
+      }
+    rescue Exception => e
+      unless e.is_a? SystemExit
+        Kernel.puts "Error in server:"
+        binding.pry if binding.respond_to? :pry
+        Kernel.puts e.message
+        Kernel.puts e.backtrace.inspect
+      end
+      raise
+    end
+
+    def stop
+    end
+
+    def log(str)
+      # Kernel.puts str
+    end
+
+    def register_window(window)
+      @new_path ||= 0
+      @new_path += 1
+      @windows["/w#{@new_path}"] = window
+      return "w#{@new_path}"
+    end
+  end
+end

data/lib/flammarion/version.rb

@@ -0,0 +1,3 @@
+module Flammarion
+  VERSION = "0.0.1"
+end

data/lib/flammarion/writeable.rb

@@ -0,0 +1,202 @@
+module Flammarion
+  module Writeable
+    attr_reader :front_end
+    class DeferredValue < Delegator
+      def initialize
+        super @value
+      end
+      def __setobj__(value)
+        @value = value
+      end
+
+      def value
+        @value
+      end
+
+      def __getobj__
+        @value
+      end
+
+      def inspect
+        "#R#{@value.inspect}"
+      end
+
+      def checked?
+        return @value
+      end
+    end
+
+    class Spectrum
+      attr_reader :front_end
+      def initialize(id, target, front_end)
+        @id = id
+        @target = target
+        @front_end = front_end
+      end
+
+      def plot(data, options = {})
+        @front_end.send_json({action:'plot', id:@id, target:@target, data:data}.merge(options))
+      end
+    end
+
+    def send_json(hash)
+      @front_end.send_json({target: @pane_name}.merge(hash))
+    end
+
+    def send(str, options = {})
+      @front_end.send_json({action:'append', text:str, target:@pane_name}.merge(options))
+    end
+    alias_method :print, :send
+
+    def puts(str = "", options = {})
+      send str, options
+      send "\n"
+      return nil
+    end
+
+    def replace(str, options = {})
+      send_json({action:'replace', text:str}.merge(options))
+      return nil
+    end
+
+    def clear
+      send_json({action:'clear'})
+      return nil
+    end
+
+    def close
+      send_json({action:'closepane'})
+    end
+
+    def plot(values, options = {})
+      id = @front_end.make_id
+      send_json({action:'plot', data:values, id:id}.merge(options))
+      return Spectrum.new(id, @pane_name, @front_end)
+    end
+
+    def highlight(text, options = {})
+      output = text
+      output = JSON.pretty_generate(text) if text.is_a? Hash or text.is_a? Array
+      send_json({action:'highlight', text:output}.merge(options))
+      nil
+    end
+
+    def button(label, options = {}, &block)
+      id = @front_end.make_id
+      send_json({action:'button', label:label, id:id}.merge(options))
+      @front_end.callbacks[id] = block
+    end
+
+    def input(label, options = {}, &block)
+      id = @front_end.make_id
+      send_json({action:'input', label:label, id:id}.merge(options))
+      if block_given?
+        @front_end.callbacks[id] = block
+      else
+        d = DeferredValue.new
+        @front_end.callbacks[id] = Proc.new {|v| d.__setobj__ v["text"] }
+        return d
+      end
+    end
+
+    def checkbox(label, options = {}, &block)
+      id = @front_end.make_id
+      send_json({action:'checkbox', label:label, id:id}.merge(options))
+      if block_given?
+        @front_end.callbacks[id] = block
+      else
+        d = DeferredValue.new
+        d.__setobj__(options[:value] || options['value'])
+        @front_end.callbacks[id] = Proc.new {|v| d.__setobj__(v["checked"])}
+        return d
+      end
+    end
+
+    def break(options = {})
+      send_json({action:'break'}.merge(options))
+    end
+
+    def html(data)
+      send_json({action:'replace', text:data, raw:true})
+    end
+
+    def script(coffee)
+      data = CoffeeScript.compile(coffee)
+      send_json({action:'script', data:data})
+    end
+
+    def template(file)
+      data = Slim::Template.new(file).render
+      send_json({action:'replace', text:data, raw:true})
+    end
+
+    def live_reload_template(file)
+      FileWatcher.new(file).watch {|file| template(file) }
+    end
+
+    def hide
+      send_json({action:'hidepane'})
+    end
+
+    def show
+      send_json({action:'showpane'})
+    end
+
+    def subpane(name)
+      send_json({action:'subpane', name:name})
+      return Pane.new(@front_end, name)
+    end
+
+    def pane(name)
+      send_json({action:'addpane', name:name})
+      return Pane.new(@front_end, name)
+    end
+
+    def orientation=(orientation)
+      raise ArgumentError.new("Orientation must be :horizontal or :vertical") unless [:horizontal, :vertical].include?(orientation)
+      send_json({action:'reorient', orientation:orientation})
+    end
+
+    def button_box(name)
+      send_json({action:'buttonbox', name:name})
+      return Pane.new(@front_end, name)
+    end
+
+    def status(str, position = :right)
+      @front_end.send_json({action:'status', text: str, position:position})
+    end
+
+    def table(rows, options = {})
+      send_json({action:'table', rows: rows}.merge(options))
+    end
+
+    def gets(prompt = "", options = {})
+      str = nil
+      input(prompt, {once:true, focus:true}.merge(options)) {|msg| str = msg["text"]}
+      sleep 0.1 while str.nil?
+      return str
+    end
+
+    def map(*args)
+      case (args.size)
+      when 1
+        if args[0].respond_to? :keys then
+          options = args[0]
+        else
+          options = {address:args[0].to_s}
+        end
+      when 2
+        if args[1].respond_to? :keys then
+          options = {address:args[0]}.merge(args[1])
+        else
+          options = {latitude:args[0], longitude:args[1]}
+        end
+      when 3
+        options = {latitude:args[0], longitude:args[1]}.merge(args[2])
+      else
+        raise ArgumentError.new("Expected 1..3 arguments")
+      end
+      send_json({action:'map'}.merge(options))
+    end
+  end
+end