turmali 0.0.1

data/lib/turmali/runtime/bootstrap.rb

@@ -0,0 +1,48 @@
+require "turmali/runtime/class"
+# First, we create a Ruby Hash in which we'll store all constants accessible from inside
+# our runtime.
+# Then, we populate this Hash with the core classes of our language.
+Constants = {}
+
+Constants["Class"] = TurmaliClass.new                 # Defining the `Class` class.
+Constants["Class"].runtime_class = Constants["Class"] # Setting `Class.class = Class`.
+Constants["Object"] = TurmaliClass.new                # Defining the `Object` class
+Constants["Number"] = TurmaliClass.new                # Defining the `Number` class
+Constants["String"] = TurmaliClass.new
+
+# The root context will be the starting point where all our programs will
+# start their evaluation. This will also set the value of `self` at the root
+# of our programs.
+root_self = Constants["Object"].new
+RootContext = Context.new(root_self)
+
+# Everything is an object in our language, even `true`, `false` and `nil`. So they need
+# to have a class too.
+Constants["TrueClass"] = TurmaliClass.new
+Constants["FalseClass"] = TurmaliClass.new
+Constants["NilClass"] = TurmaliClass.new
+
+Constants["true"] = Constants["TrueClass"].new_with_value(true)
+Constants["false"] = Constants["FalseClass"].new_with_value(false)
+Constants["nil"] = Constants["NilClass"].new_with_value(nil)
+
+# Now that we have injected all the core classes into the runtime, we can define
+# methods on those classes.
+#
+# The first method we'll define will allow us to do `Object.new` or
+# `Number.new`. Keep in mind, `Object` or `Number`
+# are instances of the `Class` class. By defining the `new` method
+# on `Class`, it will be accessible on all its instances.
+Constants["Class"].def :new do |receiver, arguments|
+  receiver.new
+end
+
+# Next, we'll define the `print` method. Since we want to be able to call it
+# from everywhere, we'll define it on `Object`.
+# Remember from the parser's `Call` rule, methods without any receiver will be
+# sent to `self`. So `print()` is the same as `self.print()`, and
+# `self` will always be an instance of `Object`.
+Constants["Object"].def :print do |receiver, arguments|
+  puts arguments.first.ruby_value
+  Constants["nil"] # We always want to return objects from our runtime
+end

data/lib/turmali/runtime/class.rb

@@ -0,0 +1,36 @@
+require "turmali/runtime/object"
+require "turmali/runtime/context"
+
+class TurmaliClass < TurmaliObject
+  # Classes are objects in Turmali so they inherit from TurmaliObject.
+  
+  attr_reader :runtime_methods
+
+  def initialize
+    @runtime_methods = {}
+    @runtime_class = Constants["Class"]
+  end
+
+  # Lookup a method
+  def lookup(method_name)
+    method = @runtime_methods[method_name]
+    raise "Method not found: #{method_name}" if method.nil?
+    method
+  end
+
+  # Helper method to define a method on this class from Ruby.
+  def def(name, &block)
+    @runtime_methods[name.to_s] = block
+  end
+
+  # Create a new instance of this class
+  def new
+    TurmaliObject.new(self)
+  end
+  
+  # Create an instance of this Turmali class that holds a Ruby value. Like a String, 
+  # Number or true.
+  def new_with_value(value)
+    TurmaliObject.new(self, value)
+  end
+end

data/lib/turmali/runtime/context.rb

@@ -0,0 +1,9 @@
+class Context
+  attr_reader :locals, :current_self, :current_class
+  
+  def initialize(current_self, current_class=current_self.runtime_class)
+    @locals = {}
+    @current_self = current_self
+    @current_class = current_class
+  end
+end

data/lib/turmali/runtime/method.rb

@@ -0,0 +1,20 @@
+class TurmaliMethod
+  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 passed arguments to local variables.
+    @params.each_with_index do |param, index|
+      context.locals[param] = arguments[index]
+    end
+    
+    # The body is a node (created in the parser).
+    # We'll talk in details about the `eval` method in the interpreter chapter.
+    @body.eval(context)
+  end
+end

data/lib/turmali/runtime/object.rb

@@ -0,0 +1,19 @@
+class TurmaliObject  
+  # Each object has a class (named <code>runtime_class</code> to prevent conflicts
+  # with Ruby's <code>class</code> keyword).
+  # Optionally an object can hold a Ruby value. Eg.: numbers and strings will store their
+  # number or string Ruby equivalent in that variable.
+  attr_accessor :runtime_class, :ruby_value
+
+  def initialize(runtime_class, ruby_value=self)
+    @runtime_class = runtime_class
+    @ruby_value = ruby_value
+  end
+
+  # Like a typical Class-based runtime model, we store methods in the class of the
+  # object. When calling a method on an object, we need to first lookup that
+  # method in the class, and then call it.
+  def call(method, arguments=[])
+    @runtime_class.lookup(method).call(self, arguments)
+  end
+end

data/lib/turmali/version.rb

@@ -0,0 +1,3 @@
+module Turmali
+  VERSION = "0.0.1"
+end

data/turmali.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "turmali/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "turmali"
+  spec.version       = Turmali::VERSION
+  spec.authors       = ["Eiffel Qiu"]
+  spec.email         = ["eiffelqiu@qq.com"]
+
+  spec.summary       = %q{Turmali is a website building language.}
+  spec.description   = %q{Turmali is a website building language.}
+  spec.homepage      = "https://github.com/eiffelqiu/turmali."
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata["allowed_push_host"] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "bin"
+  spec.executables   = 'tml' 
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: turmali
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Eiffel Qiu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Turmali is a website building language.
+email:
+- eiffelqiu@qq.com
+executables:
+- tml
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/tml
+- lib/.DS_Store
+- lib/turmali.rb
+- lib/turmali/.DS_Store
+- lib/turmali/grammar.y
+- lib/turmali/interpreter.rb
+- lib/turmali/lexer.rb
+- lib/turmali/nodes.rb
+- lib/turmali/parser.rb
+- lib/turmali/runtime/bootstrap.rb
+- lib/turmali/runtime/class.rb
+- lib/turmali/runtime/context.rb
+- lib/turmali/runtime/method.rb
+- lib/turmali/runtime/object.rb
+- lib/turmali/version.rb
+- turmali.gemspec
+homepage: https://github.com/eiffelqiu/turmali.
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Turmali is a website building language.
+test_files: []