node-marshal 0.1.1

data/lib/node-marshal.rb

@@ -0,0 +1,64 @@
+require_relative '../ext/node-marshal/nodemarshal.so'
+require 'zlib'
+
+class NodeMarshal
+	# call-seq:
+	#   obj.to_compiled_rb(outfile, opts)
+	#
+	# Transforms node to the Ruby file
+	# - +outfile+ -- name of the output file
+	# - +opts+ -- Hash with options (+:compress+, +:so_path+)
+	#   +:compress+ can be +true+ or +false+, +:so_path+ is a test string 
+	#   with the command for nodemarshal.so inclusion (default is 
+	#   require_relative '../ext/node-marshal/nodemarshal.so')
+	def to_compiled_rb(outfile, *args)
+		compress = false
+		so_path = "require_relative '../ext/node-marshal/nodemarshal.so'"
+		if args.length > 0
+			opts = args[0]
+			if opts.has_key?(:compress)
+				compress = opts[:compress]
+			end
+			if opts.has_key?(:so_path)
+				so_path = opts[:so_path]
+			end
+		end
+		# Compression
+		if compress
+			zlib_include = "require 'zlib'"
+			data_txt = NodeMarshal.base85r_encode(Zlib::deflate(self.to_bin))
+			data_bin = "Zlib::inflate(NodeMarshal.base85r_decode(data_txt))"
+		else
+			zlib_include = "# No compression"
+			data_txt = self.to_text
+			data_bin = "NodeMarshal.base85r_decode(data_txt)"
+		end
+		# Document header
+		txt = <<EOS
+# Ruby compressed source code
+# RUBY_PLATFORM: #{RUBY_PLATFORM}
+# RUBY_VERSION: #{RUBY_VERSION}
+#{zlib_include}
+#{so_path}
+data_txt = <<DATABLOCK
+#{data_txt}
+DATABLOCK
+data_bin = #{data_bin}
+node = NodeMarshal.new(:binmemory, data_bin)
+node.filename = __FILE__
+node.filepath = File.expand_path(node.filename)
+node.compile.eval
+EOS
+		# Process input arguments
+		if outfile != nil
+			File.open(outfile, 'w') {|fp| fp << txt}
+		end
+		return txt
+	end
+
+	def self.compile_rb_file(outfile, inpfile, *args)
+		node = NodeMarshal.new(:srcfile, inpfile)
+		node.to_compiled_rb(outfile, *args)
+		return true
+	end
+end

data/test/lifegame.rb

@@ -0,0 +1,145 @@
+# Implementation of simple Convay's life game designed mainly
+# for node compiler testing
+#
+# (C) 2015 Alexey Voskov
+# License: 2-clause BSD
+module LifeGame
+
+# Representation of the cell of the game grid (field)
+# Keeps the state of the cell (EMPTY, FILLED, BORN, DEAD)
+# and neighbours of the cell (as array of pointers to another Cell
+# object examples)
+class Cell
+	EMPTY = 0
+	FILLED = 1
+	BORN = 2
+	DEAD = 3
+
+	attr_reader :value, :neighbours
+	def initialize
+		@value = EMPTY
+		@neighbours = []
+	end
+
+	def value=(val)
+		@value = val.to_i
+	end
+	
+	def neighbours=(val)
+		@neighbours = val
+	end
+
+	def chr
+		case @value
+		when EMPTY; '.'
+		when FILLED; 'O'
+		when BORN; '+'
+		when DEAD; '-'
+		else; '?'
+		end
+	end
+
+	def update
+		case @value
+		when BORN; @value = FILLED
+		when DEAD; @value = EMPTY
+		end
+	end
+end
+
+# Convay's life game grid (field)
+class Grid
+	public
+	def initialize(height, width)
+		width, height = width.to_i, height.to_i
+		raise "Invalid value of width" if (width < 3 || width > 100)
+		raise "Invalid value of height" if (height < 3 || height > 100)
+		@width, @height = width, height
+
+		@f = Array.new(@height) {|ind| Array.new(@width) {|ind| Cell.new }}
+		# Set neighbours for each cell
+		@@xy_shifts = [[-1, -1], [-1, 0], [-1, 1],
+			[0, -1], [0, 1],
+			[1, -1], [1, 0], [1, 1]]
+		(0...@height).each do |y|
+			(0...@width).each do |x|
+				# Calculate neighbours coordinates
+				xy = @@xy_shifts.map do |elem|
+					q = [elem[0] + y, elem[1] + x]
+					(q[0] < 0 || q[0] >= @height || q[1] < 0 || q[1] >= @width) ? nil : q
+				end
+				xy.compact!
+				# And transform them to the matrix
+				@f[y][x].neighbours = xy.map {|q| @f[q[0]][q[1]] }
+			end
+		end
+		self
+	end
+	# Initialize game field with one glider
+	def cfg_glider!
+		self.clear!
+		@f[1][2].value = Cell::FILLED
+		@f[2][3].value = Cell::FILLED
+		@f[3][1].value = Cell::FILLED
+		@f[3][2].value = Cell::FILLED
+		@f[3][3].value = Cell::FILLED
+	end
+	# Initialize game field with glider gun
+	def cfg_glider_gun!
+		self.clear!
+		gun = [
+		'........................O...........',
+		'......................O.O...........',
+		'............OO......OO............OO',
+		'...........O...O....OO............OO',
+		'OO........O.....O...OO..............',
+		'OO........O...O.OO....O.O...........',
+		'..........O.....O.......O...........',
+		'...........O...O....................',
+		'............OO......................'];
+		yshift, xshift = 2, 2
+		gun.each_index do |yi|
+			line = gun[yi]
+			(0..line.length).each {|xi| @f[yi+yshift][xi+xshift].value = Cell::FILLED if gun[yi][xi] == 'O'}
+		end
+	end
+	# Clear game field
+	def clear!
+		@f.each do |line|
+			line.each { |cell| cell.value = Cell::EMPTY }
+		end
+	end
+	# Convert game field to ASCII string (best viewed when typed in
+	# monospaced font). Suitable for autotesting
+	def to_ascii
+		txt = ""
+		@f.each do |line|
+			line.each { |field| txt += field.chr }
+			txt += "\n"
+		end
+		return txt
+	end
+	# Make one step (turn)
+	def make_step!
+		# Cells birth
+		@f.each_index do |yi|
+			@f[yi].each_index do |xi|
+				n = cell_neighbours_num(yi, xi)
+				@f[yi][xi].value = Cell::BORN if (@f[yi][xi].value == Cell::EMPTY && n == 3)
+				@f[yi][xi].value = Cell::DEAD if (@f[yi][xi].value == Cell::FILLED && !(n == 2 || n == 3))
+			end
+		end
+		# Cells update
+		@f.each do |line|
+			line.each {|val| val.update}
+		end
+		self
+	end
+
+	private
+	def cell_neighbours_num(y, x)
+		(@f[y][x].neighbours.select {|q| q.value == Cell::FILLED || q.value == Cell::DEAD }).length
+	end
+end
+
+end

data/test/test_base.rb

@@ -0,0 +1,161 @@
+# encoding: UTF-8
+
+require_relative '../lib/node-marshal.rb'
+require 'test/unit'
+
+# This unit test case contains several very simple "smoke tests"
+# for NodeMarshal class
+class TestNodeMarshal < Test::Unit::TestCase
+	# Test: Hello, World
+	def test_hello
+		program = <<-EOS
+puts "Hello, World"
+"Hello, World"
+EOS
+		assert_node_compiler(program)
+	end
+
+	# Test: sum of squares
+	def test_sum_of_squares
+		program = <<-EOS
+sum = 0
+(1..50).each do |n|
+	sum += n ** 2
+end
+sum
+EOS
+		assert_node_compiler(program)
+	end
+
+	# Test: factorial calculation
+	def test_factorials
+		program = <<-EOS
+ni = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+def fact(n)
+	(n == 1) ? 1 : n * fact(n - 1)
+end
+ni.map {|x| fact(x) }
+EOS
+		assert_node_compiler(program)		
+#		test_string_eval(program, [1, 2, 6, 24, 120, 720, 5040, 40320, 362880], "Factorial");
+	end
+
+	# Simple ROT13 task that combines several language construction
+	def test_rot13
+		program = <<-EOS
+class ROT13 < String
+	def initialize(str)
+		@rfunc = Proc.new do |chr, limit|
+			newcode = chr.ord + 13
+			newcode -= 26 if newcode > limit.ord
+			newcode.chr
+		end
+		super(str)
+	end
+
+	def rot13
+		ans = ""
+		self.each_char do |c|
+			case c
+			when ('A'..'Z')
+				ans += @rfunc.(c,'Z')
+			when ('a'..'z')
+				ans += @rfunc.(c,'z')
+			else
+				ans += c
+			end    
+		end
+		return ROT13.new(ans)
+	end
+end
+
+$str = ROT13.new("This is global variable string!")
+[$str.rot13, $str.rot13.rot13]
+EOS
+		assert_node_compiler(program)
+	end
+
+	# Test: array initialization and operations
+	def test_array
+		program = <<-EOS
+[2*2, 3*3, 4*5 + 6, [5,6,7], true && false].flatten
+EOS
+		assert_node_compiler(program)
+	end
+
+	# Test: Eratosthenes algorithm for searching prime numbers
+	def test_eratosthenes_primes
+		program = <<-EOS
+table = Array.new(5000) {|index| index + 2}
+table.each_index do |ind|
+	num = table[ind]
+	if num != 0 
+		((ind + num)..(table.length)).step(num) {|i| table[i] = 0 }
+	end
+end
+table.select! {|val| val != 0}
+table
+EOS
+		assert_node_compiler(program)
+	end
+
+	# Test: classes declaration and inheritance
+	def test_classes
+		program = <<-EOS
+class XYPoint
+	attr_reader :x, :y
+	def initialize(x, y)
+		@x = x.to_f
+		@y = y.to_f
+	end
+
+	def distance(p)
+		return ((@x - p.x)**2 + (@y - p.y)**2)**0.5
+	end	
+end
+
+class PolarPoint < XYPoint
+	def initialize(r, phi)
+		phi = phi * (2*Math::PI) / 360
+		super(r*Math::sin(phi), r*Math::cos(phi))
+	end
+end
+
+a, b = XYPoint.new(0.0, 0.0), XYPoint.new(3.0, 4.0)
+c, d = PolarPoint.new(1.0, 0.0), PolarPoint.new(2.0, 90.0)
+[a.distance(b), c.distance(d)]
+EOS
+
+		assert_node_compiler(program)
+	end
+
+	# Test: Base85r encoders and decoders
+	def test_base85r
+		base85_pass = ->str{NodeMarshal.base85r_decode(NodeMarshal.base85r_encode(str))}
+		# Short strings
+		assert_equal("", base85_pass.(""))
+		assert_equal(" ", base85_pass.(" "))
+		assert_equal("AB", base85_pass.("AB"))
+		assert_equal("ABC", base85_pass.("ABC"))
+		assert_equal("ABCD", base85_pass.("ABCD"))
+		assert_equal("ABCDE", base85_pass.("ABCDE"))
+		# Random strings
+		rnd = Random.new
+		20.times do
+			len, str = rnd.rand(4096), ""
+			len.times { str += rnd.rand(255).chr }
+			assert_equal(str, base85_pass.(str))
+		end
+	end
+
+	# Part of the tests: compare result of direct usage of eval
+	# for the source code and its
+	def assert_node_compiler(program)
+		res_eval = eval(program)
+		node = NodeMarshal.new(:srcmemory, program)
+		bin = node.to_bin; node = nil; GC.start
+		node = NodeMarshal.new(:binmemory, bin)
+		res_node = node.compile.eval
+		assert_equal(res_node, res_eval, "Invalid result from the compiled node")
+	end
+end

data/test/test_complex.rb

@@ -0,0 +1,133 @@
+require_relative '../lib/node-marshal.rb'
+require 'test/unit'
+
+# Wrapper for Ruby Proc class (Proc and lambdas) that
+# saves the text representation of the function
+class TestFunc
+	def initialize(text)
+		@text = text.to_s
+		@value = eval(text)
+	end
+
+	def to_s
+		@text
+	end
+
+	def inspect
+		@text
+	end
+
+	def call(x,a)
+		@value.(x,a)
+	end
+end
+
+# Class for generation of the complex structure that includes:
+# Hashes, Arrays, Floats, Fixnums, Ranges, Strings, Symbols, Procs
+# It is used for node testing
+class TestHashTree
+	attr_reader :value, :depth
+	def initialize(*args)
+		if args.length == 2
+			rnd = Random.new
+			lambdas = ['->x,a{a*x**2 + 2*x + 1}', '->x,a{Math::sin(a) + x**2 * a**0.5}']
+			data_size, depth = args[0], args[1]
+			@depth = depth
+			@value = {:depth => depth, :data => [], :leaves =>[] }
+			data_size.times do
+				case rnd.rand(30000) % 6
+				when 0
+					@value[:data] << 10**(rnd.rand(600000) * 0.001 - 300)
+				when 1
+					@value[:data] << rnd.rand(2**31 - 1)
+				when 2
+					rndstr = (Array.new(25) { (rnd.rand(127 - 32) + 32).chr }).join
+					@value[:data] << rndstr
+				when 3
+					@value[:data] << TestFunc.new(lambdas[rnd.rand(30000) % lambdas.length])
+				when 4
+					a, b = rnd.rand(100), rnd.rand(10)
+					@value[:data] << (a..(a + b))
+				when 5
+					a, b = rnd.rand(100), rnd.rand(10)
+					@value[:data] << (a...(a + b))
+				else
+					nil
+				end
+			end
+	
+			if depth > 0
+				3.times do 
+					@value[:leaves] << TestHashTree.new(data_size, depth - 1)
+				end
+			end
+		elsif args.length == 1
+			h = args[0]			
+			raise(ArgumentError, 'Input argument must be a hash') if !h.is_a?(Hash)
+			@depth = h[:depth]
+			@value = {
+				:depth => @depth,
+				:data => h[:data].map {|x| (x.class == String) ? x.dup : x },
+				:leaves => h[:leaves].map {|x| TestHashTree.new(x)}}
+		else
+			raise ArgumentError, 'Invalid numer of arguments'
+		end
+	end
+
+	def to_s
+		@value.to_s
+	end
+
+	def inspect
+		self.to_s
+	end
+	# Recursive comparison of two complex structures
+	def ==(val)
+		if (self.depth != val.depth) ||
+		   (self.value[:data].length != val.value[:data].length)
+			return false
+		else
+			# Compare data
+			res = true
+			v1, v2 = self.value[:data], val.value[:data]
+			v1.each_index do |ind|
+				if (v1[ind].class != Proc && v1[ind].class != TestFunc)
+					res = false if v1[ind] != v2[ind]
+				else
+					x, a = 1.2345, 1.5
+	                                y1, y2 = v1[ind].call(x,a), v2[ind].call(x,a)
+					res = false if y1 != y2
+				end
+			end
+			# Compare leaves
+			p1, p2 = self.value[:leaves], val.value[:leaves]
+			p1.each_index {|ind| res = false if p1[ind] != p2[ind] }
+			return res
+		end
+	end
+end
+
+# Tests that check the processing of large and/or complex nodes
+class TestComplex < Test::Unit::TestCase
+	def test_bruteforce
+		# Create test tree, turn it to node and save it to disk
+		puts 'Creating the tree...'
+		tree_src = TestHashTree.new(20, 7);
+		puts 'Dumping the node...'
+		tree_str = tree_src.to_s
+		node = NodeMarshal.new(:srcmemory, tree_str)
+		tree_bin = node.to_bin
+
+		File.open('node.bin', 'wb') {|fp| fp << tree_bin }
+		puts "  Source code size: %d bytes" % tree_str.length
+		puts "  Binary data size: %d bytes" % tree_bin.length
+		# Clear the memory
+		node = nil; GC.start
+		# Load the node from the disk and turn it to tree
+		puts 'Loading the node...'
+		node = NodeMarshal.new(:binfile, 'node.bin')
+		puts node.inspect
+		tree_dest = TestHashTree.new(node.compile.eval)
+		assert_equal(tree_src, tree_dest)
+	end
+end