statusboard 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1d8b58e432750151202b3c026d2dd4a4e631f37d
+  data.tar.gz: 511a95a6e5adcc91189b04d4173cd0c8245d8d60
+SHA512:
+  metadata.gz: 97aa5838ef052af60bdafa2197b0e92d36163fd33b4c5170d2dc238a895889d9a9e69bbf2b3ba4e78533dad0e4cb2395f11fbb3cc4178c2e4a9013237f739a8b
+  data.tar.gz: 2ca1585052559e091ef5fba019b3006eb17a0866ce24d8ca212645dade9f41075ab2dc7aae1b35b71a92f060edc16aaab0ec7bb6496eab51f409f046aaa60c8b

data/.gitignore

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

data/.ruby-version

@@ -0,0 +1 @@
+2.1.1

data/ARCHITECTURE.md

@@ -0,0 +1,14 @@
+## Architecture
+
+The gem differntiates between the application layer and the DSL.
+
+### The DSL
+The DSL is located in the `dsl` directory. All DSL-related classes normally end with `Description` (e.g. `GraphDescription`) and inherite from the class DSLBase.
+
+As the "Description" suffix already states, the DSL objects can be seen as a description of what the application layer should do - similar to a config file in a "normal" application, but in a dynamic fashion. The task of the DSL part is to take the user input (which is achieved by being a DSL), sanitizing it where required and passing it with a useful structure to the application layer.
+
+### The application layer
+The application layer uses the description it received by evaluating the DSL and uses the information to produce the desired output (in this case graph widgets).
+
+### Discussion
+It should be discussed if the separation expalined above is useful or not.

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Julian Schuh
+
+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,296 @@
+# Statusboard
+
+The statusboard gem provides a **simple, expressive DSL** which was purpose-built to feed your Panic-powered Status Board with data that matters to you. The DSL handles table, graph and DIY widgets in a way that renders messing around with raw data unnecessary.
+
+The included server module makes serving the data to the app a simple and straight-forward process that doesn't require you to write any server-related code. The Rack-compliance of the server module makes the integration with existing systems a breeze.
+
+[Visit the Panic website for more information about the Status Board app.](https://panic.com/statusboard/)
+
+## Getting Started
+
+### Installation
+Install the gem by either running `gem install statusboard` or by adding the line `gem "statusboard"` to your Gemfile and running the `bundle` command.
+
+### Your first Status Board data source:
+
+Create a file called statusboard.rb with the following contents:
+
+```ruby
+require "statusboard/main"
+
+widget "yequalsx", :graph do
+	title "My first graph"
+	type :line
+
+	data do
+		data_sequence do
+			title "f(x) = x"
+
+			(0..15).each do |n|
+				datapoint n, n
+			end
+		end
+	end
+end
+```
+
+and run `ruby statusboard.rb`. A webserver which serves the widget will automatically be started on port 8080. In your Status Board App, add a graph widget and set the URL to `your.ip:8080/widget/yequalsx`. A graph widget containing the plot of the mathematical function `f(x) = x` will be displayed.
+
+For further and more complex examples **take a look at the `examples` directory**.
+
+## DSL
+The statusboard gem features a simple and expressive DSL which is used to configure and feed the widgets with data. Supported statements of the DSL are explained in the following paragraphs.
+
+### widget
+The **widget** statement is used to define a new widget with a specified _name_ and _type_. The widgets name is used as the identifier of the widget and hence has to be unique. A block containing further DSL statements which describe the widget and its contents must be specified.
+
+```ruby
+widget name, type do
+	...
+end
+```
+
+Supported types are `:table`, `:diy` and `:graph`. The specified type directly translates to the corresponding class, e.g. `:table` will use the class `Statusboard::TableWidget`.
+
+Example:
+```ruby
+widget :sales, :graph do
+	...
+end
+```
+The above code will define a graph-widget with the name `sales`. The widget will be available at the URL `http://your.ip:8080/widget/sales/`.
+
+#### Advanced Features
+ - Custom widget types are supported: Create a subclass of `Statusboard::WidgetBase` in the `Statusboard` module with a name like `MycustomWidget` (replace `Mycustom`). Then use the corresponding identifier (e.g. `:mycustom`) with the widget statement.
+ - You can create a widget manually (by instanciating the widgets class) and pass the resulting object directly to the widget statement as the second parameter. In this case, the block must not be specified.
+
+```ruby
+my_diy = Statusboard::DiyWidget.new do
+	...
+end
+
+widget :mycustom1, my_diy
+```
+
+### Table widget
+A table widget provides one top-level statement: `data`, which accepts either a block or a proc. The specified block/proc should contain the code which is responsible to fetche the data which should be displayed. The block/proc will be executed every time the content of the widget is requested by the app.
+Within the block/proc, the DSL can be used to specify the data:
+
+The `row` statement creates a new row. A block must be specified in which the cells of the row are specified. The only statement that is accepted within `row` is the `cell` statement.
+
+The `cell` statement creates a cell within a row. A `cell` can have different properties (represented by the corresponding DSL statements) as listed below:
+
+| Statement 	| Description	|
+| ------------- | ------------- |
+| type 			| Type of the cell. (Sell table below for supported types)|
+| content 		| Main content of the cell. Depends on the cell type.|
+| width 		| Width of the cell. Can be specified in px or percent. |
+| colspan		| Colspan of the cell |
+| percentage 	| Percentage which should be displayed. Only used if cell type is `:percentage`|
+| imageurl		| URL of the image that should be displayed. Only used if cell type is `:image`|
+| noresize		| Indicates if the image should be resized or not. Only used if cell type is `:image`|
+
+The following cell types are supported:
+
+| Type 			| Description 	|
+| ------------- | ------------- |
+| `:text`		| Displays the text specified as `content` |
+| `:percentage`	| Displays a percentage indicator. Percentage must be specified using the `percentage` statement |
+| `:image`		| Displays an image. URL must be specified using the `imageurl` statement. |
+| `:cutsom`		| Enables the use of custom cell. The cell (including all necessary HTML markup) must be specified using the `content` statement. |
+
+Example:
+
+```ruby
+data_proc = Proc.new do
+	row do
+		cell do
+			type :text
+			content "First row with 20%"
+		end
+
+		cell do
+			type :percentage
+			percentage 20
+		end
+	end
+
+	row do
+		cell do
+			type :text
+			content "Second row with 80%"
+		end
+
+		cell do
+			type :percentage
+			percentage 80
+		end
+	end
+end
+
+widget :testtable, :table do
+	data data_proc
+end
+```
+
+### Graph Widget
+
+A graph widget provides seven top-level statements:
+
+| Statement		| Description 	|
+| ------------- | ------------- |
+| `data`		| A block or proc which handles fetching of the data. |
+| `x_axis`		| A block which can be used to configure the behavior of the X axis. |
+| `y_axis`		| A block which can be used to configure the behavior of the Y axis. |
+| `refresh_interval`	| Specifies how often the data should be refreshed by the app (in seconds). |
+| `title`		| Specified the title of the widget. |
+| `type`		| Specifies the type of the graph. Supported values: `:bar` and `:line` |
+| `display_totals`	| Specified wether or not the totals of all data sequences should be displayed. Can be called without parameter. |
+
+
+#### The `data` statement
+
+The `data` statement is used to feed the graph widget with data. It provides exactly one statement:
+`data_sequence`.
+The statement defines a new data sequence, which is a collection of data points that belong together. The data points of a sequence taken together yield to the corresponding line in the graph.The statement can be called multiple times if multiple data sequences should be specified.
+
+The `data_sequence` again takes a block which is used to configure the data sequence and to specify the data which should be displayed:
+
+| Statement		| Description 	|
+| ------------- | ------------- |
+| `title`		| Title describing the data sequence. E.g. "Sales per Day" |
+| `color`		| The color in which the line or bars should appear. |
+| `datapoint`	| Adds a data point to the current data sequence. The statement accespts *two* parameters: The **X** coordinate and the **Y** coordinate. The statement can be called multiple times in order to add multiple data points. Data points will displayed in the order they are added, _not_ sorted by the X coordinate. |
+
+#### The `x_axis` statement
+
+The following statement(s) are supported to configure the behavior of the **X** axis.
+
+| Statement		| Description 	|
+| ------------- | ------------- |
+| `show_every_label` | Forces every x datapoints to be displayed on the axis. Can be called without parameter. |
+
+#### The `y_axis` statement
+
+The following statement(s) are supported to configure the behavior of the **Y** axis.
+
+| Statement		| Description 	|
+| ------------- | ------------- |
+| `min_value` | Minimum value of the Y coordinate of every datapoint which should be displayed. |
+| `max_value` | Maximum value of the Y coordinate of every datapoint which should be displayed. |
+| `units_suffix` | Suffix which is appended to the Y axis labels. Can be used to add a unit to the raw data. |
+| `units_prefix` | Prefix which is prepended to the Y axis labels. Can be used to add a unit to the raw data. |
+| `scale_to` | Scales the Y coordinates by the specified value. |
+| `hide_labels` | Specified if no lebsl should be displayed at all for the Y axis. Can be called without parameter. |
+
+#### Example
+
+```ruby
+widget "yequalsx", :graph do
+	title "My first graph"
+	type :line
+
+	data do
+		data_sequence do
+			title "f(x) = x"
+
+			(0..15).each do |n|
+				datapoint n, n
+			end
+		end
+	end
+end
+```
+
+### DIY Widget
+
+The DIY widget allows to create completely custom-made, HTML-based widgets. As a further abstraction is not possible, the widgets offers only _one_ top-level statement: `content`. `content` awaits either a block, a proc or an arbitrary object which can be converted to a string.
+
+Example:
+
+```ruby
+widget "custom", :diy do
+	content do
+		%w[this is a test].join(" ")
+	end
+end
+```
+
+## Advanced Deployment
+
+The gem can be deployed in _three_ different ways:
+
+### **Standalone**
+In this scenario, the gem is used to create a standalone server application whose only purpose is to serve data to the Status Board app. As this is the prevalent case, the gem was designed to support this scenario without having to write any code other than the code that acts as the data source.
+
+If this scenario fits your needs best, just add the line
+
+```ruby
+require "statusboard/main"
+```
+
+to the top of your application file and define the widgets you want your Status Board to display using the DSL:
+
+```ruby
+widget "widget-name", :widget-type do
+	... use the DSL to describe the widget here
+end
+```
+
+Run the file and a server is started automatically.
+
+### As a module within an existing Rack-based app
+In this scenario, the gem is used within an existing, Rack-based server application. The included Rack module is mounted in the application (e.g. using the routes.rb file of a rails app).
+
+To create a server instance which can be used in a Rack-based environment, include the required files by adding the line
+
+```ruby
+require "statusboard"
+```
+to your application file.
+
+Afterwards create the server instance and use its constructors block to describe the widgets which should be served:
+
+```ruby
+app = Statusboard::StatusboardServer.new do
+	widget ... do
+    	...
+    end
+end
+```
+
+Use `app` as a parameter to the mount call to integrate the Status Board serving with your existing app.
+
+### Without a server
+The gem can be used to describe a widget and construct the Status Board compatible ouput without using any of its server components. This allows for an easy integration into existing applications like non-Rack-based web servers or the generation of data which is used and/or served statically later on.
+
+To use _only_ the data construction capabilities of the statusboard gem, add the following line to your application file:
+
+```ruby
+require "statusboard"
+```
+
+Afterwards you can instanciate the classes `Statusboard::DiyWidget`, `Statusboard::GraphWidget` or `Statusboard::TableWidget` by passing a block containing the DSL statements to the constructor. Call the `render` method on a newly created object to retrieve the Status Board compatible output:
+
+```ruby
+my_widget = Statusboard::DiyWidget.new do
+	content "My first widget with custom content!"
+end
+
+puts my_widget.render
+```
+
+## Todo
+
+ * Verify/discuss architecture of the gem
+ * Write meaningful tests
+ * Improve language of this document
+
+## Contributing
+
+1. Fork it ( https://github.com/julianschuh/statusboard/fork )
+2. Read the ARCHITECTURE.md file
+3. Create your feature branch (`git checkout -b my-new-feature`)
+4. Commit your changes (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request

data/Rakefile

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

data/examples/mountable.rb

@@ -0,0 +1,74 @@
+require "statusboard"
+
+# Required so we can run the statusboard server
+require "rack/handler"
+
+# Creates a Rackcompatible object which will serve the status board widgets when mounted or run.
+mountable_module = Statusboard::StatusboardServer.new! do |variable|
+	
+	# Specify a graph that plots the f(x)=x function
+	widget "yequalsx", :graph do
+
+		# Configure basic settings of the graph
+		title "My first graph"
+		type :line
+
+		# Specify the "data source" - in this case a block. (alternative: a proc)
+		data do
+			# One graph can have multiple data sequences (which translates to multiple lines/bar colors), we define one
+			data_sequence do
+				title "f(x) = x"
+
+				# The data sequence consists of 16 datapoints which represent the function f(x)=x from 0 to 15
+				(0..15).each do |n|
+					datapoint n, n
+				end
+			end
+		end
+	end
+
+	# Specify a table widget which contains the values of the function f(x) from 0 tp 15 (as plotted in the graph widget)
+	widget "yequalsxtable", :table do
+
+		# We specify the data as a block
+		data do
+
+			# Table header
+			row do
+				cell do
+					type :text
+					content "x"
+				end
+				cell do
+					type :text
+					content "f(x)"
+				end
+			end
+
+			# Add a row for each value to the table
+			(0..15).each do |n|
+				row do
+					cell do
+						type :text
+						content n
+					end
+					cell do
+						type :text
+						content n
+					end
+				end
+			end
+		end
+	end
+end
+
+puts "Loaded widgets: "
+mountable_module.server_description.widgets.keys.each do |widget_name|
+	puts widget_name
+end
+
+# Serve the widget using a Rack handler (could be mounted in an existing application, too).
+# This is just for educational purposes; if you want to run the statusboard server standalone, you should
+# require the file main.rb. When using main.rb, all initialization and server-related stuff is done
+# automatically.
+Rack::Handler.default.run(mountable_module)

data/examples/rendering_only.rb

@@ -0,0 +1,21 @@
+require "statusboard"
+
+# In this example, the Statusboard-compatible output will be generated without any server-related code
+# being involved. Could be used to integrate the serving of Statusboard widgets into existing applications.
+
+widget = Statusboard::GraphWidget.new do
+	title "My first graph"
+	type :line
+
+	data do
+		data_sequence do
+			title "f(x) = x"
+
+			(0..15).each do |n|
+				datapoint n, n
+			end
+		end
+	end
+end
+
+puts widget.render

data/examples/standalone.rb

@@ -0,0 +1,59 @@
+require "statusboard/main"
+
+# Server listens on port 7777
+server_settings :Port => 7777
+
+# Specify a graph that plots the f(x)=x function
+widget "yequalsx", :graph do
+
+	# Configure basic settings of the graph
+	title "My first graph"
+	type :line
+
+	# Specify the "data source" - in this case a block. (alternative: a proc)
+	data do
+		# One graph can have multiple data sequences (which translates to multiple lines/bar colors), we define one
+		data_sequence do
+			title "f(x) = x"
+
+			# The data sequence consists of 16 datapoints which represent the function f(x)=x from 0 to 15
+			(0..15).each do |n|
+				datapoint n, n
+			end
+		end
+	end
+end
+
+# Specify a table widget which contains the values of the function f(x) from 0 tp 15 (as plotted in the graph widget)
+widget "yequalsxtable", :table do
+
+	# We specify the data as a block
+	data do
+
+		# Table header
+		row do
+			cell do
+				type :text
+				content "x"
+			end
+			cell do
+				type :text
+				content "f(x)"
+			end
+		end
+
+		# Add a row for each value to the table
+		(0..15).each do |n|
+			row do
+				cell do
+					type :text
+					content n
+				end
+				cell do
+					type :text
+					content n
+				end
+			end
+		end
+	end
+end

data/lib/statusboard.rb

@@ -0,0 +1,15 @@
+require "statusboard/version"
+
+require "statusboard/errors"
+
+require "statusboard/dsl/dsl"
+
+require "statusboard/widgets/graph"
+require "statusboard/widgets/diy"
+require "statusboard/widgets/table"
+
+require "statusboard/server"
+
+module Statusboard
+	VIEW_PATH = File.join(File.dirname(__FILE__), "statusboard", "views")
+end

data/lib/statusboard/dsl/base.rb

@@ -0,0 +1,40 @@
+module Statusboard
+	module DSL
+		class DSLBase
+
+			# Automatically creates DSL-like setters for the specified fields.
+			# Fields must be specified as symbols.
+			def self.setter(*method_names)
+				method_names.each do |name|
+					send :define_method, name do |data|
+						instance_variable_set "@#{name}".to_sym, data 
+					end
+				end
+			end
+
+			# Automatically creates a DSL-like setter for a specified field. If
+			# the setter is called by the *user without an argument*, the specified
+			# default value will be used as the value.
+			#
+			# The method will _NOT_ use the specified value as a default value for
+			# the field. If a default value is needed, the field should be set in
+			# the constructor.
+			#
+			# ==== Attributes
+			#
+			# * +method_name+ - Name of the field for which a setter should be created
+			# * +default_value+ - Default value of the argument which is used if the method is called without an argument
+			def self.setter_with_default_value(method_name, default_value)
+				send :define_method, method_name do |data = default_value|
+					instance_variable_set "@#{method_name}".to_sym, data 
+				end
+			end
+
+			# Default constructor. Executes the given block within its own context, so the block
+			# contents behave as a DSL.
+			def initialize(&block)
+				instance_eval &block
+			end
+		end
+	end
+end

data/lib/statusboard/dsl/dsl.rb

@@ -0,0 +1,262 @@
+require "statusboard/dsl/base"
+
+module Statusboard
+	# Module whoch contains the definition of the DSL that is used to
+	# describe and configure the widgets and teir data(sources).
+	module DSL
+		class ServerDescription < DSLBase
+
+			attr_reader :widgets, :server_settings
+
+			def initialize(&block)
+				@widgets = {}
+
+				@server_settings = {
+					:Port => 8080,
+					:Host => "0.0.0.0"
+				}
+
+				super &block unless block.nil?
+			end
+
+			def server_settings(settings={})
+				@server_settings.merge!(settings)
+			end
+
+			# Registers a new widget which will be served by the server.
+			#
+			# ==== Attributes
+			#
+			# * +name+ - Unique identifier of the widget. The widget will be accessible using the URL /widget/+name+
+			# * +type_or_widget+ - Either the type of the widget as a symbol (:table, :graph, :diy) or an already initialized widget object
+			# * +&block+ - If only the type of the widget was specified in the previous paremeter, the block must be specified and contain the DSL statements which descibe the widget
+			def widget(name, type_or_widget, &block)
+				raise ArgumentError, "Widget name " + name.to_s + " already taken" unless @widgets[name.to_sym].nil?
+
+				if type_or_widget.respond_to?(:render)
+					@widgets[name.to_sym] = type_or_widget
+				else
+					raise ArgumentError, "Widget " + name.to_s + " specified without block." if block.nil?
+
+					begin
+						klass = Statusboard.const_get(type_or_widget.to_s.capitalize + "Widget")
+					rescue NameError
+						raise ArgumentError, "Invalid widget type " + type_or_widget.to_s + " specified."
+					end
+
+					@widgets[name.to_sym] = klass.new(&block)
+				end
+			end
+		end
+
+		class GraphDescription < DSLBase
+
+			setter :refresh_interval, :title, :type
+			setter_with_default_value :display_totals, true
+
+			def data(proc = nil, &block)
+				@data = if proc.nil? then block else proc end
+			end
+
+			def x_axis(&block)
+				@x_axis = XAxis.new(&block)
+			end
+
+			def y_axis(&block)
+				@y_axis = YAxis.new(&block)
+			end
+
+			def construct
+				constructed = {
+					"graph" => {
+						"title" 				=> @title,
+						"refreshEveryNSeconds"	=> @refresh_interval,
+						"totals"				=> @display_totals,
+						"type"					=> @type
+					}
+				}
+
+				begin
+					data = GraphData.new(&@data)
+					constructed["graph"]["datasequences"] = data.construct
+				rescue DataSourceError => e
+					constructed["graph"]["error"] = {
+						"message" => e.message,
+						"detail" => e.message
+					}
+				end
+
+				constructed["graph"]["xAxis"] = @x_axis.construct unless @x_axis.nil?
+				constructed["graph"]["yAxis"] = @y_axis.construct unless @y_axis.nil?
+				
+				constructed
+			end
+
+			protected
+
+			class XAxis < DSLBase
+				setter_with_default_value :show_every_label, true
+
+				def construct
+					{
+						"showEveryLabel" => @show_every_label
+					}
+				end
+			end
+
+			class YAxis < DSLBase
+
+				setter :min_value, :max_value, :units_suffix, :units_prefix, :scale_to
+				setter_with_default_value :hide_labels, true
+
+				def construct
+					constructed = {
+						"scaleTo" => @scale_to,
+						"hide" => @hide_labels,
+						"units" => { }
+					}
+
+					constructed["minValue"] = @min_value unless @min_value.nil?
+					constructed["maxValue"] = @max_value unless @max_value.nil?
+					constructed["units"]["prefix"] = @units_prefix unless @units_prefix.nil?
+					constructed["units"]["suffix"] = @units_suffix unless @units_suffix.nil?
+
+					constructed
+				end
+			end
+
+			class GraphData < DSLBase
+				def initialize(&block)
+					@data_sequences = []
+
+					super &block
+				end
+
+				def data_sequence(title = nil, &block)
+					@data_sequences << DataSequence.new(title, &block)
+				end
+
+				def construct
+					@data_sequences.map(&:construct)
+				end
+			end
+
+			class DataSequence < DSLBase
+				def initialize(title, &block)
+					@datapoints = []
+					@title = title
+
+					super &block
+				end
+
+				setter :title, :color
+
+				def datapoint(x, y)
+					@datapoints << {title: x.to_s, value: y.to_s}
+				end
+
+	            def construct
+	                constructed = {
+	                    "title" => @title,
+	                    "datapoints" => @datapoints
+	                }
+	                constructed["color"] = @color unless @color.nil?
+
+	                constructed
+	            end
+			end
+		end
+
+		class DiyDescription < DSLBase
+			def content(proc_or_content = nil, &block)
+				@content = if proc_or_content.nil? then block else proc_or_content end
+			end
+
+			def construct
+				content = if @content.respond_to?(:call) then @content.call() else @content end
+
+				{
+					content: content
+				}
+			end
+		end
+
+		class TableDescription < DSLBase
+			def data(proc = nil, &block)
+				@data = if proc.nil? then block else proc end
+			end
+
+			def construct
+				data = TableData.new(&@data).construct
+
+				{
+					data: data
+				}
+			end
+
+			protected
+
+			class TableData < DSLBase
+				def initialize(&block)
+					@rows = []
+
+					super &block
+				end
+
+				def row(&block)
+					@rows << TableRow.new(&block)
+				end
+
+				def construct
+					{
+						rows: @rows.map(&:construct)
+					}
+				end
+			end
+
+			class TableRow < DSLBase
+				def initialize(&block)
+					@cells = []
+
+					super &block
+				end
+
+				def cell(type = :text, &block)
+					@cells << TableCell.new(type, &block)
+				end
+
+				def construct
+					{
+						cells: @cells.map(&:construct)
+					}
+				end
+			end
+
+			class TableCell < DSLBase
+				setter :content, :colspan, :width, :percentage, :imageurl, :type
+				setter_with_default_value :noresize, true
+
+				def initialize(type, &block)
+
+					@type = :text
+					@type = type unless type.nil?
+
+					@noresize = false
+
+					super &block
+				end
+
+				def construct
+					{
+						content: @content,
+						type: @type,
+						width: @width,
+						percentage: @percentage,
+						imageurl: @imageurl,
+						noresize: @noresize
+					}
+				end
+			end
+		end
+	end
+end

data/lib/statusboard/errors.rb

@@ -0,0 +1,2 @@
+class DataSourceError < StandardError
+end

data/lib/statusboard/main.rb

@@ -0,0 +1,22 @@
+require "statusboard"
+require "statusboard/server"
+
+require "rack/handler"
+require "rack-handlers"
+
+app = Statusboard::StatusboardServer.new! # create a new, _unwrapped_ instance of the server class
+
+# Make the top-level syntax work by delegating the right function calls to the right destination
+Sinatra::Delegator.target = app.server_description		# Why this? We want all top level function calls to be DSL calls -> So we have to call them in the actual DSL instance, and not the app class itself (which gets its settings from its DSL class instance)
+Sinatra::Delegator.delegate :widget, :server_settings	# Allowed calls
+
+# include would include the module in Object
+# extend only extends the main object
+extend Sinatra::Delegator
+
+class Rack::Builder
+  include Sinatra::Delegator
+end
+
+# Run the app _after_ the applications main file (where this file was included in) was executed successfully to allow for configuration
+at_exit { Rack::Handler.default.run(app, app.server_description.server_settings) if $!.nil? }

data/lib/statusboard/server.rb

@@ -0,0 +1,29 @@
+require "sinatra/base"
+
+module Statusboard
+
+	# Simple Sinatra-based server whose task it is to serve widgets to the app(s)
+	# using http. Widgets can be defined directly using the DSL or by passing already
+	# initialized Widget-objects. The widgets are identified using a unique name for
+	# each defined widget.
+	class StatusboardServer < Sinatra::Base
+
+		attr_reader :server_description
+
+		# Initializes a new instance of the server using the configuration specified via
+		# the DSL in the block. The server will be initialized without any widgets if no
+		# block is specified.
+		def initialize(*args, &block)
+
+			super(*args, &nil)	# Dont pass the block to super as it would result in errors because the dsl methods aren't available if not instance_eval'd
+
+			@server_description = DSL::ServerDescription.new &block
+		end
+
+		get "/widget/:name/?" do |widget|
+			raise Sinatra::NotFound if @server_description.widgets[widget.to_sym].nil?
+
+			@server_description.widgets[widget.to_sym].render
+		end
+	end
+end

data/lib/statusboard/version.rb

@@ -0,0 +1,3 @@
+module Statusboard
+  VERSION = "0.1.0"
+end

data/lib/statusboard/views/table/custom_cell.erb

@@ -0,0 +1 @@
+<%= content %>

data/lib/statusboard/views/table/image_cell.erb

@@ -0,0 +1,6 @@
+<td
+<%= if noresize then "class=\"noresize\"" end %>
+ <%= if width then "style=\"width: " + width + ";\"" end %>
+>
+<img src="<%= imageurl %>" />
+</td>

data/lib/statusboard/views/table/percentage_cell.erb

@@ -0,0 +1,7 @@
+<td class="projectsBars">
+
+<% (1..(percentage / (100 / 8.0)).round).each do |bar_num| %>
+<div class="barSegment value<%= bar_num %>"></div>
+<% end %>
+
+</td>

data/lib/statusboard/views/table/row.erb

@@ -0,0 +1,5 @@
+<tr>
+<% cells.each do |cell| %>
+	<%= render_template cell[:type].to_s + "_cell.erb", cell %>
+<% end %>
+</tr>

data/lib/statusboard/views/table/table.erb

@@ -0,0 +1,7 @@
+<table>
+
+<% data[:rows].each do |row| %>
+	<%= render_template "row.erb", row %>
+<% end %>
+
+</table>

data/lib/statusboard/views/table/text_cell.erb

@@ -0,0 +1,5 @@
+<td
+<%= if width then "style=\"width: " + width + ";\"" end %>
+>
+<%= content %>
+</td>

data/lib/statusboard/widgets/base.rb

@@ -0,0 +1,37 @@
+require "erb"
+require "tilt/erb"
+
+module Statusboard
+
+	# (Abstract) class that represents a widget which can be displayed
+	# using the Status Board app.
+	# The class must be subclassed for each supported widget type.
+	class WidgetBase
+
+		# Each widget must be initialized using a DSL. When creating the
+		# widget, the block containing the DSL statements must be specified
+		# in the constructor.
+		def initialize(&block)
+			raise "Not implemented."
+		end
+
+		# Method that renders the specific widget into a (text-)format understandable
+		# by the Status Board app.
+		def render
+			raise "Not implemented."
+		end
+
+	protected
+		# Renders a specified template with the specified local variables in the context
+		# of the object itself. The method will search for the template in a subdirectory
+		# of the gems VIEW_PATH. The subdirectory will be derived from the class name.
+		#
+		# Example:
+		# 			GraphWidget => views/graph/,
+		# 			TestWidget => views/test/
+		def render_template(template, locals = {})
+			widget_type = self.class.name.split('::').last.sub(/Widget$/, '').downcase
+			Tilt::ERBTemplate.new(File.join(Statusboard::VIEW_PATH, widget_type, template)).render(self, locals)
+		end
+	end
+end

data/lib/statusboard/widgets/diy.rb

@@ -0,0 +1,17 @@
+require "statusboard/widgets/base"
+
+module Statusboard
+
+	# Represents do-it-yourself (DIY) widgets. The widget is configured and
+	# filled with data using a DSL which must be passed to the constructor.
+	class DiyWidget < WidgetBase
+
+		def initialize(&block)
+			@diy_description = DSL::DiyDescription.new(&block)
+		end
+
+		def render
+			@diy_description.construct[:content]
+		end
+	end
+end

data/lib/statusboard/widgets/graph.rb

@@ -0,0 +1,22 @@
+require "statusboard/widgets/base"
+
+require "json"
+
+module Statusboard
+	# Class which represents graph widgets for Status Board.
+	# The widget is configured and filled with data using a DSL
+	# whoch is passed to the constructor.
+	class GraphWidget < WidgetBase
+
+		# Initializes a new graph widget instance using the configuration
+		# and data source specified in the block. The block is excepted to
+		# use the DSL.
+		def initialize(&block)
+			@graph_description = DSL::GraphDescription.new(&block)
+		end
+
+		def render
+			@graph_description.construct.to_json
+		end
+	end
+end

data/lib/statusboard/widgets/table.rb

@@ -0,0 +1,20 @@
+require "statusboard/widgets/base"
+
+module Statusboard
+
+	# Class which represents table widgets for Status Board.
+	# The widget is configured and filled with data using a DSL
+	# which is passed to the constructor.
+	class TableWidget < WidgetBase
+
+		def initialize(&block)
+			@table_description = DSL::TableDescription.new(&block)
+		end
+
+		def render
+			table_data = @table_description.construct
+
+			render_template("table.erb", table_data)
+		end
+	end
+end

data/statusboard.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'statusboard/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "statusboard"
+  spec.version       = Statusboard::VERSION
+  spec.authors       = ["Julian Schuh"]
+  spec.email         = ["julez@julez.in"]
+  spec.summary       = %q{Feed the Status Board App by Panic with custom data.}
+  spec.description   = %q{Use a convenient and expressive DSL to feed the Status Board App by Panic with custom data. Benefit directly from rubys expressiveness without having to touch any server-related code.}
+  spec.homepage      = "http://julez.io"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "tilt", ">= 1.4.0"          # Simple Template parsing
+  spec.add_dependency "rack-handlers", "~> 0.7"   # Rack handler
+  spec.add_dependency "sinatra", "~> 1.4.5"       # Server part is based on sinatra
+  spec.add_dependency "rack", "~> 1.5.2"
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: statusboard
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Julian Schuh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+- !ruby/object:Gem::Dependency
+  name: rack-handlers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.4.5
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+description: Use a convenient and expressive DSL to feed the Status Board App by Panic
+  with custom data. Benefit directly from rubys expressiveness without having to touch
+  any server-related code.
+email:
+- julez@julez.in
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".gitignore"
+- ".ruby-version"
+- ARCHITECTURE.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/.gitkeep
+- examples/mountable.rb
+- examples/rendering_only.rb
+- examples/standalone.rb
+- lib/.DS_Store
+- lib/statusboard.rb
+- lib/statusboard/.DS_Store
+- lib/statusboard/dsl/base.rb
+- lib/statusboard/dsl/dsl.rb
+- lib/statusboard/errors.rb
+- lib/statusboard/main.rb
+- lib/statusboard/server.rb
+- lib/statusboard/version.rb
+- lib/statusboard/views/table/custom_cell.erb
+- lib/statusboard/views/table/image_cell.erb
+- lib/statusboard/views/table/percentage_cell.erb
+- lib/statusboard/views/table/row.erb
+- lib/statusboard/views/table/table.erb
+- lib/statusboard/views/table/text_cell.erb
+- lib/statusboard/widgets/.DS_Store
+- lib/statusboard/widgets/base.rb
+- lib/statusboard/widgets/diy.rb
+- lib/statusboard/widgets/graph.rb
+- lib/statusboard/widgets/table.rb
+- statusboard.gemspec
+homepage: http://julez.io
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Feed the Status Board App by Panic with custom data.
+test_files: []