convert_svg_string_to_gcode 0.0.0 → 0.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fffdd21de1f5a9589a8cdb8bae44a8d7f2c114fb
-  data.tar.gz: d538bee8a59380ef1d77d2f78c2e778afd0dacf1
+  metadata.gz: 13748aa4d3d130df359a1289a74818dd293fa890
+  data.tar.gz: f9f2d073c74e4b99cbeed2a2ecd0aa23c87b41dd
 SHA512:
-  metadata.gz: bbbacdf173ef099cb5df712d6f5aa1aa08a0af40c51b42511f9395dee176b651e962f5f93fd08b07a3946870f4d0c606cc34390b7f4427f13260ec96a93bb168
-  data.tar.gz: e00bf27f2038323e47a4a488dd2a316aedf8df75e5cacc292e772c48ed4b59c08c09946981d8881061bc6de9344fd888db9c2b46ba43823631a9756ea3f408cb
+  metadata.gz: 9df4d2c3e7a31b7cfd1f6ed7ee08a1fd75d0f8378934f970d58677b61e3e962850f8b404e7fddd5df683cdcb78c15ac9480cc103f7b293faef35616c125b42d2
+  data.tar.gz: b8cf68ba6afbb465d94c5453a1e1c4b44262350899f7d50ed0fbeb43e1a297cd0edb8ad462a7c1aca6d3a55cf631684f4657edbf5b6d21220faa4c6e9b30ea0b

data/.gitignore

@@ -0,0 +1 @@
+.DS_Store

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'rake'
+gem 'nokogiri',   '~> 1.6.7'
+gem 'pry'
+gem 'pry-nav'
+gem 'wirb'
+
+group :test do
+  gem 'activerecord'
+  gem 'database_cleaner'
+  gem 'pg'
+  gem 'rspec'
+  gem 'webmock'
+  gem 'rack-test'
+end

data/Gemfile.lock

@@ -0,0 +1,93 @@
+PATH
+  remote: .
+  specs:
+    convert_svg_string_to_gcode (0.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (4.2.6)
+      activesupport (= 4.2.6)
+      builder (~> 3.1)
+    activerecord (4.2.6)
+      activemodel (= 4.2.6)
+      activesupport (= 4.2.6)
+      arel (~> 6.0)
+    activesupport (4.2.6)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    addressable (2.4.0)
+    arel (6.0.3)
+    builder (3.2.2)
+    coderay (1.1.1)
+    crack (0.4.3)
+      safe_yaml (~> 1.0.0)
+    database_cleaner (1.5.3)
+    diff-lcs (1.2.5)
+    hashdiff (0.3.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    method_source (0.8.2)
+    mini_portile2 (2.0.0)
+    minitest (5.9.0)
+    nokogiri (1.6.7.1)
+      mini_portile2 (~> 2.0.0.rc2)
+    paint (1.0.1)
+    pg (0.18.4)
+    pry (0.10.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-nav (0.2.4)
+      pry (>= 0.9.10, < 0.11.0)
+    rack (1.6.4)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rake (10.5.0)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    safe_yaml (1.0.4)
+    slop (3.6.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    webmock (2.0.2)
+      addressable (>= 2.3.6)
+      crack (>= 0.3.2)
+      hashdiff
+    wirb (2.0.0)
+      paint (>= 0.9, < 2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord
+  convert_svg_string_to_gcode!
+  database_cleaner
+  nokogiri (~> 1.6.7)
+  pg
+  pry
+  pry-nav
+  rack-test
+  rake
+  rspec
+  webmock
+  wirb
+
+BUNDLED WITH
+   1.10.6

data/config/console.rb

@@ -0,0 +1,4 @@
+require 'wirb'
+
+Wirb.start
+Dir['./lib/**/**/*.rb'].each {|file| require file}

data/convert_svg_string_to_gcode.gemspec

@@ -3,7 +3,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |s|
   s.name        = 'convert_svg_string_to_gcode'
-  s.version     = '0.0.0'
+  s.version     = '0.0.1'
   s.date        = '2016-03-24'
   s.summary     = "Converts SVG paths to GCode strings"
   s.description = "A gem that converts SVG paths (passed in as strings) into GCode strings"

data/lib/convert_svg_string_to_gcode.rb

@@ -1,9 +1,9 @@
-require 'convert_svg_string_to_gcode/parse_svg_string'
-require 'convert_svg_string_to_gcode/tokenize_parsed_svg'
-require 'convert_svg_string_to_gcode/create_commands_from_tokens'
-require 'convert_svg_string_to_gcode/adjust_svg_commands_for_plotter'
-require 'convert_svg_string_to_gcode/create_gcode_array_from_svg_commands'
-require 'convert_svg_string_to_gcode/create_gcode_from_gcode_array'
+require 'convert_svg_string_to_gcode/helpers/parse_svg_string'
+require 'convert_svg_string_to_gcode/helpers/tokenize_parsed_svg'
+require 'convert_svg_string_to_gcode/helpers/create_commands_from_tokens'
+require 'convert_svg_string_to_gcode/helpers/adjust_svg_commands_for_plotter'
+require 'convert_svg_string_to_gcode/helpers/create_gcode_array_from_svg_commands'
+require 'convert_svg_string_to_gcode/helpers/create_gcode_from_gcode_array'
 
 class ConvertSVGStringToGCode
 
@@ -11,7 +11,7 @@ class ConvertSVGStringToGCode
     parsed_svg            = ParseSVGString.perform(svg_as_string)
     svg_tokens            = TokenizeParsedSVG.perform(parsed_svg)
     svg_commands          = CreateCommandsFromTokens.perform(svg_tokens)
-    adjusted_svg_commands = AdjustSVGCommandsForPlotter.perform(svg_commands, 0.10)
+    adjusted_svg_commands = AdjustSVGCommandsForPlotter.perform(svg_commands, ConversionConstants::PROPORTION)
     gcode_array           = CreateGCodeArrayFromSVGCommands.perform(adjusted_svg_commands)
     CreateGCodeFromGCodeArray.perform(gcode_array)
   end

data/lib/convert_svg_string_to_gcode/constants/conversion_constants.rb

@@ -1,9 +1,16 @@
 
 class ConversionConstants
-  MOVE           = 'M'
-  LINE_TO        = 'L'
-  CURVE          = 'C'
-  X_LABELS       = [:x,:cp0x,:cp1x,:p1x]
-  Y_LABELS       = [:y,:cp0y,:cp1y,:p1y]
-  GCODE_COMMANDS = 'CLM'
+  MOVE                 = 'M'
+  LINE_TO              = 'L'
+  CURVE                = 'C'
+  X_LABELS             = [:p0x,:p1x,:cp0x,:cp1x,:p0x,:p1x]
+  Y_LABELS             = [:p0y,:p1y,:cp0y,:cp1y,:p0y,:p1y]
+  TYPE_LABEL           = :type
+  VALID_CMD_ATTRIBUTES = X_LABELS + Y_LABELS << TYPE_LABEL
+  GCODE_COMMANDS       = 'CLM'
+  PROPORTION           = 0.7
+  STEP                 = 0.20
+
+  raise TypeError.new('Proportion must be a Float.') if PROPORTION.class != Float
+  raise TypeError.new('Step must be a Float.') if STEP.class != Float
 end

data/lib/convert_svg_string_to_gcode/constants/plotter_config.rb

@@ -0,0 +1,10 @@
+require 'convert_svg_string_to_gcode/constants/conversion_constants'
+
+class PlotterConfig
+  ORIGIN_X = "X0.0"
+  ORIGIN_Y = "Y0.0"
+  Z_DOWN   = "Z10.0"
+  Z_UP     = "Z30.0"
+  HEADER   = ["%", "G21", "G00 #{Z_UP}", "G00 X0.0 Y0.0"]
+  FOOTER   = ["G00 #{ORIGIN_X} #{ORIGIN_Y} #{Z_UP}", "%"]
+end

data/lib/convert_svg_string_to_gcode/helpers/adjust_svg_commands_for_plotter.rb

@@ -1,57 +1,89 @@
+require 'convert_svg_string_to_gcode/models/svg_command'
+require 'convert_svg_string_to_gcode/helpers/box_helper'
 
 class AdjustSVGCommandsForPlotter
-  def self.perform(svg_commands,proportion=0.10)
-    skewed_svg_commands, min_x, min_y = resize_svg_commands_by_proportion_and_get_min_x_y(svg_commands, proportion)
+  def self.perform(svg_commands,proportion=ConversionConstants::PROPORTION)
+    skewed_svg_commands = resize_svg_commands_by_proportion(svg_commands, proportion)
     min_x, min_y = get_min_x_y(skewed_svg_commands)
+    max_x, max_y = get_max_x_y(skewed_svg_commands)
     buffered_svg_commands = add_margin_to_svg_commands(skewed_svg_commands, min_x, min_y)
+    optimize_commands(buffered_svg_commands)
   end
 
-  def self.resize_svg_commands_by_proportion_and_get_min_x_y(svg_commands, proportion)
-    min_x = nil
-    min_y = nil
-    skewed_svg_commands = svg_commands.map do |command|
-      mutated_command = {}
-      command.each_key do |k|
-        mutated_command[k] = Float(command[k])*proportion unless k==:command
-        mutated_command[k] = command[k] if k==:command
-      end
-      mutated_command
+  def self.optimize_commands(svg_commands)
+    grouped_non_move_commands = group_commands_and_remove_moves(svg_commands)
+    ordered_svg_commands = sort_commands_ascending_by_x(grouped_non_move_commands)
+    sorted_svg_commands = BoxHelper.sort_commands_into_boxes(ordered_svg_commands)
+    add_moves_back_to_svg_commands(sorted_svg_commands)
+  end
+
+  def self.resize_svg_commands_by_proportion(svg_commands, proportion)
+    svg_commands.map do |command|
+      command.adjust_by_proportion(proportion)
     end
-    return skewed_svg_commands, min_x, min_y
   end
 
   def self.get_min_x_y(svg_commands)
     min_x = nil
     min_y = nil
-
     svg_commands.map do |command|
-      command.each_key do |key|
-        if ConversionConstants::X_LABELS.include? key
-          min_x = command[key] if !min_x || command[key]<min_x
-        end
+      command_min_x = [command.p0x, command.p1x].min
+      min_x = command_min_x if  !min_x || command_min_x<min_x || min_x == 0.0
 
-        if ConversionConstants::Y_LABELS.include? key
-          min_y = command[key] if !min_y || command[key]<min_y
-        end
-      end
+      command_min_y = [command.p0y, command.p1y].min
+      min_y = command_min_y if  !min_y || command_min_y<min_y || min_y == 0.0
     end
     return min_x, min_y
   end
 
+  def self.get_max_x_y(svg_commands)
+    max_x = nil
+    max_y = nil
+
+    svg_commands.map do |command|
+      command_max_x = [command.p0x, command.p1x].max
+      max_x = command_max_x if  !max_x || command_max_x>max_x || max_x == 0.0
+
+      command_max_y = [command.p0y, command.p1y].max
+      max_y = command_max_y if  !max_y || command_max_y>max_y || max_y == 0.0
+    end
+    return max_x, max_y
+  end
+
   def self.add_margin_to_svg_commands(svg_commands, min_x, min_y, buffer=20.0)
+    x_margin = buffer-min_x
+    y_margin = buffer-min_y
+
     svg_commands.map do |command|
-      buffered_command={}
-      command.each_key do |k|
-        if [:x,:cp0x,:cp1x,:p1x].include? k
-          buffered_command[k] = command[k]-min_x+buffer
-        elsif [:y,:cp0y,:cp1y,:p1y].include? k
-          buffered_command[k] = command[k]-min_y+buffer
-        else
-          buffered_command[k] = command[k]
+      command.add_margins(x_margin, y_margin)
+    end
+  end
+
+  def self.sort_commands_ascending_by_x(svg_commands)
+    svg_commands.sort do |a,b|
+      a.first.p0x <=> b.first.p0x
+    end
+  end
+
+  def self.add_moves_back_to_svg_commands(svg_commands)
+    commands_with_moves = svg_commands.map do |boxes|
+        boxes.map do |commands|
+          move_to_command = SVGCommand.new(
+            type: ConversionConstants::MOVE,
+            p1x: commands.first.p0x,
+            p1y: commands.first.p0y
+          )
+          [move_to_command, commands.flatten]
         end
-      end
-      buffered_command
     end
+    commands_with_moves.flatten
+  end
+
+  def self.group_commands_and_remove_moves(svg_commands)
+    svg_commands
+      .chunk { |cmd| cmd.type == 'M' }
+      .reject { |enum| enum[0] }
+      .map { |enum| enum[1] }
   end
 
 end

data/lib/convert_svg_string_to_gcode/helpers/box_helper.rb

@@ -0,0 +1,75 @@
+require 'convert_svg_string_to_gcode/models/box'
+require 'convert_svg_string_to_gcode/helpers/adjust_svg_commands_for_plotter'
+
+class BoxHelper
+
+  def self.sort_commands_into_boxes(svg_commands, rows: 10, columns: 3)
+
+    boxes = create_write_boxes(svg_commands, rows, columns)
+    boxed_commands = boxes.map { |bc| [] }
+
+    box_order = []
+
+    boxes.each_slice(rows).with_index do |box_group, i|
+      if i.even?
+        box_order << box_group.map { |b| b.box_number }
+      else
+        box_order << box_group.reverse_each.map { |b| b.box_number }
+      end
+    end
+
+    box_order_index = {}
+
+    box_order.flatten.each.with_index do |order_number, i|
+      box_order_index[order_number] = i
+    end
+
+    svg_commands.each do |command|
+      box_order.flatten.each do |box_number|
+        next unless command_is_within_box?(command, boxes[box_number])
+        boxed_commands[box_order_index[box_number]] << command
+      end
+    end
+    boxed_commands
+  end
+
+  def self.command_is_within_box?(command, box)
+    command.first.p0x.between?(box.x_min, box.x_max) &&
+      command.first.p0y.between?(box.y_min, box.y_max)
+  end
+
+  def self.create_write_boxes(svg_commands, rows = 10, columns= 3)
+    x_max, y_max = AdjustSVGCommandsForPlotter.get_max_x_y(svg_commands.flatten)
+    x_step = x_max/columns
+    y_step = y_max/rows
+
+    x = 0
+    y = 0
+    boxes = []
+
+    columns.times do |c|
+      x_min = x
+      x_max = x+x_step
+      x = x+x_step
+
+      rows.times do |r|
+        y_min = y
+        y_max = y+y_step
+        y = y+y_step
+
+        boxes << Box.new(
+          box_number:rows*c+r,
+          x_min: x_min,
+          x_max: x_max,
+          y_min: y_min,
+          y_max: y_max
+        )
+      end
+      y=0
+    end
+    boxes
+  end
+
+  private_class_method :create_write_boxes
+
+end

data/lib/convert_svg_string_to_gcode/helpers/create_commands_from_tokens.rb

@@ -1,28 +1,56 @@
+require 'convert_svg_string_to_gcode/models/svg_command'
 
 class CreateCommandsFromTokens
   def self.perform(svg_tokens)
+    last_command = SVGCommand.new(
+      type: ConversionConstants::MOVE,
+      p1x: 0.0,
+      p1y: 0.0,
+      p0x: 0.0,
+      p0y: 0.0,
+      p1x: 0.0,
+      p1y: 0.0
+    )
+
     svg_commands = svg_tokens.each_with_index.map do |token, i|
-      svg_command=nil
+      svg_command = nil
+
       if token.match(%r{[#{ConversionConstants::GCODE_COMMANDS}]})
         case token
         when ConversionConstants::MOVE
-          svg_command = {command: ConversionConstants::MOVE, x: svg_tokens[i+1], y: svg_tokens[i+2]}
+          svg_command = SVGCommand.new(
+            type: ConversionConstants::MOVE,
+            p0x: last_command.p1x,
+            p0y: last_command.p1y,
+            p1x: svg_tokens[i+1],
+            p1y: svg_tokens[i+2]
+          )
         when ConversionConstants::LINE_TO
-          svg_command = {command: ConversionConstants::LINE_TO, x: svg_tokens[i+1], y: svg_tokens[i+2]}
+          svg_command = SVGCommand.new(
+            type: ConversionConstants::LINE_TO,
+            p0x: last_command.p1x,
+            p0y: last_command.p1y,
+            p1x: svg_tokens[i+1],
+            p1y: svg_tokens[i+2]
+          )
         when ConversionConstants::CURVE
-          svg_command = {
-            command: ConversionConstants::CURVE,
+          svg_command = SVGCommand.new(
+            type: ConversionConstants::CURVE,
+            p0x:  last_command.p1x,
+            p0y:  last_command.p1y,
             cp0x: svg_tokens[i+1],
             cp0y: svg_tokens[i+2],
             cp1x: svg_tokens[i+3],
             cp1y: svg_tokens[i+4],
             p1x:  svg_tokens[i+5],
             p1y:  svg_tokens[i+6]
-          }
+          )
         end
       end
+      last_command = svg_command if svg_command
       svg_command
     end
     svg_commands.compact
   end
+
 end

data/lib/convert_svg_string_to_gcode/helpers/create_gcode_array_from_svg_commands.rb

@@ -1,48 +1,47 @@
-
+require 'convert_svg_string_to_gcode/constants/plotter_config'
 class CreateGCodeArrayFromSVGCommands
   def self.perform(commands, options = {step: 0.20})
     start_point = nil
     step=options[:step]
 
     gcode_array = commands.map do |c|
-      case c[:command]
+      case c.type
       when ConversionConstants::MOVE
-        command_array, start_point = move_to_point(c)
+        move_to_point(c)
       when ConversionConstants::LINE_TO
-        command_array, start_point = draw_to_point(c)
+        draw_to_point(c)
       when ConversionConstants::CURVE
-        command_array, start_point = create_gcode_path_from_bezier(start_point, c,step)
+        create_gcode_path_from_bezier(c, step)
       else
         throw Error
       end
-      command_array
     end
   end
 
   def self.move_to_point(new_point)
-    x_value = new_point[:x].to_f
-    y_value = new_point[:y].to_f
-    command = ["G0 X#{x_value} Y#{y_value} #{MakeblockXYConfig::Z_UP}"]
-    return command, new_point
+    x_value = new_point.p1x
+    y_value = new_point.p1y
+    command = ["G0 X#{x_value} Y#{y_value} #{PlotterConfig::Z_UP}"]
+    return command
   end
 
   def self.draw_to_point(new_point)
-    x_value = new_point[:x].to_f
-    y_value = new_point[:y].to_f
-    command = ["G1 X#{x_value} Y#{y_value} #{MakeblockXYConfig::Z_DOWN}"]
-    return command, new_point
+    x_value = new_point.p1x
+    y_value = new_point.p1y
+    command = ["G1 X#{x_value} Y#{y_value} #{PlotterConfig::Z_DOWN}"]
+    return command
   end
 
-  def self.create_gcode_path_from_bezier(start_point, svg_command, step)
+  def self.create_gcode_path_from_bezier(svg_command, step)
 
-    p0x  = start_point[:x].to_f
-    p0y  = start_point[:y].to_f
-    cp0x = svg_command[:cp0x].to_f
-    cp0y = svg_command[:cp0y].to_f
-    cp1x = svg_command[:cp1x].to_f
-    cp1y = svg_command[:cp1y].to_f
-    p1x  = svg_command[:p1x].to_f
-    p1y  = svg_command[:p1y].to_f
+    p0x  = svg_command.p0x
+    p0y  = svg_command.p0y
+    cp0x = svg_command.cp0x
+    cp0y = svg_command.cp0y
+    cp1x = svg_command.cp1x
+    cp1y = svg_command.cp1y
+    p1x  = svg_command.p1x
+    p1y  = svg_command.p1y
 
     t  = step
 
@@ -63,10 +62,10 @@ class CreateGCodeArrayFromSVGCommands
 
       new_point_x = ( (1 - t) * dx ) + (t * ex)
       new_point_y = ( (1 - t) * dy ) + (t * ey)
-      gcode_array << "G1 X#{new_point_x} Y#{new_point_y} Z0"
+      gcode_array << "G1 X#{new_point_x} Y#{new_point_y} #{PlotterConfig::Z_DOWN}"
       t+=step
     end
-   return gcode_array, {x: p1x, y: p1y}
+   return gcode_array
   end
 
 end

data/lib/convert_svg_string_to_gcode/helpers/create_gcode_from_gcode_array.rb

@@ -3,8 +3,8 @@ class CreateGCodeFromGCodeArray
   def self.perform(
       gcode_array,
       options = {
-        header: MakeblockXYConfig::HEADER,
-        footer: MakeblockXYConfig::FOOTER,
+        header: PlotterConfig::HEADER,
+        footer: PlotterConfig::FOOTER,
       }
     )
 

data/lib/convert_svg_string_to_gcode/helpers/read_svg_to_string.rb

@@ -0,0 +1,6 @@
+
+class ReadSVGToString
+  def self.perform(path_to_remote_file)
+    file = File.read(path_to_remote_file)
+  end
+end

data/lib/convert_svg_string_to_gcode/models/box.rb

@@ -0,0 +1,12 @@
+class Box
+  attr_accessor :box_number, :x_min, :x_max, :y_min, :y_max
+
+  def initialize(**params)
+    @box_number = params[:box_number]
+    @x_min = params[:x_min]
+    @x_max = params[:x_max]
+    @y_min = params[:y_min]
+    @y_max = params[:y_max]
+  end
+
+end

data/lib/convert_svg_string_to_gcode/models/svg_command.rb

@@ -0,0 +1,64 @@
+class SVGCommand
+  attr_accessor :type
+  def initialize(**params)
+    @type = params[:type]
+    @points = params.each_with_object({}) do |(param, value), hsh|
+      unless ConversionConstants::VALID_CMD_ATTRIBUTES.include?(param)
+        raise TypeError.new('Point label not defined')
+      end
+      hsh[param] = Float(value) unless value == nil || param == ConversionConstants::TYPE_LABEL
+    end
+  end
+
+  def method_missing(name)
+    super unless ConversionConstants::VALID_CMD_ATTRIBUTES.include? name
+    value = @points[name]
+    return value
+  end
+
+  def adjust_by_proportion(proportion)
+    mutated_cp0x = self.cp0x*proportion if self.cp0x
+    mutated_cp0y = self.cp0y*proportion if self.cp0y
+    mutated_cp1x = self.cp1x*proportion if self.cp1x
+    mutated_cp1y = self.cp1y*proportion if self.cp1y
+    mutated_p0x  = self.p0x*proportion if self.p0x
+    mutated_p0y  = self.p0y*proportion if self.p0y
+    mutated_p1x  = self.p1x*proportion if self.p1x
+    mutated_p1y  = self.p1y*proportion if self.p1y
+
+    SVGCommand.new(
+      type: @type,
+      cp0x: mutated_cp0x,
+      cp0y: mutated_cp0y,
+      cp1x: mutated_cp1x,
+      cp1y: mutated_cp1y,
+      p0x: mutated_p0x,
+      p0y: mutated_p0y,
+      p1x: mutated_p1x,
+      p1y: mutated_p1y
+    )
+  end
+
+  def add_margins(x_margin, y_margin)
+    mutated_cp0x = self.cp0x+x_margin if self.cp0x
+    mutated_cp0y = self.cp0y+y_margin if self.cp0y
+    mutated_cp1x = self.cp1x+x_margin if self.cp1x
+    mutated_cp1y = self.cp1y+y_margin if self.cp1y
+    mutated_p0x  = self.p0x+x_margin if self.p0x
+    mutated_p0y  = self.p0y+y_margin if self.p0y
+    mutated_p1x  = self.p1x+x_margin if self.p1x
+    mutated_p1y  = self.p1y+y_margin if self.p1y
+
+    SVGCommand.new(
+      type: @type,
+      p0x: mutated_p0x,
+      p0y: mutated_p0y,
+      p1x: mutated_p1x,
+      p1y: mutated_p1y,
+      cp0x: mutated_cp0x,
+      cp0y: mutated_cp0y,
+      cp1x: mutated_cp1x,
+      cp1y: mutated_cp1y,
+    )
+  end
+end

data/script/console

@@ -0,0 +1,3 @@
+#!/bin/bash -e
+
+bundle exec pry -r ./config/console

data/script/test

@@ -0,0 +1,3 @@
+#!/bin/bash -e
+
+RACK_ENV=test bundle exec rspec $@

data/spec/factory_helper.rb

@@ -0,0 +1,29 @@
+require 'convert_svg_string_to_gcode/helpers/parse_svg_string'
+require 'convert_svg_string_to_gcode/helpers/tokenize_parsed_svg'
+require 'convert_svg_string_to_gcode/helpers/create_commands_from_tokens'
+require 'convert_svg_string_to_gcode/helpers/adjust_svg_commands_for_plotter'
+require 'convert_svg_string_to_gcode/helpers/create_gcode_array_from_svg_commands'
+require 'convert_svg_string_to_gcode/helpers/create_gcode_from_gcode_array'
+require 'fixtures/spec_constants'
+
+class FactoryHelper
+  def self.parsed_svg
+    ParseSVGString.perform(SpecConstants::TEST_SVG_AS_STRING)
+  end
+
+  def self.svg_tokens
+    TokenizeParsedSVG.perform(parsed_svg)
+  end
+
+  def self.svg_commands
+    CreateCommandsFromTokens.perform(svg_tokens)
+  end
+
+  def self.adjusted_svg_commands
+    AdjustSVGCommandsForPlotter.perform(svg_commands, ConversionConstants::PROPORTION )
+  end
+
+  def self.gcode_array
+    CreateGCodeArrayFromSVGCommands.perform(adjusted_svg_commands)
+  end
+end

data/spec/fixtures/spec_constants.rb

@@ -0,0 +1,16 @@
+require 'convert_svg_string_to_gcode/models/svg_command'
+require 'convert_svg_string_to_gcode/constants/conversion_constants'
+
+class SpecConstants
+  TEST_SVG_AS_STRING             = "<?xml version=\"1.0\" standalone=\"yes\"?>\n<svg width=\"6375\" height=\"4781\">\n<path style=\"stroke:#020202; stroke-linecap: round; stroke-width:5;fill:none;\" d=\"M524 313C537.472 324.483 557.635 339.142 575 343.649\"/>\n</svg>\n"
+  TEST_SVG_TOKENS                = [ConversionConstants::MOVE, "524", "313", "C", "537.472",
+                                   "324.483", "557.635", "339.142", "575", "343.649"]
+  TEST_SVG_COMMANDS              = [SVGCommand.new(type:"M", p0x:0.0, p0y:0.0, p1x:"524", p1y:"313"),SVGCommand.new(type:"C", p0x: "524", p0y:"313", cp0x: "537.472", cp0y: "324.483", cp1x: "557.635", cp1y: "339.142", p1x:"575", p1y:"343.649")]
+  TEST_ADJUSTED_COMMANDS         = [SVGCommand.new(type: "M", p1x: 20.0, p1y:20.0), SVGCommand.new(type:"C", p0x:20.0, p0y:20.0, cp0x:29.43040000000002, cp0y:28.038099999999986, cp1x:43.54450000000003, cp1y:38.29939999999999, p1x:55.700000000000045, p1y:41.45429999999999)]
+
+  TEST_GCODE_ARRAY               = [["G0 X20.0 Y20.0 Z30.0"], ["G1 X26.167145600000012 Y25.015007199999996 Z10.0", "G1 X33.13954880000002 Y30.115761599999992 Z10.0", "G1 X40.59837920000004 Y34.85444239999999 Z10.0", "G1 X48.224806400000034 Y38.78322879999999 Z10.0"]]
+
+  EXPECTED_GCODE_TEST_SVG_OUTPUT = "%\nG21\nG00 Z30.0\nG00 X0.0 Y0.0\nG0 X20.0 Y20.0 Z30.0\nG1 X26.167145600000012 Y25.015007199999996 Z10.0\nG1 X33.13954880000002 Y30.115761599999992 Z10.0\nG1 X40.59837920000004 Y34.85444239999999 Z10.0\nG1 X48.224806400000034 Y38.78322879999999 Z10.0\nG00 X0.0 Y0.0 Z30.0\n%"
+
+  TEST_IMAGE_LOCATION            = "https://res.cloudinary.com/trunk-club/image/upload/v1456519728/original_note.jpg"
+end

data/spec/fixtures/test.svg

@@ -0,0 +1,4 @@
+<?xml version="1.0" standalone="yes"?>
+<svg width="6375" height="4781">
+<path style="stroke:#020202; stroke-linecap: round; stroke-width:5;fill:none;" d="M524 313C537.472 324.483 557.635 339.142 575 343.649"/>
+</svg>

data/spec/helpers.rb

@@ -0,0 +1,36 @@
+module Helpers
+
+  def now
+    Time.parse("2013-01-01T00:00:00Z")
+  end
+
+  def stubs_time
+    allow(Time).to receive(:now).and_return(now)
+  end
+
+  def client
+    api_client
+  end
+
+  def api_client
+    # Fail if the clients receive unexpected messages, stubbing is expected in specs
+    @client ||= double
+  end
+
+  def build_response(payload, status=200)
+    double(status: status, body: payload.to_json)
+  end
+
+  def service_fails_unexpectedly(http_verb, error_payload={message: "Oh snap!"})
+    allow(client).to receive(http_verb).and_return(build_response(error_payload, 500))
+  end
+
+  def last_json
+    last_response.body
+  end
+
+  def response_payload
+    JSON.parse(last_json)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'rspec'
+require 'rack/test'
+require 'database_cleaner'
+require_relative 'helpers'
+require 'fixtures/spec_constants'
+
+RSpec.configure do |config|
+  config.include(Helpers)
+
+  # Raise errors for deprecated rspec syntax
+  config.raise_errors_for_deprecations!
+
+  # Colored tests are more _exciting_
+  config.color = true
+
+  # Set the order to random unless we pass it in from the command line
+  config.order = :rand unless ARGV.any? { |arg| %w(--order --seed).include?(arg) }
+
+  #  Define DatabaseCleaner strategy
+  # -------------------------------------------
+  # config.before(:suite) do
+    # DatabaseCleaner[:active_record].strategy = :transaction
+    # DatabaseCleaner.clean_with(:truncation)
+  # end
+
+  #  Wire up DatabaseCleaner before and after each example
+  # -------------------------------------------
+  # config.around(:each) do |example|
+    # DatabaseCleaner.cleaning do
+      # example.run
+    # end
+  # end
+
+end

data/spec/unit/adjust_svg_commands_for_plotter_spec.rb

@@ -0,0 +1,24 @@
+require 'convert_svg_string_to_gcode/helpers/adjust_svg_commands_for_plotter'
+require 'spec_helper'
+require 'factory_helper'
+
+RSpec.describe AdjustSVGCommandsForPlotter do
+  let(:svg_commands) { FactoryHelper.svg_commands }
+  let(:spec_adjusted_commands) { SpecConstants::TEST_ADJUSTED_COMMANDS }
+
+  it 'adjusts SVG commands for the plotter' do
+    adjusted_svg_commands = AdjustSVGCommandsForPlotter.perform(svg_commands, ConversionConstants::PROPORTION)
+
+    expect(adjusted_svg_commands.first.p1x).to eq(spec_adjusted_commands.first.p1x)
+    expect(adjusted_svg_commands.first.p1y).to eq(spec_adjusted_commands.first.p1y)
+
+    expect(adjusted_svg_commands.second.cp0x).to eq(spec_adjusted_commands.second.cp0x)
+    expect(adjusted_svg_commands.second.cp0y).to eq(spec_adjusted_commands.second.cp0y)
+    expect(adjusted_svg_commands.second.cp1x).to eq(spec_adjusted_commands.second.cp1x)
+    expect(adjusted_svg_commands.second.cp1y).to eq(spec_adjusted_commands.second.cp1y)
+    expect(adjusted_svg_commands.second.p0x).to eq(spec_adjusted_commands.second.p0x)
+    expect(adjusted_svg_commands.second.p0y).to eq(spec_adjusted_commands.second.p0y)
+    expect(adjusted_svg_commands.second.p1x).to eq(spec_adjusted_commands.second.p1x)
+    expect(adjusted_svg_commands.second.p1y).to eq(spec_adjusted_commands.second.p1y)
+  end
+end

data/spec/unit/convert_svg_string_to_gcode_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'convert_svg_string_to_gcode'
+require 'convert_svg_string_to_gcode/helpers/parse_svg_string'
+require 'convert_svg_string_to_gcode/helpers/tokenize_parsed_svg'
+
+RSpec.describe ConvertSVGStringToGCode do
+  let(:svg_as_string) { SpecConstants::TEST_SVG_AS_STRING }
+
+  it 'converts SVG string into G-Code' do
+    gcode = ConvertSVGStringToGCode.perform(svg_as_string)
+    expect(gcode).to eq(SpecConstants::EXPECTED_GCODE_TEST_SVG_OUTPUT)
+  end
+end

data/spec/unit/create_commands_from_token_spec.rb

@@ -0,0 +1,26 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'convert_svg_string_to_gcode/helpers/create_commands_from_tokens'
+require 'factory_helper'
+
+RSpec.describe CreateCommandsFromTokens do
+  let(:svg_tokens) { SpecConstants::TEST_SVG_TOKENS }
+  let(:spec_commands) { SpecConstants::TEST_SVG_COMMANDS }
+
+  it 'creates command array from tokens' do
+    commands = CreateCommandsFromTokens.perform(svg_tokens)
+
+    expect(spec_commands.first.p1x).to eq(spec_commands.first.p1x)
+    expect(spec_commands.first.p1y).to eq(spec_commands.first.p1y)
+
+    expect(spec_commands.second.cp0x).to eq(spec_commands.second.cp0x)
+    expect(spec_commands.second.cp0y).to eq(spec_commands.second.cp0y)
+    expect(spec_commands.second.cp1x).to eq(spec_commands.second.cp1x)
+    expect(spec_commands.second.cp1y).to eq(spec_commands.second.cp1y)
+    expect(spec_commands.second.p0x).to eq(spec_commands.second.p0x)
+    expect(spec_commands.second.p0y).to eq(spec_commands.second.p0y)
+    expect(spec_commands.second.p1x).to eq(spec_commands.second.p1x)
+    expect(spec_commands.second.p1y).to eq(spec_commands.second.p1y)
+  end
+
+end

data/spec/unit/create_gcode_array_from_svg_commands_spec.rb

@@ -0,0 +1,13 @@
+require 'convert_svg_string_to_gcode/helpers/create_gcode_array_from_svg_commands'
+require 'spec_helper'
+require 'factory_helper'
+
+RSpec.describe CreateGCodeArrayFromSVGCommands do
+  let(:adjusted_svg_commands) { FactoryHelper.adjusted_svg_commands }
+
+  it 'creates a G-Code array from SVG commands' do
+    gcode_array = CreateGCodeArrayFromSVGCommands.perform(adjusted_svg_commands)
+    expect(gcode_array).to eq(SpecConstants::TEST_GCODE_ARRAY)
+  end
+
+end

data/spec/unit/create_gcode_from_gcode_array_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'factory_helper'
+require 'convert_svg_string_to_gcode/helpers/create_gcode_from_gcode_array'
+
+
+RSpec.describe CreateGCodeFromGCodeArray do
+  let(:gcode_array) { FactoryHelper.gcode_array }
+
+  it 'converts G-Code Array to G-Code' do
+     gcode = CreateGCodeFromGCodeArray.perform(gcode_array)
+     expect(gcode).to eq(SpecConstants::EXPECTED_GCODE_TEST_SVG_OUTPUT)
+  end
+end

data/spec/unit/parse_svg_string_spec.rb

@@ -0,0 +1,10 @@
+require 'convert_svg_string_to_gcode/helpers/parse_svg_string'
+
+RSpec.describe ParseSVGString do
+
+  it 'parses svg string' do
+    svg_as_string = SpecConstants::TEST_SVG_AS_STRING
+    parsed_svg = ParseSVGString.perform(svg_as_string)
+  end
+
+end

data/spec/unit/read_svg_to_string_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'convert_svg_string_to_gcode/helpers/read_svg_to_string'
+
+RSpec.describe ReadSVGToString do
+  let(:svg_file) { File.open('spec/fixtures/test.svg') }
+
+  it 'reads in an SVG file and outputs a string' do
+    svg_as_string = ReadSVGToString.perform(svg_file)
+    expect(svg_as_string).to eq(SpecConstants::TEST_SVG_AS_STRING)
+  end
+end

data/spec/unit/tokenize_parsed_svg_spec.rb

@@ -0,0 +1,11 @@
+require 'convert_svg_string_to_gcode/helpers/tokenize_parsed_svg'
+require 'factory_helper'
+
+RSpec.describe TokenizeParsedSVG do
+  let(:parsed_svg) { FactoryHelper.parsed_svg }
+
+  it 'takes a parsed SVG and returns tokens' do
+    svg_tokens = TokenizeParsedSVG.perform(parsed_svg)
+    expect(svg_tokens).to eq(SpecConstants::TEST_SVG_TOKENS)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: convert_svg_string_to_gcode
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1
 platform: ruby
 authors:
 - Jesse Furmanek
@@ -16,15 +16,40 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- config/console.rb
+- convert_svg_string_to_gcode-0.0.0.gem
 - convert_svg_string_to_gcode.gemspec
 - lib/convert_svg_string_to_gcode.rb
 - lib/convert_svg_string_to_gcode/constants/conversion_constants.rb
+- lib/convert_svg_string_to_gcode/constants/plotter_config.rb
 - lib/convert_svg_string_to_gcode/helpers/adjust_svg_commands_for_plotter.rb
+- lib/convert_svg_string_to_gcode/helpers/box_helper.rb
 - lib/convert_svg_string_to_gcode/helpers/create_commands_from_tokens.rb
 - lib/convert_svg_string_to_gcode/helpers/create_gcode_array_from_svg_commands.rb
 - lib/convert_svg_string_to_gcode/helpers/create_gcode_from_gcode_array.rb
 - lib/convert_svg_string_to_gcode/helpers/parse_svg_string.rb
+- lib/convert_svg_string_to_gcode/helpers/read_svg_to_string.rb
 - lib/convert_svg_string_to_gcode/helpers/tokenize_parsed_svg.rb
+- lib/convert_svg_string_to_gcode/models/box.rb
+- lib/convert_svg_string_to_gcode/models/svg_command.rb
+- script/console
+- script/test
+- spec/factory_helper.rb
+- spec/fixtures/spec_constants.rb
+- spec/fixtures/test.svg
+- spec/helpers.rb
+- spec/spec_helper.rb
+- spec/unit/adjust_svg_commands_for_plotter_spec.rb
+- spec/unit/convert_svg_string_to_gcode_spec.rb
+- spec/unit/create_commands_from_token_spec.rb
+- spec/unit/create_gcode_array_from_svg_commands_spec.rb
+- spec/unit/create_gcode_from_gcode_array_spec.rb
+- spec/unit/parse_svg_string_spec.rb
+- spec/unit/read_svg_to_string_spec.rb
+- spec/unit/tokenize_parsed_svg_spec.rb
 homepage: http://rubygems.org/gems/svg_path_to_gcode
 licenses:
 - MIT