duby 0.0.2-java

data/History.txt

@@ -0,0 +1,8 @@
+=== 0.0.2 / 2010-02-15
+
+* More language features added
+
+=== 0.0.1 / 2009-10-27
+
+* First gem release
+  * Most things necessary for simple apps, scripts, servlets are working

data/README.txt

@@ -0,0 +1,39 @@
+= duby
+
+* http://kenai.com/projects/duby
+
+== DESCRIPTION:
+
+Duby is a customizable programming language featuring static types,
+local type inference and a heavily Ruby-inspired syntax. Duby
+currently includes a typer/compiler backend for the JVM which can
+output either JVM bytecode or Java source files.
+
+== FEATURES/PROBLEMS:
+
+* Ruby syntax
+* Compiles to .class or .java
+* Fast as Java
+
+== SYNOPSIS:
+
+duby <script.duby>
+duby -e "inline script"
+dubyc <script.duby>
+dubyc -e "inline script" # produces dash_e.class
+dubyc -java <script.duby>
+dubyc -java -e "inline script" # produces dash_e.java
+
+== REQUIREMENTS:
+
+* JRuby 1.4RC2 or higher.
+* BiteScript 0.0.5 or higher
+
+== INSTALL:
+
+* gem install duby
+
+To build from source you should have a checkout of both jruby and
+bitescript in Duby's parent directory. Run "ant jar-complete" in
+jruby, then in the duby directory "ant bootstrap" followed by "ant"
+should build it.

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rake'
+require 'rake/testtask'
+require 'java'
+
+task :default => :test
+
+Rake::TestTask.new :test do |t|
+  t.libs << "lib"
+  # This is hacky, I know
+  t.libs.concat Dir["../bitescript*/lib"]
+  t.test_files = FileList["test/**/*.rb"]
+  java.lang.System.set_property("jruby.duby.enabled", "true")
+end

data/bin/duby

@@ -0,0 +1,9 @@
+#!/usr/bin/env jruby
+begin
+  require 'duby'
+rescue LoadError
+  $: << File.dirname(File.dirname(__FILE__)) + '/lib'
+  require 'duby'
+end
+
+Duby.run(*ARGV)

data/bin/dubyc

@@ -0,0 +1,9 @@
+#!/usr/bin/env jruby
+begin
+  require 'duby'
+rescue LoadError
+  $: << File.dirname(File.dirname(__FILE__)) + '/lib'
+  require 'duby'
+end
+
+Duby.compile(*ARGV)

data/bin/dubyp

@@ -0,0 +1,9 @@
+#!/usr/bin/env jruby
+begin
+  require 'duby'
+rescue LoadError
+  $: << File.dirname(File.dirname(__FILE__)) + '/lib'
+  require 'duby'
+end
+
+puts Duby.parse(*ARGV).inspect

data/examples/README

@@ -0,0 +1,16 @@
+Duby: A Type-Inferred Ruby-Like JVM Language
+
+Duby is an experimental project to create a JVM bytecode compiler for a 
+Ruby-like language that infers static types from argument declarations 
+and called methods. It is currently under development, but may eventually
+be used to implement portions of JRuby, since Duby combines the terse,
+neat syntax of Ruby with the performance of statically-typed Java 
+bytecode. 
+
+To compile the samples, run the following lines:
+
+jruby lib/ruby/site_ruby/1.8/compiler/duby/compiler.rb <filename>
+
+And to load and call them, use JRuby's Java integration:
+
+CLASSPATH=. jruby -rjava -e "p Java::Foo.new.fib(35)"

data/examples/appengine/Rakefile

@@ -0,0 +1,72 @@
+require 'appengine-sdk'
+require 'appengine-tools/web-xml'
+require 'appengine-tools/xml-formatter'
+
+SRC = File.expand_path(File.dirname(__FILE__) + '/src')
+LIB = File.expand_path(File.dirname(__FILE__) + '/lib')
+WAR = File.expand_path(File.dirname(__FILE__) + '/war')
+CONFIG_RU = File.expand_path(File.dirname(__FILE__) + '/config.ru')
+SERVLET = AppEngine::SDK::SDK_ROOT +
+          '/lib/shared/geronimo-servlet_2.5_spec-1.2.jar'
+APIS = AppEngine::SDK::API_JAR
+
+WEB_INF_CLASSES = WAR + '/WEB-INF/classes'
+WEB_XML = WAR + '/WEB-INF/web.xml'
+AEWEB_XML = WAR + '/WEB-INF/appengine-web.xml'
+
+MODEL = 'com/google/appengine/ext/duby/db/Model'
+DUBY_APP = 'com/ribrdb/DubyApp'
+
+MODEL_DUBY = "#{SRC}/#{MODEL}.duby"
+MODEL_CLASS = "#{WEB_INF_CLASSES}/#{MODEL}.class"
+DUBY_APP_DUBY = "#{SRC}/#{DUBY_APP}.duby"
+DUBY_APP_CLASS = "#{WEB_INF_CLASSES}/#{DUBY_APP}.class"
+LIST = "#{SRC}/com/ribrdb/list.dhtml"
+
+def dubyc(*files)
+  chdir(File.dirname(__FILE__) + '/src') do
+    files = files.join ' '
+    dest = '-d ../war/WEB-INF/classes'
+    dubyc = '../../../bin/dubyc'
+    options = "-I #{LIB} -p datastore"
+    orig_classpath = ENV['CLASSPATH']
+    ENV['CLASSPATH'] ||= ''
+    ENV['CLASSPATH'] += ":#{SERVLET}:#{APIS}:#{WEB_INF_CLASSES}"
+    sh %{#{dubyc} #{dest} #{options} #{files}}
+    ENV['CLASSPATH'] = orig_classpath
+  end
+end
+
+directory WEB_INF_CLASSES
+
+file MODEL_CLASS => MODEL_DUBY do
+  dubyc("#{MODEL}.duby")
+end
+
+file DUBY_APP_CLASS => [DUBY_APP_DUBY, LIST, MODEL_CLASS] do
+  dubyc("#{DUBY_APP}.duby")
+end
+
+file WEB_XML => [WEB_INF_CLASSES, CONFIG_RU] do
+  builder = WebXmlBuilder.new do
+    eval IO.read(CONFIG_RU), nil, 'config.ru', 1
+  end
+  open(WEB_XML, 'w') do |webxml|
+    xml = AppEngine::Rack::XmlFormatter.format(builder.to_xml)
+    webxml.write(xml)
+  end
+  open(AEWEB_XML, 'w') do |aeweb|
+    xml = AppEngine::Rack::XmlFormatter.format(AppEngine::Rack.app.to_xml)
+    aeweb.write(xml)
+  end
+end
+
+task :server => [WEB_XML, DUBY_APP_CLASS] do
+  sh "dev_appserver.rb #{WAR}"
+end
+
+task :upload => [WEB_XML, DUBY_APP_CLASS] do
+  sh "appcfg.rb update #{WAR}"
+end
+
+task :default => :server

data/examples/appengine/Readme

@@ -0,0 +1,27 @@
+Run rake to compile the application and start the development server.
+
+Requirements:
+ - Install the google-appengine gem (under MRI, not JRUBY)
+ - Have jruby on your path so dubyc can run.
+
+Datastore API:
+  Model.get(key)
+  Model.delete(key)
+  Model.all -> Query
+  property foo, String # or any supported datastore type
+                       # For numbers use Long or Double
+  
+  instance.save
+  instance.key
+  
+  instance.foo
+  instance.foo=
+
+  Query.count
+  Query.run -> Model[]
+  Query.first -> instance || nil
+  Query.sort(property_name)
+  Query.sort(property_name, true) # descending
+  Query.foo('foo').bar(3)  # Only return instances where foo = 'foo' and bar = 3
+  Query.offset(10)
+  Query.limit(5)

data/examples/appengine/config.ru

@@ -0,0 +1,7 @@
+require 'appengine-rack'
+require 'appengine-rack/java'
+
+# TODO: Fill in your app id
+AppEngine::Rack.app.configure(:application => '', :version => '1')
+
+run JavaServlet.new('com.ribrdb.DubyApp')

data/examples/appengine/lib/duby/plugin/datastore.rb

@@ -0,0 +1,171 @@
+class DatastorePlugin
+  @models = {}
+  
+  class ModelState
+    include Duby::AST
+    attr_reader :kind, :query, :read, :save, :transformer
+    
+    def initialize(transformer, klass, parent, position, ast)
+      @transformer = transformer
+      @kind = klass.name.split('.')[-1]
+      init_query(klass.name, parent, position, ast)
+      init_static(parent, ast)
+      init_read(parent, position, ast)
+      init_save(parent, position, ast)
+    end
+    
+    def init_query(classname, parent, position, ast)
+      name = "#{classname}$Query"
+      @query = ClassDefinition.new(parent, position, name) do |classdef|
+        queryinit = <<-EOF
+          def initialize; end
+        
+          def kind
+            "#{kind}"
+          end
+
+          def first
+            it = _prepare.asIterator
+            if it.hasNext
+              e = Entity(it.next)
+              m = #{kind}.new
+              m._read_from(e)
+              m
+            else
+              #{kind}(nil)
+            end
+          end
+
+          def run
+            entities = _prepare.asList(_options)
+            models = #{kind}[entities.size]
+            it = entities.iterator
+            i = 0
+            while (it.hasNext)
+              e = Entity(it.next)
+              m = #{kind}.new
+              m._read_from(e)
+              models[i] = m
+              i += 1
+            end
+            models
+          end
+        EOF
+        [Duby::AST.type('com.google.appengine.ext.duby.db.DQuery'),
+         eval(classdef, queryinit)]
+      end
+      ast.children << @query
+    end
+    
+    def init_read(parent, position, ast)
+      @read = eval(parent, <<-EOF)
+        def _read_from(e:Entity)
+        end
+      EOF
+      @read.body = @read.children[2] = Body.new(@read, position) {[]}
+      ast.children << @read
+    end
+    
+    def init_save(parent, position, ast)
+      @save = eval(parent, <<-EOF)
+        def _save_to(e:Entity)
+        end
+      EOF
+      @save.body = @save.children[2] = Body.new(@save, position) {[]}
+      ast.children << @save
+    end
+    
+    def init_static(parent, ast)
+      ast.children << eval(parent, <<-EOF)
+        import com.google.appengine.api.datastore.Entity
+        import com.google.appengine.api.datastore.Blob
+        import com.google.appengine.api.datastore.Category
+        import com.google.appengine.api.datastore.Email
+        import com.google.appengine.api.datastore.GeoPt
+        import com.google.appengine.api.datastore.IMHandle
+        import com.google.appengine.api.datastore.Key
+        import com.google.appengine.api.datastore.Link
+        import com.google.appengine.api.datastore.PhoneNumber
+        import com.google.appengine.api.datastore.PostalAddress
+        import com.google.appengine.api.datastore.Rating
+        import com.google.appengine.api.datastore.ShortBlob
+        import com.google.appengine.api.datastore.Text
+        import '#{kind}__Query__', '#{kind}$Query'
+
+        def self.get(key:Key)
+          m = #{kind}.new
+          m._read_from(Model._datastore.get(key))
+          m
+        end
+        
+        def self.all
+          #{kind}__Query__.new
+        end
+      EOF
+    end
+
+    def eval(parent, src)
+      ast = Duby::AST.parse_ruby(src, __FILE__)
+      transformer.transform(ast.body_node, parent)
+    end
+
+    def extend_query(code)
+      query.body.children << eval(query.body, code)
+    end
+
+    def extend_read(code)
+      code = 'e=nil;' + code
+      read.body.children.concat eval(read.body, code).children[1..-1]
+    end
+    
+    def extend_save(code)
+      code = 'e=nil;' + code
+      save.body.children.concat eval(save.body, code).children[1..-1]
+    end
+  end
+  
+  def self.find_class(node)
+    node = node.parent until Duby::AST::ClassDefinition === node
+    node
+  end
+  
+  Duby::AST.defmacro("property") do |transformer, fcall, parent|
+    result = Duby::AST::Body.new(parent, fcall.position) {[]}
+    klass = find_class(parent)
+    unless @models[klass]
+      @models[klass] = ModelState.new(
+          transformer, klass, parent, fcall.position, result)
+    end
+    model = @models[klass]
+
+    name = fcall.args_node.get(0).name
+    type = fcall.args_node.get(1).name
+
+    model.extend_query(<<-EOF)
+      def #{name}(value:#{type})
+        returns :void
+        _query.addFilter("#{name}", _eq_op, value)
+      end
+    EOF
+    
+    model.extend_read(<<-EOF)
+      @#{name} = #{type}(e.getProperty("#{name}"))
+    EOF
+    
+    model.extend_save(<<-EOF)
+      e.setProperty("#{name}", @#{name})
+    EOF
+    
+    result.children << model.eval(parent, <<-EOF)
+      def #{name}
+        @#{name}
+      end
+      
+      def #{name}=(value:#{type})
+        @#{name} = value
+      end
+    EOF
+
+    result
+  end
+end

data/examples/appengine/src/com/google/appengine/ext/duby/db/Model.duby

@@ -0,0 +1,132 @@
+import com.google.appengine.api.datastore.DatastoreServiceFactory
+import com.google.appengine.api.datastore.Entity
+import com.google.appengine.api.datastore.EntityNotFoundException
+import com.google.appengine.api.datastore.Key
+import com.google.appengine.api.datastore.KeyFactory
+import com.google.appengine.api.datastore.Query
+import 'Builder', 'com.google.appengine.api.datastore.FetchOptions$Builder'
+import 'FilterOperator', 'com.google.appengine.api.datastore.Query$FilterOperator'
+import 'SortDirection', 'com.google.appengine.api.datastore.Query$SortDirection'
+
+class DQuery
+  def initialize
+    @query = Query.new(kind)
+  end
+  
+  def kind
+    "foo"
+  end
+  
+  def limit(l:int)
+    returns :void
+    if @options
+      @options.limit(l)
+    else
+      @options = Builder.withLimit(l)
+    end
+  end
+  
+  def offset(o:int)
+    returns :void
+    if @options
+      @options.offset(o)
+    else
+      @options = Builder.withOffset(o)
+    end
+  end
+  
+  def sort(name:String)
+    sort(name, false)
+  end
+  
+  def sort(name:String, descending:boolean)
+    returns :void
+    if descending
+      @query.addSort(name, _desc)
+    else
+      @query.addSort(name)
+    end
+  end
+  
+  def count
+    _prepare.countEntities
+  end
+  
+  def _query
+    @query
+  end
+  
+  def _options
+    if @options.nil?
+      @options = Builder.withOffset(0)
+    end
+    @options
+  end
+  
+  def _prepare
+    Model._datastore.prepare(@query)
+  end
+  
+  def _eq_op
+    FilterOperator.valueOf("EQUAL")
+  end
+  
+  def _desc
+    SortDirection.valueOf("DESCENDING")
+  end
+end
+
+class Model
+  def initialize
+  end
+  
+  def self._datastore
+    unless @service
+      @service = DatastoreServiceFactory.getDatastoreService
+    end
+    @service
+  end
+  
+  def self.delete(key:Key)
+    returns :void
+    keys = Key[1]
+    keys[0] = key
+    Model._datastore.delete(keys)
+  end
+  
+  def kind
+    getClass.getSimpleName
+  end
+  
+  def key
+    if @entity
+      @entity.getKey
+    else
+      Key(nil)
+    end
+  end
+  
+  def save
+    Model._datastore.put(to_entity)
+  end
+  
+  def delete
+    returns :void
+    Model.delete(key)
+  end
+  
+  def to_entity
+    unless @entity
+      @entity = Entity.new(kind)
+    end
+    _save_to(@entity)
+    @entity
+  end
+  
+  # protected
+  def _save_to(e:Entity)
+  end
+  
+  def _read_from(e:Entity)
+  end
+end