minichart 0.2.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 767c1bdbf55e5aedb689c5286535fb84d3c48cf2c1c054b01da97237dee3437a
-  data.tar.gz: ea0b462ccfd166eea1df2e2a4ad08f32060c713a06f1aea36170079bc90a3671
+  metadata.gz: 3c2af3f30a91b6f557ec75c02d6250153919290dd962c318bd58008600068b22
+  data.tar.gz: b00bd9ad950b213a7430178d55673aed0b9f4ee80b3b82f20a456d16f2d91b5d
 SHA512:
-  metadata.gz: 57524a378c6ce4df0ad08d4edc134630d3ae6ebbb35e68638f11926ab61f4c3b3f6e8e0861d49213de54d619d52df2cb74c4813e2349409e9e444b0ddca2cb44
-  data.tar.gz: 45820a40054e716bfe412d661ba814ea4fb8589b39145fbeff6a079841ea83990d2adbaf6733c328378627133eaaa5891f5e87d268f66abab69a412727cbc29a
+  metadata.gz: e183bdd8e7876c9f58503a3edcc80ffaf1fa1d03fde54d400de153e894bb3e51012f30d7b87683c887c2f482cedc331d57ea14fc5ddc4ae4f5c318e2bdc30a22
+  data.tar.gz: fbca221fb51fa31ee37b1532c2a4d0d7f28b44d94aeaf3c47b7c8744d68dc0188a44341fc265ba286c84eea479350be3d0be4b45d32a5b2dd5152917677f3ce1

data/README.md

@@ -8,6 +8,28 @@ Create SVG mini charts with Ruby
 
 ---
 
+* [Install](#install)
+* [Usage](#usage)
+* [Chart Types](#chart-types)
+  * [Line Chart](#line-chart)
+  * [Bar Chart](#bar-chart)
+  * [Area Chart](#area-chart)
+  * [Horizontal Bar Meter](#horizontal-bar-meter)
+  * [Vertical Bar Meter](#vertical-bar-meter)
+  * [Horizontal Status Leds](#horizontal-status-leds)
+  * [Vertical Status Leds](#vertical-status-leds)
+* [Configuration](#configuration)
+  * [Class-level default options](#class-level-default-options)
+  * [Instance initialization options](#instance-initialization-options)
+  * [Instance-level options](#instance-level-options)
+* [Options Reference](#options-reference)
+  * [Basic Options](#basic-options)
+  * [Meter Options](#meter-options)
+  * [Leds Options](#leds-options)
+* [Examples](#examples)
+
+---
+
 ## Install
 
 ```shell
@@ -33,15 +55,13 @@ Initialize a chart with data, and optional options:
 
 ```ruby
 data = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 9]
-line = LineChart.new data, color: 'blue'
-bars = BarChart.new data, color: 'blue'
-area = AreaChart.new data, color: 'blue'
+chart = AreaChart.new data, color: 'blue'
 ```
 
 Get the full SVG output by calling `#render`:
 
 ```ruby
-puts area.render
+puts chart.render
 #=> <?xml version="1.0" standalone="no"?>
 #   <svg> ... </svg>
 ```
@@ -49,42 +69,194 @@ puts area.render
 Save it to file, by calling `#save`:
 
 ```ruby
-area.save "my-chart.svg"
+chart.save "my-chart.svg"
 ```
 
 Get its inner SVG string by calling `#to_s`:
 
 ```ruby
-puts area.to_s
+puts chart.to_s
 #=> <polyline fill="blue" stroke="blue" stroke-width="2" points="..."/>
 ```
 
 
 The objects returned from all the mini chart classes are [Victor::SVG][2] objects, so they support all methods supported by it as well.
 
-## Options
+## Chart Types
+
+### Line Chart
+
+<img src='examples/line_chart.svg' align='right' width=300>
+
+```ruby
+LineChart.new [10, 30, 20, 40, 30], background: '#eee',
+  height: 50, width: 250, color: 'green'
+```
+
+### Bar Chart
+
+<img src='examples/bar_chart.svg' align='right' width=300>
+
+```ruby
+BarChart.new [10, 30, 20, 40, 30], background: '#eee',
+  height: 50, width: 250, color: 'green'
+```
+
+### Area Chart
+
+<img src='examples/area_chart.svg' align='right' width=300>
+
+```ruby
+AreaChart.new [10, 30, 20, 40, 30], background: '#eee',
+  height: 50, width: 250, color: 'green'
+```
+
+### Horizontal Bar Meter
+
+<img src='examples/multiple_horizontal_bars.svg' align='right'>
+
+```ruby
+positive = HorizontalBarMeter.new 70,
+  height: 20, width: 250, background: '#9f9', color: 'green'
+
+negative = HorizontalBarMeter.new -80,
+  height: 20, width: 250, background: '#f99', color: 'red'
+
+dual = HorizontalBarMeter.new 80,
+  height: 20, width: 250, background: '#99f', color: 'blue',
+  mode: :dual, notches: [0]
+```
+
+Meter charts support [additional options](#meter-options).
+
+### Vertical Bar Meter
+
+<img src='examples/multiple_vertical_bars.svg' align='right'>
+
+```ruby
+positive = VerticalBarMeter.new 70,
+  width: 20, height: 250, background: '#9f9', color: 'green'
+
+negative = VerticalBarMeter.new -80,
+  width: 20, height: 250, background: '#f99', color: 'red'
+
+dual = VerticalBarMeter.new 80,
+  width: 20, height: 250, background: '#99f', color: 'blue',
+  mode: :dual, notches: [0]
+```
+
+Meter charts support [additional options](#meter-options).
+
+### Horizontal Status Leds
+
+<img src='examples/horizontal_status_leds.svg' align='right' width=150>
 
-All minichart classes support a second hash argument for options
+```ruby
+HorizontalStatusLeds.new [1,1,-1,0,1,1,1,1,1,-1,-1,1],
+  background: '#ccc'
+```
+
+Led charts support [additional options](#leds-options).
+
+### Vertical Status Leds
+
+<img src='examples/vertical_status_leds.svg' align='right' width=25>
+
+```ruby
+VerticalStatusLeds.new [1,1,1,1,-1,1,-1,1,0,1],
+  background: '#ccc'
+```
+
+Led charts support [additional options](#leds-options).
+
+
+## Configuration
+
+Chart options can be set in one of three ways.
+
+### Class-level default options
+
+See or set default options for any chart class by calling its `::options` method:
+
+```ruby
+# See all options
+p AreaChart.options
+#=> {:background=>"white", :height=>100, :width=>300, :stroke=>2, :style=>{}, :color=>"#66f"}
+
+# Set a single default option
+AreaChart.options[:color] = '#333'
+
+# Set multiple options at once
+AreaChart.options background: 'black', color: 'green'
+```
+
+### Instance initialization options
+
+Set options by providing a hash as the second argument on initialization:
 
 ```ruby
-chart = LineChart.new data, options
+chart = AreaChart.new data, height: 120, width: 500
 ```
 
-| Option         | Default                      | Description             |
-| -------------- | ---------------------------- | ----------------------- |
-| `background`   | *None*                       | Chart background color  |
-| `color`        | #333                         | Chart color             |
-| `aspect_ratio` | 3                            | Set automatic width     |
-| `height`       | 100                          | Chart height in pixels  |
-| `width`        | Calculated by `aspect_ratio` | Chart width in pixels   |
-| `stroke`       | 2                            | Line stroke width       |
-| `style`        | *None*                       | Style hash for the SVG  |
+### Instance-level options
+
+After initialization, you can still update individual options:
+
+```ruby
+chart = AreaChart.new data
+chart.options[:background] = 'yellow'
+```
+
+## Options Reference
+
+### Basic Options
 
+- **background**: Chart background color.
+- **color**: Chart color.
+- **height**: Chart height in pixels.
+- **width**: Chart width in pixels.
+- **stroke**: Line stroke width. This has a different effect in different chart types.
+- **style**: CSS Style hash to apply to the entire SVG.
+- **padding**: Chart padding in pixels.
+
+### Meter Options
+
+Meter charts support these options in additon to the basic options:
+
+- **mode**: Display mode. Can be `:positive`, `:negative`, `:dual` or `:auto` (default).
+  The `:auto` mode will switch between `:positive` and `:negative` based on the
+  value.
+- **max**: The absolute maximum value. This number should be positive even for negative
+  charts.
+- **notches**: An array of one or more levels to place a notch marker. Use positive values
+  only.
+- **notch_thickness**: Thickness of the notch markers.
+- **notch_color**: Color of the notch markers.
+- **clipping_indicator**: If true, show a marker when the value exceeds the range.
+- **clipping_indicator_thickness**: Thickness of the clipping indicator.
+- **clipping_indicator_color**: Color of the clipping indicator.
+
+### Leds Options
+
+Led charts support these options in additon to the basic options (excluding
+the `color` option):
+
+- **positive_color**: Color to use when the value is greater than 0.
+- **negative_color**: Color to use when the value is less than 0.
+- **neutral_color**: Color to use when the value is 0 or nil.
+- **min_opacity**: A value between 0 and 1 representing the minimum opacity that will be applied to values when they are lower than the maximum range.
 
 ## Examples
 
 See more examples (code and SVG output) in the [examples folder][1].
 
+## Contributing / Support
+
+If you experience any issue, have a question or a suggestion, or if you wish
+to contribute, feel free to [open an issue][issues].
+
+---
 
 [1]: https://github.com/DannyBen/minichart/tree/master/examples#examples
-[2]: https://github.com/DannyBen/victor
+[2]: https://github.com/DannyBen/victor
+[issues]: https://github.com/DannyBen/minichart/issues

data/lib/minichart.rb

@@ -1,7 +1,15 @@
 require 'victor'
-require 'minichart/chart'
-require 'minichart/line_chart'
-require 'minichart/bar_chart'
-require 'minichart/area_chart'
+require 'minichart/id_generator'
+require 'minichart/base'
+require 'minichart/charts/chart'
+require 'minichart/charts/line_chart'
+require 'minichart/charts/bar_chart'
+require 'minichart/charts/area_chart'
+require 'minichart/meters/meter'
+require 'minichart/meters/vertical_bar_meter'
+require 'minichart/meters/horizontal_bar_meter'
+require 'minichart/leds/leds'
+require 'minichart/leds/horizontal_status_leds'
+require 'minichart/leds/vertical_status_leds'
 
 require 'byebug' if ENV['BYEBUG']

data/lib/minichart/base.rb

@@ -0,0 +1,72 @@
+module Minichart
+  # Base class for all Minichart classes
+  class Base < Victor::SVGBase
+    attr_reader :data, :options
+
+    class << self
+      def master_defaults
+        {
+          background: 'white',
+          height: 100,
+          width: 300,
+          stroke: 2,
+          style: {},
+          color: '#66f',
+          padding: 10,
+        }
+      end
+
+      # For subclasses to define
+      def defaults
+        {}
+      end
+
+      def options(update_hash = nil)
+        @options ||= master_defaults.merge defaults
+        @options.merge! update_hash if update_hash
+        @options
+      end
+    end
+
+    def initialize(data, user_options = {})
+      @data = data
+      @options = self.class.options.merge user_options
+
+      super viewBox: viewbox, style: options[:style]
+      element :rect, x: 0, y: 0,
+        width: full_width, height: full_height,
+        fill: options[:background], stroke_width: 0
+
+      clip_path_id = IDGenerator.next
+      setup_clip_path clip_path_id
+
+      element :g, clip_path: "url(##{clip_path_id})" do
+        build
+      end      
+    end
+
+    def setup_clip_path(id)
+      element :defs do
+        element :clipPath, id: id do
+          element :rect, width: full_width, height: full_height
+        end
+      end
+    end
+
+    def viewbox
+      "0 0 #{full_width} #{full_height}"
+    end
+
+    def full_height
+      options[:height] + options[:padding] * 2
+    end
+
+    def full_width
+      options[:width] + options[:padding] * 2
+    end
+
+    def build
+      raise NotImplementedError, "#build is not implemented"
+    end
+  end
+end

data/lib/minichart/charts/area_chart.rb

@@ -0,0 +1,31 @@
+module Minichart
+  class AreaChart < Chart
+    def build
+      element :polyline, fill: options[:color],
+        stroke: options[:color],
+        stroke_width: options[:stroke],
+        stroke_linejoin: :round,
+        stroke_linecap: :round,
+        points: points
+    end
+
+  protected
+
+    def points
+      first_point = "#{options[:padding]},#{options[:height] + options[:padding]}"
+      result = [first_point]
+
+      inverted_points.each do |point|
+        x = options[:width] * point[0] + options[:padding]
+        y = options[:height] * point[1] + options[:padding]
+        result << "#{x},#{y}"
+      end
+
+      result << "#{options[:width] + options[:padding]},#{options[:height] + options[:padding]}"
+      result << first_point
+      
+
+      result
+    end
+  end
+end

data/lib/minichart/charts/bar_chart.rb

@@ -0,0 +1,34 @@
+module Minichart
+  class BarChart < Chart
+    def build
+      opts  = { x_point_count: data.size }
+
+      inverted_points(opts).each do |x, y|
+        element :rect, bar_options(x, y)
+      end
+    end
+
+  protected
+
+    def bar_width
+      @bar_width ||= options[:width] / data.size
+    end
+
+    def bar_options(x, y)
+      y = y * options[:height] + options[:padding]
+
+      bar_height = options[:height] - y + options[:padding]
+      { 
+        x: x * options[:width] + options[:padding], 
+        y: y, 
+        width: bar_width,
+        height: bar_height,
+        style: {
+          fill: options[:color],
+          stroke_width: options[:stroke],
+          stroke: options[:background]
+        }
+      }
+    end
+  end
+end

data/lib/minichart/charts/chart.rb

@@ -0,0 +1,28 @@
+module Minichart
+  # Base class for charts with data series
+  class Chart < Base
+  
+  protected
+
+    def inverted_points(opts={})
+      normalized_points(opts).map { |point| [point[0], 1-point[1]] }
+    end
+
+    def normalized_points(opts={})
+      x_point_count = opts[:x_point_count] || data.count-1
+
+      range   = (data.max - data.min).to_f
+      x_width = 1 / (x_point_count).to_f
+      result  = []
+
+      data.each_with_index do |y, index|
+        x = index*x_width
+        y = (y - data.min) / range
+        result << [x,y]
+      end
+
+      result
+    end
+
+  end
+end

data/lib/minichart/{line_chart.rb → charts/line_chart.rb}

@@ -1,10 +1,11 @@
 module Minichart
   class LineChart < Chart
     def build
-      polyline fill: :none,
-        stroke: color,
-        stroke_width: stroke,
+      element :polyline, fill: :none,
+        stroke: options[:color],
+        stroke_width: options[:stroke],
         stroke_linejoin: :round,
+        stroke_linecap: :round,
         points: points
     end
 
@@ -13,8 +14,8 @@ module Minichart
     def points
       result = []
       inverted_points.each do |point|
-        x = width*point[0]
-        y = height*point[1]
+        x = options[:width] * point[0] + options[:padding]
+        y = options[:height] * point[1] + options[:padding]
         result << "#{x},#{y}"
       end
       result

data/lib/minichart/id_generator.rb

@@ -0,0 +1,14 @@
+module Minichart
+  module IDGenerator
+    class << self
+      def next
+        @id ||= 0
+        "minichart-#{@id += 1}"
+      end
+
+      def reset
+        @id = 0
+      end
+    end
+  end
+end

data/lib/minichart/leds/horizontal_status_leds.rb

@@ -0,0 +1,44 @@
+module Minichart
+  class HorizontalStatusLeds < Leds
+    class << self
+      def defaults
+        leds_defaults.merge width: 300, height: 50
+      end
+    end
+
+    def build
+      data.each_with_index do |value, i|
+        element :rect, bar_options(value, i)
+      end
+    end
+
+  protected
+
+    def bar_width
+      @bar_width ||= options[:width] / data.size.to_f
+    end
+
+    def bar_options(value, i)
+      color = if value == 0 or !value
+        :neutral_color
+      elsif value > 0
+        :positive_color
+      else
+        :negative_color
+      end
+
+      { 
+        x: (options[:padding] + i * bar_width),
+        y: options[:padding], 
+        width: bar_width,
+        height: options[:height],
+        style: {
+          opacity: opacity(value),
+          fill: options[color],
+          stroke_width: options[:stroke],
+          stroke: options[:background]
+        }
+      }
+    end
+  end
+end

data/lib/minichart/leds/leds.rb

@@ -0,0 +1,31 @@
+module Minichart
+  # Base class for led charts
+  class Leds < Base
+    class << self
+      def leds_defaults
+        @meter_defaults ||= {
+          positive_color: '#6f6',
+          negative_color: '#f66',
+          neutral_color: '#eee',
+          min_opacity: 1,
+          padding: 2,
+        }
+      end
+    end
+
+  protected
+
+    # Returns opacith level for a given value
+    def opacity(value)
+      return 1 if !value or value == 0
+      value.abs * ((1 - options[:min_opacity]) / max) + options[:min_opacity]
+    end
+
+    # Returns the absolute highest or loest value.
+    # Used to define the availble range of values
+    def max
+      @max ||= [data.compact.max, data.compact.min.abs].max.to_f
+    end
+
+  end
+end

data/lib/minichart/leds/vertical_status_leds.rb

@@ -0,0 +1,50 @@
+module Minichart
+  class VerticalStatusLeds < Leds
+    class << self
+      def defaults
+        leds_defaults.merge width: 50, height: 300
+      end
+    end
+
+    def build
+      data.each_with_index do |value, i|
+        element :rect, bar_options(value, i)
+      end
+    end
+
+  protected
+
+    def points
+      @points ||= data.size
+    end
+
+    def bar_height
+      @bar_height ||= options[:height] / points.to_f
+    end
+
+    def bar_options(value, i)
+      y = options[:padding] + (points - i - 1) * bar_height
+      
+      color = if value == 0 or !value
+        :neutral_color
+      elsif value > 0
+        :positive_color
+      else
+        :negative_color
+      end
+
+      { 
+        x: options[:padding],
+        y: y,
+        width: options[:width],
+        height: bar_height,
+        style: {
+          opacity: opacity(value),
+          fill: options[color],
+          stroke_width: options[:stroke],
+          stroke: options[:background]
+        }
+      }
+    end
+  end
+end

data/lib/minichart/meters/horizontal_bar_meter.rb

@@ -0,0 +1,81 @@
+module Minichart
+  class HorizontalBarMeter < Meter
+    class << self
+      def defaults
+        meter_defaults.merge width: 300, height: 50
+      end
+    end
+
+    def build
+      draw_bar
+      draw_notches if options[:notches]
+      draw_clipping_indicator if options[:clipping_indicator] and clipping?
+    end
+
+  protected
+
+    def draw_bar
+      x1 = x_for 0
+      x2 = x_for clamped_value
+      x = [x1, x2].min
+
+      element :rect, x: x, y: options[:padding], height: options[:height],
+        width: bar_width, style: style
+    end
+
+    def draw_notches
+      options[:notches].each do |notch|
+        draw_notch notch
+        draw_notch -notch if mode == :dual and notch != 0
+      end
+    end
+
+    def draw_notch(notch)
+      draw_vertical_line notch, stroke: options[:notch_thickness],
+        color: options[:notch_color]
+    end
+
+    def draw_clipping_indicator
+      draw_vertical_line clamped_value,
+        stroke: options[:clipping_indicator_thickness],
+        color: options[:clipping_indicator_color]
+    end
+
+    def draw_vertical_line(target_value, color:, stroke:)
+      x = x_for target_value
+
+      element :line, x1: x, x2: x,
+        y1: options[:padding], y2: options[:height] + options[:padding],
+        stroke: color, stroke_width: stroke
+    end
+
+    def width_factor
+      options[:width] / options[:max].to_f
+    end
+
+    def half_width
+      options[:width] * 0.5
+    end
+
+    def bar_width
+      if mode == :dual
+        clamped_value.abs * width_factor * 0.5
+      else
+        clamped_value.abs * width_factor
+      end
+    end
+
+    def x_for(target_value)
+      result = target_value.abs / options[:max].to_f * options[:width] + options[:padding]
+
+      case mode
+      when :positive
+        result
+      when :negative
+        full_width - result
+      when :dual
+        target_value / options[:max].to_f * half_width + half_width + options[:padding]
+      end
+    end
+  end
+end

data/lib/minichart/meters/meter.rb

@@ -0,0 +1,64 @@
+module Minichart
+  # Base class for charts with a single value
+  class Meter < Base
+
+    class << self
+      def meter_defaults
+        @meter_defaults ||= {
+          max: 100,
+          notches: [],
+          notch_thickness: 4,
+          notch_color: 'black',
+          clipping_indicator: false,
+          clipping_indicator_thickness: 4,
+          clipping_indicator_color: 'yellow',
+          padding: 2,
+        }
+      end
+    end
+
+  protected 
+
+    def value
+      data
+    end
+
+    def clipping?
+      value > options[:max] || value < -options[:max]
+    end
+
+    def mode
+      @mode ||= mode!
+    end
+
+    def mode!
+      options[:mode] ||= :auto
+
+      if options[:mode] == :auto
+        value >= 0 ? :positive : :negative
+      else
+        options[:mode].to_sym
+      end
+    end
+
+    def clamped_value
+      case mode
+      when :positive
+        value.clamp 0, options[:max]
+      when :negative
+        value.clamp -options[:max], 0
+      when :dual
+        value.clamp -options[:max], options[:max]
+      end
+    end
+
+    def style
+      {
+        fill: options[:color],
+        stroke_width: options[:stroke],
+        stroke: options[:background]
+      }
+    end
+
+  end
+end

data/lib/minichart/meters/vertical_bar_meter.rb

@@ -0,0 +1,81 @@
+module Minichart
+  class VerticalBarMeter < Meter
+    class << self
+      def defaults
+        meter_defaults.merge width: 50, height: 300
+      end
+    end
+    
+    def build
+      draw_bar
+      draw_notches if options[:notches]
+      draw_clipping_indicator if options[:clipping_indicator] and clipping?
+    end
+
+  protected
+
+    def draw_bar
+      y1 = y_for 0
+      y2 = y_for clamped_value
+      y = [y1, y2].min
+
+      element :rect, x: options[:padding], y: y, height: bar_height,
+        width: options[:width], style: style
+    end
+
+    def draw_notches
+      options[:notches].each do |notch|
+        draw_notch notch
+        draw_notch -notch if mode == :dual and notch != 0
+      end
+    end
+
+    def draw_notch(notch)
+      draw_horizontal_line notch, stroke: options[:notch_thickness],
+        color: options[:notch_color]
+    end
+
+    def draw_clipping_indicator
+      draw_horizontal_line clamped_value,
+        stroke: options[:clipping_indicator_thickness],
+        color: options[:clipping_indicator_color]
+    end
+
+    def draw_horizontal_line(target_value, color:, stroke:)
+      y = y_for target_value
+
+      element :line, x1: options[:padding], x2: options[:width] + options[:padding],
+        y1: y, y2: y,
+        stroke: color, stroke_width: stroke
+    end
+
+    def height_factor
+      options[:height] / options[:max].to_f
+    end
+
+    def half_height
+      options[:height] * 0.5
+    end
+
+    def bar_height
+      if mode == :dual
+        clamped_value.abs * height_factor * 0.5
+      else
+        clamped_value.abs * height_factor
+      end
+    end
+
+    def y_for(target_value)
+      result = target_value.abs / options[:max].to_f * options[:height] + options[:padding]
+
+      case mode
+      when :positive
+        full_height - result
+      when :negative
+        result
+      when :dual
+        options[:height] - (target_value / options[:max].to_f * half_height + half_height) + options[:padding]
+      end
+    end
+  end
+end

data/lib/minichart/version.rb

@@ -1,3 +1,3 @@
 module Minichart
-  VERSION = "0.2.0"
+  VERSION = "0.3.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minichart
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Danny Ben Shitrit
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-29 00:00:00.000000000 Z
+date: 2020-06-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: victor
@@ -32,10 +32,18 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/minichart.rb
-- lib/minichart/area_chart.rb
-- lib/minichart/bar_chart.rb
-- lib/minichart/chart.rb
-- lib/minichart/line_chart.rb
+- lib/minichart/base.rb
+- lib/minichart/charts/area_chart.rb
+- lib/minichart/charts/bar_chart.rb
+- lib/minichart/charts/chart.rb
+- lib/minichart/charts/line_chart.rb
+- lib/minichart/id_generator.rb
+- lib/minichart/leds/horizontal_status_leds.rb
+- lib/minichart/leds/leds.rb
+- lib/minichart/leds/vertical_status_leds.rb
+- lib/minichart/meters/horizontal_bar_meter.rb
+- lib/minichart/meters/meter.rb
+- lib/minichart/meters/vertical_bar_meter.rb
 - lib/minichart/version.rb
 homepage: https://github.com/DannyBen/minichart
 licenses:
@@ -49,7 +57,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.4.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/minichart/area_chart.rb

@@ -1,27 +0,0 @@
-module Minichart
-  class AreaChart < Chart
-    def build
-      polyline fill: color,
-        stroke: color,
-        stroke_width: stroke,
-        stroke_linejoin: :round,
-        points: points
-    end
-
-  protected
-
-    def points
-      result = ["0,#{height}"]
-
-      inverted_points.each do |point|
-        x = width*point[0]
-        y = height*point[1]
-        result << "#{x},#{y}"
-      end
-
-      result << "#{width},#{height}"
-
-      result
-    end
-  end
-end

data/lib/minichart/bar_chart.rb

@@ -1,29 +0,0 @@
-module Minichart
-  class BarChart < Chart
-    def build
-      opts  = { x_point_count: data.size }
-
-      inverted_points(opts).each do |x, y|
-        rect bar_options x, y
-      end
-    end
-
-  protected
-
-    def bar_width
-      @bar_width ||= width / data.size
-    end
-
-    def bar_options(x, y)
-      y = y*height
-      bar_height = height-y
-      { 
-        x: x*width, 
-        y: y, 
-        width: bar_width, 
-        height: bar_height, 
-        style: { fill: color, stroke_width: stroke, stroke: background }
-      }
-    end
-  end
-end

data/lib/minichart/chart.rb

@@ -1,50 +0,0 @@
-module Minichart
-  class Chart < Victor::SVG
-    attr_reader :aspect_ratio, :background, :color, :data,
-      :height, :stroke, :style, :width
-
-    def initialize(data, opts = {})
-      @data = data
-      @background = opts[:background]
-      @aspect_ratio = opts[:aspect_ratio] || 3
-      @height = opts[:height] || 100
-      @width = opts[:width] || (aspect_ratio * height).round
-      @stroke = opts[:stroke] || 2
-      @style = opts[:style] || {}
-      @color = opts[:color] || '#333'
-
-      super height: height, width: width, style: style, 
-        viewBox: "0 0 #{width} #{height}"
-      
-      rect x: 0, y: 0, width: width, height: height, fill: background if background
-
-      build
-    end
-
-    def build
-      raise NotImplementedError, "#build is not implemented"
-    end
-
-  protected
-
-    def inverted_points(opts={})
-      normalized_points(opts).map { |point| [point[0], 1-point[1]] }
-    end
-
-    def normalized_points(opts={})
-      x_point_count = opts[:x_point_count] || data.count-1
-
-      range   = (data.max - data.min).to_f
-      x_width = 1/(x_point_count).to_f
-      result  = []
-
-      data.each_with_index do |y, index|
-        x = index*x_width
-        y = (y-data.min)/range
-        result << [x,y]
-      end
-
-      result
-    end
-  end
-end