SAVAGE 0.1.0

data/LICENSE.txt

@@ -0,0 +1,13 @@
+Copyright 2013 Mason Simon
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,69 @@
+# SAVAGE
+
+## Intro
+
+Savage is a graphics language layered on top of SVG, in the spirit of Sass and Haml.
+
+## Usage
+
+  1. clone repo
+  1. bundle
+  1. bundle exec ruby compiler.rb < test.svge > test.svg
+  1. View test.svg in a web browser or other SVG renderer.
+
+## Example
+
+    // Set dimensions of your graphic (width x height).
+    400 x 300
+
+    // Draw a circle of radius 100 at (200,150).
+    (100) @ 200,150
+
+    // Draw an ellipse with x-radius 50 and y-radius 40 at 10,10.
+    (50,40) @ 10,10
+
+    // Draw a square of side length 10.
+    [10] @ 100,200
+
+    // Draw a rectangle of width 50, height 30.
+    [50,30] @ 300,0
+
+    // Draw a line from (20,30) to (40,50), then to (50,60).
+    -
+      @ 20,30
+      @ 40,50
+      @ 50,60
+
+    // Draw an arrow.
+    ~
+      M 100,225
+      L 100,115
+      L 130,115
+      L 70,15
+      L 10,115
+      L 40,115
+      L 40,225
+      z
+
+    // Style using Sass.
+    :sass
+      .dot
+        fill: red
+
+      #point
+        fill: blue
+
+    [15].dot @ 300,250
+
+    [15].dot @ 350,270
+
+    (15)#point @ 360, 230
+
+## License
+
+Apache 2.0. See LICENSE.txt.
+
+## Credits
+
+Marc-André Cournoyer for writing [http://createyourproglang.com/](http://createyourproglang.com/), which got this project off the ground. The authors of [Haml](http://haml.info/), [Sass](http://sass-lang.com/), and [Coffeescript](http://coffeescript.org/), for demonstrating that we need not be content with the languages W3C gives us.
+

data/bin/savage

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'lexer'
+require 'parser'
+
+tokens = Lexer.new.tokenize(ARGF.read)
+parsed = Parser.new(tokens)
+
+puts '<?xml version="1.0" standalone="yes"?>'
+puts parsed.translate
+

data/lib/lexer.rb

@@ -0,0 +1,100 @@
+class Lexer
+  def tokenize(code)
+    code.chomp!
+
+    tokens = []
+
+    # TODO: Switch to a state machine framework (state_machine, Ragel);
+    # this is getting gross.
+
+    # Advance 1 char at a time until finding something parsable.
+    i = 0
+
+    indented = false
+
+    while i < code.size
+      chunk = code[i..-1]
+
+      if comment = chunk.match(/\A\/\/.*?\n/)
+        i += comment.to_s.size - 1
+      elsif dimension = chunk.match(/\A(\d+)\sx\s(\d+)/)
+        w, h = dimension.captures.map(&:to_i)
+        tokens << [:DIMENSION, [w, h]]
+        i += dimension.to_s.size
+      elsif sass = chunk.match(/\A\:sass\n((?:(?:[ ]+.*?\n)|\n)+)/)
+        src = sass[1]
+        indented = true
+        tokens << [:SASS, src]
+        i += sass.to_s.size - 1
+      elsif circle = chunk.match(/\A\((\d+)\)/)
+        r = circle[1].to_i
+        tokens << [:CIRCLE, r]
+        i += circle.to_s.size
+      elsif ellipse = chunk.match(/\A\((\d+),\s*(\d+)\)/)
+        rx, ry = ellipse.captures.map(&:to_i)
+        tokens << [:ELLIPSE, [rx, ry]]
+        i += ellipse.to_s.size
+      elsif round_rect = chunk.match(/\A\[(\d+),\s*(\d+),\s*(\d+),\s*(\d+)\)/)
+        w, h, rx, ry = round_rect.captures.map(&:to_i)
+        tokens << [:ROUND_RECT, [w, h, rx, ry]]
+        i += round_rect.to_s.size
+      elsif rect = chunk.match(/\A\[(\d+),\s*(\d+)\]/)
+        w, h = rect.captures.map(&:to_i)
+        tokens << [:RECT, [w, h]]
+        i += rect.to_s.size
+      elsif square = chunk.match(/\A\[(\d+)\]/)
+        s = square[1].to_i
+        tokens << [:RECT, [s, s]]
+        i += square.to_s.size
+      elsif text = chunk.match(/\A\"([^\"]+)\"/)
+        t = text[1]
+        tokens << [:TEXT, t]
+        i += text.to_s.size
+      elsif line = chunk.match(/\A\-/)
+        tokens << [:LINE]
+        i += line.to_s.size
+      elsif path = chunk.match(/\A\~/)
+        tokens << [:PATH]
+        i += path.to_s.size
+      elsif pathdef = chunk.match(/\A([MmZzLlHhVvCcSsQqTtAa])\s?((?:[\d\.\-,](?: )?)+)?/)
+        command, params = pathdef.captures
+        tokens << [:PATHDEF, [command, params]]
+        i += pathdef.to_s.size
+      elsif id = chunk.match(/\A#([a-zA-Z0-9_\-]+)/)
+        name = id[1]
+        tokens << [:ID, name]
+        i += id.to_s.size
+      elsif classname = chunk.match(/\A\.([a-zA-Z0-9_\-]+)/)
+        name = classname[1]
+        tokens << [:CLASS, name]
+        i += classname.to_s.size
+      elsif coords = chunk.match(/\A@\s*(\d+)\s*,\s*(\d+)/)
+        x, y = coords.captures
+        tokens << [:LOCATION, [x.to_i, y.to_i]]
+        i += coords.to_s.size
+      elsif chunk.match(/\A\n\n/)
+        tokens << [:NEWLINE]
+        i += 1
+      elsif indent = chunk.match(/\A\n\s+/)
+        indented = true
+        tokens << [:INDENT]
+        i += indent.to_s.size
+      elsif indented && chunk.match(/\A\n[^\s]/)
+        indented = false
+        tokens << [:DEDENT]
+        i += 1
+      elsif indented && (attribute = chunk.match(/\A(\w+):\s*([^\s]+?)(?:\n|\Z)/))
+        key, value = attribute.captures
+        tokens << [:ATTRIBUTE, [key, value]]
+        i += attribute.to_s.size - 1 # Don't advance beyond newline.
+      else
+        i += 1
+      end
+    end
+    tokens << [:EOF]
+
+    tokens
+  end
+end
+
+

data/lib/parser.rb

@@ -0,0 +1,82 @@
+require_relative 'parsers/svg'
+require_relative 'parsers/sass'
+require_relative 'parsers/circle'
+require_relative 'parsers/ellipse'
+require_relative 'parsers/round_rect'
+require_relative 'parsers/rect'
+require_relative 'parsers/text'
+require_relative 'parsers/line'
+require_relative 'parsers/path'
+
+class Parser
+  attr_reader :els
+
+  def initialize(tokens)
+    @els = Svg.new
+    curr = @els
+
+    # TODO: Switch to a state machine framework (state_machine, Ragel);
+    # this is getting gross.
+    tokens.each do |token|
+      if curr == @els
+        if token.first == :DIMENSION
+          el = Svg.new
+          el << token
+          @els = el
+          curr = el
+        elsif token.first == :SASS
+          el = SassEl.new
+          el << token
+          curr << el
+          curr = el
+        elsif token.first == :CIRCLE
+          el = Circle.new
+          el << token
+          curr << el
+          curr = el
+        elsif token.first == :ELLIPSE
+          el = Ellipse.new
+          el << token
+          curr << el
+          curr = el
+        elsif token.first == :ROUND_RECT
+          el = RoundRect.new
+          el << token
+          curr << el
+          curr = el
+        elsif token.first == :RECT
+          el = Rect.new
+          el << token
+          curr << el
+          curr = el
+        elsif token.first == :TEXT
+          el = Text.new
+          el << token
+          curr << el
+          curr = el
+        elsif token.first == :LINE
+          el = Line.new
+          el << token
+          curr << el
+          curr = el
+        elsif token.first == :PATH
+          el = Path.new
+          el << token
+          curr << el
+          curr = el
+        end
+      else
+        if [:EOF, :DEDENT, :NEWLINE].include? token.first
+          curr = @els
+        else
+          curr << token
+        end
+      end
+    end
+  end
+
+  def translate
+    @els.translate
+  end
+end
+

data/lib/parsers/circle.rb

@@ -0,0 +1,28 @@
+require_relative 'element'
+
+class Circle < Element
+  def <<(token)
+    if @tokens.empty?
+      raise "Invalid starting token: #{token}" unless token.first == :CIRCLE
+      radius = token.last
+      @attributes['r'] = radius
+    end
+
+    if token.first == :LOCATION
+      x, y = token.last
+      @attributes['cx'] = x
+      @attributes['cy'] = y
+    elsif token.first == :ATTRIBUTE
+      k, v = token.last
+      @attributes[k] = v
+    end
+
+    super(token)
+  end
+
+  def translate
+    attrs = @attributes.map { |k,v| "#{k}='#{v}'" }.join(' ')
+    "<circle #{attrs} />"
+  end
+end
+

data/lib/parsers/element.rb

@@ -0,0 +1,20 @@
+class Element
+  def initialize
+    @tokens = []
+    @attributes = {}
+    @children = []
+  end
+
+  def <<(token)
+    if token.is_a? Array
+      if token.first == :ID
+        @attributes['id'] = token.last
+      elsif token.first == :CLASS
+        @attributes['class'] = token.last
+      end
+    end
+
+    @tokens << token
+  end
+end
+

data/lib/parsers/ellipse.rb

@@ -0,0 +1,29 @@
+require_relative 'element'
+
+class Ellipse < Element
+  def <<(token)
+    if @tokens.empty?
+      raise "Invalid starting token: #{token}" unless token.first == :ELLIPSE
+      rx, ry = token.last
+      @attributes['rx'] = rx
+      @attributes['ry'] = ry
+    end
+
+    if token.first == :LOCATION
+      x, y = token.last
+      @attributes['cx'] = x
+      @attributes['cy'] = y
+    elsif token.first == :ATTRIBUTE
+      k, v = token.last
+      @attributes[k] = v
+    end
+
+    super(token)
+  end
+
+  def translate
+    attrs = @attributes.map { |k,v| "#{k}='#{v}'" }.join(' ')
+    "<ellipse #{attrs} />"
+  end
+end
+

data/lib/parsers/line.rb

@@ -0,0 +1,31 @@
+require_relative 'element'
+
+class Line < Element
+  def initialize
+    super
+    @points = []
+  end
+
+  def <<(token)
+    if @tokens.empty?
+      raise "Invalid starting token: #{token}" unless token.first == :LINE
+    end
+
+    if token.first == :LOCATION
+      x, y = token.last
+      @points << [x, y]
+    elsif token.first == :ATTRIBUTE
+      k, v = token.last
+      @attributes[k] = v
+    end
+
+    super(token)
+  end
+
+  def translate
+    attrs = @attributes.map { |k,v| "#{k}='#{v}'" }.join(' ')
+    points = @points.map { |coords| coords.join(',') }.join(' ')
+    "<polyline points='#{points}' #{attrs} />"
+  end
+end
+

data/lib/parsers/path.rb

@@ -0,0 +1,34 @@
+require_relative 'element'
+
+class Path < Element
+  def initialize
+    super
+    @pathdefs = []
+  end
+
+  def <<(token)
+    if @tokens.empty?
+      raise "Invalid starting token: #{token}" unless token.first == :PATH
+    end
+
+    if token.first == :LOCATION
+      x, y = token.last
+      @points << [x, y]
+    elsif token.first == :ATTRIBUTE
+      k, v = token.last
+      @attributes[k] = v
+    elsif token.first == :PATHDEF
+      command, params = token.last
+      @pathdefs << [command, params]
+    end
+
+    super(token)
+  end
+
+  def translate
+    attrs = @attributes.map { |k,v| "#{k}='#{v}'" }.join(' ')
+    definition = @pathdefs.map { |command, params| "#{command} #{params}" }.join(' ')
+    "<path d='#{definition}' #{attrs} />"
+  end
+end
+

data/lib/parsers/rect.rb

@@ -0,0 +1,29 @@
+require_relative 'element'
+
+class Rect < Element
+  def <<(token)
+    if @tokens.empty?
+      raise "Invalid starting token: #{token}" unless token.first == :RECT
+      w, h = token.last
+      @attributes['width'] = w
+      @attributes['height'] = h
+    end
+
+    if token.first == :LOCATION
+      x, y = token.last
+      @attributes['x'] = x
+      @attributes['y'] = y
+    elsif token.first == :ATTRIBUTE
+      k, v = token.last
+      @attributes[k] = v
+    end
+
+    super(token)
+  end
+
+  def translate
+    attrs = @attributes.map { |k,v| "#{k}='#{v}'" }.join(' ')
+    "<rect #{attrs} />"
+  end
+end
+

data/lib/parsers/round_rect.rb

@@ -0,0 +1,31 @@
+require_relative 'element'
+
+class RoundRect < Element
+  def <<(token)
+    if @tokens.empty?
+      raise "Invalid starting token: #{token}" unless token.first == :ROUND_RECT
+      w, h, rx, ry = token.last
+      @attributes['width'] = w
+      @attributes['height'] = h
+      @attributes['rx'] = rx
+      @attributes['ry'] = ry
+    end
+
+    if token.first == :LOCATION
+      x, y = token.last
+      @attributes['x'] = x
+      @attributes['y'] = y
+    elsif token.first == :ATTRIBUTE
+      k, v = token.last
+      @attributes[k] = v
+    end
+
+    super(token)
+  end
+
+  def translate
+    attrs = @attributes.map { |k,v| "#{k}='#{v}'" }.join(' ')
+    "<rect #{attrs} />"
+  end
+end
+

data/lib/parsers/sass.rb

@@ -0,0 +1,27 @@
+require_relative 'element'
+require 'sass'
+
+class SassEl < Element
+  def <<(token)
+    if @tokens.empty?
+      raise "Invalid starting token: #{token}" unless token.first == :SASS
+
+      # Dedent the text.
+      lines = token.last.split("\n")
+      indent = lines.first.match(/\A(\s+)/)[1].size
+      @sass = lines.map { |l| l[indent..-1] }.join("\n")
+    end
+
+    super(token)
+  end
+
+  def translate
+    css = Sass::Engine.new(@sass).render
+    """<style type='text/css' media='screen'>
+  <![CDATA[
+    #{css}
+  ]]>
+</style>"""
+  end
+end
+

data/lib/parsers/svg.rb

@@ -0,0 +1,41 @@
+require_relative 'element'
+
+class Svg < Element
+  def initialize
+    super
+    @attributes = {
+      'width' => 100,
+      'height' => 100,
+      'version' => '1.1',
+      'xmlns' => 'http://www.w3.org/2000/svg',
+    }
+  end
+
+  def <<(token)
+    if @tokens.empty?
+      raise "Invalid starting token: #{token}" unless token.first == :DIMENSION
+      w, h = token.last
+      @attributes['width'] = w
+      @attributes['height'] = h
+    end
+
+    if token.is_a? Array
+      if token.first == :ATTRIBUTE
+        k, v = token.last
+        @attributes[k] = v
+      end
+    elsif token.class < Element
+      @children << token
+    end
+
+    super(token)
+  end
+
+  def translate
+    attrs = @attributes.map { |k,v| "#{k}='#{v}'" }.join(' ')
+    """<svg #{attrs}>
+  #{@children.map { |el| el.translate }.join("\n")}
+</svg>"""
+  end
+end
+

data/lib/parsers/text.rb

@@ -0,0 +1,27 @@
+require_relative 'element'
+
+class Text < Element
+  def <<(token)
+    if @tokens.empty?
+      raise "Invalid starting token: #{token}" unless token.first == :TEXT
+      @text = token.last
+    end
+
+    if token.first == :LOCATION
+      x, y = token.last
+      @attributes['x'] = x
+      @attributes['y'] = y
+    elsif token.first == :ATTRIBUTE
+      k, v = token.last
+      @attributes[k] = v
+    end
+
+    super(token)
+  end
+
+  def translate
+    attrs = @attributes.map { |k,v| "#{k}='#{v}'" }.join(' ')
+    "<text #{attrs}>#{@text}</text>"
+  end
+end
+

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: SAVAGE
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Mason Simon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sass
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Savage is a graphics language layered on top of SVG, in the spirit of
+  Sass and Haml.
+email: masonsimon@gmail.com
+executables:
+- savage
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/lexer.rb
+- lib/parser.rb
+- lib/parsers/circle.rb
+- lib/parsers/element.rb
+- lib/parsers/ellipse.rb
+- lib/parsers/line.rb
+- lib/parsers/path.rb
+- lib/parsers/rect.rb
+- lib/parsers/round_rect.rb
+- lib/parsers/sass.rb
+- lib/parsers/svg.rb
+- lib/parsers/text.rb
+- bin/savage
+- LICENSE.txt
+- README.md
+homepage: https://bitbucket.org/masonicboom/savage
+licenses: []
+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: Text-editor friendly graphics language that compiles to SVG.
+test_files: []