poetics 0.0.1

data/lib/poetics/parser/poetics.kpeg

@@ -0,0 +1,42 @@
+%% name = Poetics::Parser
+
+root      = - value? - end
+
+end       = !.
+-         = (" " | "\t" | "\n")*
+
+value     = string
+          | number
+          | boolean
+
+
+boolean   = position (
+            true
+          | false
+          | null
+          | undefined)
+
+true      = "true" ~true_value
+false     = "false" ~false_value
+null      = "null" ~null_value
+undefined = "undefined" ~undefined_value
+
+
+number    = position (
+            real
+          | hex
+          | int )
+
+hexdigits = /[0-9A-Fa-f]/
+hex       = '0x' < hexdigits+ > ~hexadecimal(text)
+digits    = '0' | /[1-9]/ /[0-9]/*
+int       = < digits > ~number(text)
+real      = < digits '.' digits ('e' /[-+]/? /[0-9]/+)? > ~number(text)
+
+
+string    = position '"' < /[^\\"]*/ > '"' ~string_value(text)
+
+# keep track of column and line
+line      = { current_line }
+column    = { current_column }
+position  = line:l column:c { position(l, c) }

data/lib/poetics/syntax.rb

@@ -0,0 +1,3 @@
+require 'poetics/syntax/node'
+require 'poetics/syntax/literal'
+require 'poetics/syntax/ast'

data/lib/poetics/syntax/ast.rb

@@ -0,0 +1,31 @@
+module Poetics
+  module Syntax
+    def number(value)
+      Number.new line, column, value
+    end
+
+    def hexadecimal(value)
+      Number.new line, column, value.to_i(16)
+    end
+
+    def true_value
+      True.new line, column
+    end
+
+    def false_value
+      False.new line, column
+    end
+
+    def null_value
+      Null.new line, column
+    end
+
+    def undefined_value
+      Undefined.new line, column
+    end
+
+    def string_value(value)
+      String.new line, column, value
+    end
+  end
+end

data/lib/poetics/syntax/literal.rb

@@ -0,0 +1,65 @@
+module Poetics
+  module Syntax
+    class Value < Node
+      def to_sexp
+        [sexp_name, value, line, column]
+      end
+    end
+
+    class Number < Value
+      attr_accessor :value
+
+      def initialize(line, column, value)
+        super
+        @value = value.to_f
+      end
+
+      def sexp_name
+        :number
+      end
+    end
+
+    class Boolean < Node
+      def to_sexp
+        [sexp_name, line, column]
+      end
+    end
+
+    class True < Boolean
+      def sexp_name
+        :true
+      end
+    end
+
+    class False < Boolean
+      def sexp_name
+        :false
+      end
+    end
+
+    class Null < Boolean
+      def sexp_name
+        :null
+      end
+    end
+
+    class Undefined < Boolean
+      def sexp_name
+        :undefined
+      end
+    end
+
+    class String < Value
+      attr_accessor :value
+
+      def initialize(line, column, text)
+        super
+        @value = text
+      end
+
+      def sexp_name
+        :string
+      end
+    end
+  end
+end

data/lib/poetics/syntax/node.rb

@@ -0,0 +1,15 @@
+module Poetics
+  module Syntax
+    class Node
+      attr_accessor :line, :column
+
+      def initialize(line, column, *)
+        @line = line
+        @column = column
+      end
+
+      def to_sexp
+      end
+    end
+  end
+end

data/lib/poetics/version.rb

@@ -0,0 +1,5 @@
+module Poetics
+  VERSION = "0.0.1"
+  RELEASE_DATE = "yyyy-mm-dd"
+  COMMAND_VERSION = "poetics #{VERSION} (1.1.0 #{RELEASE_DATE})"
+end

data/poetics.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "poetics/version"
+
+Gem::Specification.new do |s|
+  s.name        = "poetics"
+  s.version     = Poetics::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Brian Ford"]
+  s.email       = ["brixen@gmail.com"]
+  s.homepage    = "https://github.com/brixen/poetics"
+  s.summary     = %q{A native implementation of CoffeeScript on the Rubinius VM}
+  s.description =<<-EOD
+Poetics implements CoffeeScript (http://jashkenas.github.com/coffee-script/)
+directly on the Rubinius VM (http://rubini.us). It includes a REPL for
+exploratory programming, as well as executing CoffeeScript scripts directly.
+  EOD
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = Dir["spec/**/*.rb"]
+  s.executables   = ["poetics"]
+  s.require_paths = ["lib"]
+end

data/spec/custom.rb

@@ -0,0 +1,4 @@
+require 'spec/custom/runner/relates'
+require 'spec/custom/matchers/parse_as'
+require 'spec/custom/utils/options'
+require 'spec/custom/utils/script'

data/spec/custom/matchers/parse_as.rb

@@ -0,0 +1,21 @@
+class ParseAsMatcher
+  def initialize(expected)
+    @expected = expected
+  end
+
+  def matches?(actual)
+    @actual = Poetics::Parser.parse_to_sexp actual
+    @actual == @expected
+  end
+
+  def failure_message
+    ["Expected:\n#{@actual.inspect}\n",
+     "to equal:\n#{@expected.inspect}"]
+  end
+end
+
+class Object
+  def parse_as(sexp)
+    ParseAsMatcher.new sexp
+  end
+end

data/spec/custom/runner/relates.rb

@@ -0,0 +1,97 @@
+# NOTE: Copied from Rubinius
+#
+# SpecDataRelation enables concise specs that involve several different forms
+# of the same data. This is specifically useful for the parser and compiler
+# specs where the output of each stage is essentially related to the input
+# Ruby source. Together with the #relates spec method, it enables specs like:
+#
+#   describe "An If node" do
+#     relates "a if b" do
+#       parse do
+#         # return the expected sexp
+#       end
+#
+#       compile do |g|
+#         # return the expected bytecode
+#       end
+#
+#       jit do |as|
+#         # return the expected asm/machine code
+#       end
+#     end
+#
+#     relates "if a; b; end" do
+#       # ...
+#     end
+#   end
+
+class SpecDataRelation
+  # Provides a simple configurability so that any one or more of the possible
+  # processes can be run. See the custom options in custom/utils/options.rb.
+  def self.enable(process)
+    @processors ||= []
+    @processors << process
+  end
+
+  # Returns true if no process is specifically set or if +process+ is in the
+  # list of enabled processes. In other words, all processes are enabled by
+  # default, or any combination of them may be enabled.
+  def self.enabled?(process)
+    @processors.nil? or @processors.include?(process)
+  end
+
+  def initialize(ruby)
+    @ruby = ruby
+  end
+
+  # Formats the Ruby source code for reabable output in the -fs formatter
+  # option. If the source contains no newline characters, wraps the source in
+  # single quotes to set if off from the rest of the description string. If
+  # the source does contain newline characters, sets the indent level to four
+  # characters.
+  def format(ruby)
+    if /\n/ =~ ruby
+      lines = ruby.rstrip.to_a
+      if /( *)/ =~ lines.first
+        if $1.size > 4
+          dedent = $1.size - 4
+          ruby = lines.map { |l| l[dedent..-1] }.join
+        else
+          indent = " " * (4 - $1.size)
+          ruby = lines.map { |l| "#{indent}#{l}" }.join
+        end
+      end
+      "\n#{ruby}"
+    else
+      "'#{ruby}'"
+    end
+  end
+
+  # Creates spec example blocks if the compile process is enabled.
+  def compile(*plugins, &block)
+    return unless self.class.enabled? :compiler
+
+    ruby = @ruby
+    it "is compiled from #{format ruby}" do
+      generator = Rubinius::TestGenerator.new
+      generator.instance_eval(&block)
+
+      ruby.should compile_as(generator, *plugins)
+    end
+  end
+
+  def parse(&block)
+    return unless self.class.enabled? :parser
+
+    ruby = @ruby
+    it "is parsed from #{format ruby}" do
+      ruby.should parse_as(block.call)
+    end
+  end
+end
+
+class Object
+  def relates(str, &block)
+    SpecDataRelation.new(str).instance_eval(&block)
+  end
+end

data/spec/custom/utils/options.rb

@@ -0,0 +1,21 @@
+# Custom MSpec options
+#
+class MSpecOptions
+  def compiler
+    # The require is inside the method because this file has to be able to be
+    # loaded in MRI and there are parts of the custom ensemble that are
+    # Rubinius specific (primarily iseq, which could potentially be fixed by
+    # better structuring the compiler).
+    require 'spec/custom/runner/relates'
+
+    on("--compiler", "Run only the compile part of the compiler specs") do
+      SpecDataRelation.enable :compiler
+    end
+  end
+
+  def parser
+    on("--parser", "Run only the parse part of the compiler specs") do
+      SpecDataRelation.enable :parser
+    end
+  end
+end

data/spec/custom/utils/script.rb

@@ -0,0 +1,26 @@
+# Custom options for mspec-run
+#
+class MSpecRun
+  def custom_options(options)
+    options.compiler
+    options.parser
+  end
+end
+
+# Custom options for mspec-ci
+#
+class MSpecCI
+  def custom_options(options)
+    options.compiler
+    options.parser
+  end
+end
+
+# Custom options for mspec-tag
+#
+class MSpecTag
+  def custom_options(options)
+    options.compiler
+    options.parser
+  end
+end

data/spec/default.mspec

@@ -0,0 +1,6 @@
+# vim: filetype=ruby
+require 'spec/custom'
+
+class MSpecScript
+  set :target, 'rbx'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$: << File.expand_path('../../lib', __FILE__)
+
+require 'poetics'

data/spec/syntax/literal_spec.rb

@@ -0,0 +1,60 @@
+require 'spec/spec_helper'
+
+describe "The Number node" do
+  relates "42" do
+    parse { [:number, 42.0, 1, 1] }
+  end
+
+  relates " 42" do
+    parse { [:number, 42.0, 1, 2] }
+  end
+
+  relates "42 " do
+    parse { [:number, 42.0, 1, 1] }
+  end
+
+  relates "1.23" do
+    parse { [:number, 1.23, 1, 1] }
+  end
+
+  relates "0x2a" do
+    parse { [:number, 42.0, 1, 1] }
+  end
+end
+
+describe "The True node" do
+  relates "true" do
+    parse { [:true, 1, 1] }
+  end
+end
+
+describe "The False node" do
+  relates "false" do
+    parse { [:false, 1, 1] }
+  end
+end
+
+describe "The Null node" do
+  relates "null" do
+    parse { [:null, 1, 1] }
+  end
+end
+
+describe "The Undefined node" do
+  relates "undefined" do
+    parse { [:undefined, 1, 1] }
+  end
+end
+
+describe "The String node" do
+  relates '"hello, world"' do
+    parse { [:string, "hello, world", 1, 1] }
+  end
+
+  relates <<-ruby do
+      "hello"
+    ruby
+
+    parse { [:string, "hello", 1, 7] }
+  end
+end