prawn_charts 0.0.4 → 0.0.5

data/lib/prawn_charts/helpers.rb

@@ -0,0 +1,26 @@
+module PrawnCharts
+  module Helpers
+    def stroke_axis(options={})
+      options = { :height => (cursor - 20).to_i,
+                  :width => bounds.width.to_i
+                }.merge(options)
+
+      dash(1, :space => 4)
+      stroke_horizontal_line(-21, options[:width], :at => 0)
+      stroke_vertical_line(-21, options[:height], :at => 0)
+      undash
+
+      fill_circle [0, 0], 1
+
+      (100..options[:width]).step(100) do |point|
+        fill_circle [point, 0], 1
+        draw_text point, :at => [point-5, -10], :size => 7
+      end
+
+      (100..options[:height]).step(100) do |point|
+        fill_circle [0, point], 1
+        draw_text point, :at => [-17, point-2], :size => 7
+      end
+    end
+  end
+end

data/lib/prawn_charts/linear_vertical_data_collector.rb

@@ -0,0 +1,23 @@
+module PrawnCharts
+  class LinearVerticalDataCollector
+    attr_reader :height, :y_labels_units
+    def initialize(height, y_labels_units)
+      @height = height
+      @y_labels_units = y_labels_units
+    end
+
+    def convert_to_pdf(n)
+      pdf_points_per_y_unit * n
+    end
+
+    private
+
+    def pdf_points_per_y_unit
+      height.to_f / total_y_units
+    end
+
+    def total_y_units
+      y_labels_units.max - y_labels_units.min
+    end
+  end
+end

data/lib/prawn_charts/log_vertical_data_collector.rb

@@ -0,0 +1,27 @@
+module PrawnCharts
+  class LogVerticalDataCollector
+    attr_reader :height, :y_labels_units
+    def initialize(height, y_labels_units)
+      @height = height
+      @y_labels_units = y_labels_units
+    end
+
+    def convert_to_pdf(n)
+      Math.log10(n) * pdf_points_per_increment
+    end
+
+    private
+
+    def number_of_labels
+      y_labels_units.length
+    end
+
+    def number_of_increments
+      number_of_labels - 1
+    end
+
+    def pdf_points_per_increment
+      height.to_f / number_of_increments
+    end
+  end
+end

data/lib/prawn_charts/prawn_chart_renderer.rb

@@ -0,0 +1,139 @@
+module PrawnCharts
+  module PrawnChartRenderer
+
+    def draw_graph(input, colors = {})
+      @assistant = RendererAssistant.new(input)
+      @collector = @assistant.collector
+      @colors = colors
+      #stroke_axis
+      translate(*input[:graph][:starting_point]) do
+        draw_rectangle_with_color
+        fill_rectangle_with_color
+        draw_line_with_color
+        draw_dots_with_color
+        draw_x_labels_with_color
+        draw_y_labels_with_color
+        draw_horizontal_lines_with_color
+        draw_title_with_color
+        draw_x_title_with_color
+        draw_y_title_with_color
+      end
+    end
+
+    def draw_line(graph_points)
+      graph_points.each_index do |i|
+        stroke_line(graph_points[i].coordinate, graph_points[i + 1].coordinate) unless graph_points[i + 1].nil?
+      end
+    end
+
+    def draw_dots(graph_points, dot_radius)
+      graph_points.each do |point|
+        fill_circle(point.coordinate, dot_radius)
+      end
+    end
+
+    def draw_x_labels(data_points, offset, options)
+      label_width = options[:width]
+      centering_adjustment = label_width / 2
+      translate(0, offset) do
+        data_points.each do |data_point|
+         text_box(data_point.x_label, {at: [(data_point.x_pdf - centering_adjustment), 0]}.merge(options))
+        end
+      end
+    end
+
+    def draw_y_labels(label_data, offset, options)
+      label_height = options[:height]
+      centering_adjustment = label_height / 2
+      translate(offset, 0) do
+        label_data.each do |data|
+          text_box(data[:label], {at: ([0, data[:y] + centering_adjustment]) }.merge(options))
+        end
+      end
+    end
+
+    def draw_horizontal_lines(data)
+      data.each do |start_point, end_point|
+        stroke_line(start_point, end_point)
+      end
+    end
+
+    def draw_title(translation, title, options)
+      translate(*translation) do
+        text_box(title, options)
+      end
+    end
+
+    def set_color_and_execute(method, component, &block)
+      self.send(method, @colors[component]) if @colors[component]
+      yield if @assistant.components_to_draw.include?(component)
+      set_color_black(method)
+    end
+
+    def set_color_black(method)
+      black = "000000"
+      self.send(method, black)
+    end
+
+    def draw_rectangle_with_color
+      set_color_and_execute(:stroke_color, :rectangle_border) do
+        stroke_rectangle([0, @collector.height], @collector.width, @collector.height)
+      end
+    end
+
+    def fill_rectangle_with_color
+      set_color_and_execute(:fill_color, :rectangle_fill) do
+        fill_rectangle([0, @collector.height], @collector.width, @collector.height)
+      end
+    end
+
+    def draw_line_with_color
+      set_color_and_execute(:stroke_color, :line) do
+        draw_line(@collector.graph_points)
+      end
+    end
+
+    def draw_dots_with_color
+      set_color_and_execute(:fill_color, :dots) do
+        draw_dots(@collector.graph_points, @assistant.dot_radius)
+      end
+    end
+
+    def draw_x_labels_with_color
+      set_color_and_execute(:fill_color, :x_labels) do
+        draw_x_labels(@collector.data_points, @assistant.x_labels_offset, @assistant.x_labels_options)
+      end
+    end
+
+    def draw_y_labels_with_color
+      set_color_and_execute(:fill_color, :y_labels) do
+        draw_y_labels(@collector.y_labels, @assistant.y_labels_offset, @assistant.y_labels_options)
+      end
+    end
+
+    def draw_horizontal_lines_with_color
+      set_color_and_execute(:stroke_color, :horizontal_lines) do
+        draw_horizontal_lines(@collector.horizontal_lines)
+      end
+    end
+
+    def draw_title_with_color
+      set_color_and_execute(:fill_color, :graph_title) do
+        draw_title(@assistant.graph_title_translate, @assistant.graph_title, @assistant.graph_title_options)
+      end
+    end
+
+    def draw_x_title_with_color
+      set_color_and_execute(:fill_color, :x_title) do
+        draw_title(@assistant.x_title_translate, @assistant.x_title, @assistant.x_title_options)
+      end
+    end
+
+    def draw_y_title_with_color
+      set_color_and_execute(:fill_color, :y_title) do
+        draw_title(@assistant.y_title_translate, @assistant.y_title, @assistant.y_title_options)
+      end
+    end
+
+  end
+end

data/lib/prawn_charts/renderer_assistant.rb

@@ -0,0 +1,146 @@
+module PrawnCharts
+  class RendererAssistant
+    # Parses input data and responds with smart defaults or user specified data
+    attr_reader :input
+    def initialize(input)
+      @input = input
+    end
+
+    def collector
+      @collector ||= DataCollector.new(input.fetch(:graph))
+    end
+
+    def components_to_draw
+      available_components = [:rectangle_border, :rectangle_fill, :line, :dots, :x_labels, :y_labels, :horizontal_lines, :graph_title, :y_title, :x_title]
+      specified_components = [:rectangle_border, :rectangle_fill, :line] + @input.keys
+      @components_to_draw = available_components & specified_components
+    end
+
+    # dots
+    def dot_radius
+      return default_dot_radius unless input.dig(:dots, :radius)
+      input[:dots][:radius]
+    end
+
+    # graph_title
+    def graph_title_translate
+      [0, collector.height + offset(:graph_title, default_graph_title_offset)]
+    end
+
+    def graph_title
+      raise "Graph must have title" unless input.dig(:graph_title, :title)
+      input[:graph_title][:title]
+    end
+
+    def graph_title_options
+      return default_graph_title_options unless input.dig(:graph_title, :text_box_options)
+      input[:graph_title][:text_box_options]
+    end
+
+    # x_title
+    def x_title_translate
+      [0, offset(:x_title, default_x_title_offset)]
+    end
+
+    def x_title
+      raise "Graph must have title" unless input.dig(:x_title, :title)
+      input[:x_title][:title]
+    end
+
+    def x_title_options
+      return default_x_title_options unless input.dig(:x_title, :text_box_options)
+      input[:x_title][:text_box_options]
+    end
+
+    # y_title
+    def y_title_translate
+      [offset(:y_title, default_y_title_offset), 0]
+    end
+
+    def y_title
+      raise "Graph must have title" unless input.dig(:y_title, :title)
+      input[:y_title][:title]
+    end
+
+    def y_title_options
+      return default_y_title_options unless input.dig(:y_title, :text_box_options)
+      input[:y_title][:text_box_options]
+    end
+
+    # x_labels
+    def x_labels_offset
+      offset(:x_labels, default_x_labels_offset)
+    end
+
+    def x_labels_options
+      return default_x_labels_options unless input.dig(:x_labels, :text_box_options)
+      input[:x_labels][:text_box_options]
+    end
+
+    # y_labels
+    def y_labels_offset
+      offset(:y_labels, default_y_labels_offset)
+    end
+
+    def y_labels_options
+      return default_y_labels_options unless input.dig(:y_labels, :text_box_options)
+      default_y_labels_options.merge(input[:y_labels][:text_box_options])
+    end
+
+    private
+
+    def default_dot_radius
+      4
+    end
+
+    def offset(title_type, default_offset)
+      return default_offset unless input.dig(title_type, :offset)
+      input[title_type][:offset]
+    end
+
+    # graph title
+    def default_graph_title_options
+      {at: [0, -20], width: collector.width, height: 20, align: :center}
+    end
+
+    def default_graph_title_offset
+      50
+    end
+
+    # x title
+    def default_x_title_options
+      {at: [0, 20], width: collector.width, height: 20, align: :center}
+    end
+
+    def default_x_title_offset
+      -60
+    end
+
+    # y title
+    def default_y_title_options
+      {at: [0, 0], width: collector.height, height: 20, align: :center, valign: :center, rotate: 90}
+    end
+
+    def default_y_title_offset
+      -50
+    end
+
+    # x_labels
+    def default_x_labels_offset
+      -50
+    end
+
+    def default_x_labels_options
+      { :width => 100, :height => 20, align: :center, rotate: 45 }
+    end
+
+    # y_labels
+    def default_y_labels_offset
+      -40
+    end
+
+    def default_y_labels_options
+      { width: 40, :height => 40, valign: :center }
+    end
+  end
+end

data/lib/prawn_charts/version.rb

@@ -1,3 +1,3 @@
 module PrawnCharts
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/data_collector_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+module PrawnCharts
+  describe DataCollector do
+
+    data = [
+      {x_label: "Apr-11", y: 10},
+      {x_label: "May-11", y: nil},
+      {x_label: "Jun-11", y: 30}
+    ]
+    input = { :width => 300, :height => 200, :data => data, :y_labels => [0, 10, 20] }
+    let(:collector) { DataCollector.new(input) }
+
+    context "#y_labels" do
+      it "returns y_labels and associated y_pdf position" do
+        collector.stub(:y_convert_to_pdf).with(0) { "zero" }
+        collector.stub(:y_convert_to_pdf).with(10) { "ten" }
+        collector.stub(:y_convert_to_pdf).with(20) { "twenty" }
+        expected = [{:label=>"0", :y=>"zero"}, {:label=>"10", :y=>"ten"}, {:label=>"20", :y=>"twenty"}]
+        expect(collector.y_labels).to eq expected
+      end
+    end
+
+    context "#horizontal_lines" do
+      it "returns starting and ending points for graph lines at y_labels" do
+        collector.stub(:y_convert_to_pdf).with(0) { 10 }
+        collector.stub(:y_convert_to_pdf).with(10) { 20 }
+        collector.stub(:y_convert_to_pdf).with(20) { 30 }
+        expected = [[[0, 10], [300, 10]], [[0, 20], [300, 20]], [[0, 30], [300, 30]]]
+        expect(collector.horizontal_lines).to eq expected
+      end
+    end
+
+    context "#data_points" do
+      it "makes a DataPoint corresponding to every piece of data it is initialized with" do
+        expect(collector.data_points).to have(3).things
+      end
+    end
+
+    context "#graph_points" do
+      it "returns all DataPoints with a y_pdf value that is truthy" do
+        data_point_inputs = { x_units: 1, y_units: 2, x_pdf: 12, y_pdf: 16, x_label: "jan 12" }
+        dp_1 = DataPoint.new(data_point_inputs)
+        dp_2 = DataPoint.new(data_point_inputs)
+        dp_3 = DataPoint.new(data_point_inputs.merge({ y_pdf: nil }))
+        data_points = [dp_1, dp_2, dp_3]
+        collector.stub(:data_points) { data_points }
+        expect(collector.graph_points).to eq [dp_1, dp_2]
+      end
+    end
+
+    context "#y_convert_to_pdf" do
+      it "converts linear y_unit to y_pdf" do
+        expect(collector.y_convert_to_pdf(8)).to eq 80
+      end
+
+      it "converts log y_unit to y_pdf" do
+        input = { :width => 300, :height => 200, :data => [], :y_labels => [0, 10, 100], :scale => :log }
+        collector = DataCollector.new(input)
+        expect(collector.y_convert_to_pdf(12)).to be_within(0.1).of 107.9
+      end
+    end
+  end
+end

data/spec/linear_vertical_data_collector_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+module PrawnCharts
+  describe LinearVerticalDataCollector do
+    context "#convert_to_pdf" do
+      it "converts a y_unit point to a y_pdf point" do
+        collector = LinearVerticalDataCollector.new(200, [0, 10, 20, 30, 40, 50])
+        expect(collector.convert_to_pdf(15)).to eq 60
+      end
+
+      it "accounts for linear scales that don't start at 0" do
+        collector = LinearVerticalDataCollector.new(200, [30, 40, 50])
+        expect(collector.convert_to_pdf(15)).to eq 150
+      end
+    end
+  end
+end