dagon 0.1.0

data/dagon/scanner.rl

@@ -0,0 +1,143 @@
+# vim: set syntax=ruby:
+
+=begin
+%%{
+  machine new_parser;
+  newline = "\r"? "\n" | "\r";
+  newlines = newline+;
+  keyword = 'if' | 'elseif' | 'else' | 'while' | 'true' | 'false' | 'void';
+  string = '"' ( [^"\\] | /\\./ )* '"';
+  comment = '#' (any - newline)* newline;
+  constant = upper (alnum | '-')*;
+  identifier = '-'? lower (lower | digit | '-')*;
+  assignment = ': ';
+  arrow = '->';
+  colon = ':';
+  operator = ' + ' | ' - ' | ' * ' | ' / ' | ' = ' | ' != ' | ' < ' | ' > ' | ' <= ' | ' >= ' | ' && ' | ' || ' | ' ^ ';
+  exponent = ' ** ';
+  lparen = '(';
+  rparen = ')';
+  lbracket = '[';
+  rbracket = ']';
+  lbrace = '{';
+  rbrace = '}';
+  comma = ', ';
+  bang = '!';
+  dot = '.';
+  float = digit+ '.' digit+;
+  integer = '-'? digit+;
+  indent = "  ";
+  at = "@";
+
+  main := |*
+    newlines { @last_indent_count = @indent_count; @indent_count = 0; @line += data[ts...te].lines.count; @column = 0; @check_indents = true };
+    comment { handle_indents };
+    keyword => { emit(data[ts...te].upcase.to_sym, data, ts, te) };
+    string => { emit_string(data, ts, te) };
+    constant => { emit(:CONSTANT, data, ts, te) };
+    identifier => { emit(:IDENTIFIER, data, ts, te) };
+    assignment => { emit(:ASSIGNMENT, data, ts, te-1) };
+    arrow => { emit(:ARROW, data, ts, te) };
+    colon => { emit(':', data, ts, te) };
+    float => { emit(:FLOAT, data, ts, te) };
+    integer => { emit(:INTEGER, data, ts, te) };
+    indent => { @indent_count += 1; };
+    lparen => { emit(:LPAREN, data, ts, te) };
+    rparen => { emit(:RPAREN, data, ts, te) };
+    lbrace => { emit(:LBRACE, data, ts, te) };
+    rbrace => { emit(:RBRACE, data, ts, te) };
+    lbracket => { emit(:LBRACKET, data, ts, te) };
+    rbracket => { emit(:RBRACKET, data, ts, te) };
+    dot => { emit(:DOT, data, ts, te) };
+    bang => { emit('!', data, ts, te) };
+    at => { emit('@', data, ts, te) };
+    operator => { emit(data[(ts+1)...(te-1)], data, ts + 1, te - 1) };
+    exponent => { emit(:EXPONENT, data, ts + 1, te - 1) };
+    comma => { emit(:COMMA, data, ts, te) };
+    space;
+
+    any => { problem(data, ts, te) };
+  *|;
+}%%
+=end
+
+module Dagon
+  class Token < Struct.new(:data, :line); end
+  class Scanner
+
+    def initialize
+      %% write data;
+      # % fix syntax highlighting
+    end
+
+    def emit(name, data, start_char, end_char)
+      handle_indents
+      if @tokens.last && @tokens.last[0] == :IDENTIFIER && name == :LBRACKET
+        @tokens << ['[', Token.new(data[start_char...end_char], @line)]
+      else
+        @tokens << [name, Token.new(data[start_char...end_char], @line)]
+      end
+      @column += end_char - start_char
+    end
+
+    def emit_string(data, start_char, end_char)
+      handle_indents
+      str = data[(start_char+1)...(end_char-1)]
+      str = eval("\"#{str}\"") # ...
+      @tokens << [:STRING, Token.new(str, @line)]
+      @column += end_char - start_char
+    end
+
+    def handle_indents
+      if @check_indents
+        @check_indents = false
+        if @indent_count > @last_indent_count
+          (@indent_count - @last_indent_count).times do
+            @tokens << [:INDENT, Token.new("  ", @line)]
+          end
+        elsif @indent_count < @last_indent_count
+          (@last_indent_count - @indent_count).times do
+            @tokens << [:DEDENT, Token.new("  ", @line)]
+          end
+          @last_indent_count = @indent_count
+        end
+      end
+    end
+
+    def problem(data, ts, te)
+      puts "Unexpected \"#{data[ts...te]}\" on line #{@line}\n" +
+            "#{@line}: #{@lines[@line-1]}"
+      exit(1)
+    end
+
+    def self.tokenize data, filename
+      new.tokenize(data, filename)
+    end
+
+    def reset
+      @line = 1
+      @column = 0
+      @tokens = []
+      @indent_count = 0
+      @last_indent_count = 0
+      @check_indents = true
+    end
+
+    def tokenize(data, filename)
+      @filename = filename
+      @data = data
+      @lines = data.lines.to_a
+      reset
+      %% write init;
+      eof = data.length
+      %% write exec;
+      @check_indents = true
+      if @indent_count != 0
+        @last_indent_count = @indent_count
+        @indent_count = 0
+      end
+      handle_indents
+      @tokens
+    end
+  end
+end

data/examples/assert.dg

@@ -0,0 +1,8 @@
+assert(value):
+  if value
+    true
+  else
+    puts("Failed assertion.")
+
+assert(true)
+assert(false)

data/examples/assignment.dg

@@ -0,0 +1,2 @@
+x: 1
+puts(x)

data/examples/block.dg

@@ -0,0 +1,8 @@
+indent-block:
+  puts("indented")
+
+
+inline-block: { puts("inline") }
+
+indent-block()
+inline-block()

data/examples/class.dg

@@ -0,0 +1,6 @@
+MyClass:
+  x: 5
+
+s: String("Hello")
+
+puts(s)

data/examples/conditional.dg

@@ -0,0 +1,3 @@
+if true
+  puts("Hello wombat")
+

data/examples/conditions.dg

@@ -0,0 +1,6 @@
+if false
+  puts(1)
+elseif true
+  puts("fuck yeah")
+else
+  puts("huh?")

data/examples/equality.dg

@@ -0,0 +1,6 @@
+if 1 = 1
+  puts("numbers")
+if "foo" = "foo"
+  puts("strings")
+if "foo" = "bar"
+  puts("Should not see this")

data/examples/error.dg

@@ -0,0 +1 @@
+1 + 2()

data/examples/eval.dg

@@ -0,0 +1 @@
+eval("puts(\"Hello wombat\")")

data/examples/fibonacci.dg

@@ -0,0 +1,15 @@
+current: 3
+fibonacci-imperative(n):
+  current: 0
+  next: 1
+
+  n.times ->
+    temp: next
+    next: next + current
+    current: temp
+
+  current
+
+
+puts(fibonacci-imperative(10))
+puts(current)

data/examples/greeter.dg

@@ -0,0 +1,6 @@
+Greeter:
+  greet(name):
+    puts("Hello " + name)
+
+greeter: Greeter()
+greeter.greet("wombat")

data/examples/input.dg

@@ -0,0 +1,3 @@
+puts("What is your name")
+name: gets
+puts("Hello " + name)

data/examples/instance_variables.dg

@@ -0,0 +1,11 @@
+Foo:
+  init:
+    @wombat: "wombat"
+  to-s:
+    @wombat
+  to-foo:
+    @foo
+
+foo: Foo()
+puts(foo.to-s())
+puts(foo.to-foo())

data/examples/iterate.dg

@@ -0,0 +1,2 @@
+[1, 2, 3, 4, 5].each ->(i)
+  puts(i)

data/examples/method_call.dg

@@ -0,0 +1,9 @@
+tell(name, message):
+  print("Hey, ")
+  print(name)
+  print(": ")
+  print(message)
+  puts("!")
+
+tell("Caleb", "you're a hero")
+tell(message: "what's up", name: "Dagon")

data/examples/method_definition.dg

@@ -0,0 +1,4 @@
+foo(bar):
+  puts(bar)
+foo("banana")
+

data/examples/operators.dg

@@ -0,0 +1,6 @@
+puts(5 + 3)
+puts(12 - 6)
+puts(7 * 1)
+puts(10 / 2)
+puts(3 ** 1)
+puts(4 - 2 * 2)

data/examples/output.dg

@@ -0,0 +1 @@
+puts("Hello world")

data/examples/require.dg

@@ -0,0 +1 @@
+require("greeter")

data/spec/array_spec.dg

@@ -0,0 +1,26 @@
+require("assertions")
+require("dspec")
+
+describe("Array") ->
+  it("can be accessed") ->
+    array: [1, 2, 3]
+    assert-equal(array[0], 1)
+
+  it("can add arrays together") ->
+    assert-equal([1, 2, 3] + [4], [1, 2, 3, 4])
+
+  it("can subtract arrays from each other") ->
+    assert-equal([1, 1, 2, 2, 3, 3, 4, 5] - [1, 2, 4], [3, 3, 5])
+
+  it("can compact") ->
+    assert-equal([1, void, 2].compact, [1, 2])
+
+  it("knows it's length") ->
+    assert-equal([1, 2, 3].length, 3)
+
+  it("can iterate over the array") ->
+    array: [1, 2, 3]
+    x: 0
+    array.each ->(i)
+      x: x + i
+    assert-equal(x, 6)

data/spec/assertions.dg

@@ -0,0 +1,11 @@
+-assert(expression):
+  if expression
+    true
+  else
+    false
+
+assert-equal(lhs, rhs):
+  -assert(lhs = rhs)
+
+assert-not-equal(lhs, rhs):
+  -assert(lhs != rhs)

data/spec/boolean_spec.dg

@@ -0,0 +1,48 @@
+describe("Booleans") ->
+  it("!true = false") ->
+    assert-equal(!true, false)
+
+  it("!false = true") ->
+    assert-equal(!false, true)
+
+  it("!!false = false") ->
+    assert-equal(!!false, false)
+
+  it("!!true = true") ->
+    assert-equal(!!true, true)
+
+  it("true && true = true") ->
+    assert-equal(true && true, true)
+
+  it("true && false = false") ->
+    assert-equal(true && false, false)
+
+  it("false && true = false") ->
+    assert-equal(false && true, false)
+
+  it("false && false = false") ->
+    assert-equal(false && false, false)
+
+  it("true || true = true") ->
+    assert-equal(true || true, true)
+
+  it("true || false = true") ->
+    assert-equal(true || false, true)
+
+  it("false || true = true") ->
+    assert-equal(false || true, true)
+
+  it("false || false = false") ->
+    assert-equal(false || false, false)
+
+  it("true ^ true = false") ->
+    assert-equal(true ^ true, false)
+
+  it("true ^ false = true") ->
+    assert-equal(true ^ false, true)
+
+  it("false ^ true = true") ->
+    assert-equal(false ^ true, true)
+
+  it("false ^ false = false") ->
+    assert-equal(false ^ false, false)

data/spec/dspec.dg

@@ -0,0 +1,16 @@
+require("spec/assertions")
+
+describe(descriptor, descriptions):
+  puts(descriptor)
+  descriptions.call()
+  puts("")
+
+it(description, block):
+  success: block.call()
+  if success
+    print("\e[32m")
+  else
+    print("\e[31m")
+  print("- ")
+  print(description)
+  puts("\e[0m")

data/spec/float_spec.dg

@@ -0,0 +1,15 @@
+require("assertions")
+require("dspec")
+
+describe("Float") ->
+  it("is equal to an identical float") ->
+    assert-equal(1.2, 1.2)
+
+  it("addable") ->
+    assert-equal(1.2 + 0.8, 2.0)
+
+  it("subtractable") ->
+    assert-equal(1.2 - 0.2, 1.0)
+
+  it("can compare to integers") ->
+    assert-equal(2.0, 2)

data/spec/hash_spec.dg

@@ -0,0 +1,6 @@
+describe("Hash") ->
+  it("can be empty") ->
+    assert-equal({}, {})
+  it("can have keys with values") ->
+    assert-not-equal({ foo: "bar" }, {})
+  puts { foo: "bar" }

data/spec/number_spec.dg

@@ -0,0 +1,18 @@
+describe("Numbers") ->
+  it("can be multiplied") ->
+    assert-equal(-1 * -1, 1)
+
+  it("can be added") ->
+    assert-equal(1 + 5, 6)
+
+  it("can be subtracted") ->
+    assert-equal(1 - 5, -4)
+
+  it("can be divided") ->
+    assert-equal(6 / 3, 2)
+
+  it("can do interger division") ->
+    assert-equal(3 / 2, 1)
+
+  it("can be taken to a power") ->
+    assert-equal(2 ** 3, 8)

data/spec/return_spec.dg

@@ -0,0 +1,12 @@
+test-method:
+  "wombat"
+
+test-conditional-method:
+  if true
+    "wombat"
+
+describe("Return values") ->
+  it("returns the result of a one-line method") ->
+    assert-equal("wombat", test-method)
+  it("returns the result of a method with a conditional") ->
+    assert-equal("wombat", test-conditional-method)

data/spec/string_spec.dg

@@ -0,0 +1,18 @@
+describe("String") ->
+  it("is equal to an identical string") ->
+    assert-equal("foo", "foo")
+
+  it("is not equal to a different string") ->
+    assert-not-equal("foo", "bar")
+
+  it("can be added to another string") ->
+    assert-equal("foo" + "bar", "foobar")
+
+  it("knows it's length") ->
+    assert-equal("foo".length, 3)
+
+  it("can convert to an Integer") ->
+    assert-equal("12".to-i, 12)
+
+  it("can convert to a Float") ->
+    assert-equal("12.5".to-f, 12.5)