riml 0.1.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 by Luke Gruber
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,148 @@
+[![Build Status](https://travis-ci.org/luke-gru/riml.png)](https://travis-ci.org/luke-gru/riml)
+
+Riml, a relaxed version of Vimscript
+====================================
+
+Riml aims to be a superset of VimL that includes some nice features that I
+enjoy in other scripting languages, including classes, string interpolation,
+heredocs, default case-sensitive string comparison and other things most
+programmers take for granted. Also, Riml takes some liberties and provides
+some syntactic sugar for lots of VimL constructs. To see how Riml constructs
+are compiled into VimL, just take a look in this README. The left side is Riml,
+and the right side is the equivalent VimL after compilation.
+
+Variables
+---------
+
+    count = 1                     let s:count = 1
+    while count < 5               while s:count < 5
+      source other.vim              source other.vim
+      count += 1                    let s:count += 1
+    end                           endwhile
+
+If you don't specify a scope modifier, it's script local by default in the
+global namespace. Within a function, variables without scope modifiers are plain
+old local variables.
+
+###globally
+
+    a = 3                         let s:a = 3
+
+###locally
+
+    a = 3                         let a = 3
+
+###Freeing memory
+
+    a = nil                       unlet! a
+
+###Checking for existence
+
+    unless s:callcount?                    if !exists("s:callcount")
+      callcount = 0                         let s:callcount = 0
+    end                                    endif
+    callcount += 1                         let s:callcount += 1
+    puts "called #{callcount} times"       echo "called " . s:callcount . " times"
+
+Comparisons
+-----------
+
+    a = "hi" == "hi"                      if ("hi" ==# "hi")
+                                            let s:a = 1
+                                          else
+                                            let s:a = 0
+                                          endif
+
+Heredocs
+--------
+
+    msg = <<EOS                           let s:msg = "a vim heredoc!\n"
+    a vim heredoc!
+    EOS
+
+Classes
+-------
+
+###Riml example 1
+
+    class MyClass
+      def initialize(arg1, arg2, *args)
+      end
+
+      defm getData
+        return self.data
+      end
+
+      defm getOtherData
+        return self.otherData
+      end
+    end
+
+###Viml example 1
+
+
+    function! g:MyClassConstructor(arg1, arg2, ...)
+      let myClassObj = {}
+      function! myClassObj.getData() dict
+        return self.data
+      endfunction
+      function! myClassObj.getOtherData() dict
+        return self.otherData
+      endfunction
+      return myClassObj
+    endfunction
+
+###Riml example 2
+
+    class Translation
+      def initialize(input)
+        self.input = input
+      end
+    end
+
+    class FrenchToEnglishTranslation < Translation
+      defm translate
+        if (self.input == "Bonjour!")
+          echo "Hello!"
+        else
+          echo "Sorry, I don't know that word."
+        end
+      end
+    end
+
+    translation = new FrenchToEnglishTranslation("Bonjour!")
+    translation.translate()
+
+###VimL example 2
+
+    function! g:TranslationConstructor(input)
+      let translationObj = {}
+      let translationObj.input = a:input
+      return translationObj
+    endfunction
+
+    function! g:FrenchToEnglishTranslationConstructor(input)
+      let frenchToEnglishTranslationObj = {}
+      let translationObj = g:TranslationConstructor(a:input)
+      call extend(frenchToEnglishTranslationObj, translationObj)
+      function! frenchToEnglishTranslationObj.translate() dict
+        if (self.input ==# "Bonjour!")
+          echo "Hello!"
+        else
+          echo "Sorry, I don't know that word."
+        endif
+      endfunction
+      return frenchToEnglishTranslationObj
+    endfunction
+
+    let s:translation = g:FrenchToEnglishTranslationConstructor("Bonjour!")
+    call s:translation.translate()
+
+Hacking
+-------
+
+Make sure to generate the parser before running tests or developing on Riml.
+Also, make sure to regenerate the parser after modifiying the grammar file.
+
+1. `bundle install`
+2. Go to the lib directory and enter `racc -o parser.rb grammar.y`

data/bin/riml

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+# vim: syntax=ruby
+
+require File.expand_path("../../config/environment", __FILE__)
+
+module Riml
+  include Environment
+  require File.join(ROOTDIR, 'version')
+  require File.join(LIBDIR, "helper")
+
+  require 'optparse'
+  require 'ostruct'
+
+  class Options
+    def self.parse(argv)
+
+      # defaults
+      options = OpenStruct.new
+      options.compile = []
+      options.riml_source_path = Dir.getwd
+
+      OptionParser.new do |opts|
+        opts.banner = "Usage: riml [options]"
+        opts.separator ""
+        opts.separator "Specific options:"
+
+        opts.on("-c", "--compile FILE", "Compile riml file to VimL") do |file|
+          if File.exists?(file)
+            options.compile << file
+          else
+            warn "Couldn't find file #{file.inspect}"
+          end
+        end
+
+        opts.on("-s", "--stdio", "pipe in riml to STDIN and get back VimL on STDOUT") do
+          options.stdio = true
+        end
+
+        opts.on_tail("-v", "--version", "Show riml version") do
+          puts VERSION.join('.')
+          exit
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end.parse!(argv)
+
+      options
+    end
+  end
+
+  class Runner
+    class << self
+      def start
+        options = Options.parse(ARGV)
+        if options.stdio
+          puts Riml.compile($stdin.gets)
+        elsif options.compile.any?
+          options.compile.each do |file|
+            Riml.compile_file(file)
+          end
+        end
+      end
+    end
+  end
+  Runner.start
+end

data/config/environment.rb

@@ -0,0 +1,10 @@
+module Riml
+  module Environment
+    ROOTDIR = File.expand_path('../../', __FILE__)
+
+    LIBDIR = File.join(ROOTDIR, "lib")
+    BINDIR = File.join(ROOTDIR, "bin")
+
+    $:.unshift(LIBDIR) unless $:.include? LIBDIR
+  end
+end

data/lib/ast_rewriter.rb

@@ -0,0 +1,268 @@
+require File.expand_path("../constants", __FILE__)
+require File.expand_path("../class_map", __FILE__)
+require File.expand_path("../walker", __FILE__)
+
+module Riml
+  class AST_Rewriter
+    include Riml::Constants
+
+    attr_reader :ast
+    def initialize(ast)
+      @ast = ast
+    end
+
+    # Map of {"ClassName" => ClassDefinitionNode}
+    # Can also query object for superclass of a named class, etc...
+    #
+    # Ex : classes["SomeClass"].superclass_name => "SomeClassBase"
+    def classes
+      @@classes ||= ClassMap.new
+    end
+
+    def rewrite
+      establish_parents(ast)
+      StrictEqualsComparisonOperator.new(ast).rewrite_on_match
+      VarEqualsComparisonOperator.new(ast).rewrite_on_match
+      ClassDefinitionToFunctions.new(ast).rewrite_on_match
+      ObjectInstantiationToCall.new(ast).rewrite_on_match
+      CallToExplicitCall.new(ast).rewrite_on_match
+      ast
+    end
+
+    def establish_parents(node)
+      Walker.walk_node(node, method(:do_establish_parents))
+    end
+    alias reestablish_parents establish_parents
+
+    def do_establish_parents(node)
+      node.children.each do |child|
+        child.parent_node = node if child.respond_to?(:parent_node=)
+      end if node.respond_to?(:children)
+    end
+
+    def rewrite_on_match(node = ast)
+      Walker.walk_node(node, method(:do_rewrite_on_match), lambda {|_| repeatable?})
+    end
+
+    def do_rewrite_on_match(node)
+      replace node if match?(node)
+    end
+
+    def repeatable?
+      true
+    end
+
+    class StrictEqualsComparisonOperator < AST_Rewriter
+      def match?(node)
+        BinaryOperatorNode === node && node.operator == '==='
+      end
+
+      def replace(node)
+        node.operator = '=='
+        node.operand1 = ListNode.wrap(node.operand1)
+        node.operand2 = ListNode.wrap(node.operand2)
+        reestablish_parents(node)
+      end
+    end
+
+    class VarEqualsComparisonOperator < AST_Rewriter
+      COMPARISON_OPERATOR_MATCH = Regexp.union(COMPARISON_OPERATORS)
+
+      def match?(node)
+        Nodes === node &&
+        AssignNode === node.nodes[0] &&
+        BinaryOperatorNode === (op = node.nodes[0].rhs) &&
+        op.operator =~ COMPARISON_OPERATOR_MATCH
+      end
+
+      def replace(node)
+        binary_op = node.nodes[0].rhs
+        old_set_var = node.nodes[0]
+        assign_true  = old_set_var.clone.tap {|assign_t| assign_t.rhs = TrueNode.new }
+        assign_false = old_set_var.clone.tap {|assign_f| assign_f.rhs = FalseNode.new }
+        node.nodes = [
+          IfNode.new(binary_op, Nodes.new([
+            assign_true, ElseNode.new(Nodes.new([
+            assign_false
+            ]))
+          ]))
+        ]
+        reestablish_parents(node)
+      end
+    end
+
+    class ClassDefinitionToFunctions < AST_Rewriter
+      def match?(node)
+        ClassDefinitionNode === node
+      end
+
+      def replace(node)
+        classes[node.name] = node
+
+        name, expressions = node.name, node.expressions
+        InsertInitializeMethod.new(node).rewrite_on_match
+        constructor = node.constructor
+        constructor.scope_modifier = 'g:' unless constructor.scope_modifier
+        constructor.name = node.constructor_name
+        # set up dictionary variable at top of function
+        dict_name = node.constructor_obj_name
+        constructor.expressions.unshift(
+          AssignNode.new('=', GetVariableNode.new(nil, dict_name), DictionaryNode.new({}))
+        )
+
+        SuperToObjectExtension.new(constructor, node).rewrite_on_match
+        MethodToNestedFunction.new(node, constructor, dict_name).rewrite_on_match
+        SelfToDictName.new(dict_name).rewrite_on_match(constructor)
+
+        constructor.expressions.push(
+          ReturnNode.new(GetVariableNode.new(nil, dict_name))
+        )
+        reestablish_parents(constructor)
+      end
+
+      class MethodToNestedFunction < AST_Rewriter
+        attr_reader :constructor, :dict_name
+        def initialize(class_node, constructor, dict_name)
+          super(class_node)
+          @dict_name, @constructor = dict_name, constructor
+        end
+
+        def match?(node)
+          DefMethodNode === node
+        end
+
+        def replace(node)
+          def_node = node.to_def_node
+          node.parent_node = ast.expressions
+          node.remove
+          def_node.name.insert(0, "#{dict_name}.")
+          def_node.parent_node = constructor.expressions
+          constructor.expressions << def_node
+          reestablish_parents(node)
+        end
+      end
+
+      class SelfToDictName < AST_Rewriter
+        attr_reader :dict_name
+        def initialize(dict_name)
+          @dict_name = dict_name
+        end
+
+        def match?(node)
+          AssignNode === node && DictGetNode === node.lhs && node.lhs.dict.name == "self"
+        end
+
+        def replace(node)
+          node.lhs.dict.name = dict_name
+        end
+      end
+
+      class InsertInitializeMethod < AST_Rewriter
+        # if doesn't have an initialize method, put one at the beginning
+        # of the class definition
+        def match?(class_node)
+          ClassDefinitionNode === class_node && class_node.constructor.nil?
+        end
+
+        def replace(class_node)
+          if class_node.superclass?
+            def_node = DefNode.new(
+              '!', nil, "initialize", superclass_params, nil, Nodes.new([SuperNode.new([], false)])
+            )
+          else
+            def_node = DefNode.new(
+              '!', nil, "initialize", [], nil, Nodes.new([])
+            )
+          end
+          class_node.expressions.unshift(def_node)
+          reestablish_parents(class_node)
+        end
+
+        def superclass_params
+          classes.superclass(ast.name).constructor.parameters
+        end
+
+        def repeatable?
+          false
+        end
+      end
+
+      class SuperToObjectExtension < AST_Rewriter
+        attr_reader :class_node
+        def initialize(constructor, class_node)
+          super(constructor)
+          @class_node = class_node
+        end
+
+        def match?(constructor)
+          DefNode === constructor && constructor.super_node
+        end
+
+        def replace(constructor)
+          superclass = classes.superclass(class_node.name)
+          super_constructor = superclass.constructor
+
+          set_var_node = AssignNode.new('=', GetVariableNode.new(nil, superclass.constructor_obj_name),
+            CallNode.new(
+              super_constructor.scope_modifier,
+              super_constructor.name,
+              super_arguments(constructor.super_node)
+            )
+          )
+
+          constructor.super_node.replace_with(set_var_node)
+          constructor.expressions.insert_after(set_var_node,
+            ExplicitCallNode.new(
+              nil,
+              "extend",
+              [
+                GetVariableNode.new(nil, class_node.constructor_obj_name),
+                GetVariableNode.new(nil, superclass.constructor_obj_name)
+              ]
+            )
+          )
+          reestablish_parents(constructor)
+        end
+
+        def super_arguments(super_node)
+          if super_node.use_all_arguments?
+            # here, ast is 'constructor'
+            ast.parameters.map {|p| GetVariableNode.new(nil, p)}
+          else
+            super_node.arguments
+          end
+        end
+
+        def repeatable?
+          false
+        end
+      end
+    end # ClassDefinitionToFunctions
+
+    class ObjectInstantiationToCall < AST_Rewriter
+      def match?(node)
+        ObjectInstantiationNode === node
+      end
+
+      def replace(node)
+        constructor_name = node.call_node.name
+        class_node = classes[constructor_name]
+        call_node = node.call_node
+        call_node.name = class_node.constructor_name
+        call_node.scope_modifier = class_node.constructor.scope_modifier
+      end
+    end
+
+    class CallToExplicitCall < AST_Rewriter
+      def match?(node)
+        node.instance_of?(CallNode) && node.must_be_explicit_call?
+      end
+
+      def replace(node)
+        node.replace_with(ExplicitCallNode.new(node[0], node[1], node[2]))
+        reestablish_parents(node)
+      end
+    end
+
+  end
+end

data/lib/class_map.rb

@@ -0,0 +1,46 @@
+module Riml
+  class ClassNotFound < NameError; end
+
+  class ClassMap
+    def initialize
+      @map = {}
+    end
+
+    def [](key)
+      ensure_key_is_string!(key)
+      @map[key]
+    end
+
+    def []=(key, val)
+      ensure_key_is_string!(key)
+      @map[key] = val
+    end
+
+    def superclass(key)
+      ensure_key_is_string!(key)
+      super_key = @map[key].superclass_name
+      raise ClassNotFound.new(super_key) unless @map[super_key]
+      @map[super_key]
+    end
+
+    def classes
+      @map.values
+    end
+
+    def class_names
+      @map.keys
+    end
+
+    def clear
+      @map.clear
+    end
+
+    protected
+    def ensure_key_is_string!(key)
+      unless key.is_a?(String)
+        raise ArgumentError, "key must be name of class (String)"
+      end
+    end
+
+  end
+end