mirah 0.0.7-java → 0.0.8-java

data/examples/macros/string-each-char.mirah

@@ -0,0 +1,14 @@
+
+macro def eachChar(value, &block)
+
+    quote { 
+        `value`.toCharArray.each do | my_char |
+            `block.body`
+        end 
+    }
+end
+
+eachChar('laat de leeeuw niet in zijn hempie staan') do | my_char |
+    puts my_char
+end
+

data/examples/maven/README.txt

@@ -0,0 +1,2 @@
+This is a sample project that uses the Mirah plugin for Maven to
+build and compile source.

data/examples/maven/pom.xml

@@ -0,0 +1,23 @@
+<project xmlns="http://maven.apache.org/POM/5.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <artifactId>yourArtifact</artifactId>
+  <groupId>yourGroup</groupId>
+  <version>0.0.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+  <name>Sample Maven build for Mirah source</name>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.mirah.maven</groupId>
+        <artifactId>maven-mirah-plugin</artifactId>
+        <version>1.0</version>
+        <executions>
+          <execution>
+            <goals><goal>compile</goal></goals>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>

data/examples/maven/src/main/mirah/hello_mirah.mirah

@@ -0,0 +1,9 @@
+package dummy
+
+class HelloMirah
+  def print_hello
+    5.times do
+      puts "Hello, Mirah!"
+    end
+  end
+end

data/examples/rosettacode/100-doors.mirah

@@ -0,0 +1,44 @@
+import java.util.ArrayList
+
+class Door
+	:state
+
+	def initialize
+		@state=false
+	end
+ 
+	def closed?; !@state; end
+	def open?; @state; end
+
+	def close; @state=false; end
+	def open; @state=true; end
+ 
+	def toggle
+		if closed?
+			open
+		else
+			close
+		end
+	end
+ 
+	def toString; Boolean.toString(@state); end
+end
+ 
+doors=ArrayList.new
+1.upto(100) do
+    doors.add(Door.new)
+end 
+
+1.upto(100) do |multiplier|
+    index = 0
+    doors.each do |door|
+        Door(door).toggle if (index+1)%multiplier == 0
+        index += 1
+    end
+end
+
+i = 0
+doors.each do |door| 
+    puts "Door #{i+1} is #{door}."
+    i+=1
+end

data/examples/rosettacode/99-bottles-of-beer.mirah

@@ -0,0 +1,13 @@
+plural = 's'
+99.downto(1) do |i|
+  puts "#{i} bottle#{plural} of beer on the wall,"
+  puts "#{i} bottle#{plural} of beer"
+  puts "Take one down, pass it around!"
+  plural = '' if i - 1 == 1
+  if i > 1
+    puts "#{i-1} bottle#{plural} of beer on the wall!"
+    puts
+  else
+    puts "No more bottles of beer on the wall!"
+  end
+end

data/examples/rosettacode/README.txt

@@ -0,0 +1,9 @@
+
+This example set is all the code for Mirah from the Rosetta Code wiki
+(http://rosettacode.org/. 
+
+This code is the canonical source for the wiki. Please add as many more 
+samples as you'd like. Either add the sample here and send a pull request
+to the project owners, or add a sample to the Rosetta Code wiki and send
+a message to the project owners. Either way, we'd like to try and keep
+the wiki page and this repository synchronized. 

data/examples/rosettacode/boolean-values.mirah

@@ -0,0 +1,29 @@
+import java.util.ArrayList
+import java.util.HashMap
+
+# booleans 
+puts 'true is true' if true
+puts 'false is false' if (!false)
+
+# lists treated as booleans
+x = ArrayList.new
+puts "empty array is true" if x
+x.add("an element")
+puts "full array is true" if x
+puts "isEmpty() is false" if !x.isEmpty()
+
+# maps treated as booleans
+map = HashMap.new
+puts "empty map is true" if map
+map.put('a', '1')
+puts "full map is true" if map
+puts "size() is 0 is false" if !(map.size() == 0)
+
+# these things do not compile
+# value = nil   # ==> cannot assign nil to Boolean value
+# puts 'nil is false' if false == nil  # ==> cannot compare boolean to nil
+# puts '0 is false' if (0 == false)    # ==> cannot compare int to false
+
+#puts 'TRUE is true' if TRUE   # ==> TRUE does not exist
+#puts 'FALSE is false' if !FALSE   # ==> FALSE does not exist
+

data/examples/rosettacode/comments.mirah

@@ -0,0 +1,2 @@
+puts 'code' # I am a comment
+ 

data/examples/rosettacode/copy-a-string.mirah

@@ -0,0 +1,10 @@
+src = "Hello"
+new_alias = src
+
+puts 'interned strings are equal' if src == new_alias
+
+str_copy = String.new(src)
+puts 'non-interned strings are not equal' if str_copy != src
+puts 'compare strings with equals()' if str_copy.equals(src)
+
+

data/examples/rosettacode/count-occurrences-of-a-substring.mirah

@@ -0,0 +1,40 @@
+import java.util.regex.Pattern
+import java.util.regex.Matcher
+
+#The "remove and count the difference" method
+def count_substring(pattern:string, source:string)
+    (source.length() - source.replace(pattern, "").length()) / pattern.length()
+end
+ 
+puts count_substring("th", "the three truths")      # ==> 3
+puts count_substring("abab", "ababababab")          # ==> 2
+puts count_substring("a*b", "abaabba*bbaba*bbab")   # ==> 2
+
+
+# The "split and count" method
+def count_substring2(pattern:string, source:string)
+    # the result of split() will contain one more element than the delimiter
+	# the "-1" second argument makes it not discard trailing empty strings
+    source.split(Pattern.quote(pattern), -1).length - 1
+end
+
+puts count_substring2("th", "the three truths")      # ==> 3
+puts count_substring2("abab", "ababababab")          # ==> 2
+puts count_substring2("a*b", "abaabba*bbaba*bbab")   # ==> 2
+
+
+# This method does a match and counts how many times it matches
+def count_substring3(pattern:string, source:string)
+    result = 0
+    Matcher m = Pattern.compile(Pattern.quote(pattern)).matcher(source);
+    while (m.find())
+        result = result + 1
+    end
+    result
+end
+
+puts count_substring3("th", "the three truths")      # ==> 3
+puts count_substring3("abab", "ababababab")          # ==> 2
+puts count_substring3("a*b", "abaabba*bbaba*bbab")   # ==> 2
+
+

data/examples/rosettacode/create-a-file.mirah

@@ -0,0 +1,6 @@
+import java.io.File
+
+File.new('output.txt').createNewFile()
+File.new('docs').mkdir()
+File.new("docs#{File.separator}output.txt").createNewFile()
+

data/examples/rosettacode/empty-string.mirah

@@ -0,0 +1,9 @@
+
+empty_string1 = ""
+empty_string2 = String.new
+
+puts "empty string is empty" if empty_string1.isEmpty()
+puts "empty string has no length" if empty_string2.length() == 0
+puts "empty string is not nil" unless empty_string1 == nil
+
+

data/examples/rosettacode/factorial.mirah

@@ -0,0 +1,10 @@
+def factorial_iterative(n:int)
+    2.upto(n-1) do |i|
+        n *= i 
+    end
+    n
+end
+
+puts factorial_iterative 10
+
+

data/examples/rosettacode/fibonacci.mirah

@@ -0,0 +1,21 @@
+
+def fibonacci(n:int)
+    return n if n < 2
+    fibPrev = 1
+    fib = 1
+    3.upto(Math.abs(n)) do 
+        oldFib = fib
+        fib = fib + fibPrev
+        fibPrev = oldFib
+    end
+    fib * (n<0 ? int(Math.pow(n+1, -1)) : 1)
+end
+
+puts fibonacci 1
+puts fibonacci 2
+puts fibonacci 3
+puts fibonacci 4
+puts fibonacci 5
+puts fibonacci 6
+puts fibonacci 7
+

data/examples/rosettacode/file-size.mirah

@@ -0,0 +1,5 @@
+import java.io.File
+
+puts File.new('file-size.mirah').length()
+puts File.new("./#{File.separator}file-size.mirah").length()
+

data/examples/rosettacode/fizz-buzz.mirah

@@ -0,0 +1,21 @@
+1.upto(100) do |n|
+    print "Fizz" if a = ((n % 3) == 0)
+    print "Buzz" if b = ((n % 5) == 0) 
+    print n unless (a || b)
+    print "\n"
+end
+
+# a little more straight forward 
+1.upto(100) do |n|
+    if (n % 15) == 0
+        puts "FizzBuzz"
+    elsif (n % 5) == 0
+        puts "Buzz"
+    elsif (n % 3) == 0
+        puts "Fizz"
+    else
+        puts n
+    end
+end
+
+

data/examples/rosettacode/flatten-a-list.mirah

@@ -0,0 +1,24 @@
+import java.util.ArrayList
+import java.util.List
+import java.util.Collection
+
+def flatten(list: Collection) 
+    flatten(list, ArrayList.new)
+end
+def flatten(source: Collection, result: List)
+
+    source.each do |x|
+        if (Collection.class.isAssignableFrom(x.getClass())) 
+            flatten(Collection(x), result)  
+        else
+            result.add(x)
+            result  # if branches must return same type
+        end 
+    end
+    result
+end
+
+# creating a list-of-list-of-list fails currently, so constructor calls are needed
+source = [[1], 2, [[3, 4], 5], [[ArrayList.new]], [[[6]]], 7, 8, ArrayList.new]
+
+puts flatten(source)

data/examples/rosettacode/guess-the-number.mirah

@@ -0,0 +1,21 @@
+def getInput:int
+    s = System.console.readLine()
+    Integer.parseInt(s)
+end
+
+
+number = int(Math.random() * 10 + 1)
+
+puts "guess the number between 1 and 10"
+guessed = false
+while !guessed do
+    userNumber = getInput
+    if userNumber == number
+        guessed = true
+        puts "you guessed it"
+    elsif userNumber > number 
+        puts "too high"
+    else
+        puts "too low"        
+    end
+end

data/examples/rosettacode/is-string-numeric.mirah

@@ -0,0 +1,127 @@
+import java.text.NumberFormat
+import java.text.ParsePosition
+import java.util.Scanner
+
+# this first example relies on catching an exception, 
+# which is bad style and poorly performing in Java
+def is_numeric?(s:string)
+    begin
+        Double.parseDouble(s)
+        return true
+    rescue
+        return false
+    end
+end
+
+puts '123   is numeric' if is_numeric?('123')
+puts '-123  is numeric' if is_numeric?('-123')
+puts '123.1 is numeric' if is_numeric?('123.1')
+
+puts 'nil   is not numeric' unless is_numeric?(nil)
+puts "''    is not numeric" unless is_numeric?('')
+puts 'abc   is not numeric' unless is_numeric?('abc')
+puts '123-  is not numeric' unless is_numeric?('123-')
+puts '1.2.3 is not numeric' unless is_numeric?('1.2.3')
+
+
+# check every element of the string
+def is_numeric2?(s: string) 
+    if (s == nil || s.isEmpty()) 
+        return false 
+    end 
+    if (!s.startsWith('-')) 
+        if s.contains('-')
+            return false 
+        end
+    end 
+    
+    0.upto(s.length()-1) do |x|
+        c = s.charAt(x)
+        if ((x == 0) && (c == '-'.charAt(0)))
+            # negative number
+        elsif (c == '.'.charAt(0))
+            if (s.indexOf('.', x) > -1) 
+                return false # more than one period
+            end        
+        elsif (!Character.isDigit(c))
+            return false
+        end
+    end 
+    true
+end
+
+
+puts '123   is numeric' if is_numeric2?('123')
+puts '-123  is numeric' if is_numeric2?('-123')
+puts '123.1 is numeric' if is_numeric2?('123.1')
+
+puts 'nil   is not numeric' unless is_numeric2?(nil)
+puts "''    is not numeric" unless is_numeric2?('')
+puts 'abc   is not numeric' unless is_numeric2?('abc')
+puts '123-  is not numeric' unless is_numeric2?('123-')
+puts '1.2.3 is not numeric' unless is_numeric2?('1.2.3')
+
+
+
+# use a regular  expression 
+def is_numeric3?(s:string)
+  s == nil || s.matches("[-+]?\\d+(\\.\\d+)?")
+end
+
+puts '123   is numeric' if is_numeric3?('123')
+puts '-123  is numeric' if is_numeric3?('-123')
+puts '123.1 is numeric' if is_numeric3?('123.1')
+
+puts 'nil   is not numeric' unless is_numeric3?(nil)
+puts "''    is not numeric" unless is_numeric3?('')
+puts 'abc   is not numeric' unless is_numeric3?('abc')
+puts '123-  is not numeric' unless is_numeric3?('123-')
+puts '1.2.3 is not numeric' unless is_numeric3?('1.2.3')
+
+
+#  use the positional parser in the java.text.NumberFormat object 
+# (a more robust solution). If, after parsing, the parse position is at 
+# the end of the string, we can deduce that the entire string was a 
+# valid number.
+def is_numeric4?(s:string) 
+    return false if s == nil    
+    formatter = NumberFormat.getInstance()
+    pos = ParsePosition.new(0)
+    formatter.parse(s, pos)
+    s.length() == pos.getIndex()
+end
+
+
+puts '123   is numeric' if is_numeric4?('123')
+puts '-123  is numeric' if is_numeric4?('-123')
+puts '123.1 is numeric' if is_numeric4?('123.1')
+
+puts 'nil   is not numeric' unless is_numeric4?(nil)
+puts "''    is not numeric" unless is_numeric4?('')
+puts 'abc   is not numeric' unless is_numeric4?('abc')
+puts '123-  is not numeric' unless is_numeric4?('123-')
+puts '1.2.3 is not numeric' unless is_numeric4?('1.2.3')
+
+
+# use the java.util.Scanner object. Very useful if you have to 
+# scan multiple entries. Scanner also has similar methods for longs, 
+# shorts, bytes, doubles, floats, BigIntegers, and BigDecimals as well 
+# as methods for integral types where you may input a base/radix other than 
+# 10 (10 is the default, which can be changed using the useRadix method).
+def is_numeric5?(s:string)
+    return false if s == nil
+    Scanner sc = Scanner.new(s)
+    sc.hasNextDouble()
+end
+
+puts '123   is numeric' if is_numeric5?('123')
+puts '-123  is numeric' if is_numeric5?('-123')
+puts '123.1 is numeric' if is_numeric5?('123.1')
+
+puts 'nil   is not numeric' unless is_numeric5?(nil)
+puts "''    is not numeric" unless is_numeric5?('')
+puts 'abc   is not numeric' unless is_numeric5?('abc')
+puts '123-  is not numeric' unless is_numeric5?('123-')
+puts '1.2.3 is not numeric' unless is_numeric5?('1.2.3')
+
+