g-coder 0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gcoder.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 32leaves
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+gcoder
+======
+
+GCoder is a Ruby library to deal with GCode in various flavours. It's designed to make scripting GCode filters easy, and to work with Opal to enable web-based GCode editors/viewers.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/gcoder.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gcoder/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "g-coder"
+  spec.version       = GCoder::VERSION
+  spec.authors       = ["32leaves"]
+  spec.email         = ["info@32leav.es"]
+  spec.summary       = %q{GCoder is a Ruby library to deal with GCode in various flavours.}
+  spec.description   = %q{GCoder is designed to make scripting GCode filters easy, and to work with Opal to enable web-based GCode editors/viewers.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end

data/lib/gcoder.rb

@@ -0,0 +1,4 @@
+require 'gcoder/dialects/default'
+require 'gcoder/version'
+require 'gcoder/gcode'
+require 'gcoder/parser'

data/lib/gcoder/dialects/default.rb

@@ -0,0 +1,95 @@
+
+module GCoder
+
+  module Dialects
+
+    def self.default
+      map = {}
+      map[:C] = {}
+      map[:G] = {}
+      map[:M] = {}
+      map[:G][0] = :MoveRapid
+      map[:G][1] = :MoveByFeedrate
+      map[:G][2] = :ClockwiseCircularArcAtFeedrate
+      map[:G][3] = :CounterClockwiseCircularArcAtFeedrate
+      map[:G][4] = :Dwell
+      map[:G][9] = :ExactStopCheck
+      map[:G][10] = :ProgrammableParameterInput
+      map[:G][15] = :TurnPolarCoordinatesOffReturnToCartesianCoordinates
+      map[:G][16] = :TurnPolarCoordinatesOn
+      map[:G][17] = :SelectXYPlane
+      map[:G][18] = :SelectXZPlane
+      map[:G][19] = :SelectYZPlane
+      map[:G][20] = :ProgramCoordinatesAreInches
+      map[:G][21] = :ProgramCoordinatesAreMm
+      map[:G][27] = :ReferencePointReturnCheck
+      map[:G][28] = :ReturnToHomePosition
+      map[:G][29] = :ReturnFromTheReferencePosition
+      map[:G][30] = :ReturnToThe2nd3rdAnd4thReferencePoint
+      map[:G][32] = :ConstantLeadThreading
+      map[:G][40] = :ToolCutterCompensationOff
+      map[:G][41] = :ToolCutterCompensationLeft
+      map[:G][42] = :ToolCutterCompensationRight
+      map[:G][43] = :ApplyToolLengthCompensationPlus
+      map[:G][44] = :ApplyToolLengthCompensationMinus
+      map[:G][49] = :ToolLengthCompensationCancel
+      map[:G][50] = :ResetAllScaleFactorsTo1
+      map[:G][51] = :TurnOnScaleFactors
+      map[:G][53] = :MachineCoordinateSystem
+      map[:G][54] = :WorkCoordinateSystem1stWorkpiece
+      map[:G][55] = :WorkCoordinateSystem2ndWorkpiece
+      map[:G][56] = :WorkCoordinateSystem3rdWorkpiece
+      map[:G][57] = :WorkCoordinateSystem4thWorkpiece
+      map[:G][58] = :WorkCoordinateSystem5thWorkpiece
+      map[:G][59] = :WorkCoordinateSystem6thWorkpiece
+      map[:G][61] = :ExactStopCheckMode
+      map[:G][62] = :AutomaticCornerOverride
+      map[:G][63] = :TappingMode
+      map[:G][64] = :BestSpeedPath
+      map[:G][65] = :CustomMacroSimpleCall
+      map[:G][68] = :CoordinateSystemRotation
+      map[:G][69] = :CancelCoordinateSystemRotation
+      map[:G][73] = :HighSpeedDrillingCycle
+      map[:G][74] = :LeftHandTappingCycle
+      map[:G][76] = :FineBoringCyle
+      map[:G][80] = :CancelCannedCycle
+      map[:G][81] = :SimpleDrillingCycle
+      map[:G][82] = :DrillingCycleWithDwell
+      map[:G][83] = :PeckDrillingCycle
+      map[:G][84] = :TappingCycle
+      map[:G][85] = :BoringCannedCycleNoDwellFeedOut
+      map[:G][86] = :BoringCannedCycleSpindleStopRapidOut
+      map[:G][87] = :BackBoringCannedCycle
+      map[:G][88] = :BoringCannedCycleSpindleStopManualOut
+      map[:G][89] = :BoringCannedCycleDwellFeedOut
+      map[:G][90] = :AbsoluteProgrammingOfXYZ
+      map[:G][91] = :IncrementalProgrammingOfXYZ
+      map[:G][92] = :OffsetCoordinateSystemAndSaveParameters
+      map[:G][921] = :CancelOffsetAndZeroParameters
+      map[:G][922] = :CancelOffsetAndRetainParameters
+      map[:G][923] = :OffsetCoordinateSystemWithSavedParameters
+      map[:G][94] = :UnitsPerMinuteFeedModeUnitsInInchesOrMm
+      map[:G][95] = :UnitsPerRevolutionFeedModeUnitsInInchesOrMm
+      map[:G][96] = :ConstantSurfaceSpeed
+      map[:G][97] = :CancelConstantSurfaceSpeed
+      map[:G][98] = :ReturnToInitialZPlaneAfterCannedCycle
+      map[:G][99] = :ReturnToInitialRPlaneAfterCannedCycle
+      map[:M][0] = :ProgramStop
+      map[:M][1] = :ProgramStopOptional
+      map[:M][2] = :EndOfProgram
+      map[:M][3] = :SpindleOnCwRotation
+      map[:M][4] = :SpindleOnCcwRotation
+      map[:M][5] = :SpindleStop
+      map[:M][6] = :ToolChange
+      map[:M][7] = :MistCoolantOn
+      map[:M][8] = :FloodCoolantOn
+      map[:M][9] = :CoolantOff
+      map[:M][30] = :EndOfProgramRewindAndResetModes
+      map[:M][98] = :SubprogramCall
+      map[:M][99] = :ReturnFromSubprogram
+      map
+    end
+
+  end
+
+end

data/lib/gcoder/gcode.rb

@@ -0,0 +1,321 @@
+require 'delegate'
+
+class Object
+
+  #
+  # A combination of to_i and to_f.
+  # If this object is nil?, nil is returned.
+  # If this object is an integer, to_i is returned.
+  # If this object is a floating point number, to_f is returned.
+  #
+  def to_nif
+    if nil?
+      nil
+    elsif to_i.to_s == self
+      to_i
+    else
+      to_f
+    end
+  end
+
+end
+
+module GCoder
+
+  module GCode
+
+    class ProgramContext < SimpleDelegator
+      attr_accessor :position, :feedrate, :units, :absolute
+
+      def initialize(position = [0,0,0], feedrate = 0, units = :mm, absolute = false)
+        super({})
+
+        @position = position
+        @feedrate = feedrate
+        @units = units
+        @absolute = absolute
+      end
+
+      def absolute?; absolute; end
+
+      def update_position(pos)
+        if absolute
+          @position = @position.each_with_index.map {|e, i| pos[i] || @position[i] }
+        else
+          @position = @position.each_with_index.map {|e, i| @position[i] + (pos[i] || 0) }
+        end
+      end
+
+      def update_feedrate(feedrate)
+        @feedrate = feedrate unless feedrate.nil?
+      end
+    end
+
+    class Program < SimpleDelegator
+      include GCoder::GCode
+
+      def initialize(commands)
+        super(commands)
+      end
+
+      #
+      # Interpretes aspects of the GCode program, namely position, feedrate, unit of measure
+      # and absolute/incremental positioning. This information is made available to the optional
+      # block as second parameter, through a ProgramContext instance.
+      #
+      # Returns an array with two elements, the mapping result and context.
+      #
+      #
+      def map_with_context(&block)
+        ctx = ProgramContext.new
+
+        map_result = self.map do |cmd|
+          if block_given?
+            r = yield(cmd, ctx)
+          else
+            r = cmd
+          end
+
+          if cmd.is_a? MoveRapid or cmd.is_a? MoveByFeedrate
+            ctx.update_position cmd.position
+            ctx.update_feedrate cmd.feedrate
+          elsif cmd.is_a? ProgramCoordinatesAreMm
+            ctx.units = :mm
+          elsif cmd.is_a? ProgramCoordinatesAreInches
+            ctx.units = :inch
+          elsif cmd.is_a? AbsoluteProgrammingOfXYZ
+            ctx.absolute = true
+          elsif cmd.is_a? IncrementalProgrammingOfXYZ
+            ctx.absolute = false
+          end
+
+          r
+        end
+
+        [map_result, ctx]
+      end
+
+
+    end
+
+    class Command
+      attr_reader :code, :args
+
+      def initialize(code, args)
+        @code = code
+        @args = args
+      end
+
+      def to_s
+        ( [code] + args.map {|e| e.join } ).join(" ")
+      end
+
+    end
+
+    class Comment < Command
+      # Returns the text of the comment without the parentheses
+      def text
+        code
+      end
+
+      def to_s
+        "(#{code})"
+      end
+    end
+
+    class CategoryCommand < Command
+    end
+    class MotionCommand < Command
+
+      def position
+        [ args[:X], args[:Y], args[:Z] ].map {|x| x.to_nif }
+      end
+
+      def feedrate
+        args[:F].to_nif
+      end
+
+    end
+    class CompensationCommand < Command
+    end
+    class CoordinateCommand < Command
+    end
+    class MotionCommand < Command
+    end
+    class CannedCommand < Command
+    end
+    class CompensationCommand < Command
+    end
+    class CoordinateCommand < Command
+    end
+    class OtherCommand < Command
+    end
+    class CannedCommand < Command
+    end
+    class MCodeCommand < Command
+    end
+
+    class MoveRapid < MotionCommand
+    end
+    class MoveByFeedrate < MotionCommand
+    end
+    class ClockwiseCircularArcAtFeedrate < MotionCommand
+    end
+    class CounterClockwiseCircularArcAtFeedrate < MotionCommand
+    end
+    class Dwell < MotionCommand
+    end
+    class ExactStopCheck < MotionCommand
+    end
+    class ProgrammableParameterInput < CompensationCommand
+    end
+    class TurnPolarCoordinatesOffReturnToCartesianCoordinates < CoordinateCommand
+    end
+    class TurnPolarCoordinatesOn < CoordinateCommand
+    end
+    class SelectXYPlane < CoordinateCommand
+    end
+    class SelectXZPlane < CoordinateCommand
+    end
+    class SelectYZPlane < CoordinateCommand
+    end
+    class ProgramCoordinatesAreInches < CoordinateCommand
+    end
+    class ProgramCoordinatesAreMm < CoordinateCommand
+    end
+    class AbsoluteProgrammingOfXYZ < CoordinateCommand
+    end
+    class IncrementalProgrammingOfXYZ < CoordinateCommand
+    end
+    class ReferencePointReturnCheck < MotionCommand
+    end
+    class ReturnToHomePosition < MotionCommand
+    end
+    class ReturnFromTheReferencePosition < MotionCommand
+    end
+    class ReturnToThe2nd3rdAnd4thReferencePoint < MotionCommand
+    end
+    class ConstantLeadThreading < CannedCommand
+    end
+    class ToolCutterCompensationOff < CompensationCommand
+    end
+    class ToolCutterCompensationLeft < CompensationCommand
+    end
+    class ToolCutterCompensationRight < CompensationCommand
+    end
+    class ApplyToolLengthCompensationPlus < CompensationCommand
+    end
+    class ApplyToolLengthCompensationMinus < CompensationCommand
+    end
+    class ToolLengthCompensationCancel < CompensationCommand
+    end
+    class ResetAllScaleFactorsTo1 < CompensationCommand
+    end
+    class TurnOnScaleFactors < CompensationCommand
+    end
+    class MachineCoordinateSystem < CoordinateCommand
+    end
+    class WorkCoordinateSystem1stWorkpiece < CoordinateCommand
+    end
+    class WorkCoordinateSystem2ndWorkpiece < CoordinateCommand
+    end
+    class WorkCoordinateSystem3rdWorkpiece < CoordinateCommand
+    end
+    class WorkCoordinateSystem4thWorkpiece < CoordinateCommand
+    end
+    class WorkCoordinateSystem5thWorkpiece < CoordinateCommand
+    end
+    class WorkCoordinateSystem6thWorkpiece < CoordinateCommand
+    end
+    class ExactStopCheckMode < OtherCommand
+    end
+    class AutomaticCornerOverride < OtherCommand
+    end
+    class TappingMode < OtherCommand
+    end
+    class BestSpeedPath < OtherCommand
+    end
+    class CustomMacroSimpleCall < OtherCommand
+    end
+    class CoordinateSystemRotation < CoordinateCommand
+    end
+    class CancelCoordinateSystemRotation < CoordinateCommand
+    end
+    class HighSpeedDrillingCycle < CannedCommand
+    end
+    class LeftHandTappingCycle < CannedCommand
+    end
+    class FineBoringCyle < CannedCommand
+    end
+    class CancelCannedCycle < CannedCommand
+    end
+    class SimpleDrillingCycle < CannedCommand
+    end
+    class DrillingCycleWithDwell < CannedCommand
+    end
+    class PeckDrillingCycle < CannedCommand
+    end
+    class TappingCycle < CannedCommand
+    end
+    class BoringCannedCycleNoDwellFeedOut < CannedCommand
+    end
+    class BoringCannedCycleSpindleStopRapidOut < CannedCommand
+    end
+    class BackBoringCannedCycle < CannedCommand
+    end
+    class BoringCannedCycleSpindleStopManualOut < CannedCommand
+    end
+    class BoringCannedCycleDwellFeedOut < CannedCommand
+    end
+    class OffsetCoordinateSystemAndSaveParameters < CoordinateCommand
+    end
+    class ClampOfMaximumSpindleSpeed < MotionCommand
+    end
+    class CancelOffsetAndZeroParameters < CoordinateCommand
+    end
+    class CancelOffsetAndRetainParameters < CoordinateCommand
+    end
+    class OffsetCoordinateSystemWithSavedParameters < CoordinateCommand
+    end
+    class UnitsPerMinuteFeedModeUnitsInInchesOrMm < MotionCommand
+    end
+    class UnitsPerRevolutionFeedModeUnitsInInchesOrMm < MotionCommand
+    end
+    class ConstantSurfaceSpeed < MotionCommand
+    end
+    class CancelConstantSurfaceSpeed < MotionCommand
+    end
+    class ReturnToInitialZPlaneAfterCannedCycle < CannedCommand
+    end
+    class ReturnToInitialRPlaneAfterCannedCycle < CannedCommand
+    end
+    class ProgramStop < MCodeCommand
+    end
+    class ProgramStopOptional < MCodeCommand
+    end
+    class EndOfProgram < MCodeCommand
+    end
+    class SpindleOnCwRotation < MCodeCommand
+    end
+    class SpindleOnCcwRotation < MCodeCommand
+    end
+    class SpindleStop < MCodeCommand
+    end
+    class ToolChange < MCodeCommand
+    end
+    class MistCoolantOn < MCodeCommand
+    end
+    class FloodCoolantOn < MCodeCommand
+    end
+    class CoolantOff < MCodeCommand
+    end
+    class EndOfProgramRewindAndResetModes < MCodeCommand
+    end
+    class SubprogramCall < MCodeCommand
+    end
+    class ReturnFromSubprogram < MCodeCommand
+    end
+
+  end
+
+end

data/lib/gcoder/parser.rb

@@ -0,0 +1,45 @@
+
+module GCoder
+
+  class Parser
+
+    #
+    # Rudimentary GCode parser that also maps the commands to their respective classes according to the dialect.
+    #
+    # Returns a GCode::Program containing the commands.
+    #
+    def parse(code, dialect = GCoder::Dialects::default)
+      code = code.split("\n") unless code.is_a? Array
+
+      commands = code.map do |caa|
+        r = nil
+        caa.strip!
+        unless caa.empty?
+          cmd, *args = caa.strip.split(" ")
+          root_code = cmd[0...1]
+          child_code = cmd[1..-1]
+          args = args.inject({}) {|m,e| m[e[0...1].to_sym] = e[1..-1]; m }
+
+          if root_code == '('
+            r = GCoder::GCode::Comment.new(caa.strip[1...-1], {})
+          else
+            commands = dialect[root_code.to_sym]
+            throw "Dialect does not support #{root_code} commands" if commands.nil?
+
+            unless child_code.nil? or child_code.empty?
+              cmd_class = commands[child_code.to_i]
+              throw "Dialect does not support command: #{child_code}" if cmd_class.nil?
+
+              r = eval("GCoder::GCode::#{cmd_class}").new(cmd, args)
+            end
+          end
+        end
+        r
+      end.compact
+
+      GCode::Program.new(commands)
+    end
+
+  end
+
+end

data/lib/gcoder/version.rb

@@ -0,0 +1,6 @@
+
+module GCoder
+
+  VERSION = 0.1
+
+end

data/spec/default_dialect_spec.rb

@@ -0,0 +1,13 @@
+require 'rspec'
+require 'spec_helper'
+
+describe 'Default dialect' do
+
+  it 'should use only classes that exist in GCoder' do
+    GCoder::Dialects::default.values.map {|e| e.values }.flatten.each do |classname|
+      GCoder::GCode.const_defined?(classname).should be_true, "Undefined class #{classname}"
+      GCoder::GCode.const_get(classname).new("Code", {})
+    end
+  end
+
+end

data/spec/gcode_program_spec.rb

@@ -0,0 +1,56 @@
+require 'rspec'
+require 'spec_helper'
+
+describe 'GCode program' do
+
+  it 'should maintain the correct position (in absolute mode) in map_with_context' do
+    program = GCoder::Parser.new.parse("""
+G90
+G0 X0 Y0 Z0 F140
+G1 X42 Y13 Z22.2 F100.001
+G0 X11.1 Y0 Z102
+M0
+""")
+
+    program.map_with_context.last.absolute?.should eq true
+    program.map_with_context {|cmd, ctx| ctx.position }.first.should eq [
+        [ 0, 0, 0 ],
+        [ 0, 0, 0 ],
+        [ 0, 0, 0 ],
+        [ 42, 13, 22.2 ],
+        [ 11.1, 0, 102 ]
+    ]
+  end
+
+  it 'should maintain the correct position (in relative mode) in map_with_context' do
+    program = GCoder::Parser.new.parse("""
+G91
+G0 X0 Y0 Z0 F140
+G1 X42 Y13 Z22.2 F100.001
+G0 X11.1 Y0 Z102
+M0
+""")
+
+    program.map_with_context.last.absolute?.should eq false
+    program.map_with_context {|cmd, ctx| ctx.position }.first.should eq [
+        [ 0, 0, 0 ],
+        [ 0, 0, 0 ],
+        [ 0, 0, 0 ],
+        [ 42, 13, 22.2 ],
+        [ 53.1, 13, 124.2 ]
+    ]
+  end
+
+  it 'should maintain the correct feedrate in map_with_context' do
+    program = GCoder::Parser.new.parse("""
+G90
+G0 X0 Y0 Z0 F140
+G1 X42 Y13 Z22.2 F100.001
+G0 X11.1 Y0 Z102
+M0
+""")
+
+    program.map_with_context {|cmd, ctx| ctx.feedrate }.first.should eq [ 0, 0, 140, 100.001, 100.001 ]
+  end
+
+end

data/spec/parser_spec.rb

@@ -0,0 +1,54 @@
+require 'rspec'
+require 'spec_helper'
+
+describe 'GCode parser' do
+
+  before do
+    @parser = GCoder::Parser.new
+  end
+
+  it 'should return a GCode program' do
+    @parser.parse("G0 X0 Y0 Z0 F1").should be_an_instance_of GCoder::GCode::Program
+  end
+
+  it 'should parse rapid motion GCode' do
+    cmd = @parser.parse("G0 X1 Y22.22 Z33.3 F12").first
+
+    cmd.should be_an_instance_of GCoder::GCode::MoveRapid
+    cmd.feedrate.should eq 12
+    cmd.position.should eq [ 1, 22.22, 33.3 ]
+  end
+
+  it 'should parse feedrate motion GCode' do
+    cmd = @parser.parse("G1 X1 Y22.22 Z33.3 F12").first
+
+    cmd.should be_an_instance_of GCoder::GCode::MoveByFeedrate
+    cmd.feedrate.should eq 12
+    cmd.position.should eq [ 1, 22.22, 33.3 ]
+  end
+
+  it 'should omit empty lines' do
+    prog = @parser.parse("""
+G0 X1 Y2 Z3
+
+M0
+""")
+    prog.length.should eq 2
+  end
+
+  it 'should parse comments' do
+    comments = [
+        "Hello World, this is a comment",
+        "Let's try another comment"
+    ]
+
+    prog = @parser.parse(comments.map {|c| "(#{c})\n" }.join("\n"))
+
+    prog.length.should eq comments.length
+    prog.each_with_index do |cmd, idx|
+      cmd.should be_an_instance_of GCoder::GCode::Comment
+      cmd.text.should eq comments[idx]
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'gcoder'
+require 'pry'

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: g-coder
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- 32leaves
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: GCoder is designed to make scripting GCode filters easy, and to work
+  with Opal to enable web-based GCode editors/viewers.
+email:
+- info@32leav.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- gcoder.gemspec
+- lib/gcoder.rb
+- lib/gcoder/dialects/default.rb
+- lib/gcoder/gcode.rb
+- lib/gcoder/parser.rb
+- lib/gcoder/version.rb
+- spec/default_dialect_spec.rb
+- spec/gcode_program_spec.rb
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: GCoder is a Ruby library to deal with GCode in various flavours.
+test_files:
+- spec/default_dialect_spec.rb
+- spec/gcode_program_spec.rb
+- spec/parser_spec.rb
+- spec/spec_helper.rb