crossplane 0.1.5

data/lib/crossplane/builder.rb

@@ -0,0 +1,203 @@
+require 'crossplane/globals'
+require 'json'
+require 'pathname'
+require 'pp'
+
+#require_relative 'globals.rb'
+
+module CrossPlane
+	class Builder
+		DELIMITERS = ['{', '}', ';']
+		EXTERNAL_BUILDERS = {}
+		NEWLINE = "\n"
+		TAB = "\t"
+
+		attr_accessor :header
+		attr_accessor :indent
+		attr_accessor :padding
+		attr_accessor :payload
+		attr_accessor :state
+		attr_accessor :tabs
+
+		def initialize(*args)
+			args = args[0] || {}
+
+			required = ['payload']
+			conflicts = []
+			requires = {}
+			valid = {
+				'params' => [
+					'header',
+					'indent',
+					'payload',
+					'tabs',
+				]
+			}
+
+			content = CrossPlane.utils.validate_constructor(client: self, args: args, required: required, conflicts: conflicts, requires: requires, valid: valid)
+			self.header = (content[:header] && content[:header] == true) ? true : false
+			self.indent = content[:indent] ? content[:indent] : 4
+			self.payload = content[:payload] ? content[:payload] : nil
+			self.tabs = (content[:tabs] && content[:tabs] == true) ? true : false
+		end
+
+		def build(*args)
+			self.padding = self.tabs ? TAB : ' ' * self.indent
+			self.state = {
+				'prev_obj' => nil,
+				'depth' => -1,
+			}
+
+			if self.header
+				lines = [
+					"# This config was built from JSON using NGINX crossplane.\n",
+					"# If you encounter any bugs please report them here:\n",
+					"# https://github.com/gdanko/crossplane/issues\n",
+					"\n"
+				]
+			else
+				lines = []
+			end
+
+			lines += _build_lines(payload)
+			puts lines.join('')
+			exit
+			return lines.join('')
+		end
+
+		private
+		def _put_line(line, obj)
+			margin = self.padding * self.state['depth']
+
+			# don't need put \n on first line and after comment
+			if self.state['prev_obj'].nil?
+				return margin + line
+			end
+
+			# trailing comments have to be without \n
+			if obj['directive'] == '#' and obj['line'] == self.state['prev_obj']['line']
+				return ' ' + line
+			end
+
+			return NEWLINE + margin + line
+		end
+
+		def _build_lines(objs)
+			lines = Enumerator.new do |y|
+				self.state['depth'] = self.state['depth'] + 1
+
+				objs.each do |obj|
+					directive = obj['directive']
+					if EXTERNAL_BUILDERS[directive]
+						#built = external_builder(obj, padding, state)
+						#y.yield(_put_line(built_obj))
+						#next
+					end
+
+					if directive == '#'
+						y.yield(_put_line(
+							'#' + obj['comment'],
+							obj
+						))
+						next
+					end
+
+					args = obj['args'].map{|arg| _enquote(arg)}
+
+					if directive == 'if'
+						line = format('if (%s)', args.join(' '))
+					elsif args
+						line = format('%s %s', directive, args.join(' '))
+					else
+						line = directive
+					end
+
+					if not obj.key?('block')
+						y.yield(_put_line(line + ';', obj))
+					else
+						y.yield(_put_line(line + ' {', obj))
+
+						# set prev_obj to propper indentation in block
+						self.state['prev_obj'] = obj
+						_build_lines(obj['block']).each do |line|
+							y.yield(line)
+						end
+						y.yield(_put_line('}', obj))
+					end
+					self.state['prev_obj'] = obj
+				end
+				self.state['depth'] = self.state['depth'] - 1
+			end
+			lines.to_a
+		end
+
+		def _escape(string)
+			chars = Enumerator.new do |y|
+				prev, char = '', ''
+				string.split('').each do |char|
+					if prev == '\\' or prev + char == '${'
+						prev += char
+						y.yield char
+						next
+					end
+					
+					if prev == '$'
+						y.yield prev
+					end
+
+					if not ['\\', '$'].include?(char)
+						y.yield char
+					end
+					prev = char
+				end
+
+				if ['\\', '$'].include?(char)
+					y.yield char
+				end
+			end
+			chars
+		end
+
+		def _needs_quotes(string)
+			if string == ''
+				return true
+			elsif DELIMITERS.include?(string)
+				return false
+			end
+
+			# lexer should throw an error when variable expansion syntax
+			# is messed up, but just wrap it in quotes for now I guess
+			chars = _escape(string)
+
+			begin
+				while char = chars.next
+
+
+					# arguments can't start with variable expansion syntax
+					if CrossPlane.utils.isspace(char) or ['{', ';', '"', "'", '${'].include?(char)
+						return true
+					end
+
+					expanding = false
+					#chars.each do |char|
+					#	if CrossPlane.utils.isspace(char) or ['{', ';', '"', "'"].include(char)
+					#		return true
+					#	elsif char == 
+					# char in ('\\', '$') or expanding
+					return expanding
+				end
+			rescue StopIteration
+			end
+		end
+
+		def _enquote(arg)
+			if _needs_quotes(arg)
+				#arg = repr(codecs.decode(arg, 'raw_unicode_escape'))
+				arg = arg.gsub('\\\\', '\\')
+			end
+			return arg
+		end
+
+
+	end
+end

data/lib/crossplane/cli.rb

@@ -0,0 +1,139 @@
+require 'crossplane/builder'
+require 'crossplane/config'
+require 'crossplane/parser'
+require 'json'
+require 'logger'
+require 'pp'
+require 'thor'
+require 'yaml'
+
+#require_relative 'builder.rb'
+#require_relative 'config.rb'
+#require_relative 'parser.rb'
+
+$script = File.basename($0)
+$config = CrossPlane::Config.new()
+
+trap('SIGINT') {
+	puts("\nControl-C received.")
+	exit(0)
+}
+
+def configure_options(thor, opt_type, opts)
+	opts = opts.sort_by { |k| k[:name].to_s }
+	opts.each do |opt|
+		required = opt.key?(:required) ? opt[:required] : false
+		aliases = opt.key?(:aliases) ? opt[:aliases] : []
+		if opt_type == "class"
+			thor.class_option(opt[:name], :banner => opt[:banner], :desc => opt[:desc], :aliases => aliases, :required => required, :type => opt[:type])
+		elsif opt_type == "method"
+			thor.method_option(opt[:name], :banner => opt[:banner], :desc => opt[:desc], :aliases => aliases, :required => required, :type => opt[:type])
+		end
+	end
+end
+
+class CLI < Thor
+	desc 'parse <filename>', 'parses an nginx config file and returns a json payload'
+	configure_options(self, 'method', $config.parse_options)
+	def parse(filename)
+		payload = CrossPlane::Parser.new(
+			filename: filename,
+			combine: options['combine'] || false,
+			strict: options['strict'] || false,
+			catch_errors: options['no_catch'] ? false : true,
+			comments: options['include_comments'] || false,
+			ignore: options['ignore'] ? options['ignore'].split(/\s*,\s*/) : [],
+			single: options['single'] || false,
+		).parse()
+		
+		if options['out']
+			File.open(options['out'], 'w') do |f|
+				f.write(JSON.pretty_generate(payload))
+			end
+		else
+			puts options['pretty'] ? JSON.pretty_generate(payload) : payload.to_json
+		end
+		exit 0
+	end
+
+	desc 'build <filename>', 'builds an nginx config from a json payload'
+	configure_options(self, 'method', $config.build_options)
+	def build(filename)
+		dirname = Dir.pwd unless dirname
+		
+		# read the json payload from the specified file
+		payload = JSON.parse(File.read(filename))
+		builder = CrossPlane::Builder.new(
+			payload: payload['config'][0]['parsed']
+		)	
+		
+		if not options['force'] and not options['stdout']
+			existing = []
+			payload['config'].each do |config|
+				path = config['file']
+				p = Pathname.new(path)
+				path = p.absolute? ? path: File.join(dirname, path)
+				if File.exist?(path)
+					existing.push(path)
+				end
+			end
+
+
+			# ask the user if it's okay to overwrite existing files
+			if existing.length > 0
+				puts(format('building %s would overwrite these files:', filename))
+				puts existing.join("\n")
+				# if not _prompt_yes():
+				#   print('not overwritten')
+				#   return
+			end
+		end
+
+		# if stdout is set then just print each file after another like nginx -T
+		#if options['stdout']
+			payload['config'].each do |config|
+				path = config['file']
+				p = Pathname.new(path)
+				path = p.absolute? ? path: File.join(dirname, path)
+				parsed = config['parsed']
+				output = builder.build(
+					parsed,
+					indent: options['indent'] || 4, # fix default option in config.rb
+					tabs: options['tabs'],
+					header: options['header']
+				)
+				output = output.rstrip + "\n"
+			end
+			return
+		#end
+	end
+
+	desc 'lex <filename>', 'lexes tokens from an nginx config file'
+	configure_options(self, 'method', $config.lex_options)
+	def lex(filename)
+		payload = CrossPlane::Lexer.new(
+			filename: filename,
+		).lex()
+		lex = (not options['line_numbers'].nil? and options['line_numbers'] == true) ? payload : payload.map{|e| e[0]}
+
+		if options['out']
+			File.open(options['out'], 'w') do |f|
+				f.write(JSON.pretty_generate(lex))
+			end
+		else
+			puts options['pretty'] ? JSON.pretty_generate(lex) : lex.to_json
+		end
+	end
+
+	desc 'minify', 'removes all whitespace from an nginx config'
+	def minify(filename)
+		puts 'minifiy'
+		exit
+	end
+
+	#desc 'format', 'formats an nginx config file'
+	#def format(filename)
+	#	puts 'format'
+	#	exit
+	#end
+end

data/lib/crossplane/config.rb

@@ -0,0 +1,56 @@
+module CrossPlane
+	class Config
+		attr_accessor :opts
+		attr_accessor :common_opts
+		attr_accessor :parse_opts
+		attr_accessor :build_opts
+		attr_accessor :lex_opts
+		attr_accessor :minify_opts
+		attr_accessor :format_opts
+
+		def initialize(*args)
+			self.common_opts = {
+
+			}
+
+			self.parse_opts = {
+				'out' => {:name => :out, :aliases => ['-o'], :banner => '<string>', :desc => 'write output to a file', :type => :string, :required => false},
+				'pretty' => {:name => :pretty, :desc => 'pretty print the json output', :type => :boolean, :required => false, :default => :false},
+				'ignore' => {:name => :ignore, :banner => '<str>', :desc => 'ignore directives (comma-separated)', :type => :string, :required => false, :default => []},
+				'no-catch' => {:name => :no_catch, :desc => 'only collect first error in file', :type => :boolean, :required => false, :default => :false},
+				#'tb-onerror' => {:name => :tb_onerror, :desc => 'include tracebacks in config errors', :type => :boolean, :required => false},
+				#'combine' => {:name => :combine, :desc => 'use includes to create one single file', :type => :boolean, :required => false},
+				#'single' => {:name => :single, :desc => 'do not include other config files', :type => :boolean, :required => false},
+				'include-comments' => {:name => :include_comments, :desc => 'include comments in json', :type => :boolean, :required => false, :default => :false},
+				'strict' => {:name => :strict, :desc => 'raise errors for unknown directives', :type => :boolean, :required => false, :default => :false},
+			}
+
+			self.build_opts = {
+				'dir' => {:name => :dir, :banner => '<string>', :desc => 'the base directory to build in', :type => :string, :required => false},
+				'force' => {:name => :force, :desc => 'overwrite existing files', :type => :boolean, :required => false},
+				'indent' => {:name => :indent, :banner => '<string>', :desc => 'number of spaces to indent output', :type => :numeric, :required => false, :default => 4},
+				'tabs' => {:name => :tabs, :desc => 'indent with tabs instead of spaces', :type => :boolean, :required => false},
+				#'no-headers' => {:name => :no_header2, :desc => 'do not write header to configsd', :type => :boolean, :required => false},
+				'stdout' => {:name => :stdout, :desc => 'write configs to stdout instead', :type => :boolean, :required => false},
+			}
+
+			self.lex_opts = {
+				'out' => {:name => :out, :aliases => ['-o'], :banner => '<string>', :desc => 'write output to a file', :type => :string, :required => false},
+				'indent' => {:name => :indent, :aliases => ['-i'], :banner => '<int>', :desc => 'number of spaces to indent output', :type => :numeric, :required => false, :default => 4},
+				'numbers' => {:name => :line_numbers, :aliases => ['-n'], :desc => 'include line numbers in json payload', :type => :boolean, :required => false, :default => true},
+			}
+		end
+
+		def parse_options()
+			return self.common_opts.merge(self.parse_opts).map { |_k, v| v }
+		end
+
+		def build_options()
+			return self.common_opts.merge(self.build_opts).map { |_k, v| v }
+		end
+	
+		def lex_options()
+			return self.common_opts.merge(self.lex_opts).map { |_k, v| v }
+		end
+	end
+end

data/lib/crossplane/errors.rb

@@ -0,0 +1,64 @@
+module CrossPlane
+	class ConstructorError < StandardError
+		def initialize(errors: nil)
+			@errors = errors
+			@error = @errors.join('; ')
+			super(@error)
+		end
+	end
+
+	class NgxParserBaseException < StandardError
+		attr_reader :filename, :lineno, :strerror
+		def initialize(filename, lineno, strerror)
+			@filename = filename
+			@lineno = lineno
+			@strerror = strerror
+			if @lineno.nil?
+				@error = format('%s in %s', @strerror, @filename)
+			else
+				@error = format('%s in %s:%s', @strerror, @filename, @lineno)
+			end
+			super(@error)
+		end
+	end
+
+	class NgxParserDirectiveError < StandardError
+		def initialize(reason, filename, lineno)
+			@reason = reason
+			@filename = filename
+			@lineno = lineno
+			@error = (format('%s in %s:%s', @reason, @filename, @lineno))
+			super(@error)
+		end
+	end
+
+	class NgxParserSyntaxError < NgxParserBaseException
+		def initialize(filename, lineno, strerror)
+			super(filename, lineno, strerror)
+		end
+	end
+
+	class NgxParserDirectiveArgumentsError < NgxParserBaseException
+		def initialize(filename, lineno, strerror)
+			super(filename, lineno, strerror)
+		end
+	end
+
+	class NgxParserDirectiveContextError < NgxParserBaseException
+		def initialize(filename, lineno, strerror)
+			super(filename, lineno, strerror)
+		end
+	end
+
+	class NgxParserDirectiveUnknownError < NgxParserBaseException
+		def initialize(filename, lineno, strerror)
+			super(filename, lineno, strerror)
+		end
+	end
+
+	class NgxParserIncludeError < NgxParserBaseException
+		def initialize(filename, lineno, strerror)
+			super(filename, lineno, strerror)
+		end
+	end
+end

data/lib/crossplane/globals.rb

@@ -0,0 +1,42 @@
+require 'crossplane/config'
+require 'crossplane/utils'
+
+#require_relative 'config.rb'
+#require_relative 'utils.rb'
+
+module CrossPlane
+	def self.utils=(utils)
+		@utils = utils
+	end
+
+	def self.utils
+		@utils
+	end
+	
+	def self.config=(config)
+		@config = config
+	end
+
+	def self.config
+		@config
+	end
+
+	def self.debug=(debug)
+		@debug = debug
+	end
+
+	def self.debug
+		@debug
+	end
+
+	def self.logger=(logger)
+		@logger = logger
+	end
+
+	def self.logger
+		@logger || CrossPlane.utils.configure_logger(debug: true)
+	end
+
+	CrossPlane.config = CrossPlane::Config.new()
+	CrossPlane.utils = CrossPlane::Utils.new()
+end

data/lib/crossplane/lexer.rb

@@ -0,0 +1,155 @@
+require 'crossplane/errors'
+require 'crossplane/globals'
+
+#require_relative 'errors.rb'
+#require_relative 'globals.rb'
+
+module CrossPlane
+	class Lexer
+		EXTERNAL_LEXERS = {}
+		NEWLINE = "\n"
+
+		attr_accessor :filename
+		def initialize(*args)
+			args = args[0] || {}
+
+			required = ['filename']
+			conflicts = []
+			requires = {}
+			valid = {
+				'params' => [
+					'filename',
+				]
+			}
+
+			content = CrossPlane.utils.validate_constructor(client: self, args: args, required: required, conflicts: conflicts, requires: requires, valid: valid)
+			self.filename = content[:filename]
+		end
+
+		def lex(*args)
+			tokens = _lex_file()
+			_balance_braces(tokens)
+			tokens
+		end
+
+		private
+		def _lex_file(*args)
+			token = ''  # the token buffer
+			next_token_is_directive = true
+			
+			enum = Enumerator.new do |y|
+				File.open(self.filename, 'r') { |f|
+					f.each do |line|
+						lineno = $.
+						line.split('').each do |char|
+							y.yield [char, lineno]
+						end
+					end
+				}
+			end
+
+			tokens = []
+			begin
+				while tuple = enum.next
+					char, line = tuple
+					if CrossPlane.utils.isspace(char)
+						if not token.empty?
+							tokens.push([token, line])
+							if next_token_is_directive and EXTERNAL_LEXERS[token]
+								next_token_is_directive = true
+							else
+								next_token_is_directive = false
+							end
+						end
+
+						while CrossPlane.utils.isspace(char)
+							char, line = enum.next
+						end
+
+						token = ''
+					end
+
+					# if starting comment
+					if token.empty? and char == '#'
+						while not char.end_with?(NEWLINE)
+							token = token + char
+							char, _ = enum.next
+						end
+						tokens.push([token, line])
+						token = ''
+						next
+					end
+
+					# handle parameter expansion syntax (ex: "${var[@]}")
+					if token and token[-1] == '$' and char == '{'
+						next_token_is_directive = false
+						while token[-1] != '}' and not CrossPlane.utils.isspace(char)
+							token += char
+							char, line = enum.next
+						end
+					end
+
+					# if a quote is found, add the whole string to the token buffer
+					if ['"', "'"].include?(char)
+						if not token.empty?
+							token = token + char
+							next
+						end
+						quote = char
+						char, line = enum.next
+						while char != quote
+							if char == '\\' + quote
+								token = token + quote
+							else
+								token = token + char
+							end
+							char, line = enum.next
+						end
+
+						tokens.push([token, line])
+						token = ''
+						next
+					end
+
+					if ['{', '}', ';'].include?(char)
+						if not token.empty?
+							tokens.push([token, line])
+							token = ''
+						end
+						tokens.push([char, line]) if char.length > 0
+						next_token_is_directive = true
+						next
+					end
+					token = token + char
+				end
+			rescue StopIteration
+			end
+			tokens
+		end
+
+		def _balance_braces(tokens)
+			depth = 0
+
+			for token, line in tokens
+				if token == '}'
+					depth = depth -1
+				elsif token == '{'
+					depth = depth + 1
+				end
+
+				if depth < 0
+					reason = 'unexpected "}"'
+					raise CrossPlane::NgxParserSyntaxError.new(self.filename, line, reason)
+				else
+					yield token, line if block_given?
+				end
+			end
+
+			if depth > 0
+				reason = 'unexpected end of file, expecting "}"'
+				raise CrossPlane::NgxParserSyntaxError.new(self.filename, line, reason)
+			end
+		end
+	end
+end
+