sinatra-liveviews 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3e4050bfda0d859257cca1ae07c88d4dd2a1667e
+  data.tar.gz: 16746a5b6f1358d2dad46aa81d1d0c9f75a97abb
+SHA512:
+  metadata.gz: 25a70fe0a0103fe46624f23df6a308d2c8b68244ebd4b0640cc8dff3c4bff4a3af123f7b8736852bf5da0ce541884132a281120df85fb1c0f64d87d3409c2b00
+  data.tar.gz: 58e6a8e2aa33e03d14b04a7c3b88c31af99c6d78552516af5c91d48cb5bdc1df4308283a9d4066f4bd927d14efeec55ccb568189d336dc55d481eba34ea105de

data/.gitignore

@@ -0,0 +1 @@
+liveviews.demo.db

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,17 @@
+PATH
+  remote: .
+  specs:
+    sinatra-liveviews (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.9)
+  rake (~> 10.0)
+  sinatra-liveviews!

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Nathan Reed
+
+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,22 @@
+# Sinatra::Liveviews
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sinatra-liveviews'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sinatra-liveviews
+
+## Usage
+
+
+

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+  t.pattern = "test/*_test.rb"
+end
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sinatra/liveviews"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/demo/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'sinatra'
+gem 'sinatra-contrib'
+gem 'sqlite3'
+gem 'sequel'
+gem "sinatra-liveviews", :path => "/Users/reednj/Documents/dev/sinatra-live-pages/gem/sinatra-liveviews"

data/demo/Gemfile.lock

@@ -0,0 +1,57 @@
+PATH
+  remote: /Users/reednj/Documents/dev/sinatra-live-pages/gem/sinatra-liveviews
+  specs:
+    sinatra-liveviews (0.1.0)
+      json
+      sinatra
+      sinatra-websocket
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.3.8)
+    backports (3.6.8)
+    daemons (1.2.3)
+    em-websocket (0.3.8)
+      addressable (>= 2.1.1)
+      eventmachine (>= 0.12.9)
+    eventmachine (1.0.8)
+    json (1.8.1)
+    multi_json (1.11.2)
+    rack (1.6.4)
+    rack-protection (1.5.3)
+      rack
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    sequel (4.32.0)
+    sinatra (1.4.6)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (>= 1.3, < 3)
+    sinatra-contrib (1.4.6)
+      backports (>= 2.0)
+      multi_json
+      rack-protection
+      rack-test
+      sinatra (~> 1.4.0)
+      tilt (>= 1.3, < 3)
+    sinatra-websocket (0.3.1)
+      em-websocket (~> 0.3.6)
+      eventmachine
+      thin (>= 1.3.1, < 2.0.0)
+    sqlite3 (1.3.11)
+    thin (1.6.4)
+      daemons (~> 1.0, >= 1.0.9)
+      eventmachine (~> 1.0, >= 1.0.4)
+      rack (~> 1.0)
+    tilt (1.4.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  sequel
+  sinatra
+  sinatra-contrib
+  sinatra-liveviews!
+  sqlite3

data/demo/app.rb

@@ -0,0 +1,36 @@
+
+require 'sinatra'
+
+if development?
+	require 'bundler'
+	require 'sinatra/reloader'
+	Bundler.require
+end
+
+require 'sinatra/liveviews'
+require './lib/model'
+
+configure :development do
+	also_reload './lib/model.rb'
+end
+
+get '/' do
+	redirect to('/admin/stats')
+end
+
+get '/admin/stats' do
+	erb :home
+end
+
+live '/admin/stats' do |document|
+
+	document.on_load do
+		document.element('#js-count').text = 'ready'
+	end
+
+	UserScore.where(:user_id => 1).on_count_change do |scores|
+		document.element('#js-count').text = "#{scores.count} records"
+		document.element('#js-sum').text = "total: #{scores.sum(:score).round}"
+		document.element('#js-avg').text = "avg: #{scores.avg(:score).round(2)}"
+	end
+end

data/demo/config.ru

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require
+
+require './app'
+run Sinatra::Application

data/demo/lib/model.rb

@@ -0,0 +1,14 @@
+require 'sequel'
+require 'sqlite3'
+
+DB = Sequel.sqlite './liveviews.demo.db'
+
+DB.create_table? :user_scores do
+	primary_key :id
+	Integer :user_id, :null => false
+	Float :score
+end
+
+class UserScore < Sequel::Model
+
+end

data/demo/test-inserts.rb

@@ -0,0 +1,23 @@
+require './lib/model'
+
+class App
+	def main
+		@score_offset = rand() * 50
+
+		loop do
+			s = insert_random
+			puts s.score.round(2)
+			sleep 0.34
+		end
+	end
+
+	def insert_random
+		s = UserScore.new
+		s.user_id = (rand() * 10).to_i
+		s.score = rand() * (100 - @score_offset ) + @score_offset
+		s.save_changes
+		return s
+	end
+end
+
+App.new.main

data/demo/views/home.erb

@@ -0,0 +1,21 @@
+<!doctype html>
+<html>
+<head>
+	<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+	<meta name='viewport' content='width=device-width' />
+
+	<script type='text/javascript' src='https://code.jquery.com/jquery-2.2.2.min.js'></script>
+	<script type='text/javascript' src='/sinatra/liveviews.js'></script>
+
+</head>
+
+<body>
+
+	<div style='font-family: arial; margin: 16px;'>
+		<h1 id='js-count'>...</h1>
+		<h1 id='js-sum'>...</h1>
+		<h1 id='js-avg'>...</h1>
+	</div>
+
+</body>
+</html>

data/lib/sequel/sequel-extensions.rb

@@ -0,0 +1,27 @@
+# we don't actually want this to be dependent on sequel, so only add
+# the extensions if its already been included in the app
+if defined? Sequel
+
+	class Sequel::Dataset
+		def on_count_change
+			Thread.new do
+				loop do 
+					await_count_change
+					yield(self)
+				end
+			end
+		end
+
+		def await_count_change
+			polling_interval = 1.5
+			current_count = self.count
+
+			loop do
+				break if self.count != current_count
+				sleep polling_interval
+			end
+			
+		end
+	end
+
+end

data/lib/sinatra/js/extensions.js

@@ -0,0 +1,70 @@
+// Basic javascript Class object. No inheritance or anything like that
+// but allows the nice encapsulation of properties and methods.
+//
+// Takes as its only argument an object with a set of methods for the 
+// class. If there is a method called initialize, it will be used as the
+// constructor.
+//
+// Usage:
+//
+// var Logger = new Class({
+//   initialize: function(name) {
+//     this.name = name;
+//     console.log('init: ' + this.name);
+//   },
+//   
+//   log: function(txt) {
+//     console.log('log ' + this.name + ': ' + txt);
+//   }
+// });
+//
+var Class = function (obj) {
+    obj = obj || {};
+
+    var $Class = function () {
+        var emptyFn = (function () { });
+        (obj.initialize || emptyFn).apply(this, arguments);
+    };
+
+    for (k in obj) {
+        if (obj.hasOwnProperty(k)) {
+            var fn = obj[k];
+            if (typeof fn == 'function') {
+                $Class.prototype[k] = fn;
+            }
+        }
+    };
+
+    return $Class;
+};
+
+(function () {
+	
+
+	var implement = function(name, fn) {
+		if(!this.prototype[name])
+			this.prototype[name] = fn;
+
+		return this;
+	};
+
+	if(!Function.prototype.implement) {
+		Function.prototype.implement = implement;
+	}
+
+	if(!Element.prototype.implement) {
+		Element.implement = implement;
+		Element.prototype.implement = implement;
+	}
+
+})();
+
+(function() {
+	Function.implement('delay', function(time_ms, scope) {
+		return setTimeout(this.bind(scope), time_ms);
+	});
+
+	Function.implement('periodical', function(time_ms, scope) {
+		return setInterval(this.bind(scope), time_ms);
+	});
+})();

data/lib/sinatra/js/live-pages.js

@@ -0,0 +1,22 @@
+var LivePageHandler = new Class({
+	initialize: function() {
+		var referrer_url = encodeURIComponent(document.location.href);
+		var socket_url = JSONSocket.websocketUrlForPath('/sinatra/liveviews/ws');
+
+		this.websocket = new JSONSocket({
+			url: socket_url + '?url=' + referrer_url,
+			on_exec: function(data) {
+				$(data.selector)[data.method](data.content);
+			},
+
+			on_message: function(data) {
+				console.log('live pages: ' + data.content);
+			}
+
+		});
+	}
+});
+
+$(document).ready(function() {
+	window._live_page_handler = new LivePageHandler();
+});

data/lib/sinatra/js/socket.js

@@ -0,0 +1,135 @@
+
+if(typeof WebSocket === 'undefined') {
+	// if websockets are not supported, then we just create
+	// a dummy one that does nothing, but gives no errors	
+	WebSocket = new Class({
+		initialize: function() {},
+		send: function() {}
+	});
+}
+
+
+var JSONSocket = new Class({
+	initialize: function(options) {
+		this.options = options || {};
+		this.options.url = this.options.url || null;
+		this.options.onOpen = this.options.onOpen || function() {};
+		this.options.onClose = this.options.onClose || function() {};
+
+		this.options.autoreconnect = this.options.autoreconnect === false ? false : true;
+		this.options.autoconnect = this.options.autoconnect === false ? false : true;
+		this.options.connectWait = 1;
+
+		this._stats = {in: 0, out: 0};
+
+		if(this.options.autoconnect) {
+			this.initSocket();
+		}
+	},
+
+	initSocket: function() {
+		this.ws = new WebSocket(this.options.url);
+		this.ws.onopen = this.onOpen.bind(this);
+		this.ws.onclose = this.onClose.bind(this);
+		this.ws.onmessage = function(e) {
+			this.onMessage(JSON.parse(e.data));
+		}.bind(this);
+	},
+	
+	onOpen: function() {
+		this.options.connectWait = 1;
+		this.options.onOpen(this, this.ws);
+	},
+	
+	onClose: function() {
+		this.options.onClose(this, this.ws);
+
+		if(this.options.autoreconnect === true) {
+			this.open.delay(this.options.connectWait * 1000, this);
+			this.options.connectWait *= 2;
+			
+			if(this.options.connectWait > 30) {
+				this.options.connectWait = 30;
+			}
+
+		}
+	},
+	
+	onMessage: function(msg) {
+		if(msg.event && typeof msg.event == 'string') {
+			this._stats.in++;
+			(this.eventNameToFunction(msg.event))(msg.data);
+		}
+	},
+	
+	send: function(eventType, data) {
+		if(this.isConnected()) {
+			var str = JSON.encode({event: eventType, data: data});
+			this.ws.send(str);
+			this._stats.out++;
+		}
+	},
+
+	addEvents: function(events) {
+		Object.each(events, function(fn, eventType) {
+			this.addEvent(eventType, fn);
+		}.bind(this));
+
+		return this;
+	},
+
+	addEvent: function(eventType, fn) {
+		
+		if(eventType && typeof fn == 'function') {
+			var fnName = 'on_' + eventType;
+			
+			if(!this.options[fnName]) {
+				this.options[fnName] = fn;
+			} else if(typeof this.options[fnName] == 'function') {
+				var currentFn = this.options[fnName];
+				this.options[fnName] = function() {
+					currentFn.apply(this, arguments);
+					fn.apply(this, arguments);
+				};
+			}
+		}
+
+		return this;
+	},
+
+	eventNameToFunction: function(eventType) {
+		if(eventType) {
+			var fnName = 'on_' + eventType;
+			return this.options[fnName] || (function() {});
+		}
+	},
+
+	isConnected: function() {
+		WebSocket.OPEN = WebSocket.OPEN || 1; // turns out not all browsers define the state consts
+		return this.ws && this.ws.readyState === WebSocket.OPEN;
+	},
+
+	close: function() {
+		this.options.autoreconnect = false;
+		this.ws.close();
+	},
+
+	open: function() {
+		this.initSocket();
+	},
+
+	stats: function() {
+		return this._stats;
+	}
+});
+
+JSONSocket.websocketUrlForPath = function(path) {
+	var protocol = 'ws://';
+
+	if(document.location.protocol.indexOf('https') != -1) {
+		protocol = 'wss://';
+	}
+	
+	return protocol + document.location.hostname + ':' + (document.location.port || '80') + (path || '/');;
+};
+

data/lib/sinatra/liveviews.rb

@@ -0,0 +1,47 @@
+require 'sinatra/base'
+require 'sinatra/liveviews/version'
+
+require_relative './liveviews/page-websocket'
+require_relative '../sequel/sequel-extensions'
+
+module LivePages
+	def live(url, options = {}, &block)
+		method_name = _method_name 'LIVE', url
+		_register_callback method_name, &block
+	end
+
+	def _method_name(verb, url)
+		"#{verb} #{url}".to_sym
+	end
+
+	def _register_callback(method_name, &block)
+		self.send :define_method, method_name, &block
+	end
+
+	def self.registered(app)
+		app.get '/sinatra/liveviews/ws' do
+			return 'websockets only' if !request.websocket?
+
+			request.websocket do |ws|
+				PageWebSocket.new ws, { 
+					:app => self,
+					:url => params[:url] || request.referrer
+				}
+			end
+		end
+
+		app.get '/sinatra/liveviews.js' do
+			folder = File.join File.dirname(__FILE__), './js/'
+			js = ['extensions.js', 'socket.js', 'live-pages.js'].map do |file|
+				path = File.join folder, file
+				File.read path
+			end
+
+			return 200, {'Content-type' => 'text/javascript'}, js.join("\n")
+		end
+	end
+end
+
+module Sinatra
+	register LivePages
+end

data/lib/sinatra/liveviews/json-websocket.rb

@@ -0,0 +1,109 @@
+# A wrapper around the great sinatra-websocket gem (https://github.com/simulacre/sinatra-websocket) that
+# allows for event based websockets
+#
+# Each message to the client should be a json object in the form {'event': string, 'data': obj }
+# When received by the server the appropriate method for that event is called, if it exists. For
+# example, the event 'setCell' would try to call the method on_set_cell with object contained
+# in 'data'. You should subclass WebSocketHelper in order to implement these methods
+#
+# Nathan Reed (@reednj) 2013-08-21
+
+require 'json'
+require 'sinatra-websocket'
+
+class WebSocketHelper
+	attr_accessor :latency
+
+	def initialize(ws)
+		self.latency = nil
+		# the sockets list is the list of all other WebSocketHelper classes
+		# for all other connections. This makes it easy to send a message to 
+		# all connected clients
+		@sockets = SharedList.list
+		@ws = ws
+
+		@ws.onopen { self.on_open }
+		@ws.onclose { self.on_close }
+		@ws.onmessage { |msg|
+			d = JSON.parse(msg, {:symbolize_names => true})
+			if d != nil && d[:event] != nil
+				Thread.new { self.on_message(d[:event], d[:data]) }
+			end
+		 }
+	end
+
+	def on_open
+		@sockets.push self
+	end
+
+	def on_message(event, data)
+		event_method = 'on_' + event.underscore
+		
+		begin
+			simulate_latency if !self.latency.nil?
+			method(event_method).call(data) if self.respond_to? event_method
+		rescue => e
+			# if the subclass has defined an error handler, then use that if something has
+			# happened, otherwise we just rethrow it
+			if self.respond_to? 'handle_error'
+				handle_error(e, event_method, data)
+			else
+				raise
+			end
+		end
+	end
+	
+	def on_close
+		@sockets.delete(self)
+	end
+
+	# send a message in to the current client
+	def send(event, data = {})
+		@ws.send({:event => event, :data => data}.to_json)
+	end
+	
+	# sends a message to all connected clients, including the current client
+	def send_all(event, data)
+		EM.next_tick {
+			@sockets.each do |s|
+				s.send(event, data) 
+			end
+		}
+	end
+
+	# sends a message to all connected clients, *except* the current one
+	def send_others(event, data)
+		EM.next_tick {
+			@sockets.each do |s|
+				s.send(event, data) if s != self
+			end
+		}
+	end
+
+	def simulate_latency
+		return if self.latency.nil?
+		factor = ((rand() * 0.2 - 0.1) + 1) # 0.9 to 1.1
+		delay = self.latency * factor
+		sleep delay
+	end
+
+	#def handle_error(e, path)
+end
+
+class String
+	def underscore
+		self.gsub(/::/, '/').
+		gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+		gsub(/([a-z\d])([A-Z])/,'\1_\2').
+		tr("-", "_").
+		downcase
+	end
+end
+
+class SharedList
+	@@data = nil
+	def self.list
+		@@data = [] if @@data == nil
+		return @@data
+	end
+end

data/lib/sinatra/liveviews/page-websocket.rb

@@ -0,0 +1,91 @@
+require_relative './json-websocket'
+
+class PageWebSocket < WebSocketHelper
+
+	def initialize(ws, options = {})
+		super(ws)
+
+		# todo: validate the url and the app instances
+		@app = options[:app]
+		@url = options[:url]
+	end
+
+	def on_open
+		super
+
+		uri = URI.parse(@url)
+		path = uri.path
+		method_name = @app.class._method_name('LIVE', path)
+
+		if @app.respond_to? method_name
+			@app.send(method_name, document)
+		else
+			# send an error back to the client
+			self.send 'message', { :content => "no live handler for #{path}" }
+		end
+
+	end
+
+	def on_close
+		super
+	end
+
+	def document
+		if @document.nil?
+			@document = ClientDocument.new(self)
+			@document.location = @url
+		end
+
+		return @document
+	end
+	
+end
+
+class ClientDocument
+	attr_accessor :location
+
+	def initialize(client)
+		raise 'client must be a WebSocketHelper' unless client.is_a? WebSocketHelper
+		@client = client
+	end
+
+	def element(selector)
+		ClientElement.new(selector, @client)
+	end
+
+	def on_load
+		# maybe later we can do something else with this, but for now
+		# just call the load method straight away
+		yield()
+	end
+end
+
+class ClientElement
+	attr_accessor :selector
+	
+	def initialize(selector, client)
+		raise 'client must be a WebSocketHelper' unless client.is_a? WebSocketHelper
+
+		@client = client
+		self.selector = selector.to_s
+	end
+
+	def execute(method, content)
+		@client.send('exec', {
+			:selector => self.selector,
+			:method => method,
+			:content => content.to_s
+		})
+	end
+
+	def text=(s)
+		self.execute 'text', s
+	end
+
+	def html=(s)
+		self.execute 'html', s
+	end
+
+end
+
+

data/lib/sinatra/liveviews/version.rb

@@ -0,0 +1,5 @@
+module Sinatra
+  module Liveviews
+    VERSION = "0.5.0"
+  end
+end

data/sinatra-liveviews.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sinatra/liveviews/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sinatra-liveviews"
+  spec.version       = Sinatra::Liveviews::VERSION
+  spec.authors       = ["Nathan Reed"]
+  spec.email         = ["reednj@gmail.com"]
+
+  spec.summary       = %q{ create dashboards in sinatra that instantly update when the database changes }
+  spec.homepage      = "https://github.com/reednj/sinatra-liveviews"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_runtime_dependency "json"
+  spec.add_runtime_dependency "sinatra"
+  spec.add_runtime_dependency "sinatra-websocket"
+
+end

data/test/liveviews_test.rb

@@ -0,0 +1,19 @@
+ENV['RACK_ENV'] = 'development'
+
+require 'rubygems'
+require 'minitest/autorun'
+require 'rack/test'
+require 'test/unit'
+
+require_relative './app'
+
+class LiveViewsTest < Test::Unit::TestCase
+	include Rack::Test::Methods
+
+	def app
+		Sinatra::Application
+	end
+
+
+end
+

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: sinatra-liveviews
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Nathan Reed
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra-websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- reednj@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- demo/Gemfile
+- demo/Gemfile.lock
+- demo/app.rb
+- demo/config.ru
+- demo/lib/model.rb
+- demo/test-inserts.rb
+- demo/views/home.erb
+- lib/sequel/sequel-extensions.rb
+- lib/sinatra/js/extensions.js
+- lib/sinatra/js/live-pages.js
+- lib/sinatra/js/socket.js
+- lib/sinatra/liveviews.rb
+- lib/sinatra/liveviews/json-websocket.rb
+- lib/sinatra/liveviews/page-websocket.rb
+- lib/sinatra/liveviews/version.rb
+- sinatra-liveviews.gemspec
+- test/liveviews_test.rb
+homepage: https://github.com/reednj/sinatra-liveviews
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: create dashboards in sinatra that instantly update when the database changes
+test_files:
+- test/liveviews_test.rb