RubyGems - duby - Versions diffs - 0.0.2-java - Mend

duby 0.0.2-java

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (77) hide show

data/History.txt +8 -0
data/README.txt +39 -0
data/Rakefile +13 -0
data/bin/duby +9 -0
data/bin/dubyc +9 -0
data/bin/dubyp +9 -0
data/examples/README +16 -0
data/examples/appengine/Rakefile +72 -0
data/examples/appengine/Readme +27 -0
data/examples/appengine/config.ru +7 -0
data/examples/appengine/lib/duby/plugin/datastore.rb +171 -0
data/examples/appengine/src/com/google/appengine/ext/duby/db/Model.duby +132 -0
data/examples/appengine/src/com/ribrdb/DubyApp.duby +28 -0
data/examples/appengine/src/com/ribrdb/list.dhtml +15 -0
data/examples/construction.duby +8 -0
data/examples/edb.duby +3 -0
data/examples/fib.duby +24 -0
data/examples/fields.duby +22 -0
data/examples/fractal.duby +57 -0
data/examples/java_thing.duby +13 -0
data/examples/simple_class.duby +12 -0
data/examples/swing.duby +20 -0
data/examples/tak.duby +15 -0
data/examples/test.edb +9 -0
data/javalib/JRubyParser.jar +0 -0
data/lib/duby.rb +168 -0
data/lib/duby/ast.rb +386 -0
data/lib/duby/ast/call.rb +145 -0
data/lib/duby/ast/class.rb +154 -0
data/lib/duby/ast/flow.rb +332 -0
data/lib/duby/ast/intrinsics.rb +56 -0
data/lib/duby/ast/literal.rb +97 -0
data/lib/duby/ast/local.rb +92 -0
data/lib/duby/ast/method.rb +244 -0
data/lib/duby/ast/structure.rb +62 -0
data/lib/duby/ast/type.rb +93 -0
data/lib/duby/c/compiler.rb +134 -0
data/lib/duby/compiler.rb +282 -0
data/lib/duby/jvm/compiler.rb +766 -0
data/lib/duby/jvm/method_lookup.rb +193 -0
data/lib/duby/jvm/source_compiler.rb +605 -0
data/lib/duby/jvm/source_generator/builder.rb +387 -0
data/lib/duby/jvm/source_generator/loops.rb +110 -0
data/lib/duby/jvm/source_generator/precompile.rb +170 -0
data/lib/duby/jvm/source_generator/typer.rb +11 -0
data/lib/duby/jvm/typer.rb +131 -0
data/lib/duby/jvm/types.rb +331 -0
data/lib/duby/jvm/types/basic_types.rb +19 -0
data/lib/duby/jvm/types/boolean.rb +11 -0
data/lib/duby/jvm/types/enumerable.rb +63 -0
data/lib/duby/jvm/types/factory.rb +155 -0
data/lib/duby/jvm/types/floats.rb +70 -0
data/lib/duby/jvm/types/integers.rb +110 -0
data/lib/duby/jvm/types/intrinsics.rb +230 -0
data/lib/duby/jvm/types/literals.rb +82 -0
data/lib/duby/jvm/types/methods.rb +381 -0
data/lib/duby/jvm/types/number.rb +92 -0
data/lib/duby/nbcompiler.rb +29 -0
data/lib/duby/old/compiler_old.rb +845 -0
data/lib/duby/old/declaration.rb +72 -0
data/lib/duby/old/mapper.rb +72 -0
data/lib/duby/old/signature.rb +52 -0
data/lib/duby/old/typer_old.rb +163 -0
data/lib/duby/plugin/edb.rb +25 -0
data/lib/duby/plugin/java.rb +42 -0
data/lib/duby/plugin/math.rb +84 -0
data/lib/duby/transform.rb +1028 -0
data/lib/duby/typer.rb +369 -0
data/test/TestUser.class +0 -0
data/test/test_ast.rb +391 -0
data/test/test_compilation.rb +98 -0
data/test/test_java_typer.rb +199 -0
data/test/test_javac_compiler.rb +58 -0
data/test/test_jvm_compiler.rb +1770 -0
data/test/test_math_plugin.rb +87 -0
data/test/test_typer.rb +246 -0
metadata +156 -0

data/examples/appengine/src/com/ribrdb/DubyApp.duby ADDED

@@ -0,0 +1,28 @@
+import javax.servlet.http.HttpServlet
+import com.google.appengine.ext.duby.db.Model
+class Post < Model
+  def initialize; end
+  property title, String
+  property body, Text
+end
+class DubyApp < HttpServlet
+  def_edb(list, 'com/ribrdb/list.dhtml')
+  def doGet(request, response)
+    returns :void
+    @posts = Post.all.run
+    response.getWriter.write(list)
+  end
+  def doPost(request, response)
+    post = Post.new
+    post.title = request.getParameter('title')
+    post.body = Text.new(request.getParameter('body'))
+    post.save
+    doGet(request, response)
+  end
+end

data/examples/appengine/src/com/ribrdb/list.dhtml ADDED

@@ -0,0 +1,15 @@
+<title>Posts</title>
+<body>
+  <h1>All Posts:</h1>
+  <% for post in @posts %>
+    <h2><%= post.title %></h2>
+    <p><%= post.body.getValue %></p>
+  <% end %>
+  <hr>
+  <h1>New Post:</h1>
+  <form method=post>
+    Title: <input type=text name=title><br>
+    Body: <textarea name=body></textarea><br>
+    <input type=submit>
+  </form>
+</body>

data/examples/construction.duby ADDED

@@ -0,0 +1,8 @@
+import "java.lang.StringBuffer"
+import "java.util.ArrayList"
+list = ArrayList.new
+sb = StringBuffer.new("Hello")
+sb.append(", world")
+list.add(sb)
+puts list

data/examples/edb.duby ADDED

@@ -0,0 +1,3 @@
+def_edb :render, 'test.edb'
+@message = "Hello"
+puts render

data/examples/fib.duby ADDED

@@ -0,0 +1,24 @@
+import "java.lang.System"
+def fib(a:int)
+  if a < 2
+    a
+  else
+    fib(a - 1) + fib(a - 2)
+  end
+end
+def bench(times:int)
+  while times > 0
+    time_start = System.currentTimeMillis
+    puts "fib(45):"
+    puts fib(45)
+    time_total = System.currentTimeMillis - time_start
+    puts "Total time:"
+    puts time_total
+    times -= 1
+  end
+  nil
+end
+bench 10

data/examples/fields.duby ADDED

@@ -0,0 +1,22 @@
+import 'java.util.ArrayList'
+class Bar
+  def initialize
+    @a = ArrayList
+  end
+  def list=(a:ArrayList)
+    @a = a
+  end
+  def foo
+    puts @a
+  end
+end
+b = Bar.new
+list = ArrayList.new
+list.add('hello')
+list.add('world')
+b.list = list
+b.foo

data/examples/fractal.duby ADDED

@@ -0,0 +1,57 @@
+import java.lang.System
+def run
+  puts "Rendering"
+  y = -39.0
+  while y <= 39.0
+    puts
+    x = -39.0
+    while x <= 39.0
+      i = iterate(x/40.0,y/40.0)
+      if (i == 0)
+        print "*"
+      else
+        print " "
+      end
+      x += 1
+    end
+    y += 1
+  end
+  puts
+end
+def iterate(x:double,y:double)
+  cr = y-0.5
+  ci = x
+  zi = 0.0
+  zr = 0.0
+  i = 0
+  result = 0
+  while true
+    i += 1
+    temp = zr * zi
+    zr2 = zr * zr
+    zi2 = zi * zi
+    zr = zr2 - zi2 + cr
+    zi = temp + temp + ci
+    if (zi2 + zr2 > 16)
+      result = i
+      break
+    end
+    if (i > 1000)
+      result = 0
+      break
+    end
+  end
+  result
+end
+i = 0
+while i < 10
+  start = System.currentTimeMillis
+  run
+  puts "Time: " + (System.currentTimeMillis - start) / 1000.0
+  i += 1
+end

data/examples/java_thing.duby ADDED

@@ -0,0 +1,13 @@
+import "java.lang.System"
+def foo
+  home = System.getProperty "java.home"
+  System.setProperty "hello.world", "something"
+  hello = System.getProperty "hello.world"
+  puts home
+  puts hello
+end
+puts "Hello world!"
+foo

data/examples/simple_class.duby ADDED

@@ -0,0 +1,12 @@
+class Foo
+  def initialize
+    puts 'constructor'
+    @hello = 'Hello, '
+  end
+  def hello(a:string)
+    puts @hello; puts a
+  end
+end
+Foo.new.hello('Duby')

data/examples/swing.duby ADDED

@@ -0,0 +1,20 @@
+import javax.swing.JFrame
+import javax.swing.JButton
+import java.awt.event.ActionListener
+frame = JFrame.new "Welcome to Duby"
+frame.setSize 300, 300
+frame.setVisible true
+button = JButton.new "Press me"
+frame.add button
+frame.show
+class AL; implements ActionListener
+  def initialize; end
+  def actionPerformed(event)
+    JButton(event.getSource).setText "Duby Rocks!"
+  end
+end
+button.addActionListener AL.new

data/examples/tak.duby ADDED

@@ -0,0 +1,15 @@
+def tak(x:fixnum, y:fixnum, z:fixnum)
+  unless y < x
+    z
+  else
+    tak( tak(x-1, y, z),
+         tak(y-1, z, x),
+         tak(z-1, x, y))
+  end
+end
+i = 0
+while i<1000
+  tak(24, 16, 8)
+  i+=1
+end

data/examples/test.edb ADDED

@@ -0,0 +1,9 @@
+<html>
+  <head>
+    <title><%= @message %></title>
+  </head>
+  <body>
+  <h1><%= @message %></h1>
+  </body>
+</html>

data/javalib/JRubyParser.jar ADDED

Binary file

data/lib/duby.rb ADDED

@@ -0,0 +1,168 @@
+require 'fileutils'
+require 'duby/transform'
+require 'duby/ast'
+require 'duby/typer'
+require 'duby/compiler'
+begin
+  require 'bitescript'
+rescue LoadError
+  $: << File.dirname(__FILE__) + '/../../bitescript/lib'
+  require 'bitescript'
+end
+require 'duby/jvm/compiler'
+require 'duby/jvm/typer'
+Dir[File.dirname(__FILE__) + "/duby/plugin/*"].each {|file| require "#{file}" if file =~ /\.rb$/}
+require 'jruby'
+module Duby
+  def self.run(*args)
+    DubyImpl.new.run(*args)
+  end
+  def self.compile(*args)
+    DubyImpl.new.compile(*args)
+  end
+  def self.parse(*args)
+    DubyImpl.new.parse(*args)
+  end
+end
+class DubyImpl
+  def run(*args)
+    ast = parse(*args)
+    main_cls = nil
+    compile_ast(ast) do |outfile, builder|
+      bytes = builder.generate
+      name = builder.class_name.gsub(/\//, '.')
+      cls = JRuby.runtime.jruby_class_loader.define_class(name, bytes.to_java_bytes)
+      proxy_cls = JavaUtilities.get_proxy_class(name)
+      # TODO: using first main; find correct one
+      if proxy_cls.respond_to? :main
+        main_cls ||= proxy_cls
+      end
+    end
+    if main_cls
+      main_cls.main(args.to_java(:string))
+    else
+      puts "No main found"
+    end
+  end
+  def compile(*args)
+    process_flags!(args)
+    expand_files(args).each do |duby_file|
+      if duby_file == '-e'
+        @filename = '-e'
+        next
+      elsif @filename == '-e'
+        ast = parse('-e', duby_file)
+      else
+        ast = parse(duby_file)
+      end
+      exit 1 if @error
+      compile_ast(ast) do |filename, builder|
+        filename = "#{@dest}#{filename}"
+        FileUtils.mkdir_p(File.dirname(filename))
+        bytes = builder.generate
+        File.open(filename, 'w') {|f| f.write(bytes)}
+      end
+      @filename = nil
+    end
+  end
+  def parse(*args)
+    process_flags!(args)
+    @filename = args.shift
+    if @filename == '-e'
+      @filename = 'dash_e'
+      src = args[0]
+    else
+      src = File.read(@filename)
+    end
+    Duby::AST.type_factory = Duby::JVM::Types::TypeFactory.new(@filename)
+    ast = Duby::AST.parse_ruby(src, @filename)
+    @transformer = Duby::Transform::Transformer.new
+    ast = @transformer.transform(ast, nil)
+    @transformer.errors.each do |ex|
+      raise ex.cause || ex if @verbose
+      puts "#@filename:#{ex.position.start_line+1}: #{ex.message}"
+    end
+    @error = @transformer.errors.size > 0
+    ast
+  end
+  def compile_ast(ast, &block)
+    typer = Duby::Typer::JVM.new(@filename, @transformer)
+    typer.infer(ast)
+    begin
+      typer.resolve(true)
+    ensure
+      typer.errors.each do |ex|
+        puts ex.message
+        puts ex.backtrace if @verbose
+      end
+    end
+    compiler = @compiler_class.new(@filename)
+    ast.compile(compiler, false)
+    compiler.generate(&block)
+  end
+  def process_flags!(args)
+    while args.length > 0
+      case args[0]
+      when '-V'
+        Duby::Typer.verbose = true
+        Duby::AST.verbose = true
+        Duby::Compiler::JVM.verbose = true
+        @verbose = true
+        args.shift
+      when '-java'
+        require 'duby/jvm/source_compiler'
+        @compiler_class = Duby::Compiler::JavaSource
+        args.shift
+      when '-d'
+        args.shift
+        @dest = File.join(args.shift, '')
+      when '-p'
+        args.shift
+        plugin = args.shift
+        require "duby/plugin/#{plugin}"
+      when '-I'
+        args.shift
+        $: << args.shift
+      else
+        break
+      end
+    end
+    @compiler_class ||= Duby::Compiler::JVM
+  end
+  def expand_files(files)
+    expanded = []
+    files.each do |filename|
+      if File.directory?(filename)
+        Dir[File.join(filename, '*')].each do |child|
+          if File.directory?(child)
+            files << child
+          elsif child =~ /\.duby$/
+            expanded << child
+          end
+        end
+      else
+        expanded << filename
+      end
+    end
+    expanded
+  end
+end
+if __FILE__ == $0
+  Duby.run(ARGV[0], *ARGV[1..-1])
+end

data/lib/duby/ast.rb ADDED

@@ -0,0 +1,386 @@
+require 'duby/transform'
+module Duby
+  module AST
+    class << self
+      attr_accessor :verbose
+    end
+    # The top of the AST class hierarchy, this represents an abstract AST node.
+    # It provides accessors for _children_, an array of all child nodes,
+    # _parent_, a reference to this node's parent (nil if none), and _newline_,
+    # whether this node represents a new line.
+    class Node
+      attr_accessor :children
+      attr_accessor :parent
+      attr_accessor :position
+      attr_accessor :newline
+      attr_accessor :inferred_type
+      def initialize(parent, position, children = [])
+        @parent = parent
+        @newline = false
+        @inferred_type = nil
+        @resolved = false
+        @position = position
+        if block_given?
+          @children = yield(self) || []
+        else
+          @children = children
+        end
+      end
+      def line_number
+        if @position
+          @position.start_line + 1
+        else
+          0
+        end
+      end
+      def log(message)
+        puts "* [AST] [#{simple_name}] " + message if AST.verbose
+      end
+      def inspect(indent = 0)
+        indent_str = ' ' * indent
+        str = indent_str + to_s
+        children.each do |child|
+          if child
+            if ::Array === child
+              child.each {|ary_child|
+                str << "\n#{ary_child.inspect(indent + 1)}"
+              }
+            elsif ::Hash === child
+              str << "\n#{indent_str} #{child.inspect}"
+            else
+              str << "\n#{child.inspect(indent + 1)}"
+            end
+          end
+        end
+        str
+      end
+      def simple_name
+        self.class.name.split("::")[-1]
+      end
+      def to_s; simple_name; end
+      def [](index) children[index] end
+      def each(&b) children.each(&b) end
+      def resolved!
+        log "#{to_s} resolved!"
+        @resolved = true
+      end
+      def resolved?; @resolved end
+      def resolve_if(typer)
+        unless resolved?
+          @inferred_type = yield
+          @inferred_type ? resolved! : typer.defer(self)
+        end
+        @inferred_type
+      end
+      def self.===(other)
+        super || (other.kind_of?(NodeProxy) && (self === other.__getobj__))
+      end
+    end
+    class ErrorNode < Node
+      def initialize(parent, error)
+        super(parent, error.position)
+        @error = error
+        @inferred_type = TypeReference::ErrorType
+        @resolved = true
+      end
+      def infer(typer)
+      end
+    end
+    module Named
+      attr_accessor :name
+      def to_s
+        "#{super}(#{name})"
+      end
+    end
+    module Typed
+      attr_accessor :type
+    end
+    module Valued
+      include Typed
+      attr_accessor :value
+    end
+    module Literal
+      include Typed
+      attr_accessor :literal
+      def to_s
+        "#{super}(#{literal.inspect})"
+      end
+    end
+    module Scoped
+      def scope
+        @scope ||= begin
+          scope = parent
+          raise "No parent for #{self.class.name} at #{line_number}" if scope.nil?
+          scope = scope.parent until scope.class.include?(Scope)
+          scope
+        end
+      end
+    end
+    module ClassScoped
+      def scope
+        @scope ||= begin
+          scope = parent
+          scope = scope.parent until scope.nil? || ClassDefinition === scope
+          scope
+        end
+      end
+    end
+    module Annotated
+      attr_accessor :annotations
+      def annotation(name)
+        name = name.to_s
+        annotations.find {|a| a.name == name}
+      end
+    end
+    module Scope; end
+    class Colon2 < Node; end
+    class Constant < Node
+      include Named
+      def initialize(parent, position, name)
+        @name = name
+        super(parent, position, [])
+      end
+      def infer(typer)
+        @inferred_type ||= begin
+          typer.type_reference(name, false, true)
+        end
+      end
+    end
+    class Self < Node
+      def infer(typer)
+        @inferred_type ||= typer.self_type
+      end
+    end
+    class VoidType < Node; end
+    class Annotation < Node
+      def initialize(parent, position, klass)
+        super(parent, position)
+        @class = klass
+        @values = []
+      end
+      def name
+        @class.name
+      end
+      def type
+        @class
+      end
+      def []=(name, value)
+        # TODO support annotation arguments
+      end
+    end
+    class TypeReference < Node
+      include Named
+      attr_accessor :array
+      alias array? array
+      attr_accessor :meta
+      alias meta? meta
+      def initialize(name, array = false, meta = false, position=nil)
+        super(nil, position)
+        @name = name
+        @array = array
+        @meta = meta
+      end
+      def to_s
+        "Type(#{name}#{array? ? ' array' : ''}#{meta? ? ' meta' : ''})"
+      end
+      def ==(other)
+        to_s == other.to_s
+      end
+      def eql?(other)
+        self == other
+      end
+      def hash
+        to_s.hash
+      end
+      def is_parent(other)
+        # default behavior now is to disallow any polymorphic types
+        self == other
+      end
+      def compatible?(other)
+        # default behavior is only exact match right now
+        self == other ||
+            error? || other.error? ||
+            unreachable? || other.unreachable?
+      end
+      def iterable?
+        array?
+      end
+      def component_type
+        AST.type(name) if array?
+      end
+      def narrow(other)
+        # only exact match allowed for now, so narrowing is a noop
+        if error? || unreachable?
+          other
+        else
+          self
+        end
+      end
+      def unmeta
+        TypeReference.new(name, array, false)
+      end
+      def meta
+        TypeReference.new(name, array, true)
+      end
+      def error?
+        name == :error
+      end
+      def unreachable?
+        name == :unreachable
+      end
+      def block?
+        name == :block
+      end
+      def primitive?
+        true
+      end
+      NoType = TypeReference.new(:notype)
+      NullType = TypeReference.new(:null)
+      ErrorType = TypeReference.new(:error)
+      UnreachableType = TypeReference.new(:unreachable)
+      BlockType = TypeReference.new(:block)
+    end
+    class TypeDefinition < TypeReference
+      attr_accessor :superclass, :interfaces
+      def initialize(name, superclass, interfaces)
+        super(name, false)
+        @superclass = superclass
+        @interfaces = interfaces
+      end
+    end
+    def self.type_factory
+      Thread.current[:ast_type_factory]
+    end
+    def self.type_factory=(factory)
+      Thread.current[:ast_type_factory] = factory
+    end
+    # Shortcut method to construct type references
+    def self.type(typesym, array = false, meta = false)
+      factory = type_factory
+      if factory
+        factory.type(typesym, array, meta)
+      else
+        TypeReference.new(typesym, array, meta)
+      end
+    end
+    def self.no_type
+      factory = type_factory
+      if factory
+        factory.no_type
+      else
+        TypeReference::NoType
+      end
+    end
+    def self.error_type
+      TypeReference::ErrorType
+    end
+    def self.unreachable_type
+      TypeReference::UnreachableType
+    end
+    def self.block_type
+      TypeReference::BlockType
+    end
+    def self.fixnum(parent, position, literal)
+      factory = type_factory
+      if factory
+        factory.fixnum(parent, position, literal)
+      else
+        Fixnum.new(parent, position, literal)
+      end
+    end
+    def self.float(parent, position, literal)
+      factory = type_factory
+      if factory
+        factory.float(parent, position, literal)
+      else
+        Float.new(parent, position, literal)
+      end
+    end
+    def self.defmacro(name, &block)
+      @macros ||= {}
+      raise "Conflicting macros for #{name}" if @macros[name]
+      @macros[name] = block
+    end
+    def self.macro(name)
+      @macros[name]
+    end
+  end
+end
+require 'duby/ast/local'
+require 'duby/ast/call'
+require 'duby/ast/flow'
+require 'duby/ast/literal'
+require 'duby/ast/method'
+require 'duby/ast/class'
+require 'duby/ast/structure'
+require 'duby/ast/type'
+require 'duby/ast/intrinsics'