Opal 0.2.5.0

data/lib/opal.rb

@@ -0,0 +1,527 @@
+#!/usr/bin/env ruby
+# This is the main file for Opal.
+
+class Object
+	def about
+		if defined?(Colored)
+			return "-- " + self.class.name.cyan.bold + " methods".magenta.bold + " --\n" + self.methods(false).join("\n").green.bold.underline + "\n" + self.private_methods(false).join("\n").red.bold.underline
+		else
+			return "-- #{self.class.name} methods --\n" + self.methods(false).join("\n") + "\n" +  self.private_methods(false).join("\n")
+		end
+	end
+	def htdoc
+		return <<EOF
+<div style="background-color: black; color: white; font-family: Courier New; padding: 7px;">
+-- <strong style="color: cyan;">#{self.class.name}</strong> <strong style="color: magenta;">methods</strong> --
+<div style="color: lime; text-decoration: underline;">
+#{self.methods(false).join("<br/>\n")}
+</div>
+<div style="color: red; text-decoration: underline;">
+#{self.private_methods(false).join("<br/>\n")}
+</div>
+</div>
+EOF
+	end
+	def oidb
+		puts self.about
+	end
+	def me
+		self
+	end
+end
+
+class Module
+	def about
+		if defined?(Colored)
+			sc = " < " + "Module".cyan.bold
+			return "-- " + self.name.cyan.bold + sc + " methods".magenta.bold + " --\n" + (self.instance_methods(false)).join("\n").green.bold.underline + "\n" +  (self.private_instance_methods(false)).join("\n").red.bold.underline + "\n-- " + self.name.cyan.bold + sc + " namespaces".magenta.bold + " --\n" + (self.constants).join("\n").blue.bold.underline
+		else
+			sc = " < " + "Module"
+			return "-- #{self.name + sc} methods --\n" + (self.instance_methods(false)).join("\n") + "\n" +  (self.private_instance_methods(false)).join("\n") + "\n-- #{self.name + sc} namespaces --\n" + (self.constants).join("\n")
+		end
+	end
+	def htdoc(lsuper=false)
+		sc = " < <strong style=\"color: cyan;\">" + "Module" + "</strong>"
+		return <<EOF
+<div style="background-color: black; color: white; font-family: Courier New; padding: 7px;">
+-- <strong style="color: cyan;">#{self.name}</strong>#{sc} <strong style="color: magenta;">methods</strong> --
+<div style="color: lime; text-decoration: underline;">
+#{(self.instance_methods(false)).join("<br/>\n")}
+</div>
+<div style="color: red; text-decoration: underline;">
+#{self.private_instance_methods(false).join("<br/>\n")}
+</div>
+-- <strong style="color: cyan;">#{self.name}</strong>#{sc} <strong style="color: magenta;">namespaces</strong> --
+<div style="color: lightblue; text-decoration: underline;">
+#{(self.constants).join("<br/>\n")}
+</div>
+</div>
+EOF
+	end
+end
+
+class Class
+	def about
+		if defined?(Colored)
+			sc = ""
+			sc = " < " + self.superclass.name.cyan.bold if self.superclass
+			return "-- " + self.name.cyan.bold + sc + " methods".magenta.bold + " --\n" + (self.methods(self == Object) - self.instance_methods(false)).join("\n").yellow.bold.underline + "\n" +  (self.private_methods(self == Object) - self.private_instance_methods(self == Object)).join("\n").red.bold.underline + "\n-- " + self.name.cyan.bold + " < " + sc + " instance methods".magenta.bold + " --\n" + self.instance_methods(self == Object).join("\n").green.bold.underline + "\n" +  (self.private_instance_methods(self == Object)).join("\n").red.bold.underline + "\n-- " + self.name.cyan.bold + sc + " namespaces".magenta.bold + " --\n" + (self.constants).join("\n").blue.bold.underline
+		else
+			sc = ""
+			sc = " < " + self.superclass.name if self.superclass
+			return "-- #{self.name + sc} methods --\n" + (self.methods(self == Object) - self.instance_methods(self == Object)).join("\n") + "\n" +  (self.private_methods(self == Object) - self.private_instance_methods(self == Object)).join("\n") + "\n-- #{self.name + sc} instance methods --\n" + self.instance_methods(self == Object).join("\n") + "\n" +  (self.private_instance_methods(self == Object)).join("\n") + "\n-- #{self.name + sc} namespaces --\n" + (self.constants).join("\n")
+		end
+	end
+	def htdoc(lsuper=false)
+		a1 = "" ; a2 = ""
+		a1 = "<a href=\"#{self.superclass.name + ".doc.htm" rescue ""}\" style=\"color: cyan;\">" if lsuper
+		a2 = "</a>" if lsuper
+		sc = ""
+		sc = " < <strong style=\"color: cyan;\">" + a1 + self.superclass.name + a2 + "</strong>" if self.superclass
+		return <<EOF
+<div style="background-color: black; color: white; font-family: Courier New; padding: 7px;">
+-- <strong style="color: cyan;">#{self.name}</strong>#{sc} <strong style="color: magenta;">methods</strong> --
+<div style="color: yellow; text-decoration: underline;">
+#{(self.methods(self == Object) - self.instance_methods(self == Object)).join("<br/>\n")}
+</div>
+<div style="color: red; text-decoration: underline;">
+#{(self.private_methods(self == Object) - self.private_instance_methods(self == Object)).join(" private!<br/>\n")}
+</div>
+-- <strong style="color: cyan;">#{self.name}</strong>#{sc} <strong style="color: magenta;">instance methods</strong> --
+<div style="color: lime; text-decoration: underline;">
+#{(self.instance_methods(self == Object)).join("<br/>\n")}
+</div>
+<div style="color: red; text-decoration: underline;">
+#{(self.private_instance_methods(self == Object)).join(" private!<br/>\n")}
+</div>
+-- <strong style="color: cyan;">#{self.name}</strong>#{sc} <strong style="color: magenta;">namespaces</strong> --
+<div style="color: lightblue; text-decoration: underline;">
+#{(self.constants).join("<br/>\n")}
+</div>
+</div>
+EOF
+	end
+end
+
+# = Opal
+# === A neat language directly into Ruby code.
+# This is Opal. It has cool syntax. It uses all of the same classes, base, etc. as Ruby!
+# * Shell like
+# * As fast as Ruby
+# * Programs are easily translated
+# * Interactive Shell
+# And much more... Here's a comparison: Ruby code...
+#     "Hello World".gsub("l", "d") #=> Heddo Wordd
+# vs. Opal code...
+#     "Hello World" gsub "l" "d" -- => Heddo Wordd
+# But just to tell you, the Ruby code:
+#     exit 1
+# or something similar is equivlant to the Opal code:
+#     Kernel exit 1 -- or (System quit)
+# Why? Because Opal would process the Ruby code as
+#     exit.send(:'1')
+# 'cause it thinks it's a method.
+#
+# I forgot to mention variables. They're different than your general Ruby variables. No, these are special:
+#     monkey = Animal.new("Monkey")
+# That's Ruby, but what about Opal?
+#     %monkey= Animal new "Monkey"
+# And to get it again:
+#     %monkey
+# Don't forget to use this exact syntax,
+#     %monkey = Animal new "Monkey"
+# or
+#     % monkey
+# won't work.
+#
+module Opal ; extend self
+	
+	# A standard Opal error.
+	class OpalError < Exception ; end
+	# An Opal compiler error.
+	class OpalCompileError < OpalError ; end
+	# An Opal syntax error.
+	class OpalSyntaxError < OpalError ; end
+	# An Opal runtime error.
+	class OpalRuntimeError < OpalError ; end
+	# An Opal system error. Raised when I/O errors, etc.
+	class OpalSystemError < OpalError ; end
+	
+	# This is Version. Opal uses it for it's non-Float Version.
+	class Version
+		
+		attr_accessor :arr
+		
+		# Create a new Version.
+		def initialize(major, minor, build, revision)
+			@arr = [major, minor, build, revision]
+		end
+		
+		# Add two versions.
+		def +(v)
+			raise ArgumentError unless v.class == Version
+			(0..3).to_a.each { |t| @arr[t] += v.arr[t] }
+		end
+		
+		# Increment the version by one.
+		def inc!
+			@arr[3] += 1
+			if @arr[3] == 10
+				@arr[3] = 0
+				@arr[2] += 1
+				if @arr[2] == 10
+					@arr[2] = 0
+					@arr[1] += 1
+					if @arr[1] == 10
+						@arr[1] = 0
+						@arr[0] += 1
+					end
+				end
+			end
+			return self
+		end
+		
+		# Inspect the object.
+		def inspect
+			@arr.join "."
+		end
+		
+		alias to_s inspect
+		
+	end
+	
+	# Get the version.
+	def version ; Opal::Version.new(0,2,5,0) ; end
+	
+	# The Environ.
+	module Env ; extend self
+		module System ; extend self
+			# Shortcut to "version"
+			def version
+				Opal.version
+			end
+			
+			# Shortcut for Ruby "print".
+			def out(s)
+				print s
+			end
+			
+			# Shortcut for Ruby "puts".
+			def put(s)
+				puts s
+			end
+			
+			# Shortcut for Ruby "$stdin.read".
+			def tin
+				return $stdin.read
+			end
+			
+			# Shortcut for Ruby "$stdin.readline".
+			def get
+				return $stdin.readline
+			end
+			
+			# Shortcut for making arrays.
+			def array(*args)
+				return args
+			end
+			
+			# Shortcut for Ruby "require".
+			def import(name)
+				require name.to_s
+			end
+			
+			# Shortcut for making blocks.
+			def block(code)
+				return proc do
+					Opal.opal_eval code
+				end
+			end
+			
+			# Shortcut for making classes (Opal: Namespaces).
+			def namespace(n)
+				return eval("Opal::Env::#{n.to_s} = Class.new")
+			end
+			
+			# Shortcut for defining methods under classes (Opal: Namespaces).
+			def namespace_def(ns, nm, code, *argnm)
+				eval("Opal::Env::#{ns.to_s}.class_eval do\ndef #{nm.to_s}(#{argnm.join(", ")})\n#{code}\nend\nend")
+			end
+			
+			# Equal to "IO.popen".
+			def run(s)
+				IO.popen(s).read
+			end
+			
+			# Quit. (Exit)
+			def quit
+				exit
+			end
+		end
+		def quit
+			exit
+		end
+		def bind(vars)
+			binding
+		end
+	end
+	
+	# old! The Opal Compiler (to ruby)
+	def compile(s, head=true)
+		rbcode = ""
+		rbcode << "#!/usr/bin/env ruby\n# Compiled by DCWare Opal #{Opal.version.to_s}\nrequire 'opal'\ninclude Opal::Env\ncmdargs = ARGV\n" if head
+		s.split(/;|\n/).each do |line|
+			rbcode << Opal.transform(line) + "\n"
+		end
+		return rbcode
+	end
+	
+	# old! Transform Opal code into Ruby code.
+	def transform(line)
+		ret = ""
+		ln = line.split(" ")
+		ln.each do |pt|
+			pt.gsub! "`", " "
+			if pt =~ /^%/
+				pt[0] = ''
+				ln[ln.index(pt)] = "$vars[:#{pt}]" if $useglobal
+			end
+		end
+		if line =~ /--*/
+			line[0..1] = ''
+			ret = "##{line}"
+		elsif line =~ /^#!/
+		elsif line =~ /%*=\ /
+			enil = line.split(/%*=\ /)
+			enil[0][0] = ''
+			c = Opal.transform(enil[1])
+			if $useglobal
+				ret = "$vars[:#{enil[0]}] = #{c}"
+			else
+				ret = "#{enil[0]} = #{c}"
+			end
+		elsif ln.length > 2
+			ret = "#{ln[0]}.#{ln[1]}(#{ln[2..-1].join(", ")})"
+		elsif ln.length > 1
+			ret = "#{ln[0]}.#{ln[1]}"
+		elsif ln.length == 1
+			ret = ln[0]
+		end
+		return ret
+	end
+	
+	# updated! The Opal interactive mode. Requires "colored" and "readline".
+	def interactive
+		require 'colored' unless defined?(Colored)
+		require 'readline' unless defined?(Readline)
+		yexit = false
+		v = {:cmdargs => [], :file => "(opal-interactive)"}
+		trap "INT" do
+			yexit = true
+		end
+		until yexit
+			$useglobal = true
+			print "(opal-interactive)".cyan.bold + ">> ".magenta.bold
+			s = (Readline.readline rescue $stdin.readline.chomp)
+			begin
+				rets = []
+				s.split(';').each do |cm|
+					rets << Opal.run(cm, v).inspect.green.bold
+				end
+				puts "=> ".magenta.bold + rets.join("; ".magenta.bold)
+			rescue SystemExit
+				yexit = true
+			rescue Exception
+				puts ($!.class.name.sub(/^Opal::/, "") + ": ").magenta.bold + $!.message.red.bold
+			end
+		end
+		$useglobal = nil
+	end
+	
+	# updated! Evaluate!
+	def opal_eval(s, args=[], fname="(opal-eval)")
+		v = {:cmdargs => args, :file => fname}
+		lns = s.split(/\r|\n|;/)
+		lns.each do |line|
+			Opal.run(line, v)
+		end
+	end
+	
+	# new!
+	# The parser. <i>may contain traces of <b>regular expressions</b>.</i>
+	def run(linz, vars={})
+		line = linz.gsub(/[ \t]*--[^\n]+/, "")
+		if line =~ /^%[A-Za-z0-9]+\=\ /
+			eq = line.split /\=\ /
+			eq[0].sub! /^%/, ""
+			vars[eq[0].intern] = Opal.run(eq[1])
+			return true
+		elsif line =~ /^[\ ]*$/
+			return true
+		else
+			ln = line.split(" ")
+			ln.each do |pt|
+				pt.gsub! "`", " "
+				vars.each do |nm, vl|
+					pt.sub! "%#{nm.to_s}", "vars[#{nm.inspect}]"
+				end
+			end
+			Opal.joins(ln)
+			Opal.joins(ln, /^'/, /'$/)
+			Opal.joins(ln, /^\[/, /\]$/)
+			Opal.joins(ln, /^\{/, /\}$/)
+			on = eval(ln[0], Opal::Env.bind(vars)) rescue nil
+			raise OpalCompileError, "Cannot work on \"#{ln[0]}\" because it does not exist." unless on
+			mt = (ln[1] or "me").intern
+			rgs = []
+			(ln[2..-1] or []).each do |r|
+				rgs << eval(r)
+			end
+			begin
+				return on.send(mt, *rgs)
+			rescue NameError
+				raise OpalCompileError, $!.message
+			rescue TypeError
+				raise OpalSyntaxError, $!.message
+			rescue NoMethodError
+				raise OpalCompileError, $!.message
+			rescue SyntaxError
+				raise OpalSyntaxError, $!.message
+			rescue RuntimeError
+				raise OpalRuntimeError, $!.message
+			end
+		end
+	end
+	
+	# new! Joins an array based on delimiters.
+	def joins(a, sreg=/^"/, ereg=/"$/)
+		inst = false
+		a.each do |pt|
+			inst = a.index(pt) if (pt =~ sreg) and not (inst)
+			if (pt =~ ereg) and (inst)
+				rng = inst..(a.index(pt))
+				a[rng] = a[rng].join(" ")
+				inst = false
+			end
+		end
+		return a
+	end
+	
+end
+
+def errwrite(s)
+	$errwrite_used = true
+	$stderr.write s + "\n" unless $silent
+	exit 1
+end
+
+if __FILE__ == $0
+	action = (ARGV[0].dup rescue nil)
+	act_on = ARGV[1]
+	args = ARGV[2..-1]
+	if action =~ /^nocolor-/
+		$nocolor = true
+		action.sub! /nocolor-*/, ""
+	end
+	if action =~ /^silent-/
+		$silent = true
+		action.sub! /silent-*/, ""
+	end
+	require 'opcolor'
+	puts "DCWare Opal ".cyan.underline + Opal.version.to_s.yellow.bold.underline unless $silent
+	unless action and act_on
+		unless (action) and ((action.to_s.downcase == "shell") or (action.to_s.downcase == "help") or (action.to_s.downcase == "test")) # ...
+			errwrite "Error: ".magenta.bold + "No action, or nothing to act on.".red.bold
+		end
+	end
+	ay = ""
+	ay = " ".yellow + act_on.yellow.bold if act_on
+	puts "Action: ".yellow + action.downcase.yellow.bold + ay unless $silent
+	puts unless $silent
+	begin
+		case action.downcase
+			when "test"
+				Opal.opal_eval <<EOF
+Kernel puts "testing numerics..."
+Kernel print "96 + 37 = "
+%t1= 96 + 37
+Kernel puts %t1
+Kernel puts "okay."
+Kernel puts "testing blocks..."
+%t2= System block "Kernel puts 'okay.'"
+%t2 call
+Kernel puts "testing strings..."
+Kernel print "'Blah' in upper case is: "
+%t3= 'Blah' upcase
+Kernel print %t3
+Kernel print ", and 'FrOdO' in lower case is: "
+%t4= 'FrOdO' downcase
+Kernel puts %t4
+Kernel puts "okay."
+Kernel puts "testing sleep..."
+Kernel puts "will sleep for 3 seconds."
+Kernel sleep 3
+Kernel puts "okay."
+Kernel puts "testing comments..."
+Kernel puts "you should not see the message 'Hello' if all goes well below:"
+-- Kernel puts 'Hello'
+Kernel puts "okay."
+Kernel puts "all done!"
+EOF
+			when "run"
+				Opal.opal_eval File.open(act_on, "r").read, args, act_on
+			when "compile"
+				warn "Compile is deprecated."
+				print "Please wait... " unless $silent
+				f = File.open(act_on.gsub(".opl", ".cop.rb"), "w")
+				c = Opal.compile(File.open(act_on, "r").read)
+				f.write c
+				f.close
+				puts "done! (#{c.size}B)" unless $silent
+			when "shell"
+				Opal.interactive
+			when "lookup"
+				for a in ([act_on] + args)
+					begin
+						eval("#{a}.oidb")
+						puts ("~" * 12).red
+					rescue Exception
+						$stderr.write "Opal OIDB ".blue.bold + "could not find #{a}.\nPlease make sure you spelled the item correctly.\n".magenta.bold unless $silent
+					end
+				end
+			when "htlook"
+				for a in ([act_on] + args)
+					begin
+						File.open(a + ".doc.htm", "w") do |f|
+							f.write eval("#{a}.htdoc")
+						end
+						puts "Opal OIDB ".blue.bold + "put the result into ".green.bold + "#{a}.doc.htm".yellow.bold + ".".green.bold unless $silent
+					rescue Exception
+						$stderr.write "Opal OIDB ".blue.bold + "could not find #{a}.\nPlease make sure you spelled the item correctly.\n".magenta.bold unless $silent
+					end
+				end
+			when "help"
+				puts $0.blue.bold + " (nocolor-)(silent-)".green.bold
+				puts "...\t\thelp".yellow.bold
+				puts "...\t\trun ".yellow.bold + "<file> <args...>".green.bold
+				puts "...\t\tcompile ".yellow.bold + "<file> (=> \"file.cop.rb\")".green.bold
+				puts "...\t\tshell ".yellow.bold
+				puts "...\t\tlookup ".yellow.bold + "<object...>".green.bold
+				puts "...\t\thtlook ".yellow.bold + "<object...>".green.bold
+			else
+				errwrite "Opal ".blue.bold + "did not understand the action ".magenta.bold + action.yellow.bold + ".\nTry ".magenta.bold + "help".yellow.bold + ".".magenta.bold
+		end
+	rescue SystemExit
+		exit 1 if $errwrite_used
+	rescue Exception
+		$stderr.write "#{action.downcase.capitalize} failed with #{$!.class.name} status!\nDetails:\n".magenta.bold unless $silent
+		$stderr.write $!.message.red.underline + "\n" unless $silent
+		ecd = 0
+		$!.class.name.split(" ").each do |cd|
+			ecd += cd[0]
+		end
+		exit ecd
+	end
+	puts unless $silent
+	puts "#{action.downcase.capitalize} finished!".green.bold unless $silent
+end

data/lib/opcolor.rb

@@ -0,0 +1,94 @@
+require 'Win32/Console/ANSI' if PLATFORM =~ /win32/
+
+##
+# cute.
+# 
+#   >> "this is red".red
+#  
+#   >> "this is red with a blue background (read: ugly)".red_on_blue
+#
+#   >> "this is red with an underline".red.underline
+#
+#   >> "this is really bold and really blue".bold.blue
+#
+#   >> Colored.red "This is red" # but this part is mostly untested
+#
+# modded to opal standards
+module Colored
+  extend self
+
+  COLORS = { 
+    'black'   => 30,
+    'red'     => 31, 
+    'green'   => 32, 
+    'yellow'  => 33,
+    'blue'    => 34,
+    'magenta' => 35,
+    'cyan'    => 36,
+    'white'   => 37
+  }
+
+  EXTRAS = {
+    'clear'     => 0, 
+    'bold'      => 1,
+    'underline' => 4,
+    'reversed'  => 7
+  }
+  
+  COLORS.each do |color, value|
+    define_method(color) do 
+      colorize(self, :foreground => color)
+    end
+
+    define_method("on_#{color}") do
+      colorize(self, :background => color)
+    end
+
+    COLORS.each do |highlight, value|
+      next if color == highlight
+      define_method("#{color}_on_#{highlight}") do
+        colorize(self, :foreground => color, :background => highlight)
+      end
+    end
+  end
+
+  EXTRAS.each do |extra, value|
+    next if extra == 'clear'
+    define_method(extra) do 
+      colorize(self, :extra => extra)
+    end
+  end
+
+  define_method(:to_eol) do
+    tmp = sub(/^(\e\[[\[\e0-9;m]+m)/, "\\1\e[2K")
+    if tmp == self
+      return "\e[2K" << self
+    end
+    tmp
+  end
+
+  def colorize(string, options = {})
+    colored = ""
+    colored = [color(options[:foreground]), color("on_#{options[:background]}"), extra(options[:extra])].compact * '' unless $nocolor
+    colored << string
+    colored << extra(:clear)
+  end
+
+  def colors
+    @@colors ||= COLORS.keys.sort
+  end
+
+  def extra(extra_name)
+    extra_name = extra_name.to_s
+    "\e[#{EXTRAS[extra_name]}m" if EXTRAS[extra_name]
+  end
+
+  def color(color_name)
+    background = color_name.to_s =~ /on_/
+    color_name = color_name.to_s.sub('on_', '')
+    return unless color_name && COLORS[color_name]
+    "\e[#{COLORS[color_name] + (background ? 10 : 0)}m" 
+  end
+end unless Object.const_defined? :Colored
+
+String.send(:include, Colored)

metadata

@@ -0,0 +1,47 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4
+specification_version: 1
+name: Opal
+version: !ruby/object:Gem::Version 
+  version: 0.2.5.0
+date: 2007-11-10 00:00:00 -08:00
+summary: The Opal language for simplicity and Smalltalk-like syntax.
+require_paths: 
+- lib
+email: dcwareadmin@gmail.com
+homepage: http://www.dcware.co.nr/
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- DCWare Inc.
+files: 
+- lib/opcolor.rb
+- lib/opal.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+