superconductor 0.0.4 → 0.1.0

data/extconf.rb

@@ -0,0 +1,2 @@
+# rust/extconf.rb
+raise 'You have to install Rust with Cargo (https://www.rust-lang.org/)' if !system('cargo --version') || !system('rustc --version')

data/lib/superconductor.rb

@@ -1,4 +1,38 @@
-require "superconductor/engine"
+require 'fiddle'
+require 'fiddle/import'
 
 module Superconductor
+  autoload :Middleware, 'superconductor/middleware'
+  autoload :Documentation, 'superconductor/documentation'
+  autoload :VERSION, 'superconductor/version'
+
+  target = ENV['TARGET'] || 'release'
+  extend Fiddle::Importer
+  dlload File.expand_path("../../target/#{target}/libsuperconductor.dylib", __FILE__)
+  extern "char* panel_js(int)"
+  extern "char* panel_xslt()"
+  extern "int start()"
+
+  #extern "unsigned char u8_return_test()"
+  #extern "short i16_return_test()"
+  #extern "unsigned short u16_return_test()"
+  #extern "int i32_return_test()"
+  #extern "unsigned int u32_return_test()"
+  #extern "long long i64_return_test()"
+  #extern "unsigned long long u64_return_test()"
+
+  #extern "void  i8_pass_test(char)"
+  #extern "void  u8_pass_test(unsigned char)"
+  #extern "void i16_pass_test(short)"
+  #extern "void u16_pass_test(unsigned short)"
+  #extern "void i32_pass_test(int)"
+  #extern "void u32_pass_test(unsigned int)"
+  #extern "void i64_pass_test(long long)"
+  #extern "void u64_pass_test(unsigned long long)"
+
+  #extern "float f32_return_test()"
+  #extern "double f64_return_test()"
+
+  #extern "void f32_pass_test(float)"
+  #extern "void f64_pass_test(double)"
 end

data/lib/superconductor/documentation.rb

@@ -0,0 +1,34 @@
+require 'pry'
+require 'rack/request'
+require 'rack/response'
+require 'superconductor'
+
+# Superconductor Documentation Service
+# 
+#
+class Superconductor::Documentation
+  include Rack::Utils
+
+  def initialize(path: nil, index: "index.html")
+    @path ||= File.join(Dir.getwd, 'doc')
+    @index = index
+  end
+
+  def call(env)
+    path = env["PATH_INFO"][1..-1]
+    file = path == "" ? @index : path
+    headers = HeaderHash.new({
+      'Content-Type' => content_type(file)
+    })
+    body = [open(File.join(@path, file)).read]
+    status = 200
+    [status, headers, body]
+  end
+
+  private def content_type(file)
+    return "text/html"        if file =~ /.html?$/
+    return "text/css"         if file =~ /.css$/
+    return "text/javascript"  if file =~ /.js$/
+    return "text/plain"
+  end
+end

data/lib/superconductor/middleware.rb

@@ -0,0 +1,71 @@
+require 'superconductor'
+require 'pry'
+
+module Superconductor
+  class Middleware
+
+    PORT = Superconductor.start();
+    ENV["GIT_DIR"] = File.join(Dir.pwd, '.git')
+
+    def initialize(app)
+      @app = app
+      @gem_path = File.expand_path(File.join(File.dirname(__FILE__), '../..'))
+      @assets = Dir[File.join(@gem_path, 'assets/**/*.{js,css}')]
+      @assets += Dir[File.join(@gem_path, 'spec/integration/screenshots/*.png')]
+    end
+
+    def call(env)
+      path = env['PATH_INFO']
+      serve_asset(path) or serve_xslt(path) or serve_response(env)
+    end
+
+    private
+
+    def serve_asset(path)
+      if asset = @assets.find { |p| path == p[@gem_path.length..-1] }
+        status, headers = 200, {}
+        body = [open(asset).read]
+        headers['Content-Type'] = content_type(path)
+        [status, headers, body]
+      end
+    end
+
+    def content_type(path)
+      case path
+      when /.html?$/ then "text/html"
+      when /.css$/   then "text/css"
+      when /.js$/    then "text/javascript"  
+      when /.png$/   then "image/png"
+      when /.jpg$/   then "image/jpeg"
+      else "text/plain"
+      end
+    end
+
+    def serve_xslt(path)
+      if path == '/__panel.xslt'
+        status, headers = 200, {}
+        panel_xslt = Superconductor.panel_xslt
+        panel_xslt.free = Superconductor[:cleanup]
+        body = [panel_xslt.to_s]
+        headers['Content-Type'] = 'text/xml'
+        [status, headers, body]
+      end
+    end
+
+    def serve_response(env)
+      status, headers, response = *@app.call(env)
+      body = []
+      response.each do |res|
+        body << res
+      end
+      if (type = headers["Content-Type"]) && type['text/html']
+        panel_js = Superconductor.panel_js(PORT)
+        panel_js.free = Superconductor[:cleanup]
+        headers.delete('Content-Length')
+        body << panel_js.to_s
+      end
+      [status, headers, body]
+    end
+
+  end
+end

data/lib/superconductor/version.rb

@@ -1,3 +1,3 @@
 module Superconductor
-  VERSION = "0.0.4"
+  VERSION = "0.1.0"
 end

data/src/lib.rs

@@ -0,0 +1,101 @@
+#![feature(plugin)]
+#![plugin(maud_macros)]
+
+extern crate maud;
+extern crate websocket;
+extern crate yaml_rust;
+extern crate libc;
+
+#[macro_use]
+extern crate serde_derive;
+extern crate serde_xml;
+
+use libc::{c_char};
+use std::ffi::CString;
+use std::thread;
+
+extern crate rand;
+use rand::Rng;
+
+extern crate termion;
+
+extern crate git2;
+
+pub static XML: &'static str = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
+
+
+mod state;
+mod view;
+mod server;
+mod task;
+
+#[no_mangle]
+pub extern "C" fn panel_xslt() -> *mut c_char {
+    CString::new(view::panel_xslt()).unwrap().into_raw()
+}
+
+#[no_mangle]
+pub extern "C" fn start() -> i32 {
+    let mut port = 2794;
+    let mut _server = server::start(port);
+    if _server.is_err() {
+        println!("Failed to connect on default websocket port");
+        let mut rng = rand::thread_rng();
+        port = port + rng.gen::<i32>() % 10;
+        _server = server::start(port);
+    }
+    match _server {
+        Ok(server) => {
+            thread::spawn(move || {
+                for connection in server {
+                    thread::spawn(move || server::connect(connection.unwrap()));
+                }
+            });
+        },
+        _ => println!("Unable to start websocket server")
+    };
+    port
+}
+
+#[no_mangle]
+pub extern "C" fn panel_js(port: i32) -> *mut c_char {
+    let markup = html! {
+        script { "
+        if (window === window.top) {
+            //var highlight = document.createElement('script');
+            //highlight.setAttribute('src', '//cdnjs.cloudflare.com/ajax/libs/highlight.js/9.10.0/highlight.min.js');
+            //document.body.appendChild(highlight);
+            PM = document.createElement('script');
+            PM.setAttribute('src', '/assets/__pm.js');
+            PM.port = " (port) ";
+            document.body.appendChild(PM);
+        }" }
+    };
+    CString::new(markup.into_string()).unwrap().into_raw()
+}
+
+#[no_mangle]
+pub extern fn cleanup(s: *mut c_char) {
+    unsafe {
+        if s.is_null() { return }
+        CString::from_raw(s)
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    use std::env;
+    use std::process::Command;
+
+    #[test]
+    fn it_works() {
+        env::set_var("TARGET",  "debug");
+        env::set_var("GIT_DIR", "tmp/dummy/.git");
+
+        let rspec = Command::new("rspec")
+            .arg("spec/integration")
+            .status().expect("Failed to execute rspec");
+
+        assert!(rspec.success(), "rspec reported failing tests");
+    }
+}

data/src/server.rs

@@ -0,0 +1,176 @@
+use std;
+use std::thread;
+use std::time::Duration;
+use termion::color;
+use termion::clear;
+use termion::cursor;
+use rand;
+
+use websocket::{WebSocketStream, Server};
+use websocket::Message as WebMessage;
+use websocket::Sender as WebSender;
+use websocket::client::Sender as WebClientSender;
+use websocket::Receiver as WebReceiver;
+use websocket::message::Type as WebMessageType;
+use websocket::server::Connection;
+use websocket::header::WebSocketProtocol;
+
+use state::generate;
+use state::State;
+
+extern crate fsevent;
+use self::fsevent::{ITEM_MODIFIED, ITEM_CREATED, ITEM_REMOVED};
+use self::fsevent::Event as FsEvent;
+use std::sync::mpsc::channel;
+use std::sync::mpsc::Sender;
+use std::sync::mpsc::Receiver;
+
+use git2::Repository;
+
+use serde_xml as xml;
+
+const HEARTBEAT: u64 = 250;
+
+#[derive(Debug)]
+enum NotifierMessage<'a> {
+    WebMessage(WebMessage<'a>),
+    FsEvent(FsEvent)
+}
+
+pub fn start(port: i32) -> Result<Server<'static>, std::io::Error> {
+    let host = format!("127.0.0.1:{}", port);
+    Server::bind(host)
+}
+
+pub fn connect(connection: Connection<WebSocketStream, WebSocketStream>) {
+    let request = connection.read_request().unwrap();
+    let headers = request.headers.clone();
+    request.validate().unwrap();
+
+    let mut response = request.accept();
+    println!("Connected");
+
+    if let Some(&WebSocketProtocol(ref protocols)) = headers.get() {
+        if protocols.contains(&("superconductor".to_string())) {
+            response.headers.set(WebSocketProtocol(vec!["superconductor".to_string()]));
+        }
+    }
+
+    let client = response.send().unwrap();
+
+    let (tx, rx) = channel::<NotifierMessage>();
+    let (sender, mut receiver) = client.split();
+    let notifier = thread::spawn(move || start_notifier(rx, sender));
+
+    let message = WebMessage::text(generate(None));
+    tx.send(NotifierMessage::WebMessage(message)).unwrap();
+
+    let monitor_tx = tx.clone();
+    let monitor = thread::spawn(move || start_monitor(monitor_tx));
+
+    let updater_tx = tx.clone();
+    let updater = thread::spawn(move || start_updater(updater_tx));
+
+    for message in receiver.incoming_messages() {
+        let message: WebMessage = message.unwrap_or(WebMessage::close());
+        match message.opcode {
+            WebMessageType::Close => {
+                tx.send(NotifierMessage::WebMessage(message)).unwrap();
+                break;
+            },
+            _ => tx.send(NotifierMessage::WebMessage(message))
+        }.unwrap();
+    }
+
+    monitor.join().unwrap();
+    notifier.join().unwrap();
+    updater.join().unwrap();
+}
+
+fn start_monitor(tx: Sender<NotifierMessage>) {
+    let (ftx, rx) = channel();
+    let observer = thread::spawn(move || {
+        println!("Monitoring");
+        let fsevent = fsevent::FsEvent::new(ftx);
+        fsevent.append_path(".");
+        fsevent.observe();
+    });
+    loop {
+        let event = rx.recv().unwrap();
+        thread::sleep(Duration::from_millis(HEARTBEAT));
+        let mut changes = vec![event];
+        loop {
+            if let Ok(event) = rx.try_recv() {
+                if (event.flag.contains(ITEM_MODIFIED) || event.flag.contains(ITEM_CREATED) || event.flag.contains(ITEM_REMOVED)) && (!event.path.contains(".git") || !event.path.contains(".lock")) {
+                    changes.push(event);
+                }
+            } else {
+                break;
+            }
+        }
+        if !changes.is_empty() {
+            if tx.send(NotifierMessage::FsEvent(changes.pop().unwrap())).is_err() {
+                break;
+            };
+        }
+    }
+    observer.join().unwrap();
+}
+
+
+fn start_notifier(rx: Receiver<NotifierMessage>, mut sender: WebClientSender<WebSocketStream>) {
+    let mut last_state: Option<State> = None;
+    let mut rng = rand::thread_rng();
+    loop {
+        let event = rx.recv().unwrap();
+        match event {
+            NotifierMessage::WebMessage(message) => {
+                match message.opcode {
+                    WebMessageType::Close => {
+                        break;
+                    },
+                    WebMessageType::Ping => {
+                        let message = WebMessage::pong(message.payload);
+                        sender.send_message(&message).unwrap();
+                    },
+                    _ => {
+                        let payload = String::from_utf8_lossy(message.payload.as_ref());
+                        //println!("\n\n{}{}{}{}{}", clear::All, cursor::Goto(1, 1), color::Fg(color::White), payload, color::Fg(color::Reset));
+                        let mut state: State = xml::from_str(&payload).unwrap_or(last_state.clone().unwrap_or(State::blank()));
+
+                        last_state = state.apply(last_state, &mut rng).unwrap();
+                        let message = WebMessage::text(generate(Some(state)));
+                        sender.send_message(&message).unwrap();
+
+                        thread::sleep(Duration::from_millis(HEARTBEAT));
+                        flush(&rx);
+                    }
+                }
+            },
+            NotifierMessage::FsEvent(_event) => {
+                //let message = WebMessage::text("submit");
+                //sender.send_message(&message).unwrap();
+            }
+        }
+    }
+}
+
+fn start_updater(tx: Sender<NotifierMessage>) {
+    loop {
+        thread::sleep(Duration::from_secs(300));
+        let repo = Repository::open_from_env().unwrap_or(Repository::init(".").unwrap());
+        if let Ok(mut origin) = repo.find_remote("origin") {
+            println!("Updating from remote...");
+            origin.fetch(&["master"], None, None);
+        };
+    }
+}
+
+fn flush<T>(channel: &Receiver<T>) {
+    let mut flushed: i32 = 0;
+    while channel.try_recv().is_ok() {
+        flushed += 1;
+    }
+    let plural = if flushed != 1 { 's' } else { ' ' };
+    println!("  {}Flushed {} event{}{}", color::Fg(color::Yellow), flushed, plural, color::Fg(color::Reset));
+}

data/src/state/mod.rs

@@ -0,0 +1,5 @@
+mod state;
+mod xml;
+
+pub use state::state::*;
+pub use state::xml::generate;

data/src/state/state.rs

@@ -0,0 +1,233 @@
+use std::path::Path;
+use git2::Repository;
+use git2::ObjectType;
+use git2::BranchType;
+use rand::Rng;
+use termion::color;
+use rand;
+
+use task::Task;
+
+use yaml_rust::yaml::Hash;
+use yaml_rust::{Yaml, YamlEmitter};
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct State {
+    pub task: String,
+    pub focus: String,
+    pub filter: Option<Filter>,
+    pub message: String,
+    pub include: Vec<String>,
+    pub property: Vec<Property>,
+    pub diff: Vec<String>,
+    pub save_update: Option<String>,
+    pub new_task: Option<String>,
+    pub dragged: Option<String>
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct Property {
+    pub name: String,
+    pub value: String
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct Filter {
+    pub name: String,
+    pub value: String
+}
+
+#[derive(Debug)]
+pub enum StateError {
+}
+
+impl State {
+
+    pub fn blank() -> State {
+        State {
+            task: String::from("master"),
+            focus: String::new(),
+            message: String::new(),
+            include: vec![],
+            diff: vec![],
+            property: vec![],
+            save_update: None,
+            new_task: None,
+            filter: None,
+            dragged: None
+        }
+    }
+
+    pub fn reset(&mut self) {
+        self.message = String::new();
+        self.property = vec![];
+        self.include = vec![];
+        self.save_update = None;
+        self.new_task = None;
+    }
+
+    pub fn reset_with_status(&mut self) {
+        self.message = String::new();
+        self.property = self.property.iter().filter_map(|p| {
+            match &*p.name {
+                "Status" => Some(p.clone()),
+                "Ordinal" => Some(p.clone()),
+                _ => None
+            }
+        }).collect();
+        self.include = vec![];
+        self.save_update = None;
+        self.new_task = None;
+    }
+
+    pub fn apply(&mut self, mut last_state: Option<State>, rng: &mut rand::ThreadRng) -> Result<Option<State>, StateError> {
+        let new_last_state = self.clone();
+        let repo = Repository::open_from_env().unwrap_or(Repository::init(".").unwrap());
+        if let Some(ref mut last) = last_state {
+            println!("{}{:?}{}", color::Fg(color::LightBlack), last, color::Fg(color::Reset));
+            println!("{:?}", self);
+            println!("▶ ");
+            println!("Applying to repo: {:?}", repo.path());
+            if self.task != last.task && last.new_task.is_none() {
+                println!("  {}Task changing{}  {} => {}", color::Fg(color::LightYellow), color::Fg(color::Reset), last.task, self.task);
+                if self.dragged.is_some() {
+                    println!("  {}Saving last state due to dragging{}", color::Fg(color::LightGreen), color::Fg(color::Reset));
+                    last.save_update(&repo, rng);
+                    self.reset_with_status();
+                } else {
+                    let switching_to_task = self.task.clone();
+                    self.task = last.task.clone();
+                    self.save_update(&repo, rng);
+                    self.task = switching_to_task;
+                    self.reset();
+                }
+            } else {
+                println!("  {}Updating task {}{}", color::Fg(color::LightGreen), self.task, color::Fg(color::Reset));
+                //self.apply_index(&repo);
+
+                if self.save_update.is_some() || self.new_task.is_some() {
+                    self.save_update(&repo, rng);
+                }
+            }
+        } else {
+            if self.save_update.is_some() || self.new_task.is_some() {
+                self.save_update(&repo, rng);
+            }
+        }
+        Ok(Some(new_last_state))
+    }
+
+    fn save_update(&mut self, repo: &Repository, rng: &mut rand::ThreadRng) {
+        let mut index = repo.index().unwrap();
+        index.read(false).unwrap();
+
+        let author = repo.signature().unwrap();
+        let tree_oid = index.write_tree().unwrap();
+        let tree = repo.find_tree(tree_oid).unwrap();
+
+        let branch = repo.find_branch(&self.task, BranchType::Local);
+        match branch {
+            Ok(branch) => {
+                let head = branch.into_reference();
+                let commit = head.peel(ObjectType::Commit).unwrap();
+                let mut yaml = String::new();
+                let task = Task::from_ref(&head);
+                self.convert_to_yaml(&mut yaml, &repo, Some(task));
+                if self.message.len() > 0 || yaml.len() > 0 {
+                    let message = format!("{}\n{}", self.message, yaml);
+                    repo.commit(Some(&head.name().unwrap()), &author, &author, &message, &tree, &[&commit.as_commit().unwrap()]).unwrap();
+                }
+            }
+            Err(_) => {
+                println!("  {}Initial Commit{}", color::Fg(color::LightBlue), color::Fg(color::Reset));
+                let mut yaml = String::new();
+                self.convert_to_yaml(&mut yaml, &repo, None);
+                let message = format!("{}\n{}", self.message, yaml);
+                repo.commit(None, &author, &author, &message, &tree, &[]).unwrap();
+            }
+        };
+
+        println!("  {}Saved changes to {}{} {:?}", color::Fg(color::LightYellow), self.task, color::Fg(color::Reset), self);
+        if self.new_task.is_some() {
+            let num = rng.gen::<u16>();
+            let new_task = format!("{:X}", num);
+            println!("  {}Creating task {}{}", color::Fg(color::LightBlue), new_task, color::Fg(color::Reset));
+            if let Ok(master_branch) = repo.find_branch("master", BranchType::Local) {
+                let master = master_branch.into_reference();
+                let commit_obj = master.peel(ObjectType::Commit).unwrap();
+                let commit = commit_obj.as_commit().unwrap();
+                repo.branch(&new_task, &commit, false).unwrap();
+                self.task = new_task;
+                self.reset();
+                self.filter = Some(Filter {
+                    name: String::from("Status"), value: String::from("Sprint")
+                });
+                println!("  State reset: {:?}", self);
+            } else {
+                panic!("Unable to find master branch from which to fork!");
+            }
+        }
+    }
+
+    // Constructing the properties YAML from State
+    fn convert_to_yaml(&self, mut yaml: &mut String, repo: &Repository, task: Option<Task>) {
+        println!("  Converting State to YAML");
+        let mut tasks = Hash::new();
+        let mut properties = Hash::new();
+        let mut emitter = YamlEmitter::new(&mut yaml);
+        for property in self.property.clone() {
+            let name = Yaml::String(property.name);
+            let new_value = match &*property.value {
+                "" => Yaml::Null,
+                _ => Yaml::String(property.value)
+            };
+            if let Some(ref task) = task {
+                if let Some(old_value) = task.get(&repo, &name) {
+                    if old_value != new_value {
+                        properties.insert(name, new_value);
+                    }
+                } else {
+                    properties.insert(name, new_value);
+                }
+            } else {
+                properties.insert(name, new_value);
+            }
+        }
+        if !properties.is_empty() {
+            tasks.insert(Yaml::String(self.task.clone()), Yaml::Hash(properties));
+            emitter.dump(&Yaml::Hash(tasks)).unwrap();
+        }
+    }
+
+    fn apply_index(&self, repo: &Repository) {
+        let branch = repo.find_branch(&self.task, BranchType::Local);
+        let head = match branch {
+            Ok(branch) => branch.into_reference(),
+            _ => match repo.head() {
+                Ok(head) => head,
+                _ => return // cannot apply index without a reference
+            }
+        };
+        let commit = head.peel(ObjectType::Commit).unwrap();
+        let mut index = repo.index().unwrap();
+
+        // apply git index changes only if task is the working directory
+        if self.task == repo.head().unwrap().shorthand().unwrap() {
+            let to_remove = index.iter().fold(vec![], |mut acc, entry| {
+                let entry_path = String::from_utf8_lossy(entry.path.as_ref());
+                match self.include.iter().find(|i| i.as_ref() == entry_path) {
+                    None => acc.push(entry_path.into_owned()),
+                    _ => {}
+                };
+                acc
+            });
+            repo.reset_default(Some(&commit), to_remove.iter()).unwrap();
+            for change in &self.include {
+                let path = Path::new(&change);
+                index.add_path(path).unwrap();
+            }
+            index.write().unwrap();
+        }
+    }
+
+}