java_head 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ec3c3534f665067559a3fdecdcf3d8433c55da9
+  data.tar.gz: e82c020ce91bdbb202f1be04bcd0dd28f5c4db79
+SHA512:
+  metadata.gz: 6203d12e340b405add5f0c93cfa45f95b243aa46433139d9b3c4fd491b44ccb0d9d64a060c4833ed67c6aefaef95fd791cb4e7bef694c380833752671dd1a15b
+  data.tar.gz: 6f287491d1ef91290e85118558b47cbf9bc67e3407c393d85e47c269d16e3fa4749f2d07d91251311143f0851023687e7930401e628ce65dbc12c53c554a91d6

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.DS_Store

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in java_head.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 AndrewTLee
+
+MIT License
+
+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,59 @@
+# JavaHead
+
+JavaHead is designed to run Java classes easily with familiar Ruby syntax. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'java_head'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install java_head
+
+## Usage
+
+Use the two primary JavaHead classes, Package and Class, to represent Java packages and classes, respectively. Here is some basic usage:
+
+```ruby
+require 'java_head'
+
+# JavaHead::CLASSPATH is an array of Pathnames that represent where JavaHead will search for your classes. Its initial value is created based on the CLASSPATH environment variable
+# You can also change your CLASSPATH like so:
+JavaHead::CLASSPATH.push(Pathname.new('/my/java/classpath'))
+
+# Get a package, this will load the package corresponding to /my/java/classpath/com/example/foo
+package = JavaHead > 'com.example.foo'
+
+
+subpackage = package > 'bar'    # Pull up a subpackage
+subpackage.compile              # invoke javac to compile all files in the ppackage
+subpackage.remove_class         # remove .class files
+
+jclass = subpackage > 'MyClass' # Also JavaHead > 'com.example.foo.bar.MyClass' or 'com.example.foo.bar.MyClass'.java
+jclass.package == subpackage    # => true
+jclass.compile                  # Compile the class, this returns the JavaHead::Class object
+jclass.exec                     # Execute the compiled class, this returns the output of the execution
+jclass.remove_class             # Remove the .class file
+jclass.run                      # Do the same thing with only one method, this returns the same as #exec()
+jclass.run('Hello','World')     # You can also pass command-line arguments to your Java programs
+
+
+
+
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/AndrewTLee/java_head/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/java_head.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'java_head/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "java_head"
+  spec.version       = JavaHead::VERSION
+  spec.authors       = ["AndrewTLee"]
+  spec.email         = ["andytaelee@gmail.com"]
+  spec.summary       = %q{Represent, compile, and run Java code in Ruby.}
+  spec.description   = %q{JavaHead contains classes to reprsent Java packages and classes and execute them in Ruby. Use this in scripts to run Java programs from Ruby, or in IRB to develop Java in a sensible environment}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "colorize", "~> 0.7.3"
+  spec.add_development_dependency "minitest", "~> 5.4.3"
+end

data/lib/java_head/version.rb

@@ -0,0 +1,3 @@
+module JavaHead
+  VERSION = "1.0.0"
+end

data/lib/java_head.rb

@@ -0,0 +1,377 @@
+
+# Version info
+require "java_head/version"
+
+# A file to represent java Packages and Classes
+# requires pathnames
+require 'pathname'
+
+# The namespace for the classes
+module JavaHead
+  
+  # The class to represent Java packages.
+  # Packages are immutable and duplicate package names are not allowed.
+  # To this end, the ::new method is private and packages are accessed using
+  # the ::get method which checks the class's internal cache prior to creating a new object
+  class Package
+
+    # Construct a package
+    # This method is private
+    #
+    # @param [String] name The Java name of the package
+    def initialize(name)
+      raise PackageException, "Package #{name} already exists" if @@stored[name.intern]
+      
+      # Test name
+      raise PackageException, "Invalid package name #{name}" unless name.match FORMAT
+
+      
+      names = name.split('.') # An array of the package names, we will be using this a lot
+      
+      CLASSPATH.each do |base|
+        absolute = base.join(*names)
+        @path = absolute.realpath if absolute.exist? and absolute.directory?
+      end
+      raise PackageException, "Could not find directory for package #{name}" unless @path
+      
+      
+      # Set superpackage
+      @name = names.pop.freeze
+      if names.empty?
+        @superpackage = nil
+      else
+        @superpackage = self.class.get(names.join('.'))
+      end
+    end
+    
+    # getter methods for name, superpackage, path
+    attr_reader :name,:superpackage,:path
+    
+    # recursively compute fullname using superpackage fullname
+    #
+    # @return [String] The package's full name, e.g. com.example.packagename
+    def fullname
+      return @name unless @superpackage
+      "#{@superpackage.fullname}.#{@name}"
+    end
+    
+    # to_s returns fullname
+    alias to_s fullname
+    
+    # print useful fully-qualified name and path of class
+    #
+    # @return [String] A string that outlines the basic attributes of the object
+    def inspect
+      "[Java Package, name: #{fullname}, path: #{path}]"
+    end
+    
+    # return a subpackage of the current package
+    #
+    # @param [String] name the name of the child package
+    # @return [JavaHead::Package] the child package
+    def subpackage(name)
+      self.class.get("#{fullname}.#{name}")
+    end
+    
+    # return a class within the current package
+    #
+    # @param [String] name the name of the class within the package
+    # @return [JavaHead::Class] the child class
+    def class(name=nil)
+      return super() if name.eql? nil
+      Class.new("#{fullname}.#{name}")
+    end
+    
+    # get all classes in the current package
+    #
+    # @return [Array<JavaHead::Class>] all classes in the current package
+    def classes
+      Dir.chdir(@path) do
+        Dir.glob('*.java').map! do |filename|
+          self.class( filename.match(/^([A-Z][A-Za-z0-9]*)\.java$/)[1] )
+        end
+      end
+    end
+    
+    # compile all classes in the package
+    #
+    # @return [JavaHead::Package] this package
+    def compile
+      classes.each { |c| c.compile }
+      self
+    end
+    
+    # Check if all the classes in this package are compiled
+    #
+    # @return [Boolean] Whether or not all classes are compiled
+    def compiled?
+      classes.each do |jclass|
+        return false unless jclass.compiled?
+      end
+      true
+    end
+    
+    # call #remove_class on all class files of the package
+    #
+    # @return [JavaHead::Package] the current value of this
+    def remove_class
+      classes.each { |c| c.remove_class }
+      self
+    end
+    
+    
+    
+    # returns #class(name) or #subpackage(name) depending on the format of name
+    #
+    # @param [String] name the name of the member element
+    # @return [JavaHead::Package,JavaHead::Class] The child package or class
+    def member(name)
+      if name.match Class::FORMAT
+        self.class(name)
+      else
+        subpackage(name)
+      end
+      
+    end
+    
+    # > is a handy operator alias for member
+    alias > member
+    
+    
+    
+    # The required format for all package names
+    FORMAT = /^([a-z][a-z0-9]*\.)*[a-z_][a-z0-9_]*$/.freeze
+    @@stored = Hash.new
+    
+    
+    class << self
+      private :new
+      
+      # Get the package that corresponds to name
+      #
+      # @param [String] name the name of the package
+      # @return [JavaHead::Package] the package that corresponds to name
+      def get(name)
+        sym = name.intern
+        return @@stored[sym] if @@stored[sym]
+        package = new(name)
+        @@stored[sym] = package
+        package
+      end
+      
+    end
+    
+  end
+  
+  # Class to represent Java Classes
+  class Class
+    # Construct a new Class object
+    #
+    # @param [String] name the full name of the class
+    def initialize(name)
+      raise ClassException, "Invalid class name #{name}" unless name.match FORMAT
+      
+      names = name.split('.')
+      @name = names.pop.freeze
+      @package = Package.get(names.join('.'))
+      @path = @package.path.join("#{@name}.java")
+      
+      raise ClassException, "Location not found for class #{name}" unless @path.exist? and @path.file?
+    end
+    # name, package, and path are publicly visible
+    attr_reader :name, :package, :path
+    
+    # Get the fully qualified name of the class
+    # @return [String] the full name of the class, e.g. com.example.projects.Circle
+    def fullname
+      "#{@package.fullname}.#{@name}"
+    end
+    
+    # #to_s is #fullname
+    alias to_s fullname
+  
+  
+  
+  
+    # Compile the program
+    # Raises a CompilerException if there was a problem compiling
+    # @return [JavaHead::Class] this class object
+    def compile(*args)
+      remove_class if compiled?
+      command = 'javac '
+      args.each do |arg|
+        arg = arg.to_s
+        raise CompilerException, "Invalid compiling argument #{arg}" unless arg.match ARGFORMAT
+      end
+      command << args.join(' ')
+      command << ' '
+      command << @path.to_s
+      output = `#{command}`
+      raise CompilerException, "Class #{fullname} could not compile" unless compiled?
+      self
+    end
+  
+    # Remove the existing compiled class
+    #
+    # @return [JavaHead::Class, Boolean] this class object or false if not successful
+    def remove_class
+      Dir.chdir(@package.path) do
+        Pathname.glob("#{@name}$*.class") do |pathname|
+          pathname.unlink
+        end
+        Pathname.new("#{@name}.class").unlink
+      end
+      self
+      
+    # the file doesn't exist or there was a problem loading it
+    rescue Errno::ENOENT
+      return false
+    end
+  
+    # Test to see if compilation works, args are passed to the compile method
+    #
+    # @param [Array] args the arguments to be passed to the #compile method
+    # @return [JavaHead::Class,NilClass] this class object or nil if the compilation failed
+    def test(*args)
+      compile(*args)
+      remove_class
+      self
+    rescue Exception => e
+      puts "Exception of type #{e.class} while compiling #{fullname}: #{e}"
+      nil
+    end
+  
+    # Integrated compile, run, remove_class
+    # This method assumes to some extent that
+    # compilation will succeed, so although this may fail,
+    # its arguments are passed to the exec method
+    #
+    # @param [Array] args the arguments to be passed to the #exec method
+    # @return [String] the output created by the Java program
+    def run(*args)
+      compile # this is a simple list of things for the interpreter to do
+      output = exec *args
+      remove_class
+      output # return output
+    end
+  
+    # Check if the class is compiled?
+    #
+    # @return [Boolean] whether or not the class compiled
+    def compiled?
+      @path.dirname.join("#{@name}.class").exist?
+    end
+  
+    # Take given command line arguments, check them for validity, add them to a java command and run the command to execute the class
+    #
+    # @param [Array] args the command-line arguments to be passed to the Java program
+    # @return [String] the output of the program execution
+    def exec(*args)
+      raise RunnerException, "Class #{fullname} cannot be run because it is not compiled" unless compiled?
+      command = "java #{fullname}"
+      args.each do |arg|
+        arg = arg.to_s
+        raise RunnerException, "Invalid command-line argument: #{arg}" unless arg.match ARGFORMAT
+        command << ' '
+        command << arg
+      end
+      `#{command}`
+    end
+  
+    # Inspect incorporates meaningful data like name, location and whether class is compiled
+    # @return [String] useful data about the current object
+    def inspect
+      "[Java Class, name: #{fullname}, path: #{@path}, #{ compiled? ? 'Compiled' : 'Not Compiled'}]"
+    end
+    
+    # The format for command-line arguments
+    ARGFORMAT = /^[\-a-zA-Z@][a-zA-Z0-9\-:="'@]*$/.freeze
+    # The format for classnames, e.g. com.example.projects.Shape
+    FORMAT = /^([a-z_][a-z0-9_]*\.)*[A-Z][a-z0-9_]*$/.freeze
+    
+    
+  end
+  
+  # Methods in the eigenclass of Java
+  class << self
+    # Find a package using Package.get
+    #
+    # @param [String] name the name of the package to be found
+    # @return [JavaHead::Package] the package corresponding to name
+    def package(name)
+      Package.get(name)
+    end
+    
+    # Returns the class with no arguments
+    # Returns a new class with the given name if an argument is passed
+    #
+    # @param [String] name the name of the class to initialize
+    # @return [JavaHead::Class] the resulting class
+    def class(name = nil)
+      return super() if name.eql? nil
+      Class.new(name)
+    end
+    
+    # Creates either a class or a package
+    # depending on the format of the given string
+    #
+    # @param [String] name the name of the child element
+    # @return [JavaHead::Package, JavaHead::Class] the resulting package or class object
+    def member(name)
+      if name.match Class::FORMAT
+        self.class(name)
+      else
+        package(name)
+      end
+    end
+    
+    # > is an alias for member
+    alias > member
+  end
+  
+  # An array of Pathnames representing the CLASSPATH environment variable
+  # Defaults to the current values of the $CLASSPATH environment variable
+  CLASSPATH = [Pathname.new('.')]
+  
+  if ENV['CLASSPATH'] # if there is a CLASSPATH environment variable, let's use it.
+    ENV['CLASSPATH'].split(':').each do |string| # Add all class path env variables to the CLASSPATH as Pathnames
+      CLASSPATH.push( Pathname.new(string) )
+    end
+  end
+  
+  CLASSPATH.uniq!
+  
+  # General Java::Class exception
+  class ClassException < StandardError
+  end
+  # General Java::Package exception
+  class PackageException < StandardError
+  end
+  
+  # Represents exceptions while compiling
+  class CompilerException < StandardError
+  end
+  
+  
+  # Represents exceptions while running
+  class RunnerException < StandardError
+  end
+  
+end
+
+class String
+  # This method allows more convenience in initializing JavaHead objects.
+  # For instance:
+  # Java::Package.get('com.example.shapes')
+  # to be written:
+  # 'com.example.shapes'.java
+  # and
+  # Java::Class.new('com.example.shapes.Circle')
+  # to be written as
+  # 'com.example.shapes.Circle'.java
+  #
+  # @return [JavaHead::Package, JavaHead::Class] JavaHead.member(self)
+  def java
+    JavaHead.member self
+  end
+end

data/test/src/com/example/projects/broken/Broken.java

@@ -0,0 +1,5 @@
+package com.example.projects.broken;
+
+public class Broken extends NotEvenSure {
+	Cause a syntax error;
+}

data/test/src/com/example/projects/safe/Safe.java

@@ -0,0 +1,19 @@
+package com.example.projects.safe;
+
+public class Safe {
+	private int a;
+	
+	public Safe(int a) {
+		this.a = a;
+	}
+	
+	public int getA() {
+		return a;
+	}
+	
+	// This class is executable and outputs the first argument it is passed
+	public static void main(String[] args) {
+		String arg = args[0];
+		System.out.println(arg);
+	}
+}

data/test/test_class.rb

@@ -0,0 +1,40 @@
+require 'minitest/autorun'
+require 'colorize'
+require 'java_head'
+
+
+class TestClass < MiniTest::Test
+  
+  def setup
+    JavaHead::CLASSPATH.push( Pathname.new("#{__dir__}/src") )
+    @safe = JavaHead::Class.new('com.example.projects.safe.Safe')
+    @broken = JavaHead::Class.new('com.example.projects.broken.Broken')
+  end
+  
+  def test_safe_class_should_compile
+    @safe.compile
+    assert @safe.compiled?
+    @safe.remove_class
+    refute @safe.compiled?
+  end
+  
+  def test_safe_class_should_run
+    Dir.chdir "#{__dir__}/src" do
+      output = @safe.run('Input')
+      assert_equal output.chomp, 'Input'
+    end
+  end
+  
+  def test_broken_class_should_not_compile
+    assert_raises JavaHead::CompilerException do
+      puts
+      puts 'THE FOLLOWING JAVA ERROR IS EXPECTED, WE ARE TESTING THAT BROKEN CLASSES SHOULD NOT COMPILE'
+      @broken.compile()
+    end
+    @broken.remove_class
+    refute @broken.compiled?
+  end
+  
+  
+  
+end

data/test/test_package.rb

@@ -0,0 +1,33 @@
+require 'minitest/autorun'
+require 'java_head'
+
+class TestPackage < MiniTest::Test
+  def setup
+    JavaHead::CLASSPATH.push( Pathname.new("#{__dir__}/src") )
+    @package = JavaHead::Package.get 'com.example'
+  end
+  
+  def test_package_should_match_directory
+    assert_equal @package.path, Pathname.new("#{__dir__}/src/com/example")
+    assert_equal @package.superpackage, JavaHead::Package.get('com')
+    assert_equal @package.subpackage('projects'), JavaHead::Package.get('com.example.projects')
+  end
+  
+  def test_safe_package_should_compile
+    pkg = @package > 'projects.safe'
+    pkg.compile
+    assert pkg.compiled?
+    pkg.remove_class
+    refute pkg.compiled?
+  end
+  
+  def test_broken_package_should_not_compile
+    pkg = @package > 'projects.broken'
+    assert_raises JavaHead::CompilerException do
+      pkg.compile
+    end
+    refute pkg.compiled?
+  end
+  
+  
+end

data/test/test_regex.rb

@@ -0,0 +1,45 @@
+require 'minitest/autorun'
+require 'java_head'
+
+class TestRegex < MiniTest::Test
+  
+  def test_package_format
+    good = ['com.example.asdf','_name','hello.asdf']
+    bad  = ['com.example.','Name','arg-','-hello.world']
+    
+    good.each do |name|
+      assert name.match(JavaHead::Package::FORMAT)
+    end
+    
+    bad.each do |name|
+      refute name.match(JavaHead::Package::FORMAT)
+    end
+  end
+  
+  def test_class_format
+    good = ['com.example.Name','A','Map','a.b.c.d.e.f.Name']
+    bad  = ['3Package','com.example.-asdf','hello','A-name']
+    
+    good.each do |name|
+      assert name.match(JavaHead::Class::FORMAT)
+    end
+    
+    bad.each do |name|
+      refute name.match(JavaHead::Class::FORMAT)
+    end
+  end
+  
+  def test_argument_format
+    good = ['arg1','hello','-g:none','a=1','asdf="d"']
+    bad  = [';asdf','%%%']
+    
+    good.each do |arg|
+      assert arg.match(JavaHead::Class::ARGFORMAT)
+    end
+    bad.each do |arg|
+      refute arg.match(JavaHead::Class::ARGFORMAT)
+    end
+  end
+  
+  
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: java_head
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- AndrewTLee
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-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.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !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: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.3
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.4.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.4.3
+description: JavaHead contains classes to reprsent Java packages and classes and execute
+  them in Ruby. Use this in scripts to run Java programs from Ruby, or in IRB to develop
+  Java in a sensible environment
+email:
+- andytaelee@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- java_head.gemspec
+- lib/java_head.rb
+- lib/java_head/version.rb
+- test/src/com/example/projects/broken/Broken.java
+- test/src/com/example/projects/safe/Safe.java
+- test/test_class.rb
+- test/test_package.rb
+- test/test_regex.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+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.4.3
+signing_key: 
+specification_version: 4
+summary: Represent, compile, and run Java code in Ruby.
+test_files:
+- test/src/com/example/projects/broken/Broken.java
+- test/src/com/example/projects/safe/Safe.java
+- test/test_class.rb
+- test/test_package.rb
+- test/test_regex.rb