suricate 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fafd76c3fca39a449326894d87061f3fb75d3bd3
+  data.tar.gz: a0e8c87b6667fdda4c24ec5b7a5a8499ad0e7110
+SHA512:
+  metadata.gz: f7bc99b933c0fd737d6f930b4340ca66679ca367f4b924c1b65f4bc0e9ae5e4c40d103dfe74a80bbc7c09c550af9225d3e46d58a5435a67c707df860251befb6
+  data.tar.gz: a81dac32f5283ff2e91ec188c250592db16a734f86f2eb2bf50b0c3ce639cdd7045fb6400a6044d7c36d312eda2b4a1a4b6c97d45ca443999b8463dcd155316b

data/lib/suricate/application.rb

@@ -0,0 +1,90 @@
+require 'sinatra'
+require 'json'
+
+module Suricate
+  class Application < Sinatra::Base
+    extend Forwardable
+    def_delegators :@configuration, :widget_repository, :template_repository
+
+    def initialize(configuration)
+      super(nil)
+      # TODO : switch to Rack directly
+      # Good : hide Sinatra complexity from outside,
+      # the interface will be the same when switchting to Rack
+      # Bad  : set class var from instance
+      self.class.set(:configuration, configuration)
+      @configuration = configuration
+    end
+
+    configure do
+      set :public_folder,   Proc.new { configuration.public_directory }
+      set :views,           Proc.new { configuration.templates_directory }
+      set :show_exceptions, :after_handler
+    end
+
+
+
+
+    #
+    # Errors
+    #
+
+    error WidgetRepository::WidgetNotFound do
+      output.api_error(404, env['sinatra.error'].message)
+    end
+
+
+
+
+    #
+    # API
+    #
+
+    # Get widgets' configuration
+    get('/api/widgets') do
+      configurations = widget_repository.configurations.map(&:to_h)
+      output.api_success(widgets: configurations)
+    end
+
+    # Get widget's data
+    get('/api/widgets/:id') do
+      widget = widget_repository.instantiate(params['id'], context)
+      widget.execute
+    end
+
+
+
+
+    #
+    # Pages
+    #
+
+    # Pages
+    get('/:page') do
+      render_page(params['page'])
+    end
+
+    # Default page
+    get('/') do
+      render_page(@configuration.default_page)
+    end
+
+
+
+
+    private
+    def context
+      RequestContext.new(request: request, session: session, output: output)
+    end
+
+    def output
+      @output ||= SinatraOutputDriver.new(self)
+    end
+
+    def render_page(page)
+      template = template_repository.find_page(page)
+      output.render(template.render)
+    end
+  end
+
+end

data/lib/suricate/charts/chart.rb

@@ -0,0 +1,15 @@
+module Suricate
+  class Chart
+    def initialize(labels, series)
+      @labels = labels
+      @series = series
+    end
+
+    def to_h
+      {
+        labels: @labels,
+        series: @series.map(&:to_h)
+      }
+    end
+  end
+end

data/lib/suricate/charts/chart_builder.rb

@@ -0,0 +1,22 @@
+module Suricate
+  class ChartBuilder
+    def initialize
+      @series = []
+      @labels = []
+    end
+
+    def serie
+      builder = ChartSerieBuilder.new
+      yield builder
+      @series << builder.serie
+    end
+
+    def labels(labels)
+      @labels = labels
+    end
+
+    def chart
+      Chart.new(@labels, @series)
+    end
+  end
+end

data/lib/suricate/charts/chart_serie.rb

@@ -0,0 +1,19 @@
+module Suricate
+  class ChartSerie
+    attr_reader :name, :values, :color
+
+    def initialize(name, values, color)
+      @name   = name
+      @values = values
+      @color  = color
+    end
+
+    def to_h
+      {
+        name: @name,
+        values: @values,
+        color: @color
+      }
+    end
+  end
+end

data/lib/suricate/charts/chart_serie_builder.rb

@@ -0,0 +1,29 @@
+module Suricate
+  class ChartSerieBuilder
+    def initialize
+      @values = []
+    end
+
+    def name(name)
+      @name = name
+    end
+
+    def color(color)
+      @color = color
+    end
+
+    # Add multiple values
+    def values(values)
+      @values.concat(values)
+    end
+
+    # Add one value
+    def value(value)
+      @values << value
+    end
+
+    def serie
+      ChartSerie.new(@name, @values, @color)
+    end
+  end
+end

data/lib/suricate/configuration/configuration.rb

@@ -0,0 +1,13 @@
+module Suricate
+  class Configuration
+    attr_reader :template_repository, :public_directory, :widget_repository,
+                :default_page
+
+    def initialize(options = {})
+      @template_repository = options[:template_repository]
+      @public_directory    = options[:public_directory]
+      @widget_repository   = options[:widget_repository]
+      @default_page        = options[:default_page]
+    end
+  end
+end

data/lib/suricate/configuration/configuration_builder.rb

@@ -0,0 +1,29 @@
+module Suricate
+  class ConfigurationBuilder
+    attr_accessor :templates_directory, :public_directory, :default_page
+
+    def configuration
+      Configuration.new(template_repository: template_repository,
+                        widget_repository: widget_repository,
+                        default_page: @default_page,
+                        public_directory: @public_directory)
+    end
+
+    def widgets
+      yield widget_configurations_builder
+    end
+
+    private
+    def template_repository
+      TemplateRepository.new(@templates_directory)
+    end
+
+    def widget_repository
+      WidgetRepository.new(widget_configurations_builder.configurations)
+    end
+
+    def widget_configurations_builder
+      @widgets_builder ||= WidgetConfigurationsBuilder.new(template_repository)
+    end
+  end
+end

data/lib/suricate/configuration/widget_configuration.rb

@@ -0,0 +1,24 @@
+module Suricate
+  class WidgetConfiguration
+    attr_reader  :id, :klass, :collector, :options
+
+    def initialize(id, klass, collector, options = {})
+      @id        = id
+      @klass     = klass
+      @collector = collector
+      @options   = options
+    end
+
+    def instantiate(context)
+      @klass.new(id: id, context: context, collector: collector, options: options)
+    end
+
+    def to_h
+      {
+        id: @id,
+        type: @klass.type,
+        configuration: @options
+      }
+    end
+  end
+end

data/lib/suricate/configuration/widget_configurations_builder.rb

@@ -0,0 +1,64 @@
+module Suricate
+  class WidgetConfigurationsBuilder
+    using Refinements::String
+    class IDAlreadyUsedError < StandardError; end
+    attr_reader :configurations
+
+    def initialize(template_repository)
+      @template_repository = template_repository
+      @configurations      = []
+    end
+
+    def counter(id, collector, options = {})
+      register(id, CounterWidget, collector, options)
+    end
+
+    def line_chart(id, collector, options = {})
+      register(id, LineChartWidget, collector, options)
+    end
+
+    def register(id, klass, collector, options = {})
+      id = id.to_sym
+      if find_with_id(id)
+        raise IDAlreadyUsedError.new("id \"#{id}\" already taken")
+      else
+        configuration   = build_configuration(id, klass, collector, options)
+        @configurations << configuration
+      end
+    end
+
+    private
+    def build_configuration(id, klass, collector, options)
+      build_options(id, klass.type, options)
+      WidgetConfiguration.new(id.to_sym, klass, collector, options)
+    end
+
+    def build_options(id, type, options)
+      options[:template] = find_widget_template(id, type, options[:template])
+      if options[:templates]
+        options[:templates].map! do |name|
+          @template_repository.find_widget(name)
+        end
+      end
+    end
+
+    def find_widget_template(id, type, wanted_template)
+      template         = nil
+      default_template = type.underscore.sub(/_widget$/, '')
+      template_names   = [wanted_template || id.to_s, default_template]
+
+      template_names.each do |name|
+        begin
+          template = @template_repository.find_widget(name) and break
+        rescue TemplateRepository::TemplateNotFound
+        end
+      end
+
+      template.render if template
+    end
+
+    def find_with_id(id)
+      @configurations.find { |conf| conf.id == id }
+    end
+  end
+end

data/lib/suricate/delegation_callback.rb

@@ -0,0 +1,22 @@
+module Suricate
+  class DelegationCallback
+    def initialize(*callbacks)
+      callbacks.each do |callback|
+        define_callback(callback)
+      end
+    end
+
+    def call(callback_name, *args)
+      callback = instance_variable_get(:"@#{callback_name}_callback")
+      callback.call(*args) if callback
+    end
+
+
+    private
+    def define_callback(callback)
+      define_singleton_method callback.to_sym do |&block|
+        instance_variable_set(:"@#{callback}_callback", block)
+      end
+    end
+  end
+end

data/lib/suricate/generator/assets/javascript/api.js

@@ -0,0 +1,53 @@
+(function () {
+    "use strict";
+    window.Suricate = window.Suricate || {};
+
+    /*
+     * Public
+     */
+
+    Suricate.API = function(baseURL) {
+        this.baseURL = baseURL;
+    };
+
+    // Get widget configurations
+    Suricate.API.prototype.getWidgets = function(callback) {
+        this.sendRequest("GET", "/widgets", {}, function(data) {
+            callback(data.widgets);
+        });
+    };
+
+    // Get updated data for widget
+    Suricate.API.prototype.getWidgetData = function(widgetID, callback) {
+        var path = "/widgets/" + widgetID;
+        this.sendRequest("GET", path, {}, callback);
+    };
+
+
+    /*
+     * Private
+     */
+
+    // Send request to API
+    Suricate.API.prototype.sendRequest = function(method, path, params, callback) {
+        var self = this;
+        var url = this.baseURL + path;
+        $.ajax({
+            url: url,
+            method: method,
+            data: params,
+            success: function(data) {
+                self.handleResponse(url, data, callback);
+            }
+        });
+    };
+
+    Suricate.API.prototype.handleResponse = function(url, json, callback) {
+        if(json.status == 200) {
+            callback(json.data);
+        }
+        else {
+            console.error("Failed to load request", "url", url, "response", json);
+        }
+    };
+}());

data/lib/suricate/generator/assets/javascript/application.js

@@ -0,0 +1,97 @@
+(function() {
+    "use strict";
+    window.Suricate = window.Suricate || {};
+
+    Suricate.Application = function(widgetsContainer, configuration) {
+        this.widgetsContainer = new Suricate.WidgetsContainer(widgetsContainer);
+        this.configuration    = configuration;
+        this.chartFactory     = configuration.chartFactory || new Suricate.ChartJSChartFactory();
+        this.initialized      = false;
+        this.widgets          = [];
+        this.updateInterval   = undefined;
+    };
+
+
+
+    // Starts the application
+    Suricate.Application.prototype.start = function() {
+        var self = this;
+        this.init(function() {
+            self.startUpdates();
+        });
+    };
+
+    Suricate.Application.prototype.stop = function() {
+        this.stopUpdates();
+    };
+
+
+    // Creates and return an object
+    // to communicate with the API
+    Suricate.Application.prototype.createAPI = function() {
+        var baseURL = location.protocol + "//" + location.host + "/api";
+        return new Suricate.API(baseURL);
+    };
+
+    Suricate.Application.prototype.getWidgetsContainer = function() {
+        return this.widgetsContainer;
+    };
+
+    Suricate.Application.prototype.getChartFactory = function() {
+        return this.chartFactory;
+    };
+
+
+
+    /*
+     * Private
+     */
+
+    Suricate.Application.prototype.init = function(callback) {
+        if(!this.initialized) {
+            var self = this;
+            this.initWidgets(function() {
+                self.initialized = true;
+                callback();
+            });
+        }
+        else {
+            callback();
+        }
+    };
+
+    Suricate.Application.prototype.initWidgets = function(callback) {
+        var api  = this.createAPI();
+        var self = this;
+        api.getWidgets(function(configurations) {
+            var factory  = new Suricate.WidgetFactory(self, configurations);
+            self.widgets = factory.buildWidgets();
+            callback();
+        });
+    };
+
+    Suricate.Application.prototype.startUpdates = function() {
+        if(this.updateInterval === undefined) {
+            var self = this;
+            this.update();
+            this.updateInterval = window.setInterval(function() {
+                self.update();
+            }, 20000);
+        }
+    };
+
+    Suricate.Application.prototype.stopUpdates = function() {
+        if(this.updateInterval !== undefined) {
+            window.clearInterval(this.updateInterval);
+            this.updateInterval = undefined;
+        }
+    };
+
+    Suricate.Application.prototype.update = function() {
+        var now = new Date();
+        for (var widgetIndex = 0, l = this.widgets.length; widgetIndex < l; widgetIndex ++) {
+            var widget = this.widgets[widgetIndex];
+            widget.update(now);
+        }
+    };
+}());

data/lib/suricate/generator/assets/javascript/chart-js-chart-factory.js

@@ -0,0 +1,54 @@
+(function() {
+    "use strict";
+    window.Suricate = window.Suricate || {};
+
+    Suricate.ChartJSChartFactory = function() {
+
+    };
+
+    Suricate.ChartJSChartFactory.prototype.createLineChart = function(container, options) {
+        var chart = {};
+        var libraryObject;
+
+        var convertData = function(data) {
+            var datasets = [];
+            for (var index = 0, seriesCount = data.series.length; index < seriesCount; index++) {
+                var serie = data.series[index];
+                datasets.push({
+                    label: serie.name,
+                    strokeColor: serie.color,
+                    fillColor: "rgba(0, 0, 0, 0)",
+                    pointStrokeColor: serie.color,
+                    pointColor: serie.color,
+                    data: serie.values
+                });
+            }
+
+            return {
+                labels: data.labels,
+                datasets: datasets
+            };
+        };
+
+        var init = function(data, options) {
+            var ctx       = container.find(".chart")[0].getContext("2d");
+            libraryObject = new Chart(ctx).Line(data, options);
+            var legend    = libraryObject.generateLegend();
+            container.find(".legend").html(legend);
+        };
+
+        var data = {
+            labels: [],
+            datasets: [ { } ]
+        };
+        init(data, options);
+
+        chart.update = function(data) {
+            var chartJSData = convertData(data);
+            libraryObject.destroy();
+            init(chartJSData, options);
+        };
+
+        return chart;
+    };
+}());

data/lib/suricate/generator/assets/javascript/suricate.js

@@ -0,0 +1,4 @@
+(function() {
+    "use strict";
+    window.Suricate = {};
+}());