node-marshal 0.1.1

data/test/test_lifegame.rb

@@ -0,0 +1,68 @@
+require_relative '../lib/node-marshal.rb'
+require 'test/unit'
+
+# Set of tests for Convay's life game running and compilation
+# (includes tests with binary Ruby files)
+class TestLifeGame < Test::Unit::TestCase
+	# Compile and launch life game with different
+	# compiler options (requires zlib library)
+
+	def test_compile
+		compile_with_opts(nil)
+		compile_with_opts(:compress=>true)
+	end
+	# Test life game with glider gun configuration
+	def test_glider_gun
+		# Compile the class to the instuction sequence
+		bin = NodeMarshal.new(:srcfile, 'lifegame.rb')
+		puts bin.inspect
+		bin.compile.eval
+		# Calculate the life game
+		res_node = run_game
+		# Play the game of life without NodeMarshal
+		Object.send(:remove_const, :LifeGame)
+		load('lifegame.rb')
+		res_load = run_game
+		# Compare the results
+		assert_equal(res_node, res_load)
+		Object.send(:remove_const, :LifeGame)
+		puts res_load
+	end
+
+	# Runs Life game initialized with "glider gun" configuration	
+	# and makes 75 turns (changes of generations)
+	def run_game
+		g = LifeGame::Grid.new(25, 80)
+		g.cfg_glider!
+		g.cfg_glider_gun!
+		75.times {g.make_step!}
+		g.to_ascii
+	end
+
+	# Compiles Convay's life game using proposed options
+	# (opts is a Hash, see NodeMarshal#compile_rb_file method)
+	def compile_with_opts(opts)
+		stub = <<-EOS
+g = LifeGame::Grid.new(25, 80)
+g.cfg_glider_gun!
+75.times {g.make_step!}
+File.open('life.res', 'w') {|fp| fp << g.to_ascii }
+EOS
+		# Compile Life game to the file and obtain the result
+		if opts == nil
+			NodeMarshal.compile_rb_file('lifegame_bin.rb', 'lifegame.rb')
+		else
+			NodeMarshal.compile_rb_file('lifegame_bin.rb', 'lifegame.rb', opts)
+		end
+		txt = File.read('lifegame_bin.rb') + stub
+		File.open('lifegame_bin.rb', 'w') {|fp| fp << txt }
+		`ruby lifegame_bin.rb`
+		res_file = File.read('life.res')
+		`rm life.res`	
+		# Run the life game without compilation to the file
+		load('lifegame.rb')
+		res_load = run_game
+		Object.send(:remove_const, :LifeGame)
+		assert_equal(res_file, res_load)		
+	end
+end

data/test/tinytet.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/ruby
+# Simple TETRIS game for Ruby 1.9.x that uses CURSES library
+# (C) 2013 Alexey Voskov
+require "curses"
+include Curses
+# TETRIS figure
+class Figure
+	attr_accessor :mat, :x, :y, :rot
+	FIGURES = [0x0F00,0x0660,0x0270,0x0170,0x0470,0x0360,0x0C60] # Line, square, T, L, L, Z, Z
+	def initialize
+		fig = FIGURES[rand(6).round]
+		rf = ->bf{Array.new(4) {|y| Array.new(4) {|x| (1 << bf.(x,y)) & fig }}}
+		@mat = [rf.(->x,y{3-x+y*4}), rf.(->x,y{3-y+(3-x)*4}), 
+			rf.(->x,y{x+(3-y)*4}), rf.(->x,y{y+x*4})]
+		@x, @y, @rot = 5, 0, 0 # Figure position
+	end
+	def each_pos &block
+		(0..3).each {|y| (0..3).each {|x| block.(y,x) if @mat[@rot][y][x] > 0}}
+	end
+	# Test the possibility of move and move if possible
+	def move!(op, unop, scr)
+		self.each_pos {|y,x| scr.brick!(y+@y,x+@x,GameField::COL_EMPTY) }
+		op.(self)
+		unop.(self) if !(ans = scr.place?self)
+		self.each_pos {|y,x| scr.brick!(y+@y,x+@x,GameField::COL_BRICK) }
+		refresh
+		ans
+	end
+end
+# TETRIS game fields
+class GameField
+	WIDTH, HEIGHT, BRICK_WIDTH, COL_EMPTY, COL_WALL, COL_BRICK = 16, 26, 2, 0, 1, 2
+	def initialize # Initialize and show the game fields
+		@m = Array.new(HEIGHT+2) {[0,0,1,Array.new(WIDTH-6){0},1,0,0].flatten}
+		(2..WIDTH-3).each {|i| @m[HEIGHT-1][i] = COL_WALL}
+		lines!
+	end
+	def brick!(y,x,c) # Show the brick on the screen
+		@m[y][x] = c.to_i
+		return nil if y-3 <= 0
+		setpos(y-3,x*BRICK_WIDTH)
+		addstr([". ", "**", "[]"][c])
+	end
+	def place?(fig) # Check if the figure can be placed
+		fig.each_pos {|y,x| return false if @m[y+fig.y][x+fig.x] > 0}
+		return true
+	end
+	def lines! # Erase full lines from the screen
+		while (ind = @m[0..HEIGHT-2].index {|s| s[3..WIDTH-4].index(COL_EMPTY) == nil}) != nil
+			(ind-1).step(0,-1) {|i| @m[i+1] = @m[i]}
+			@m[0] = @m[HEIGHT+1].dup
+		end
+		(0..HEIGHT-1).each {|y| (2..WIDTH-3).each {|x| brick!(y,x,@m[y][x])}} # Update the screen (field + borders) 	
+	end
+end
+# Initialize the console and program data
+init_screen; clear; noecho; stdscr.keypad(true)
+fig, scr, speed = Figure.new, GameField.new, 1
+# Keyboard control thread
+keythread = Thread.new { loop {
+	case getch
+		when Key::LEFT then fig.move!(->f{f.x -=1}, ->f{f.x +=1}, scr)
+		when Key::RIGHT then fig.move!(->f{f.x +=1}, ->f{f.x -=1}, scr)
+		when Key::UP then fig.move!(->f{f.rot = (f.rot+1)%4}, ->f{f.rot = (f.rot+3)%4},scr)
+		when Key::DOWN  then speed = 0.05 # Delay for fast falling
+	end
+}}
+# Game main loop (new figure creation + falling)
+begin
+	fig, speed = Figure.new, 0.5 # Figure and delay for its normal falling
+	sleep(speed) while fig.move!(->f{f.y +=1}, ->f{f.y -=1}, scr)
+	scr.lines! 
+end until fig.y == 0
+# Finish the game
+keythread.kill
+setpos(GameField::HEIGHT/2,GameField::WIDTH-4)
+addstr("GAME OVER!")
+getch
+close_screen

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: node-marshal
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Alexey Voskov
+autorequire: 
+bindir:
+- bin
+cert_chain: []
+date: 2015-05-04 00:00:00.000000000 Z
+dependencies: []
+description: "This gem is designed for transformation of Ruby source code (eiher in
+  the form of files or strings) to the \nRuby nodes (syntax trees) used by Ruby MRI
+  internals. Obtained nodes can be serialized to the platform-dependent\nbinary or
+  ASCII strings and restored and launched from serialized format. Such kind of transformation
+  is\nirreversible and can be used for source code protection; the similar principle
+  is used by RubyEncoder commercial\nsoftware.\n"
+email: alvoskov@gmail.com
+executables:
+- noderbc
+extensions:
+- ext/node-marshal/extconf.rb
+extra_rdoc_files:
+- README.rdoc
+files:
+- README.rdoc
+- bin/noderbc
+- bin/noderbc.bat
+- ext/node-marshal/COPYING
+- ext/node-marshal/base85r.c
+- ext/node-marshal/extconf.rb
+- ext/node-marshal/libobj/readme.txt
+- ext/node-marshal/node193.h
+- ext/node-marshal/node220.h
+- ext/node-marshal/nodedump.c
+- ext/node-marshal/nodedump.h
+- ext/node-marshal/nodeinfo.c
+- lib/node-marshal.rb
+- test/lifegame.rb
+- test/test_base.rb
+- test/test_complex.rb
+- test/test_lifegame.rb
+- test/tinytet.rb
+homepage: 
+licenses:
+- 2-clause BSD
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Transforms Ruby sources to binary nodes (trees) that can be saved and loaded
+test_files: []