swagr 0.0.5

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 wapp.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Robert Feldt
+
+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,33 @@
+# Swagr
+
+Simple web app skeleton creator for Ruby based on Sinatra, Slim, Coffeescript and d3.
+
+## Installation
+
+Install yourself as:
+
+    $ gem install swagr
+
+or add this line to your application's Gemfile:
+
+    gem 'swagr'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+Create a new Swagr web app:
+
+    swagr create <dir>
+
+and then start the web app with:
+
+    ruby <dir>/app.rb
+
+and then access your web app by opening the browser and going to 0.0.0.0:4000. The default web app has a few simple examples of how to transfer data from a back-end, long-running Ruby computation and display it with a small amount of Coffeescript code that uses d3 to visualise progress. Very rudimentary for now.
+
+After you have checked the default example you can add/removed/modify slim files in <dir>/views and coffescript files in <dir>/coffee and add your own backend and access it from app.rb.
+
+NOTE! This is very early times and most things in Swagr are likely to change. There is no real "design" yet, I needed to get something up and running quickly.

data/Rakefile

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

data/bin/swagr

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'thor'
+require 'fileutils'
+
+require 'swagr'
+
+SkeletonDir = "skeletons"
+DefaultSkeletonTarball = "bootstrap_default_130109_0842.zip"
+SkeletonTarball = File.join(SkeletonDir, DefaultSkeletonTarball)
+
+StaticDir = PublicDir = "static"
+DefaultSubdirs = ["coffee", "views", StaticDir]
+
+class SwagrCommand < Thor
+
+  include Thor::Actions
+
+  def self.source_root
+    File.dirname(__FILE__).split("/")[0...-1].join("/")
+  end
+
+  desc "update", "Update all templates by re-downloading the latest versions of needed libs"
+  def update
+    inside File.join("templates", PublicDir, "js") do
+      get "http://d3js.org/d3.v3.min.js"
+      get "http://coffeescript.org/extras/coffee-script.js"
+      get "http://code.jquery.com/jquery-latest.js"
+    end
+  end
+
+  #desc "run DIR", "Run a swagr app in DIR, only things that override the base app needs to be in DIR"
+  #def run(dir)
+  #end
+
+  desc "init DIR", "Create a skeleton structure in DIR for customizing a swagr app"
+  def init(dir)
+    empty_directory dir
+    inside dir do
+      DefaultSubdirs.each {|subdir| empty_directory(subdir)}
+    end
+    # Now copy everything in the templates dir into the 
+    directory "templates", dir
+  end
+
+  desc "create DIR", "Create/setup a swagr app in DIR"
+  def create(dir)
+    init(dir)
+    public_dir = File.join(dir, PublicDir)
+    tarball = File.join(public_dir, "skeleton.zip")
+    copy_file SkeletonTarball, tarball
+    inside public_dir do
+      run "unzip skeleton.zip"
+      FileUtils.rm_rf "skeleton.zip"
+      say "Removed tarball"
+    end
+  end
+
+end
+
+SwagrCommand.start

data/examples/examples01/app.rb

@@ -0,0 +1,104 @@
+require 'rubygems'
+require 'sinatra/base'
+require 'slim'
+require 'coffee-script'
+require 'json'
+require 'feldtruby'
+
+class CoffeeEngine < Sinatra::Base
+  
+  set :views,   File.dirname(__FILE__)    + '/coffee'
+  
+  get "/coffee/*.js" do
+    filename = params[:splat].first
+    coffee filename.to_sym
+  end
+
+  get "/js/*.coffee" do
+    filename = params[:splat].first
+    coffee filename.to_sym
+  end
+  
+end
+
+require File.join(".", File.dirname(__FILE__), "brownian_searcher")
+BrownianSearcher = BrownianMotion2DSearch.new(5, 2.0)
+Thread.new {BrownianSearcher.start_search}
+
+# The data engine should return the json or csv formatted data
+# that is used in your app. You need to set this up to dynamically deliver the
+# latest data about your running Ruby app/process/server.
+class DataEngine < Sinatra::Base
+  module SendAsJson
+    def json_response(data)
+      content_type :json
+      data.to_json
+    end
+  end
+
+  helpers SendAsJson
+
+  # Static data files are served from the "/data" dir
+  set :views,   File.dirname(__FILE__)    + '/data'
+
+  # Example handler that returns a random json data set for all example requests...
+  get %r{/data/randints/arrayofsize([\d]+).json} do |size|
+    a = Array.new(size.to_i).map {-5+(10*rand()).to_i}
+    #json_response a.uniq.sort
+    b = a.uniq.sort.map {|v| {"value" => v}}
+    json_response b
+  end
+
+  get '/data/brownian_search/search_info.json' do
+    json_response BrownianSearcher.search_info
+  end
+
+  get '/data/brownian_search/current_position.json' do
+    json_response [BrownianSearcher.pos]
+  end
+
+end
+
+class WAppGuiServer < Sinatra::Base
+
+  enable :logging
+  disable :dump_errors
+
+  use DataEngine
+  use CoffeeEngine
+
+  set :views,         File.dirname(__FILE__) + '/views'
+  set :public_folder, File.dirname(__FILE__) + '/static'
+
+#  get '/example_data.json' do
+#    content_type :json
+#    [-1, 2, 4, -7, -9].to_json
+#  end
+  
+  get '/' do
+    slim :index
+  end
+
+  def copyright_holders
+    "FIXME: Your Name(s)..."
+  end
+  
+  # Set the first year you started working on this app. The copyright will then go from then to current year.
+  def first_year
+    2012
+  end
+
+  def year
+    current_year = Time.now.year
+    if current_year != first_year
+      "#{first_year}-#{current_year}"
+    else
+      "#{first_year}"
+    end
+  end
+
+end
+
+if __FILE__ == $0
+  WAppGuiServer.run! :port => 4000
+end

data/examples/examples01/brownian_searcher.rb

@@ -0,0 +1,93 @@
+require 'json'
+
+# Our dummy long-running ruby process is a Brownian motion where
+# we are interested in the max x and y values found. Our GUI
+# will present a top list of the top 3 results found so far.
+class BrownianMotion2DSearch
+  Pos = Struct.new("Pos", :x, :y, :number)
+  class Pos
+    Origo = Pos.new(0,0,-1)
+
+    def distance_to(pos)
+      Math.sqrt( (pos.x - self.x)**2 + (pos.y - self.y)**2 )
+    end
+    
+    def to_json(*a)
+      {
+        'x' => x,
+        'y' => y,
+        'number' => number,
+        'distance' => self.distance_to(Origo)
+      }.to_json(*a)
+    end
+  end
+
+  attr_reader :num_steps, :pos
+
+  def initialize(maxToplistLength = 10, maxSleepSeconds = 2.0)
+    @max_top_list_length = maxToplistLength
+    @num_steps = 0
+    @max_sleep_seconds = maxSleepSeconds
+    @pos = new_pos(0, 0)
+    @top_list = [@pos]
+  end
+
+  def new_pos(x, y)
+    Pos.new(x, y, @num_steps)
+  end
+
+  def start_search
+    while true
+      take_brownian_step()
+      puts "Step = #{@num_steps}, at pos = #{@pos}"
+      update_top_list()
+      # Sleep so we are not searching all the time => simulate other long-running calcs...
+      sleep( @max_sleep_seconds * rand() )
+    end
+  end
+
+  # Return info about the search such as the number of steps taken and the current top list
+  def search_info
+    {"step" => @num_steps, "top_list" => @top_list}
+  end
+
+  def rand_unit_step
+    rand() < 0.495 ? -1 : 1
+  end
+
+  def take_brownian_step
+    @num_steps += 1
+    @pos = new_pos(@pos.x + rand_unit_step(), @pos.y + rand_unit_step())
+  end
+
+  def update_top_list
+    @top_list << @pos
+    sort_top_list
+    limit_top_list_length
+  end
+
+  def sort_top_list
+    # Add a small value based on when the position was found => older positions with same distance
+    # are ranked higher than later found positions with same distance.
+    @top_list = @top_list.sort_by {|p| -p.distance_to(Pos::Origo)+(p.number/(1000.0*@num_steps))}
+  end
+
+  def limit_top_list_length
+    @top_list = @top_list.take(@max_top_list_length)
+  end
+end
+
+if __FILE__ == $0
+  s = BrownianMotion2DSearch.new
+  Thread.new {s.start_search}
+  require 'pp'
+  Thread.new {
+    while true
+      sleep 5.0
+      pp s.search_info
+    end
+  }
+  sleep 20
+  pp s.search_info
+  exit -1
+end

data/examples/examples01/coffee/d3graph.coffee

@@ -0,0 +1,54 @@
+root = exports ? window
+root.Swagr = if root.Swagr then root.Swagr else {}
+class root.Swagr.D3Graph
+  default_options =
+    width:                  960
+    height:                 500
+    update_interval:        1.5               # seconds
+    transition_y:           50
+    transition_x:           50
+    transition_time:        750               # milliseconds
+
+  constructor: (@selector, @dataUrl, opts = {}) ->
+    @opts = @set_default_options_unless_given(opts, default_options)
+    @_append_elements()
+    @update()     # First update so we have something to show...
+
+  set_default_options_unless_given: (givenOpts, defaultOpts) ->
+    for own option, value of defaultOpts
+      givenOpts[option] = value unless givenOpts.hasOwnProperty(option)
+    givenOpts
+
+  # Append the svg to the top-level selector
+  _append_elements: () ->
+    @svg = d3.select(@selector).append("svg")
+                .attr("width", @opts.width)
+                .attr("height", @opts.height)
+              .append("g")
+                .attr("transform", @_transform_string())
+
+  # Start updating the graph
+  start_updates: ->
+    @interval_id = root.setInterval ( => @update() ), @opts.update_interval*1000
+
+  # Stop updating the graph
+  stop_updates: -> root.clearInterval(@interval_id)
+
+  # Run the updates for a given number of seconds
+  run_updates_for: (seconds) ->
+    @start_updates()
+    setTimeout ( => @stop_updates(); console.log("Stopped updating graph!"); ), seconds*1000
+
+  update: ->
+    d3.json(@dataUrl, (error, data) =>
+      @data = data
+      # D3's general update pattern:
+      # 1. DATA JOIN - Join new data with old elements, if any, then update, enter and exit below.
+      @elems = @_join_data(data)
+      # 2. UPDATE - Update existing elements as needed.
+      @_update_existing_elements()
+      # 3. ENTER - Create new elements as needed.
+      @_enter_new_elements()
+      # 4. EXIT - Remove old elements as needed.
+      @_remove_exiting_elements()
+    )

data/examples/examples01/coffee/updating_text_graph.coffee

@@ -0,0 +1,43 @@
+root = exports ? window
+root.Swagr = if root.Swagr then root.Swagr else {}
+
+# Assumes d3graph.coffee has been required before this one...
+class root.Swagr.UpdatingTextGraph extends root.Swagr.D3Graph
+  _transform_string: -> "translate(16," + (@opts.height / 2) + ")"
+
+  _join_data: (data) -> 
+    @svg.selectAll("text").data(data, (d) -> d.value)
+
+  _update_existing_elements: (text) ->
+    @elems.attr("class", "update")
+        .text(@textmapper(@elems, @data))
+        .transition()
+        .duration(@opts.transition_time)
+        .attr("x", @xmapper(@elems, @data))
+
+  _enter_new_elements: (text) ->
+    @elems.enter().append("text")
+        .attr("class", "enter")
+        .attr("dy", ".35em")
+        .attr("y", -@opts.transition_y)
+        .attr("x", @xmapper(@elems, @data))
+        .style("fill-opacity", 1e-6)
+        .text(@textmapper(@elems, @data))
+        .transition()
+        .duration(@opts.transition_time)
+        .attr("y", 0)
+        .style("fill-opacity", 1)
+
+  _remove_exiting_elements: (text) ->
+    @elems.exit()
+        .attr("class", "exit")
+        .transition()
+        .duration(@opts.transition_time)
+        .attr("y", @opts.transition_y)
+        .style("fill-opacity", 1e-6)
+        .remove()
+
+  xmapper: (elems, data) -> (d,i) -> i * 70
+
+  textmapper: (elems, data) -> (d,i) -> 
+    d.value + ( if (i+1 isnt data.length) then "," else "" )