wexpr 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c20c67b59151ff8f72f6ad40c3f4097aa21e5c723b261b33ea21e77a04de3aa0
+  data.tar.gz: 8ed24f217b2c4fb25213bac3aae2020f2c0fd6e97e8cf108585302615c567b85
+SHA512:
+  metadata.gz: bccfac837caf12cca63d0bd90a6d1f44b3c86c7eb5633d63bcedaa6c8b6983ae201b833c66c316ce2a720b7ee4842099c3216987aef77493228d83e92d9ad3ee
+  data.tar.gz: a74c880e0108745e609104e79a476667bec93fbd842420d46cc5395eb02ee59c3d79af1d2b2348ef744d9f6e66f6bd6598a696623be1b8fc464db26c18d2c005

data/.gitignore

@@ -0,0 +1,76 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# Created by https://www.gitignore.io/api/ruby
+# Edit at https://www.gitignore.io/?templates=ruby
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+# Ignore Byebug command history file.
+.byebug_history
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+# End of https://www.gitignore.io/api/ruby
+
+# Created by https://www.gitignore.io/api/kdevelop4
+# Edit at https://www.gitignore.io/?templates=kdevelop4
+
+### KDevelop4 ###
+*.kdev4
+.kdev4/
+
+# End of https://www.gitignore.io/api/kdevelop4

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.16.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in wexpr.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    wexpr (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.11.3)
+    rake (10.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  minitest (~> 5.0)
+  rake (~> 10.0)
+  wexpr!
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Kenneth Perry (thothonegan)
+
+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,38 @@
+# Wexpr
+
+Ruby parser for the Wexpr format. See [libWexpr](https://github.com/thothonegan/libWexpr) for more details of the format.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'wexpr', :git => "git://github.com/thothonegan/ruby-wexpr.git"
+```
+
+And then execute:
+
+    $ bundle
+
+Currently it is not published to rubygems.
+
+## Usage
+
+For simple wexpr expression to an equivilant ruby hash (similar to yaml/json libraries):
+```ruby
+require 'wexpr'
+
+rubyHash = Wexpr.load("@(array #(1 2 3)")
+
+```
+
+For more complex, `Wexpr::Expression` acts like its libWexpr equivilant. See the files in [test](./test/) for examples.
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/thothonegan/ruby-wexpr.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "wexpr"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/wexprTool

@@ -0,0 +1,211 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "wexpr"
+
+require 'optparse'
+
+WEXPR_BIN_VERSION = 0x00001000 # 0.1.0
+
+# the first 8 bytes of the header
+WEXPR_HEADER_MAGIC = [
+	0x83,
+	'B'.ord, 'W'.ord, 'E'.ord, 'X'.ord, 'P'.ord, 'R'.ord,
+	0x0A
+]
+WEXPR_HEADER_MAGIC_PACK = 'CCCCCCCC'
+
+# helper functions
+def readAllInputFrom(inputPath)
+	if inputPath == "-"
+		return STDIN.read()
+	else
+		return File.read(inputPath, :mode => "rb")
+	end
+end
+
+def writeAllOutputTo(outputPath, str)
+	if outputPath == "-"
+		STDOUT.write "#{str}"
+	else
+		File.open(outputPath, "w") do |f|
+			f.write "#{str}"
+		end
+	end
+end
+
+def writeAllOutputWithFileHeaderTo(outputPath, data)
+	stream = STDOUT
+	if outputPath != "-"
+		stream = File.open(outputPath, "wb")
+	end
+	
+	# TODO: Move writing header to Wexpr, since its part of the file format
+	
+	header = WEXPR_HEADER_MAGIC # first 8 bytes
+	header += [
+		WEXPR_BIN_VERSION, #12
+		0,0,0,0,0,0,0,0 # reserved slots : header is 20 bytes
+	]
+	
+	headerSpec=WEXPR_HEADER_MAGIC_PACK + 'NC*'
+	stream.write(header.pack(headerSpec))
+	
+	# currently we have no aux chunks
+	
+	# write the main chunk
+	stream.write(data)
+	
+	# and done
+	stream.flush
+end
+
+#
+# Similar to libWexpr's WexprTool written in ruby
+#
+options = {
+	:command => "humanReadable",
+	:input => "-",
+	:output => "-"
+}
+
+optparser = OptionParser.new do |opts|
+	opts.banner = "Usage: #{$0} [OPTIONS]"
+	opts.on("-c", "--cmd=COMMAND", "Perform the requested command. Default is 'humanReadable'") do |command|
+		options[:command] = command
+	end
+	
+	opts.on("-i", "--input=FILE", "The input file to read from (default is -, stdin)") do |input|
+		options[:input] = input
+	end
+	
+	opts.on("-o", "--output=FILE", "The output file to read from (default is -, stdout)") do |output|
+		options[:output] = output
+	end
+	
+	opts.on("-h", "--help", "Display this help and exit") do
+		puts opts
+		puts ""
+		puts "Possible commands:"
+		puts "  humanReadable - [default] Makes the wexpr input human readable and outputs."
+		puts "  validate      - Checks the wexpr. If valid outputs 'true' and returns 0, otherwise 'false' and 1."
+		puts "  mini          - Minifies the wexpr output"
+		puts "  binary        - Write the wexpr out as binary"
+		exit
+	end
+	
+	opts.on("-v", "--version", "Output the version and exit") do
+		puts "wexprTool #{Wexpr::VERSION}"
+		exit
+	end
+end
+
+optparser.parse!
+
+if options[:command] == "humanReadable" or
+	options[:command] == "validate" or
+	options[:command] == "mini" or
+	options[:command] == "binary"
+
+	isValidate = (options[:command] == "validate")
+	inputString = readAllInputFrom(options[:input])
+
+	expr = nil
+	
+	# determine if binary or not.
+	# if so strip the header and do the hunk
+	begin
+		if inputString.size >= 1 and inputString[0].ord == 0x83
+			if inputString.size < 20
+				raise StandardError.new "Invalid binary header - not big enough"
+			end
+			
+			if inputString.unpack(WEXPR_HEADER_MAGIC_PACK) != WEXPR_HEADER_MAGIC
+				raise StandardError.new "Invalid binary header - invalid magic"
+			end
+			
+			version = inputString[8..-1].unpack('N')[0]
+			
+			if version != WEXPR_BIN_VERSION
+				raise StandardError.new "Invalid binary header - unknown version 0x#{version.to_s(16)}"
+			end
+			
+			# make sure reserved is blank
+			# thats the remaining 8 bytes
+			if inputString[12..-1].unpack('CCCCCCCC') != [0]*8
+				raise StandardError.new "Invalid binary header - unknown reserved bits"
+			end
+			
+			# header seems valid, skip it
+			data = inputString
+			curPos = 20
+			endPos = data.size
+			
+			while curPos < endPos
+				# read the size and type
+				size, dataNew = Wexpr::UVLQ64::read(data[curPos..-1])
+				
+				# TODO: if !dataNewPos
+				
+				# dont move past the size yet. just track it for later
+				sizeSize = data.size-curPos - dataNew.size
+				
+				type = data[curPos+sizeSize].ord
+				
+				# given: type >= 0x00
+				if type <= 0x04 # its a known type
+					# cool parse it
+					if expr != nil
+						raise StandardError.new ("Found multiple expression chunks")
+					end
+					
+					# hand it the entire chunk including the size and the type
+					expr = Wexpr::Expression.create_from_binary_chunk(
+						data[curPos..-1]
+					)
+				else
+					STDERR.puts "Warning: Unknown chunk with type #{type} at byte 0x#{(curPos+sizeSize).to_s(16)} size is #{sizeSize}"
+				end
+				
+				# move forward : pass the type, pass the size
+				curPos += Wexpr::Expression::SIZE_U8 + sizeSize
+				curPos += size
+			end
+		else
+			# assume string
+			expr = Wexpr::Expression.create_from_string(inputString)
+		end
+		
+	rescue Wexpr::Exception => e
+		if isValidate
+			writeAllOutputTo(options[:output], "false\n")
+		else
+			STDERR.puts "wexprTool: Error occurred with wexpr:"
+			STDERR.puts "wexprTool: #{options[:input]}:#{e.line}:#{e.column}: #{e.message}"
+		end
+		
+		exit 1
+	end
+
+	# loaded fine
+	if isValidate
+		writeAllOutputTo(options[:output], "true\n")
+
+	elsif options[:command] == "humanReadable"
+		writeAllOutputTo(options[:output], expr.create_string_representation(0, [:humanReadable]))
+		
+	elsif options[:command] == "mini"
+		writeAllOutputTo(options[:output], expr.create_string_representation(0, []))
+		
+	elsif options[:command] == "binary"
+		# FUTURE: create binary rep and write out
+		binData = expr.create_binary_representation()
+		
+		writeAllOutputWithFileHeaderTo(options[:output], binData)
+	end
+else
+	STDERR.puts "wexprTool: Unknown command"
+	exit 1
+end
+
+# success

data/lib/wexpr.rb

@@ -0,0 +1,34 @@
+require 'wexpr/exception'
+require 'wexpr/expression'
+require 'wexpr/object_ext'
+require 'wexpr/uvlq64'
+require 'wexpr/version'
+
+#
+# Ruby-Wexpr library
+#
+# Currently does not handle Binary Wexpr.
+#
+module Wexpr
+	#
+	# Parse Wexpr and turn it into a ruby hash
+	# Will thrown an Exception on failure
+	#
+	def self.load(str, flags=[])
+		expr = Expression::create_from_string(str, flags)
+		return expr.to_ruby
+	end
+	
+	#
+	# Emit a hash as the equivilant wexpr string, human readable or not.
+	# See possible writeflags in Expression.
+	#
+	def self.dump(variable, writeFlags=[])
+		# first step, go through the variable and create the equivilant wexpr expressions
+		expr = Expression::create_from_ruby(variable)
+		
+		# then have it write out the string
+		return expr.create_string_representation(0, writeFlags)
+	end
+	
+end