gruff 0.11.0-java → 0.14.0-java

data/lib/gruff/renderer/bezier.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
 module Gruff
+  # @private
   class Renderer::Bezier
-    def initialize(args = {})
-      @color = args[:color]
-      @width = args[:width] || 1.0
+    def initialize(renderer, color:, width: 1.0)
+      @renderer = renderer
+      @color = color
+      @width = width
     end
 
     def render(points)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke(@color)
-      draw.stroke_width(@width)
-      draw.fill_opacity(0.0)
-      draw.bezier(*points)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke(@color)
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.fill_opacity(0.0)
+      @renderer.draw.bezier(*points)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/circle.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
 module Gruff
+  # @private
   class Renderer::Circle
-    def initialize(args = {})
-      @color = args[:color]
-      @width = args[:width] || 1.0
+    def initialize(renderer, color:, width: 1.0)
+      @renderer = renderer
+      @color = color
+      @width = width
     end
 
     def render(origin_x, origin_y, perim_x, perim_y)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.fill(@color)
-      draw.stroke(@color)
-      draw.stroke_width(@width)
-      draw.circle(origin_x, origin_y, perim_x, perim_y)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.fill(@color)
+      @renderer.draw.stroke(@color)
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.circle(origin_x, origin_y, perim_x, perim_y)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/dash_line.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
 module Gruff
+  # @private
   class Renderer::DashLine
-    def initialize(args = {})
-      @color = args[:color]
-      @width = args[:width]
+    def initialize(renderer, color:, width:)
+      @renderer = renderer
+      @color = color
+      @width = width
     end
 
     def render(start_x, start_y, end_x, end_y)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke_color(@color)
-      draw.fill_opacity(0.0)
-      draw.stroke_dasharray(10, 20)
-      draw.stroke_width(@width)
-      draw.line(start_x, start_y, end_x, end_y)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke_color(@color)
+      @renderer.draw.fill_opacity(0.0)
+      @renderer.draw.stroke_dasharray(10, 20)
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.line(start_x, start_y, end_x, end_y)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/dot.rb

@@ -1,39 +1,39 @@
 # frozen_string_literal: true
 
 module Gruff
+  # @private
   class Renderer::Dot
-    def initialize(style, config)
+    def initialize(renderer, style, color:, width: 1.0)
+      @renderer = renderer
       @style = style
-      @color = config[:color]
-      @width = config[:width] || 1.0
+      @color = color
+      @width = width
     end
 
     def render(new_x, new_y, circle_radius)
-      draw = Renderer.instance.draw
-
-      # draw.push # TODO
-      draw.stroke_width(@width)
-      draw.stroke(@color)
-      draw.fill(@color)
+      # @renderer.draw.push # TODO
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.stroke(@color)
+      @renderer.draw.fill(@color)
       if @style.to_s == 'square'
-        square(draw, new_x, new_y, circle_radius)
+        square(new_x, new_y, circle_radius)
       else
-        circle(draw, new_x, new_y, circle_radius)
+        circle(new_x, new_y, circle_radius)
       end
-      # draw.pop # TODO
+      # @renderer.draw.pop # TODO
     end
 
-    def circle(draw, new_x, new_y, circle_radius)
-      draw.circle(new_x, new_y, new_x - circle_radius, new_y)
+    def circle(new_x, new_y, circle_radius)
+      @renderer.draw.circle(new_x, new_y, new_x - circle_radius, new_y)
     end
 
-    def square(draw, new_x, new_y, circle_radius)
+    def square(new_x, new_y, circle_radius)
       offset = (circle_radius * 0.8).to_i
       corner1 = new_x - offset
       corner2 = new_y - offset
       corner3 = new_x + offset
       corner4 = new_y + offset
-      draw.rectangle(corner1, corner2, corner3, corner4)
+      @renderer.draw.rectangle(corner1, corner2, corner3, corner4)
     end
   end
 end

data/lib/gruff/renderer/ellipse.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
 module Gruff
+  # @private
   class Renderer::Ellipse
-    def initialize(args = {})
-      @color = args[:color]
-      @width = args[:width] || 1.0
+    def initialize(renderer, color:, width: 1.0)
+      @renderer = renderer
+      @color = color
+      @width = width
     end
 
     def render(origin_x, origin_y, width, height, arc_start, arc_end)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke_width(@width)
-      draw.stroke(@color)
-      draw.fill('transparent')
-      draw.ellipse(origin_x, origin_y, width, height, arc_start, arc_end)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.stroke(@color)
+      @renderer.draw.fill('transparent')
+      @renderer.draw.ellipse(origin_x, origin_y, width, height, arc_start, arc_end)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/line.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 module Gruff
+  # @private
   class Renderer::Line
     EPSILON = 0.001
 
-    def initialize(args = {})
-      @color = args[:color]
-      @shadow_color = args[:shadow_color]
-      @width = args[:width]
+    def initialize(renderer, color:, width: nil, shadow_color: nil)
+      @renderer = renderer
+      @color = color
+      @width = width
+      @shadow_color = shadow_color
     end
 
     def render(start_x, start_y, end_x, end_y)
@@ -29,14 +31,12 @@ module Gruff
         end_y += EPSILON
       end
 
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke(color)
-      draw.fill(color)
-      draw.stroke_width(@width) if @width
-      draw.line(start_x, start_y, end_x, end_y)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke(color)
+      @renderer.draw.fill(color)
+      @renderer.draw.stroke_width(@width) if @width
+      @renderer.draw.line(start_x, start_y, end_x, end_y)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/polygon.rb

@@ -1,23 +1,23 @@
 # frozen_string_literal: true
 
 module Gruff
+  # @private
   class Renderer::Polygon
-    def initialize(args = {})
-      @color = args[:color]
-      @width = args[:width] || 1.0
-      @opacity = args[:opacity] || 1.0
+    def initialize(renderer, color:, width: 1.0, opacity: 1.0)
+      @renderer = renderer
+      @color = color
+      @width = width
+      @opacity = opacity
     end
 
     def render(points)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke_width(@width)
-      draw.stroke(@color)
-      draw.fill(@color)
-      draw.fill_opacity(@opacity)
-      draw.polygon(*points)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.stroke(@color)
+      @renderer.draw.fill(@color)
+      @renderer.draw.fill_opacity(@opacity)
+      @renderer.draw.polygon(*points)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/polyline.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
 module Gruff
+  # @private
   class Renderer::Polyline
-    def initialize(args = {})
-      @color = args[:color]
-      @width = args[:width]
+    def initialize(renderer, color:, width:)
+      @renderer = renderer
+      @color = color
+      @width = width
     end
 
     def render(points)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke(@color)
-      draw.fill('transparent')
-      draw.stroke_width(@width)
-      draw.polyline(*points)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke(@color)
+      @renderer.draw.fill('transparent')
+      @renderer.draw.stroke_width(@width)
+      @renderer.draw.polyline(*points)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/rectangle.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
 module Gruff
+  # @private
   class Renderer::Rectangle
-    def initialize(args = {})
-      @color = args[:color]
+    def initialize(renderer, color: nil)
+      @renderer = renderer
+      @color = color
     end
 
     def render(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
-      draw = Renderer.instance.draw
-
-      draw.push
-      draw.stroke('transparent')
-      draw.fill(@color) if @color
-      draw.rectangle(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
-      draw.pop
+      @renderer.draw.push
+      @renderer.draw.stroke('transparent')
+      @renderer.draw.fill(@color) if @color
+      @renderer.draw.rectangle(upper_left_x, upper_left_y, lower_right_x, lower_right_y)
+      @renderer.draw.pop
     end
   end
 end

data/lib/gruff/renderer/renderer.rb

@@ -1,69 +1,36 @@
 # frozen_string_literal: true
 
-require 'singleton'
-
 module Gruff
   # @private
   class Renderer
-    include Singleton
-
-    attr_accessor :draw, :image, :scale, :text_renderers
-
-    class << self
-      def setup(columns, rows, font, scale, theme_options)
-        draw = Magick::Draw.new
-        draw.font = font if font
-        # Scale down from 800x600 used to calculate drawing.
-        draw.scale(scale, scale)
-
-        image = Renderer.instance.background(columns, rows, scale, theme_options)
-
-        Renderer.instance.draw  = draw
-        Renderer.instance.scale = scale
-        Renderer.instance.image = image
-        Renderer.instance.text_renderers = []
-      end
+    attr_accessor :text_renderers
+    attr_reader :draw, :image, :scale
 
-      def setup_transparent_background(columns, rows)
-        image = Renderer.instance.render_transparent_background(columns, rows)
-        Renderer.instance.image = image
-      end
-
-      def background_image=(image)
-        Renderer.instance.image = image
-      end
-
-      def font=(font)
-        draw = Renderer.instance.draw
-        draw.font = font if font
-      end
+    def initialize(columns, rows, scale, theme_options)
+      @draw = Magick::Draw.new
+      @text_renderers = []
 
-      def finish
-        draw  = Renderer.instance.draw
-        image = Renderer.instance.image
+      @scale = scale
+      @draw.scale(scale, scale)
+      @image = background(columns, rows, scale, theme_options)
+    end
 
-        draw.draw(image)
+    def finish
+      @draw.draw(@image)
 
-        Renderer.instance.text_renderers.each do |renderer|
-          renderer.render(renderer.width, renderer.height, renderer.x, renderer.y, renderer.gravity)
-        end
-      end
-
-      def write(file_name)
-        Renderer.instance.image.write(file_name)
+      @text_renderers.each do |renderer|
+        renderer.render(renderer.width, renderer.height, renderer.x, renderer.y, renderer.gravity)
       end
+    end
 
-      def to_blob(file_format)
-        Renderer.instance.image.to_blob do
-          self.format = file_format
-        end
-      end
+    def background_image=(image)
+      @image = image
     end
 
     def background(columns, rows, scale, theme_options)
       case theme_options[:background_colors]
       when Array
-        gradated_background(columns, rows, theme_options[:background_colors][0], theme_options[:background_colors][1], theme_options[:background_direction])
+        gradated_background(columns, rows, *theme_options[:background_colors][0..1], theme_options[:background_direction])
       when String
         solid_background(columns, rows, theme_options[:background_colors])
       else
@@ -71,6 +38,10 @@ module Gruff
       end
     end
 
+    def transparent_background(columns, rows)
+      @image = render_transparent_background(columns, rows)
+    end
+
     # Make a new image at the current size with a solid +color+.
     def solid_background(columns, rows, color)
       Magick::Image.new(columns, rows) do
@@ -113,6 +84,8 @@ module Gruff
       end
     end
 
+  private
+
     # Use with a theme to use an image (800x600 original) background.
     def image_background(scale, image_path)
       image = Magick::Image.read(image_path)

data/lib/gruff/renderer/text.rb

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
 module Gruff
+  # @private
   class Renderer::Text
-    def initialize(text, args = {})
+    using Magick::GruffAnnotate
+
+    def initialize(renderer, text, font:, rotation: nil)
+      @renderer = renderer
       @text = text.to_s
-      @font = args[:font]
-      @font_size = args[:size]
-      @font_color = args[:color]
-      @font_weight = args[:weight] || Magick::NormalWeight
-      @rotation = args[:rotation]
+      @font = font
+      @rotation = rotation
     end
 
     attr_reader :width, :height, :x, :y, :gravity
+
     def add_to_render_queue(width, height, x, y, gravity = Magick::NorthGravity)
       @width = width
       @height = height
@@ -19,35 +21,36 @@ module Gruff
       @y = y
       @gravity = gravity
 
-      Renderer.instance.text_renderers << self
+      @renderer.text_renderers << self
     end
 
     def render(width, height, x, y, gravity = Magick::NorthGravity)
-      draw  = Renderer.instance.draw
-      image = Renderer.instance.image
-      scale = Renderer.instance.scale
-
-      draw.rotation = @rotation if @rotation
-      draw.fill = @font_color
-      draw.stroke = 'transparent'
-      draw.font = @font if @font
-      draw.font_weight = @font_weight
-      draw.pointsize = @font_size * scale
-      draw.gravity = gravity
-      draw.annotate_scaled(image,
-                           width, height,
-                           x, y,
-                           @text, scale)
-      draw.rotation = -@rotation if @rotation
+      @renderer.draw.rotation = @rotation if @rotation
+      @renderer.draw.fill = @font.color
+      @renderer.draw.stroke = 'transparent'
+      @renderer.draw.font = @font.file_path
+      @renderer.draw.font_weight = @font.weight
+      @renderer.draw.pointsize = @font.size * @renderer.scale
+      @renderer.draw.gravity = gravity
+      @renderer.draw.annotate_scaled(@renderer.image,
+                                     width, height,
+                                     x, y,
+                                     @text, @renderer.scale)
+      @renderer.draw.rotation = -@rotation if @rotation
     end
 
-    def self.metrics(text, size, font_weight = Magick::NormalWeight)
-      draw  = Renderer.instance.draw
-      image = Renderer.instance.image
+    def metrics
+      @renderer.draw.font = @font.file_path
+      @renderer.draw.font_weight = @font.weight
+      @renderer.draw.pointsize = @font.size
+
+      # The old ImageMagick causes SEGV with string which has '%' + alphabet (eg. '%S').
+      # This format is used to embed value into a string using image properties.
+      # However, gruff use plain image as canvas which does not have any property.
+      # So, in here, it just escape % in order to avoid SEGV.
+      text = @text.to_s.gsub(/(%+)/) { ('%' * Regexp.last_match(1).size * 2).to_s }
 
-      draw.font_weight = font_weight
-      draw.pointsize = size
-      draw.get_type_metrics(image, text.to_s)
+      @renderer.draw.get_type_metrics(@renderer.image, text)
     end
   end
 end