rubella 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c1a3fa7e3e6308ae4c40b2eafed842d45becec8f
+  data.tar.gz: cb9fba9155a39f45d4ad1b2b7bb07bde8d9c1005
+SHA512:
+  metadata.gz: 6d06ae6ad7da68feeb86e7cfcccabd78a29ce56d385dcea9e52d32b36eef1e875a956f47d718bd3eef647bfbacc14959969279859a8e511a170e0fe7bffbd579
+  data.tar.gz: 23f46a46d389a7598e9019ed02ebd75ad5353056c9ab96f407bd1dcb66de8db952cb1942ebf5762472744ceb9781d0b1782e370b3eb081c1ae43702ddbcd8db4

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem "RMagick"

data/LICENSE

@@ -0,0 +1,12 @@
+Copyright (c) 2015, Rebecca Dietrich
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,21 @@
+Rubella heatmap library
+=======================
+
+Rubella is a library to generate heatmaps to monitor visualize measured values
+easier. Like the load of multiple CPU cores over time.
+
+Therefore every CPU core gets its own JSON array over the measured time. So the
+array gets it's own row in the headmap. The more the color itensity the higher
+is the load.
+(The values are in percent. So they must be beween 0 and 100.)
+
+During the time you can see, if an unusual behavior occurs, because the image
+shows a different load distribution.
+
+see also: 
+http://dtrace.org/blogs/brendan/2011/12/18/visualizing-device-utilization/
+
+Usage
+-----
+
+Coming soon.

data/Rakefile

@@ -0,0 +1,36 @@
+# encoding: utf-8
+
+require 'rake'
+
+FileList['tasks/**/*.rake'].each { |task| import task }
+desc 'run all specs'
+
+task :spec => ['spec:unit', 'spec:integration']
+desc 'run all integration tests'
+
+task :integration => ['spec:integration']
+
+namespace :spec do
+  spec_defaults = lambda do |spec|
+    spec.rspec_opts = ['--options', 'spec/spec.opts']
+  end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('unit') do |task|
+  spec_defaults.call(task)
+  task.pattern = 'spec/unit/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new('integration') do |task|
+  spec_defaults.call(task)
+  task.pattern = 'spec/integration/**/*_spec.rb'
+end
+
+RSpec::Core::RakeTask.new('coverage') do |task|
+  spec_defaults.call(task)
+  task.pattern = 'spec/{unit,integration}/*_spec.rb'
+end
+
+end
+
+task :default => :spec

data/lib/rubella.rb

@@ -0,0 +1,4 @@
+module Rubella
+  require "rubella/map"
+  require "rubella/storage"
+end

data/lib/rubella/input/base.rb

@@ -0,0 +1,33 @@
+module Rubella
+  module Input
+
+    # Gets the raw data and translate it into a readable format for the
+    # Rubella::Weighting::Base class.
+    # This must be an array within subarrays, which have all the same lenght
+    # and contains only numeric data.
+    #
+    class Base
+      attr_reader :data
+
+      # Constructor
+      # Create a new Rubella::Input::Base object using the given data
+      #
+      # @param var Input data
+      # @return Rubell::Input::Base
+      #
+      def initialize data
+        @data = data
+      end
+
+      # Passes each dataset trought the given block.
+      #
+      # @param pointer to block
+      #
+      def each &block
+        @data.each &block
+      end
+
+    end
+
+  end
+end

data/lib/rubella/input/json.rb

@@ -0,0 +1,47 @@
+require 'rubella/input/base'
+require 'json'
+
+module Rubella
+  module Input
+
+    # Gets data in JSON formate and translate it into a Ruby readable form to
+    # make it possible to handle the data.
+    #
+    class JSON < Base
+
+      # Constructor
+      # This constructer can create a new Rubella::Input::JSON object, but it
+      # is supposed to be private. Please use Rubella::Input::JSON.string or
+      # Rubella::Input::JSON.file to create a new instance.
+      #
+      # @param json_string string A string, which contains the data as json
+      # @return Rubella::Input::JSON
+      #
+      def initialize json_string
+        @data = ::JSON::load json_string
+      end
+
+      # Constructor
+      # Creates a new Rubella::Input::JSON object, from the given json.
+      #
+      # @param json_string string A string, which contains the data as json
+      # @return Rubella::Input::JSON
+      def self.string json_string
+        self.new json_string
+      end
+
+      # Constructor
+      # Creates a new Rubella::Input::JSON object, from the given file.
+      # Only the file name is required.
+      #
+      # @param json_file string The name of the file, which json contains
+      # @return Rubella:Input::JSON
+      #
+      def self.file json_file
+        self.new File.new json_file, 'r'
+      end
+
+    end
+
+  end
+end

data/lib/rubella/map.rb

@@ -0,0 +1,87 @@
+module Rubella
+
+  # Helps to process and create the heatmap
+  #
+  class Map
+    attr_reader :input
+    attr_reader :output
+    attr_reader :weighting
+
+    # Constructor
+    #
+    # @param input_name string Name of the input type in CamelCase
+    # @param output_name string Name of the output type in CamelCase
+    # @param weighting_name string Name of the weighting type in CamelCase
+    # @return Rubella::Map
+    # @raise NotImplementedError
+    def initialize(input_name, output_name, weighting_name)
+
+      # set the input type
+      input_by_name input_name
+
+      # set the output type
+      output_by_name output_name
+
+      # set the weighting
+      weighting_by_name weighting_name
+
+    end
+
+    # Set the input type by the given name
+    #
+    # @param input_name string Name of the input type in CamelCase
+    # @raise NotImplementedError
+    def input_by_name input_name
+      @input = load_by_name "Input", input_name
+    end
+
+    # Set the output type by the given name
+    #
+    # @param output_name string Name of the output type in CamelCase
+    # @raise NotImplementedError
+    def output_by_name output_name
+      @output = load_by_name "Output", output_name
+    end
+
+    # Set the weighting type by the given name
+    #
+    # @param weighting_name string Name of the weighting type in CamelCase
+    # @raise NotImplementedError
+    def weighting_by_name weighting_name
+      @weighting = load_by_name "Weighting", weighting_name
+    end
+
+    # Loads and returns the given class
+    #
+    # @param module_name string The Name of the module in CamelCase
+    # @param class_name string The Name of the class in CamelCase
+    # @return Class
+    # @raise NotImplementedError
+    def load_by_name module_name, class_name
+      # Remove the class, if someone wants to do this
+      if class_name == nil or class_name == ""
+        return nil
+      end
+
+      # Try to load the given class
+      require "rubella/"+underscore(module_name)+"/"+underscore(class_name)
+
+      # Try to get a class by the given name
+      return Object.const_get("Rubella").const_get(module_name).const_get(class_name)
+
+      # TODO raise this error, if class is not found
+      # raise NotImplementedError, "Not supported input type "+input_name+" given"
+    end
+
+    # Converts CamelCase words into snake_case
+    #
+    # @param camel_cased_word string Word in CamelCase
+    # @return string
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").downcase
+    end
+
+  end
+end

data/lib/rubella/output/ascii.rb

@@ -0,0 +1,102 @@
+require "rubella/output/base"
+
+module Rubella
+  module Output
+
+    # Creates a ascii art representation of the given storage data.
+    # In @data will a ordenary String be stored. Print the String to your
+    # output field and it will shows a nice ascii art graphic.
+    # There are also different ascii art themes available. Including the
+    # possibility to add own themes.
+    # You only need to push an Array within 10 chars for the representation
+    # into the :symbols Hash. Then you can select it with set the used_symbols
+    # variable to you theme name.
+    #
+    # TODO Use setted field_size for representation
+    #
+    class ASCII < Base
+      attr_accessor :symbols
+      attr_reader   :used_symbols
+
+      # Constructor
+      # Sets the default field_size to 1.
+      # Also sets the used ascii art theme to "shades_ascii". See the
+      # used_symbols= for further information.
+      #
+      # @param data Rubella::Storage
+      # @param field_size int Used chars for one value
+      # @return Rubella::Output::ASCII
+      #
+      def initialize data, field_size = 1
+        @symbols = Hash.new
+        @symbols["shades"]       = 
+                  [" ", " ", "░", "░", "▒", "▒", "▓", "▓", "█", "█"]
+        @symbols["shades_ascii"] =
+                  [" ", "·", "⚬", "∞", "@", "#", "░", "▒", "▓", "█"]
+        @symbols["ascii"]       =
+                  [" ", "·", ",", ";", "o", "O", "%", "8", "@", "#"]
+        @symbols["numbers"] =
+                  [" ", "1", "2", "3", "4", "5", "6", "7", "8", "9"]
+
+        self.used_symbols = "shades_ascii"
+        super data, field_size
+      end
+
+      # Sets the used ascii theme by the given name.
+      # The theme must exist. You can also choose your custom theme here.
+      # The at default avaliable themes are:
+      #   * shades
+      #   * shades_ascii
+      #   * ascii
+      #   * numbers
+      #
+      # @param value String The theme name
+      # @raise ArgumentError
+      #
+      def used_symbols= value
+        if @symbols.has_key? value
+          @used_symbols = value
+          return
+        end
+        raise ArgumentError, "Symbol set not found, must be one of: " +
+          @symbols.keys.join(", ")
+      end
+
+      # Creates an ascii art representation.
+      #
+      # @return String
+      #
+      def render
+        buckets = @data.dataset_length
+        # columns = @data.length
+
+        # image size
+        # x = columns*@field_size
+        # y = buckets*@field_size
+
+        # start drawing the damn thing
+        ascii_arr = [] 
+        0.upto(buckets-1).each { |i| ascii_arr[i] = "" }
+
+        @data.each do |point|
+          i = 0
+          point.reverse.each do |part|
+            part = (part*10).to_i       
+
+            # Fix to prevent possible overflow.. should never happen, but we
+            # are careful
+            if part > 9
+              part = 9
+            end
+
+            ascii_arr[i] << @symbols[@used_symbols][part]
+            i = i+1
+          end
+        end
+
+        ascii_arr.join("\n")
+      end
+    end
+
+  end
+end

data/lib/rubella/output/base.rb

@@ -0,0 +1,37 @@
+module Rubella
+  module Output
+
+    # Output base class
+    # The output class gets the storage within the already weighted and in
+    # buckets sorted content. It creates a visual representation of the given
+    # data and stores this local.
+    #
+    class Base
+      attr_accessor :field_size
+
+      # Constructor
+      # Gets the field size to store it local. It's the size of one value of
+      # the later created visual representation. The unit depends on the kind
+      # of representation.
+      #
+      # @param data Rubella::Storage
+      # @param field_size int size of one value
+      # @return Rubella::Output::Base
+      #
+      def initialize data, field_size
+        @data       = data
+        @field_size = field_size
+      end
+
+      # Creates a visual representation.
+      #
+      # @return rendered data
+      #
+      def render
+        raise NotImplementedError.new "Please override 'render' in your "+
+          "concrete implementation"
+      end
+    end
+
+  end
+end

data/lib/rubella/output/image.rb

@@ -0,0 +1,68 @@
+require "rubella/output/base"
+require 'RMagick'
+
+module Rubella
+  module Output
+
+    # Creates a pixel based graphic as representation of the given storage
+    # data using ImageMagick.
+    # By the RMagick extention. @data will contain a Magick image for futher
+    # handling the data please read the RMagick library documentation:
+    # http://www.imagemagick.org/RMagick/doc/
+    #
+    class Image < Base
+
+      # Constructor
+      # Has a default field_size of 15 pixel.
+      #
+      # @param data Rubella::Storage
+      # @param field_size int How many pixel one value has
+      # @return Rubella::Output::Image
+      #
+      def initialize data, field_size = 15
+        super data, field_size
+      end
+
+      # Creates a pixel based graphic.
+      #
+      # @return RMagick::Image
+      #
+      def render
+        # image size
+        x = @data.length*@field_size         # columns x field_size
+        y = @data.dataset_length*@field_size # buckets x field_size
+
+        # start drawing the damn thing
+        image = Magick::Image.new(x, y) { self.background_color = "white" }
+
+        i = 0
+        @data.each do |point|
+          j = 0
+          point.reverse.each do |part|
+            # draw a red rectangle on the white background
+            core = Magick::Draw.new
+
+            idensity = 127.5 * part
+            # Fix for float stupidity
+            idensity = 127.5 if idensity > 127.5
+
+            # Get the correct value
+            l = (255-idensity).round
+
+            # Draw
+            core.fill(Magick::Pixel.from_hsla(0, 255, l, 1).to_color)
+            core.rectangle((i*@field_size), (j*@field_size), ((i+1)*@field_size), ((j+1)*@field_size))
+            core.draw image
+            j = j + 1
+          end
+          i = i + 1
+        end
+
+        image
+      end
+
+
+    end
+
+  end
+end

data/lib/rubella/storage.rb

@@ -0,0 +1,94 @@
+module Rubella
+
+  # The Rubella::Storage holds the weighted data.
+  # Storages can be added to get a timeline. But the Storage has no concrete
+  # knowledge of time.
+  # The Storage can have a defined length. If new data is added, it will drop
+  # the oldest entries.
+  #
+  class Storage
+    attr_reader :data
+    # :length
+
+    def initialize data, length = 0
+      @data       = data
+      self.length = length
+    end
+
+    # Defines the length of the Storage.
+    #
+    # Be careful, if your Storage has more entries, tha the new length, the
+    # oldest entries will immediately be dropped. If your Storage has less
+    # entries, it will be filled up with empty entries.
+    # Happens only if data has entries.
+    #
+    # Setting the length to 0 will disable this feature
+    #
+    # TODO fill up with 0 values, if data is not multidemensional
+    #
+    # @param length Integer The size of the storage
+    # @return Integer The new size
+    #
+    def length= length
+      @length = length
+
+      # Use length only, if length is valid
+      if @length != 0 and self.length != 0
+        # Drop entries, if more than new length
+        while self.length > @length
+          @data.pop
+        end
+        # Prefill with empty content, if less than new length
+        dummy_data = Array.new(self.dataset_length, 0)
+        while self.length < @length
+          @data.unshift dummy_data
+        end
+      end
+      
+      @length
+    end
+
+    # Returns the current length of the storage.
+    # (How many datasets it holds.)
+    #
+    # @return Integer length
+    #
+    def length
+      @data.length
+    end
+
+    # Returns the length of a dataset.
+    # Will return 0, if no datasets in storage.
+    #
+    # TODO Throw an error, if data has different lengths
+    #
+    # @return Integer length of one dataset
+    #
+    def dataset_length
+      return 0 if self.length == 0
+      return 1 unless @data[0].respond_to? "length"
+
+      @data[0].length
+    end
+
+    # Adds the data from the given storage to the own data and return this as a
+    # new Storage. Does not modify one of the storages. 
+    # 
+    # @param storage Rubella::Storage Storage with new data
+    # @return Rubella::Storage
+    #
+    def add storage
+      Storage.new (storage.data+@data), @length
+    end
+
+    # Passes each dataset through the given block.
+    #
+    # @param pointer to block
+    #
+    def each &block
+      @data.each &block
+    end
+
+  end
+
+end

data/lib/rubella/weighting/base.rb

@@ -0,0 +1,58 @@
+module Rubella
+  module Weighting
+
+
+    # The Rubella::Weighting object processes the given input data to an valid
+    # output processable Array. 
+    # These arrays contain a subarray for every unit of time. And these Array
+    # contain the buckets within the values for the output objects.
+    # The Weighting of the print intensitiy is done here, so that the output
+    # objects job is simply to print the stuff.
+    #
+    class Base
+      attr_reader :buckets
+      # :steps
+
+      # Constructor
+      # Creates a new Rubella::Weighting::xy object.
+      #
+      # @param buckets int must be one of 1, 2, 5, 10, 20, 50 default is 10
+      # @return Rubella::Weighting::Base
+      # @raise ArgumentError
+      #
+      def initialize buckets = 10
+        self.buckets = buckets
+      end
+
+      # Sets the buckets, if the value is valid
+      #
+      # @param buckets int The amount of buckets
+      # @raise ArgumentError
+      #
+      def buckets= buckets
+        # Must be divideable by 100
+        if [1, 2, 5, 10, 20, 50].index(buckets) == nil
+          raise ArgumentError.new "Amount of buckets must be 1, 2, 5, 10, 20 "+
+            "or 50"
+        end
+        
+        @steps   = 100/buckets
+        @buckets = buckets
+      end
+
+      # Creates a output readable list.
+      # This list is Array within a subarrays, which contain the buckets for
+      # every time value unit.
+      #
+      # @param input Rubella::Input An input object
+      # @return Rubella::Storage
+      #
+      def parse input
+        raise NotImplementedError.new "Please override 'parse' in your "+
+          "concrete implementation"
+      end
+
+    end
+
+  end
+end

data/lib/rubella/weighting/exponential.rb

@@ -0,0 +1,48 @@
+require "rubella/weighting/base"
+
+module Rubella
+  module Weighting
+
+    # The Rubella::Weighting::Exponential object weights every bucket per
+    # amount of cores. But the cores with higher load get a visualisation
+    # boost, which is exponential. So one high load core, will have much more
+    # color, than serveral less load cores.
+    #
+    class Exponential < Base
+
+      # Creates a output readable list.
+      # This list is Array within a subarrays, which contain the buckets for
+      # every time value unit.
+      #
+      # @param input Rubella::Input An input object
+      # @return Rubella::Storage
+      def parse input
+        # prepare data
+        data_list    = Array.new()
+        bucket_no    = 0
+
+        input.each do |cores|
+          # every 10 load percent one heatpoint
+          i = 0
+          data_list << Array.new(buckets) do
+            current_cores = cores.select do |core|
+              core >= i and
+                ((core < (i+@steps)) or (core <= (i+@steps) and i+@steps == 100))
+            end
+
+            amount = current_cores.length
+            i         = i + @steps
+            core      = (amount.to_f*bucket_no**0.8)/cores.length
+            bucket_no = bucket_no + 1
+
+            core
+          end
+        end
+
+        Rubella::Storage.new data_list
+      end
+
+    end
+
+  end
+end

data/lib/rubella/weighting/per_count.rb

@@ -0,0 +1,61 @@
+require "rubella/weighting/base"
+
+module Rubella
+  module Weighting
+
+    # The Rubella::Weighting::PerCount create a field of each given value.
+    # The weighting is based on the maximum value.
+    #
+    class PerCount < Base
+
+      # Constructor
+      # Creates a new Rubella::Weighting::PerCount object.
+      #
+      # @param buckets int
+      # @return Rubella::Weighting::Base
+      # @raise ArgumentError
+      #
+      def initialize buckets = 7
+        super buckets
+      end
+
+      # Sets the buckets
+      #
+      # @param buckets int The amount of buckets
+      # @raise ArgumentError
+      #
+      def buckets= buckets
+        @buckets = buckets
+      end
+
+      # Creates a output readable list.
+      # This list is Array within a subarrays, which contain the buckets for
+      # every time value unit.
+      #
+      # @param input Rubella::Input An input object
+      # @return Rubella::Storage
+      def parse input
+        # prepare data
+        data_list = Array.new()
+
+        # Get the maximum of commits
+        max = input.sort.pop
+
+        i = 0
+        input.each do |commits|
+          data_list << Array.new() if i == 0
+          data_list.last << commits.to_f/max
+          if i == (buckets-1)
+            i = 0
+          else
+            i = i + 1
+          end
+        end
+
+        Rubella::Storage.new data_list
+      end
+      
+    end
+
+  end
+end

data/lib/rubella/weighting/per_overall_load.rb

@@ -0,0 +1,54 @@
+require "rubella/weighting/base"
+
+module Rubella
+  module Weighting
+
+    # The Rubella::Weighting::PerOverallValue object summarizes the load of all
+    # cores in a time and computes how much load is one percent. Then it uses
+    # this as factor to weight the summarized load of every bucket.
+    # So your representation will show you the higher load cores more
+    # intensive, then the cores with lower load, depending on the current load.
+    #
+    class PerOverallLoad < Base
+
+      # Creates a output readable list.
+      # This list is Array within a subarrays, which contain the buckets for
+      # every time value unit.
+      #
+      # @param input Rubella::Input An input object
+      # @return Rubella::Storage
+      def parse input
+        # prepare data
+        data_list = Array.new()
+
+        input.each do |cores|
+
+          # Add all loads to compute how much % is one % load
+          load_sum = 0
+          cores.each { |core| load_sum = load_sum + core }
+          percent_load = 100.0/load_sum
+
+          # every 10 load percent one heatpoint
+          i = 0
+          data_list << Array.new(buckets) do
+            # Select all current cores
+            selected_cores = cores.select do |core|
+              core >= i and
+                ((core < (i+@steps)) or (core <= (i+@steps) and i+@steps == 100))
+            end
+            i = i + @steps
+
+            # add the load of the resulting cores and multiply it with the overall value
+            load_sum = 0
+            selected_cores.each { |core| load_sum = load_sum + core }
+            (load_sum.to_f*percent_load)/100
+          end
+        end
+
+        Rubella::Storage.new data_list
+      end
+
+    end
+
+  end
+end

data/lib/rubella/weighting/per_value.rb

@@ -0,0 +1,43 @@
+require "rubella/weighting/base"
+
+module Rubella
+  module Weighting
+
+    # The Rubella::Weighting::PerValue object weights every bucket set to 1 in
+    # amount. So if you have have for example four cores, every core is
+    # weighted to 0.25 no matter how much the load of a single core is. It's
+    # just a "as is" weighting.
+    #
+    class PerValue < Base
+
+      # Creates a output readable list.
+      # This list is Array within a subarrays, which contain the buckets for
+      # every time value unit.
+      #
+      # @param input Rubella::Input An input object
+      # @return Rubella::Storage
+      def parse input
+        # prepare data
+        data_list = Array.new()
+
+        input.each do |cores|
+          # every 10 load percent one heatpoint
+          i = 0
+          data_list << Array.new(buckets) do
+            current_cores = cores.select do |core|
+              core >= i and
+                ((core < (i+@steps)) or (core <= (i+@steps) and i+@steps == 100))
+            end
+            amount = current_cores.length
+            i      = i + @steps
+            amount.to_f/cores.length
+          end
+        end
+
+        Rubella::Storage.new data_list
+      end
+      
+    end
+
+  end
+end

data/spec/fixtures/json/test_01.json

@@ -0,0 +1 @@
+[1, 2, 3]

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--order random
+--format d

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+if ENV['SIMPLECOV']
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '_spec.rb'
+    add_filter 'spec_helper.rb'
+  end
+end
+
+require 'rubella'
+require 'rubella/storage'
+require 'rubella/input/json'

data/spec/unit/rubella/input/base/data_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Rubella::Input::Base, '.data' do
+
+  it "retuns the stored data" do
+    input = Rubella::Input::Base.new [3, 4, 5]
+
+    expect(input.data).to eq([3, 4, 5])
+  end
+
+end

data/spec/unit/rubella/input/base/each_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Rubella::Input::Base, '.each' do
+
+  it "passes the data through the given block" do
+    input = Rubella::Input::Base.new [3, 4, 5]
+
+    sum = 0
+    input.each do |value|
+      sum = sum + value
+    end
+
+    expect(sum).to eq(12)
+  end
+
+end

data/spec/unit/rubella/input/base/new_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Rubella::Input::Base, '.new' do
+
+  it "creates a new Input instance" do
+    input = Rubella::Input::Base.new nil
+
+    expect(input).to be_instance_of(Rubella::Input::Base)
+  end
+
+  it "uses the given data" do
+    input = Rubella::Input::Base.new 54
+
+    expect(input.data).to eq(54)
+  end
+
+end

data/spec/unit/rubella/input/json/data_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Rubella::Input::JSON, '.data' do
+
+  it "returns the stored data" do
+    input = Rubella::Input::JSON.string "[3, 4, 5]"
+
+    expect(input.data).to eq([3, 4, 5])
+  end
+
+end

data/spec/unit/rubella/input/json/each_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Rubella::Input::JSON, '.each' do
+
+  it "passes the data through the given block" do
+    input = Rubella::Input::JSON.string "[3, 4, 5]"
+
+    sum = 0
+    input.each do |value|
+      sum = sum + value
+    end
+
+    expect(sum).to eq(12)
+  end
+
+end

data/spec/unit/rubella/input/json/self_file_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Rubella::Input::JSON, '#self.file' do
+  
+  it 'returns a Rubella::Input::JSON object' do
+    input = Rubella::Input::JSON.file 'spec/fixtures/json/test_01.json'
+
+    expect(input).to be_instance_of(Rubella::Input::JSON)
+  end
+
+  it "uses the given data" do
+    input = Rubella::Input::JSON.file 'spec/fixtures/json/test_01.json'
+
+    expect(input.data).to eq([1, 2, 3])
+  end
+
+end

data/spec/unit/rubella/input/json/self_string_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Rubella::Input::JSON, '#self.string' do
+  
+  it 'returns a Rubella::Input::JSON object' do
+    input = Rubella::Input::JSON.string '[]'
+
+    expect(input).to be_instance_of(Rubella::Input::JSON)
+  end
+
+  it "uses the given data" do
+    input = Rubella::Input::JSON.string '[1, 2, 3]'
+
+    expect(input.data).to eq([1, 2, 3])
+  end
+
+end

data/spec/unit/rubella/storage/add_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Rubella::Storage, '.add' do
+  
+  it "returns a new Storage with the given Storages data before the old" do
+    storage_1 = Rubella::Storage.new [3, 4, 5]
+    storage_2 = Rubella::Storage.new [0, 1, 2]
+
+    storage_new = storage_1.add storage_2
+    expect(storage_new.data).to eq([0, 1, 2, 3, 4, 5])
+  end
+
+  it "uses the length of the first given Storage" do
+    storage_1 = Rubella::Storage.new [3, 4, 5, 6, 7], 4
+    storage_2 = Rubella::Storage.new [0, 1, 2], 3
+
+    storage_new = storage_1.add storage_2
+    expect(storage_new.length).to eq 4
+  end
+
+  it "chops the data to the given length" do
+    storage_1 = Rubella::Storage.new [3, 4, 5, 6, 7], 4
+    storage_2 = Rubella::Storage.new [0, 1, 2], 3
+
+    storage_new = storage_1.add storage_2
+    expect(storage_new.data).to eq([0, 1, 2, 3])
+  end
+
+end

data/spec/unit/rubella/storage/data_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Rubella::Storage, '.data' do
+
+  it "retuns the stored data" do
+    storage = Rubella::Storage.new [3, 4, 5]
+
+    expect(storage.data).to eq([3, 4, 5])
+  end
+
+end

data/spec/unit/rubella/storage/dataset_length_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Rubella::Storage, '.dataset_length' do
+
+  it "returns 0 if Storage is empty" do
+    storage = Rubella::Storage.new []
+
+    expect(storage.dataset_length).to eq(0)
+  end
+
+  it "returns 1 if Storage holds one dimensional array" do
+    storage = Rubella::Storage.new [1, 2, 3]
+
+    expect(storage.dataset_length).to eq(1)
+  end
+
+  it "returns 1 if Storage datasets have a length of 1" do
+    storage = Rubella::Storage.new [[1], [2], [3]]
+
+    expect(storage.dataset_length).to eq(1)
+  end
+
+  it "returns the length of the datasets" do
+    storage = Rubella::Storage.new [[1, 2], [3, 4], [5, 6]]
+
+    expect(storage.dataset_length).to eq(2)
+  end
+
+end

data/spec/unit/rubella/storage/each_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Rubella::Storage, '.each' do
+
+  it "passes the data through the given block" do
+    storage = Rubella::Storage.new [3, 4, 5]
+
+    sum = 0
+    storage.each do |value|
+      sum = sum + value
+    end
+
+    expect(sum).to eq(12)
+  end
+
+end

data/spec/unit/rubella/storage/length_eql_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Rubella::Storage, '.length=' do
+
+  it "sets the length to the given value" do
+    storage = Rubella::Storage.new [3, 4, 5]
+
+    storage.length = 2
+
+    expect(storage.length).to eq(2)
+  end
+
+  it "chops the data to the given length" do
+    storage = Rubella::Storage.new [3, 4, 5]
+
+    storage.length = 2
+
+    expect(storage.data.length).to eq(2)
+  end
+
+  it "disables the length chopping, if its set to 0" do
+    storage = Rubella::Storage.new [3, 4, 5]
+
+    storage.length = 0
+
+    expect(storage.data.length).to eq(3)
+  end
+
+  it "grows the data to the given length" do
+    storage = Rubella::Storage.new [[0, 1], [2, 3], [4, 5]]
+
+    storage.length = 5
+
+    expect(storage.data.length).to eq(5)
+  end
+
+  it "grows the data by using the length of the dataset as array length" do
+    storage = Rubella::Storage.new [[0, 1], [2, 3], [4, 5]]
+
+    storage.length = 5
+
+    expect(storage.data[0].length).to eq(2)
+    expect(storage.data[1].length).to eq(2)
+    expect(storage.data[2].length).to eq(2)
+    expect(storage.data[3].length).to eq(2)
+    expect(storage.data[4].length).to eq(2)
+  end
+
+  it "grows the data by using 0 values" do
+    storage = Rubella::Storage.new [[0, 1], [2, 3], [4, 5]]
+
+    storage.length = 5
+
+    expect(storage.data[0][0]).to eq(0)
+    expect(storage.data[0][1]).to eq(0)
+    expect(storage.data[1][0]).to eq(0)
+    expect(storage.data[1][1]).to eq(0)
+  end
+
+  it "does not grow the data, if Storage is empty" do
+    storage = Rubella::Storage.new []
+
+    storage.length = 5
+
+    expect(storage.data.length).to eq(0)
+  end
+
+end

data/spec/unit/rubella/storage/length_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Rubella::Storage, '.length' do
+
+  it "returns the current length" do
+    storage = Rubella::Storage.new [3, 4, 5]
+
+    expect(storage.length).to eq 3
+  end
+
+end

data/spec/unit/rubella/storage/new_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Rubella::Storage, '.new' do
+
+  it "creates a new Storage" do
+    storage = Rubella::Storage.new []
+
+    expect(storage).to be_an_instance_of(Rubella::Storage)
+  end
+
+  it "fills the Storage with the given data" do
+    storage = Rubella::Storage.new [1, 2, 3]
+
+    expect(storage.data).to eq([1, 2, 3])
+  end
+
+  it "disable length feature, if no length is given" do
+    storage = Rubella::Storage.new [1, 2, 3]
+
+    expect(storage.length).to eq(3)
+    expect(storage.data.length).to eq(3)
+  end
+
+  it "disable length feature, if length is 0" do
+    storage = Rubella::Storage.new [1, 2, 3], 0
+
+    expect(storage.length).to eq(3)
+    expect(storage.data.length).to eq(3)
+  end
+
+  it "sets the length" do
+    storage = Rubella::Storage.new [1, 2, 3], 2
+
+    expect(storage.length).to eq(2)
+  end
+
+  it "uses length feature, if length is given" do
+    storage = Rubella::Storage.new [1, 2, 3], 2
+
+    expect(storage.data.length).to eq(2)
+  end
+
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: rubella
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Stormwind
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-05 00:00:00.000000000 Z
+dependencies: []
+description: |-
+  Rubella is a library to generate heatmaps to monitor visualize measured values
+  easier. Like the load of multiple CPU cores over time.
+email: rebecca@quantenteilchen.de
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/rubella.rb
+- lib/rubella/input/base.rb
+- lib/rubella/input/json.rb
+- lib/rubella/map.rb
+- lib/rubella/output/ascii.rb
+- lib/rubella/output/base.rb
+- lib/rubella/output/image.rb
+- lib/rubella/storage.rb
+- lib/rubella/weighting/base.rb
+- lib/rubella/weighting/exponential.rb
+- lib/rubella/weighting/per_count.rb
+- lib/rubella/weighting/per_overall_load.rb
+- lib/rubella/weighting/per_value.rb
+- spec/fixtures/json/test_01.json
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/unit/rubella/input/base/data_spec.rb
+- spec/unit/rubella/input/base/each_spec.rb
+- spec/unit/rubella/input/base/new_spec.rb
+- spec/unit/rubella/input/json/data_spec.rb
+- spec/unit/rubella/input/json/each_spec.rb
+- spec/unit/rubella/input/json/self_file_spec.rb
+- spec/unit/rubella/input/json/self_string_spec.rb
+- spec/unit/rubella/storage/add_spec.rb
+- spec/unit/rubella/storage/data_spec.rb
+- spec/unit/rubella/storage/dataset_length_spec.rb
+- spec/unit/rubella/storage/each_spec.rb
+- spec/unit/rubella/storage/length_eql_spec.rb
+- spec/unit/rubella/storage/length_spec.rb
+- spec/unit/rubella/storage/new_spec.rb
+homepage: https://github.com/Stormwind/rubella
+licenses:
+- 3-clause BSD
+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.6
+signing_key: 
+specification_version: 4
+summary: Library to generate heatmaps
+test_files:
+- spec/fixtures/json/test_01.json
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/unit/rubella/input/base/data_spec.rb
+- spec/unit/rubella/input/base/each_spec.rb
+- spec/unit/rubella/input/base/new_spec.rb
+- spec/unit/rubella/input/json/data_spec.rb
+- spec/unit/rubella/input/json/each_spec.rb
+- spec/unit/rubella/input/json/self_file_spec.rb
+- spec/unit/rubella/input/json/self_string_spec.rb
+- spec/unit/rubella/storage/add_spec.rb
+- spec/unit/rubella/storage/data_spec.rb
+- spec/unit/rubella/storage/dataset_length_spec.rb
+- spec/unit/rubella/storage/each_spec.rb
+- spec/unit/rubella/storage/length_eql_spec.rb
+- spec/unit/rubella/storage/length_spec.rb
+- spec/unit/rubella/storage/new_spec.rb