beaglebone_usb 0.0.2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in beaglebone.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 cubuslab
+
+MIT License
+
+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,45 @@
+# beaglebone_usb-gem
+==============
+
+Detect your BeagleBone on a local USB port in your Rails web application
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'beaglebone_usb'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install beaglebone_usb
+
+Add to your application.js
+
+	//= require events
+	//= require beaglebone_usb
+
+## Usage
+
+	var bb_usb = new beaglebone_usb.USBConnection();
+
+    bb_usb.on("connect", function() {
+    	console.log ("beaglebone connected");
+    });
+
+    bb_usb.on("disconnect", function() {
+    	console.log ("beaglebone disconnected");
+    });
+
+    bb_usb.discover();
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/beaglebone_usb.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'beaglebone_usb/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "beaglebone_usb"
+  spec.version       = BeagleboneUsb::VERSION
+  spec.authors       = ["cubuslab"]
+  spec.email         = ["luetjohann@cubuslab.com"]
+  spec.description   = "encapsulates beaglebone communication via USB"
+  spec.summary       = "detect a beaglebone which is connected to your local USB port and execute remote commands"
+  spec.homepage      = ""
+  spec.license       = ""
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/beaglebone_usb.rb

@@ -0,0 +1,8 @@
+require "beaglebone_usb/version"
+
+module BeagleboneUsb
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/beaglebone_usb/version.rb

@@ -0,0 +1,3 @@
+module BeagleboneUsb
+  VERSION = "0.0.2"
+end

data/vendor/assets/javascripts/beaglebone_usb.js

@@ -0,0 +1,372 @@
+function require(file) {
+    throw 'Please perform setTargetAddress on a valid target';
+}
+
+function setTargetAddress(address, handlers) {
+    var url = address;
+    url = url.replace(/^(http:\/\/|https:\/\/)*/, 'http://');
+    url = url.replace(/(\/)*$/, '/bonescript.js');
+    loadScript(url, addHandlers);
+    function loadScript(url, onload) {
+        var head = document.getElementsByTagName('head')[0];
+        var script = document.createElement('script');
+        script.type = 'text/javascript';
+        script.src = url;
+        script.charset = 'UTF-8';
+        var scriptObj = head.appendChild(script);
+        scriptObj.onload = onload;
+    }
+    function addHandlers() {
+        if(typeof handlers == 'function') {
+            handlers();
+            return;
+        }
+        if(typeof _bonescript != 'undefined') {
+            _bonescript.address = address;
+            if(handlers.initialized) _bonescript.on.initialized = handlers.initialized;
+            if(handlers.connect) _bonescript.on.connect = handlers.connect;
+            if(handlers.connecting) _bonescript.on.connecting = handlers.connecting;
+            if(handlers.disconnect) _bonescript.on.disconnect = handlers.disconnect;
+            if(handlers.connect_failed) _bonescript.on.connect_failed = handlers.connect_failed;
+            if(handlers.reconnect_failed) _bonescript.on.reconnect_failed = handlers.reconnect_failed;
+            if(handlers.reconnect) _bonescript.on.reconnect = handlers.reconnect;
+            if(handlers.reconnecting) _bonescript.on.reconnecting = handlers.reconnecting;
+        }
+        if(typeof handlers.callback == 'function') handlers.callback();
+    }
+}
+
+
+
+(function (exports) {
+
+
+    // functions for USB discovery and communication
+
+    exports.USBConnection = function USBConnection(opts) {
+
+
+    };
+
+    exports.USBConnection.prototype = new EventEmitter;
+
+    exports.USBConnection.prototype.discover = function() {
+
+        var is;
+
+        var connectState = 'init';
+
+        var i = 0;
+        var serversToTry = [
+            '192.168.7.2',
+            'beaglebone.local',
+            'beaglebone-2.local'
+        ];  
+
+        function testForConnection() {
+
+            console.log ("BeagleBone: test for connection...");
+            var handlers = {};
+            handlers.callback = callback;
+            handlers.initialized = initialized;
+            handlers.connecting = disconnected;
+            handlers.connect_failed = connect_failed;
+            handlers.reconnect_failed = disconnected;
+            handlers.disconnect = disconnected;
+            handlers.connect = connected;
+            handlers.reconnect = connected;
+            handlers.reconnecting = connected;
+
+            $('#connect-ip').keypress(oninput);
+            
+            setTargetAddress(serversToTry[i], handlers);
+            i++;
+            if(i >= serversToTry.length) i = 0;
+
+            function oninput(e) {
+                if(e.which == 10 || e.which == 13) {
+                    var givenAddress = $('#connect-ip').val();
+                    setTargetAddress(givenAddress, handlers);
+                    serversToTry = [ givenAddress ];
+                }
+            }
+
+            function callback() {
+                if(typeof _bonescript == 'undefined') {
+                    setTimeout(testForConnection, 1000);
+                }
+            }
+            function connected() {
+                if(connectState == 'disconnected') {
+                    
+                    connectState = 'reconnecting';
+
+                    console.log ("BeagleBone: connected");
+                }
+            }
+            function initialized() {
+
+                if (typeof onbonescriptinit == 'function') onbonescriptinit();
+
+                connectState = 'connected';
+
+                console.log ("BeagleBone: initialized");
+
+                exports.USBConnection.prototype.emit("connect");
+
+            }
+            function disconnected() {
+                if(connectState == 'connected') {
+                    
+                    connectState = 'disconnected';
+
+                    console.log ("BeagleBone: disconnected");
+
+                    exports.USBConnection.prototype.emit("disconnect");
+
+                }
+            }
+            function connect_failed() {
+                if(connectState == 'init') {
+                    _onSocketIOLoaded_workaround();
+                } else {
+                    disconnected();
+                }
+
+            }
+
+            if(typeof _bonescript == 'undefined') {
+                    setTimeout(testForConnection, 5000);
+            }
+        }
+
+        testForConnection();
+
+    }
+
+
+    function _onSocketIOLoaded_workaround() {
+        //console.log("socket.io loaded");
+        var socket_addr = 'http://' + _bonescript.address + ':80';
+        var socket = io.connect(socket_addr);
+        socket.on('require', getRequireData);
+        socket.on('bonescript', _seqcall);
+        socket.on('connect', _bonescript.on.connect);
+        socket.on('connecting', _bonescript.on.connecting);
+        socket.on('disconnect', _bonescript.on.disconnect);
+        socket.on('connect_failed', _bonescript.on.connect_failed);
+        socket.on('error', _bonescript.on.error);
+        socket.on('reconnect', _bonescript.on.reconnect);
+        socket.on('reconnect_failed', _bonescript.on.reconnect_failed);
+        socket.on('reconnecting', _bonescript.on.reconnecting);
+        socket.on('initialized', _bonescript.on.initialized);
+
+        function getRequireData(m) {
+            if(!m.module || !m.data)
+                throw('Invalid "require" message sent for "' + m.module + '"');
+            //console.log('Initialized module: ' + m.module);
+            _bonescript.modules[m.module] = {};
+            for(var x in m.data) {
+                if(!m.data[x].type || !m.data[x].name || (typeof m.data[x].value == 'undefined'))
+                    throw('Invalid data in "require" message sent for "' + m.module + '.' + m.data[x] + '"');
+                if(m.data[x].type == 'function') {
+                    // define the function
+                    if(!m.data[x].value)
+                        throw('Missing args in "require" message sent for "' + m.module + '.' + m.data[x] + '"');
+                    var myargs = m.data[x].value;
+
+                    // eval of objString builds the call data out of arguments passed in
+                    var objString = '';
+                    for(var y in myargs) {
+                        if(isNaN(y)) continue;  // Need to find the source of this bug
+                        if(myargs[y] == 'callback') continue;
+                        objString += ' if(typeof ' + myargs[y] + ' == "function") {\n';
+                        objString += '  ' + myargs[y] + ' = ' + myargs[y] + '.toString();\n';
+                        objString += ' }\n';
+                        objString += ' calldata.' + myargs[y] + ' = ' + myargs[y] + ';\n';
+                    }
+                    var argsString = myargs.join(', ');
+                    var handyfunc = '_bonescript.modules["' + m.module + '"].' + m.data[x].name +
+                        ' = ' +
+                        'function (' + argsString + ') {\n' +
+                        ' var calldata = {};\n' +
+                        objString +
+                        ' if(callback) {\n' +
+                        '  _bonescript._callbacks[_bonescript._seqnum] = callback;\n' +
+                        '  calldata.seq = _bonescript._seqnum;\n' +
+                        '  _bonescript._seqnum++;\n' +
+                        ' }\n' +
+                        ' socket.emit("' + m.module + '$' + m.data[x].name + '", calldata);\n' +
+                        '};\n';
+                    eval(handyfunc);
+                } else {
+                    _bonescript.modules[m.module][m.data[x].name] = m.data[x].value;
+                }
+            }
+
+        // Work-around to add shell command
+        _bonescript.modules[m.module]["shell"] = function(command) {
+            socket.emit('shell', command);
+        }
+            
+        // Call-back initialized function
+        _bonescript.on.initialized();
+        }
+    }
+
+    exports.getboardinfo = function(callback) {
+
+
+        var b = require('bonescript');
+
+        b.setDate(Date().toString());
+
+        b.getPlatform(callback);
+
+    }
+
+
+    // functions for remote procedure calls
+
+
+    exports.Remote = function Remote(opts) {
+
+
+    };
+
+    exports.Remote.prototype = new EventEmitter;
+
+    
+    exports.Remote.prototype.fileExists = function (filename, callback_yes, callback_no) {
+
+      var b = require('bonescript');
+      b.readTextFile(filename, function(x) {
+
+        if ((x.data != null) && (x.data.length != 0)) {
+          callback_yes(x.data);
+        } else {
+          callback_no();
+        }
+
+      });
+
+    }
+
+
+    exports.Remote.prototype.removeFile = function (filename, callback_success) {
+
+      var b = require('bonescript');
+      b.writeTextFile(filename, "", callback_success);
+
+    }
+
+
+
+    exports.Remote.prototype.ScriptRemoveStatus = function (callback) {
+
+      removeFile('/var/lib/cloud9/autorun/writestatus.js', function() {
+
+        removeFile('/var/lib/cloud9/status.txt', callback);
+
+      });
+
+    }
+
+    function makeid()
+    {
+        var text = "";
+        var possible = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+
+        for( var i=0; i < 5; i++ )
+            text += possible.charAt(Math.floor(Math.random() * possible.length));
+
+        return text;
+    };
+
+    exports.Remote.prototype.execute = function(command, callback, callbackfailed, timeoutparam) {
+
+      var b = require('bonescript');
+
+      var thread_name = makeid();
+
+      var interval;
+
+      var i = 0;
+
+      var timeout = typeof timeoutparam !== 'undefined' ? timeoutparam : 5000;
+
+      var thread_fn = "/var/lib/cloud9/autorun/"+thread_name+".js";
+      var thread_out = "/var/lib/cloud9/"+thread_name+"_out.txt";
+
+      exports.Remote.prototype.removeFile(thread_out, function() {
+
+        b.writeTextFile(thread_fn, "var ownfilename = '"+thread_fn+"'; var outfilename = '"+thread_out+"';\nvar exec = require ('child_process').exec; exec ('"+command+"', function(error, stdout, stderr) {  var b = require('bonescript'); b.writeTextFile(outfilename, stdout, function() { exec ('rm '+ownfilename); setTimeout(function(){ exec ('rm '+outfilename) }, "+(timeout + 5000).toString()+") }); } ); ", function(x) {
+
+          interval = setInterval(function(){
+
+            exports.Remote.prototype.fileExists(thread_out, function(x) {
+
+              exports.Remote.prototype.removeFile(thread_out, function() {
+
+
+                clearInterval(interval);
+
+                i = 0;
+
+                callback(x);
+
+
+              });            
+
+
+            }, function(){
+
+              i = i + 500;
+
+              if (i >= timeout) {
+
+                clearInterval(interval);
+
+                callbackfailed();
+
+              }
+
+            })
+
+
+          }, 500);
+
+
+
+        });
+
+
+      });
+
+
+    };
+
+
+    exports.Remote.prototype.install = function(thread_name, command) {
+
+      var b = require('bonescript');
+
+      var interval;
+
+      var i = 0;
+
+      var timeout = typeof timeoutparam !== 'undefined' ? timeoutparam : 5000;
+
+      var thread_fn = "/var/lib/cloud9/autorun/"+thread_name+".js";
+
+      b.writeTextFile(thread_fn, "var ownfilename = '"+thread_fn+"'; ", function(x) {
+
+        // installed    
+
+      });
+
+
+    };
+
+
+})(typeof exports == 'undefined' ? this['beaglebone_usb'] = {} : exports);

data/vendor/assets/javascripts/events.js

@@ -0,0 +1,302 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+function EventEmitter() {
+  this._events = this._events || {};
+  this._maxListeners = this._maxListeners || undefined;
+}
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+EventEmitter.defaultMaxListeners = 10;
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function(n) {
+  if (!isNumber(n) || n < 0 || isNaN(n))
+    throw TypeError('n must be a positive number');
+  this._maxListeners = n;
+  return this;
+};
+
+EventEmitter.prototype.emit = function(type) {
+  var er, handler, len, args, i, listeners;
+
+  if (!this._events)
+    this._events = {};
+
+  // If there is no 'error' event listener then throw.
+  if (type === 'error') {
+    if (!this._events.error ||
+        (isObject(this._events.error) && !this._events.error.length)) {
+      er = arguments[1];
+      if (er instanceof Error) {
+        throw er; // Unhandled 'error' event
+      } else {
+        throw TypeError('Uncaught, unspecified "error" event.');
+      }
+      return false;
+    }
+  }
+
+  handler = this._events[type];
+
+  if (isUndefined(handler))
+    return false;
+
+  if (isFunction(handler)) {
+    switch (arguments.length) {
+      // fast cases
+      case 1:
+        handler.call(this);
+        break;
+      case 2:
+        handler.call(this, arguments[1]);
+        break;
+      case 3:
+        handler.call(this, arguments[1], arguments[2]);
+        break;
+      // slower
+      default:
+        len = arguments.length;
+        args = new Array(len - 1);
+        for (i = 1; i < len; i++)
+          args[i - 1] = arguments[i];
+        handler.apply(this, args);
+    }
+  } else if (isObject(handler)) {
+    len = arguments.length;
+    args = new Array(len - 1);
+    for (i = 1; i < len; i++)
+      args[i - 1] = arguments[i];
+
+    listeners = handler.slice();
+    len = listeners.length;
+    for (i = 0; i < len; i++)
+      listeners[i].apply(this, args);
+  }
+
+  return true;
+};
+
+EventEmitter.prototype.addListener = function(type, listener) {
+  var m;
+
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  if (!this._events)
+    this._events = {};
+
+  // To avoid recursion in the case that type === "newListener"! Before
+  // adding it to the listeners, first emit "newListener".
+  if (this._events.newListener)
+    this.emit('newListener', type,
+              isFunction(listener.listener) ?
+              listener.listener : listener);
+
+  if (!this._events[type])
+    // Optimize the case of one listener. Don't need the extra array object.
+    this._events[type] = listener;
+  else if (isObject(this._events[type]))
+    // If we've already got an array, just append.
+    this._events[type].push(listener);
+  else
+    // Adding the second element, need to change to array.
+    this._events[type] = [this._events[type], listener];
+
+  // Check for listener leak
+  if (isObject(this._events[type]) && !this._events[type].warned) {
+    var m;
+    if (!isUndefined(this._maxListeners)) {
+      m = this._maxListeners;
+    } else {
+      m = EventEmitter.defaultMaxListeners;
+    }
+
+    if (m && m > 0 && this._events[type].length > m) {
+      this._events[type].warned = true;
+      console.error('(node) warning: possible EventEmitter memory ' +
+                    'leak detected. %d listeners added. ' +
+                    'Use emitter.setMaxListeners() to increase limit.',
+                    this._events[type].length);
+      if (typeof console.trace === 'function') {
+        // not supported in IE 10
+        console.trace();
+      }
+    }
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.once = function(type, listener) {
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  var fired = false;
+
+  function g() {
+    this.removeListener(type, g);
+
+    if (!fired) {
+      fired = true;
+      listener.apply(this, arguments);
+    }
+  }
+
+  g.listener = listener;
+  this.on(type, g);
+
+  return this;
+};
+
+// emits a 'removeListener' event iff the listener was removed
+EventEmitter.prototype.removeListener = function(type, listener) {
+  var list, position, length, i;
+
+  if (!isFunction(listener))
+    throw TypeError('listener must be a function');
+
+  if (!this._events || !this._events[type])
+    return this;
+
+  list = this._events[type];
+  length = list.length;
+  position = -1;
+
+  if (list === listener ||
+      (isFunction(list.listener) && list.listener === listener)) {
+    delete this._events[type];
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
+
+  } else if (isObject(list)) {
+    for (i = length; i-- > 0;) {
+      if (list[i] === listener ||
+          (list[i].listener && list[i].listener === listener)) {
+        position = i;
+        break;
+      }
+    }
+
+    if (position < 0)
+      return this;
+
+    if (list.length === 1) {
+      list.length = 0;
+      delete this._events[type];
+    } else {
+      list.splice(position, 1);
+    }
+
+    if (this._events.removeListener)
+      this.emit('removeListener', type, listener);
+  }
+
+  return this;
+};
+
+EventEmitter.prototype.removeAllListeners = function(type) {
+  var key, listeners;
+
+  if (!this._events)
+    return this;
+
+  // not listening for removeListener, no need to emit
+  if (!this._events.removeListener) {
+    if (arguments.length === 0)
+      this._events = {};
+    else if (this._events[type])
+      delete this._events[type];
+    return this;
+  }
+
+  // emit removeListener for all listeners on all events
+  if (arguments.length === 0) {
+    for (key in this._events) {
+      if (key === 'removeListener') continue;
+      this.removeAllListeners(key);
+    }
+    this.removeAllListeners('removeListener');
+    this._events = {};
+    return this;
+  }
+
+  listeners = this._events[type];
+
+  if (isFunction(listeners)) {
+    this.removeListener(type, listeners);
+  } else {
+    // LIFO order
+    while (listeners.length)
+      this.removeListener(type, listeners[listeners.length - 1]);
+  }
+  delete this._events[type];
+
+  return this;
+};
+
+EventEmitter.prototype.listeners = function(type) {
+  var ret;
+  if (!this._events || !this._events[type])
+    ret = [];
+  else if (isFunction(this._events[type]))
+    ret = [this._events[type]];
+  else
+    ret = this._events[type].slice();
+  return ret;
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+  var ret;
+  if (!emitter._events || !emitter._events[type])
+    ret = 0;
+  else if (isFunction(emitter._events[type]))
+    ret = 1;
+  else
+    ret = emitter._events[type].length;
+  return ret;
+};
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+
+function isUndefined(arg) {
+  return arg === void 0;
+}

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: beaglebone_usb
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- cubuslab
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: encapsulates beaglebone communication via USB
+email:
+- luetjohann@cubuslab.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- beaglebone_usb.gemspec
+- lib/beaglebone_usb.rb
+- lib/beaglebone_usb/version.rb
+- vendor/assets/javascripts/beaglebone_usb.js
+- vendor/assets/javascripts/events.js
+homepage: ''
+licenses:
+- ''
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: detect a beaglebone which is connected to your local USB port and execute
+  remote commands
+test_files: []