sweet-lang 0.1.0

data/lib/runtime.rb

@@ -0,0 +1,7 @@
+@code = []
+
+require "runtime/object"
+require "runtime/class"
+require "runtime/method"
+require "runtime/context"
+require "runtime/bootstrap"

data/lib/runtime/bootstrap.rb

@@ -0,0 +1,41 @@
+# Bootstrap the runtime. This is where we assemble all the classes and objects together
+# to form the runtime.
+                                            # What's happening in the runtime:
+sweet_class = SweetClass.new            #  Class
+sweet_class.runtime_class = sweet_class #  Class.class = Class
+object_class = SweetClass.new             #  Object = Class.new
+object_class.runtime_class = sweet_class  #  Object.class = Class
+
+# Create the Runtime object (the root context) on which all code will start its
+# evaluation.
+Runtime = Context.new(object_class.new)
+
+Runtime["Class"] = sweet_class
+Runtime["Object"] = object_class
+Runtime["Number"] = SweetClass.new
+Runtime["String"] = SweetClass.new
+
+# Everything is an object in our language, even true, false and nil. So they need
+# to have a class too.
+Runtime["TrueClass"] = SweetClass.new
+Runtime["FalseClass"] = SweetClass.new
+Runtime["NilClass"] = SweetClass.new
+
+Runtime["true"] = Runtime["TrueClass"].new_with_value(true)
+Runtime["false"] = Runtime["FalseClass"].new_with_value(false)
+Runtime["nil"] = Runtime["NilClass"].new_with_value(nil)
+
+# Add a few core methods to the runtime.
+
+# Add the `new` method to classes, used to instantiate a class:
+#  eg.: Object.new, Number.new, String.new, etc.
+Runtime["Class"].runtime_methods["new"] = proc do |receiver, arguments|
+  receiver.new
+end
+
+# Print an object to the console.
+# eg.: print("hi there!")
+Runtime["Object"].runtime_methods["print"] = proc do |receiver, arguments|
+	@code << arguments.first.ruby_value
+  Runtime["nil"]
+end

data/lib/runtime/class.rb

@@ -0,0 +1,43 @@
+# Represents a Sweet class in the Ruby world. Classes are objects in Sweet so they
+# inherit from SweetObject.
+class SweetClass < SweetObject
+  attr_reader :runtime_methods
+
+  # Creates a new class. Number is an instance of Class for example.
+  def initialize
+    @runtime_methods = {}
+  
+    # Check if we're bootstrapping (launching the runtime). During this process the 
+    # runtime is not fully initialized and core classes do not yet exists, so we defer 
+    # using those once the language is bootstrapped.
+    # This solves the chicken-or-the-egg problem with the Class class. We can 
+    # initialize Class then set Class.class = Class.
+    if defined?(Runtime)
+      runtime_class = Runtime["Class"]
+    else
+      runtime_class = nil
+    end
+  
+    super(runtime_class)
+  end
+
+  # Lookup a method
+  def lookup(method_name)
+    method = @runtime_methods[method_name]
+    unless method
+      raise "Method not found: #{method_name}"
+    end
+    method
+  end
+
+  # Create a new instance of this class
+  def new
+    SweetObject.new(self)
+  end
+  
+  # Create an instance of this Sweet class that holds a Ruby value. Like a String, 
+  # Number or true.
+  def new_with_value(value)
+    SweetObject.new(self, value)
+  end
+end

data/lib/runtime/context.rb

@@ -0,0 +1,24 @@
+# The evaluation context.
+class Context
+  attr_reader :locals, :current_self, :current_class
+  
+  # We store constants as class variable (class variables start with @@ and instance
+  # variables start with @ in Ruby) since they are globally accessible. If you want to
+  # implement namespacing of constants, you could store it in the instance of this 
+  # class.
+  @@constants = {}
+  
+  def initialize(current_self, current_class=current_self.runtime_class)
+    @locals = {}
+    @current_self = current_self
+    @current_class = current_class
+  end
+  
+  # Shortcuts to access constants, Runtime[...] instead of Runtime.constants[...]
+  def [](name)
+    @@constants[name]
+  end
+  def []=(name, value)
+    @@constants[name] = value
+  end
+end

data/lib/runtime/method.rb

@@ -0,0 +1,19 @@
+# Represents a method defined in the runtime.
+class SweetMethod
+  def initialize(params, body)
+    @params = params
+    @body = body
+  end
+  
+  def call(receiver, arguments)
+    # Create a context of evaluation in which the method will execute.
+    context = Context.new(receiver)
+    
+    # Assign arguments to local variables
+    @params.each_with_index do |param, index|
+      context.locals[param] = arguments[index]
+    end
+    
+    @body.eval(context)
+  end
+end

data/lib/runtime/object.rb

@@ -0,0 +1,18 @@
+# Represents an Sweet object instance in the Ruby world.
+class SweetObject
+  attr_accessor :runtime_class, :ruby_value
+
+  # Each object have a class (named runtime_class to prevent errors with Ruby's class
+  # method). Optionaly an object can hold a Ruby value (eg.: numbers and strings).
+  def initialize(runtime_class, ruby_value=self)
+    @runtime_class = runtime_class
+    @ruby_value = ruby_value
+  end
+
+  # Call a method on the object.
+  def call(method, arguments=[])
+    # Like a typical Class-based runtime model, we store methods in the class of the
+    # object.
+    @runtime_class.lookup(method).call(self, arguments)
+  end
+end

data/lib/sweet.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+require "interpreter"
+require "readline"
+
+interpreter = Interpreter.new
+
+# If a file is given we eval it.
+if file = ARGV.first
+	@filename = ARGV.first.split(".")[0]
+	File.new("#{@filename}.html", "w")
+  interpreter.eval File.read(file)
+  File.open("#{@filename}.html", 'a') do |f|
+    f.puts @code.join("\n")
+  end
+  puts "Sweet code compiled!"
+
+# Start the REPL, read-eval-print-loop, or interactive interpreter
+else
+  puts "Sweet Interactive Console, CTRL+C to quit"
+  loop do
+    line = Readline::readline(">> ")
+    Readline::HISTORY.push(line)
+    value = interpreter.eval(line)
+    puts "=> #{value.ruby_value.inspect}"
+  end
+  
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: sweet-lang
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- João Moura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-13 00:00:00.000000000Z
+dependencies: []
+description: ! "Sweet is a pre-compiled language based on Ruby and Python. \n    Sweet
+  makes possible to use all the class, defs, conditionals, global and \n    local
+  variables power of server-side languages, defining blocks by indentation \n    like
+  Python in your Sweet HTML markup.\n    It comes with a SIC ( Sweet Interactive Console
+  ) the you can test your code and ideas\n    before really right and compile it."
+email: joaomdmoura@gmail.com
+executables:
+- sweet
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sweet.rb
+- lib/interpreter.rb
+- lib/lexer.rb
+- lib/nodes.rb
+- lib/parser.rb
+- lib/runtime.rb
+- lib/lexer/core.rb
+- lib/lexer/strings.rb
+- lib/lexer/tags.rb
+- lib/runtime/bootstrap.rb
+- lib/runtime/class.rb
+- lib/runtime/context.rb
+- lib/runtime/method.rb
+- lib/runtime/object.rb
+- bin/sweet
+homepage: https://github.com/joaomdmoura/sweet
+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.11
+signing_key: 
+specification_version: 3
+summary: A Sweet language, that compiles for HTML
+test_files: []