crossplane 0.1.5

data/lib/crossplane/parser.rb

@@ -0,0 +1,270 @@
+require 'crossplane/analyzer'
+require 'crossplane/globals'
+require 'crossplane/lexer'
+require 'pathname'
+require 'pp'
+
+#require_relative 'analyzer.rb'
+#require_relative 'globals.rb'
+#require_relative 'lexer.rb'
+
+module CrossPlane
+	class Parser
+		attr_accessor :analyzer
+		attr_accessor :catch_errors
+		attr_accessor :combine
+		attr_accessor :comments
+		attr_accessor :filename
+		attr_accessor :ignore
+		attr_accessor :included
+		attr_accessor :includes
+		attr_accessor :lexer
+		attr_accessor :payload
+		attr_accessor :single
+		attr_accessor :strict
+
+		def initialize(*args)
+			args = args[0] || {}
+
+			required = ['filename']
+			conflicts = []
+			requires = {}
+			valid = {
+				'params' => [
+					'catch_errors',
+					'combine',
+					'comments',
+					'filename',
+					'ignore',
+					'single',
+					'strict',
+				]
+			}
+
+			content = CrossPlane.utils.validate_constructor(client: self, args: args, required: required, conflicts: conflicts, requires: requires, valid: valid)
+			self.catch_errors = (content[:catch_errors] && content[:catch_errors] == true) ? true : false
+			self.combine = (content[:combine] && content[:combine] == true) ? true : false
+			self.comments = (content[:comments] && content[:comments] == true) ? true : false
+			self.filename = content[:filename]
+			self.ignore = content[:ignore] ? content[:ignore] : []
+			self.single = (content[:single] && content[:single] == true) ? true : false
+			self.strict = (content[:strict] && content[:strict] == true) ? true : false
+
+			self.analyzer = CrossPlane::Analyzer.new()
+			self.lexer = CrossPlane::Lexer.new(filename: self.filename)
+		end
+
+		def parse(*args, onerror:nil)
+			config_dir = File.dirname(self.filename)
+
+			self.payload = {
+				'status' => 'ok',
+				'errors' => [],
+				'config' => [],
+			}
+
+			self.includes = [[self.filename, []]] # stores (filename, config context) tuples
+			self.included = {self.filename => 0} # stores {filename: array index} hash
+
+			def _prepare_if_args(stmt)
+				args = stmt['args']
+				if args and args[0].start_with?('(') and args[-1].end_with?(')')
+					args[0] = args[0][1..-1] # left strip this
+					args[-1] = args[-1][0..-2].rstrip
+					s = args[0].empty? ? 1 : 0
+					e = args.length - (args[-1].empty? ? 1 : 0)
+					args = args[s..e]
+				end
+			end
+
+			def _handle_error(parsing, e, onerror: nil)
+				file = parsing['file']
+				error = e.to_s
+				line = e.respond_to?('lineno') ? e.lineno : nil
+
+				parsing_error = {'error' => error, 'line' => line}
+				payload_error = {'file' => file, 'error' => error, 'line' => line}
+				if not onerror.nil? and not onerror.empty?
+					payload_error['callback'] = onerror(e)
+				end
+
+				parsing['status'] = 'failed'
+				parsing['errors'].push(parsing_error)
+
+				self.payload['status'] = 'failed'
+				self.payload['errors'].push(payload_error)
+			end
+
+			def _parse(parsing, tokens, ctx:[], consume: false)
+				fname = parsing['file']
+				parsed = []
+			
+				begin
+					while tuple = tokens.next
+						token, lineno = tuple
+						# we are parsing a block, so break if it's closing
+						break if token == '}'
+
+						if consume == true
+							if token == '{'
+								_parse(parsing, tokens, consume: true)
+							end
+						end
+
+						directive = token
+
+						if self.combine
+							stmt = {
+								'file' => fname,
+								'directive' => directive,
+								'line' => lineno,
+								'args' => [],
+							}
+						else
+							stmt = {
+								'directive' => directive,
+								'line' => lineno,
+								'args' => [],
+							}
+						end
+
+						# if token is comment
+						if directive.start_with?('#')
+							if self.comments
+								stmt['directive'] = '#'
+								stmt['comment'] = token[1..-1].lstrip
+								parsed.push(stmt)
+							end
+							next
+						end
+
+						# TODO: add external parser checking and handling
+
+						# parse arguments by reading tokens
+						args = stmt['args']
+						token, _ = tokens.next
+						while not ['{', '}', ';'].include?(token)
+							stmt['args'].push(token)
+							token, _ = tokens.next
+						end
+
+						# consume the directive if it is ignored and move on
+						if self.ignore.include?(stmt['directive'])
+							# if this directive was a block consume it too
+							if token == '{'
+								_parse(parsing, tokens, consume: true)
+							end
+							next
+						end
+
+						# prepare arguments
+						if stmt['directive'] == 'if'
+							_prepare_if_args(stmt)
+						end
+
+						begin
+							# raise errors if this statement is invalid
+							self.analyzer.analyze(
+								fname,
+								stmt,
+								token,
+								ctx,
+								self.strict
+							)
+						rescue NgxParserDirectiveError => e
+							if self.catch_errors
+								_handle_error(parsing, e)
+
+								# if it was a block but shouldn't have been then consume
+								if e.strerror.end_with(' is not terminated by ";"')
+									if token != '}'
+										_parse(parsing, tokens, consume: true)
+									else
+										break
+									end
+								end
+								next
+							else
+								raise e
+							end
+						end
+
+						# add "includes" to the payload if this is an include statement
+						if not self.single and stmt['directive'] == 'include'
+							pattern = args[0]
+							p = Pathname.new(args[0])
+							if not p.absolute?
+								pattern = File.join(config_dir, args[0])
+							end
+
+							stmt['includes'] = []
+
+							# get names of all included files
+							# ruby needs a python glob.has_magic equivalent
+							if pattern =~ /\*/
+								fnames = Dir.glob(pattern)
+							else
+								begin
+									open(pattern).close
+									fnames = [pattern]
+								rescue Exception => e
+									f = CrossPlane::NgxParserIncludeError.new(fname, stmt['line'], e.message)
+									fnames = []
+									if self.catch_errors
+										_handle_error(parsing, f)
+									else
+										raise f
+									end
+								end
+							end
+
+							fnames.each do |fname|
+								# the included set keeps files from being parsed twice
+								# TODO: handle files included from multiple contexts
+								if not self.included.include?(fname)
+									self.included[fname] = self.includes.length
+									self.includes.push([fname, ctx])
+								end
+								index = self.included[fname]
+								stmt['includes'].push(index)
+							end
+						end
+
+						# if this statement terminated with '{' then it is a block
+						if token == '{'
+							inner = self.analyzer.enter_block_ctx(stmt, ctx) # get context for block
+							stmt['block'] = _parse(parsing, tokens, ctx: inner)
+						end
+						parsed.push(stmt)
+					end
+					return parsed
+				rescue StopIteration
+					return parsed
+				end
+			end
+
+			self.includes.each do |fname, ctx|
+				tokens = self.lexer.lex().to_enum
+				parsing = {
+					'file' => fname,
+					'status' => 'ok',
+					'errors' => [],
+					'parsed' => [],
+				}
+
+				begin
+					parsing['parsed'] = _parse(parsing, tokens.to_enum, ctx: ctx)
+				rescue Exception => e
+					_handle_error(parsing, e, onerror: onerror)
+				end
+				self.payload['config'].push(parsing)
+			end
+
+			if self.combine
+				return _combine_parsed_configs(payload)
+			else
+				return self.payload
+			end
+		end
+	end
+end

data/lib/crossplane/utils.rb

@@ -0,0 +1,128 @@
+require 'crossplane/errors'
+require 'logger'
+
+#require_relative 'errors.rb'
+
+module CrossPlane
+	class Utils
+		attr_accessor :logger
+
+		def initialize(*args)
+			self.logger = configure_logger()
+		end
+
+		def isspace(string)
+			return string =~ /^\s+$/ ? true : false
+		end
+
+		def generate_random(length: 64)
+			o = [('a'..'z'), ('A'..'Z')].map(&:to_a).flatten
+			string = (0...length).map { o[rand(o.length)] }.join
+			string
+		end
+
+		def configure_logger(debug: nil)
+			logger = Logger.new(STDOUT)
+			logger.datetime_format = '%Y-%m-%d %H:%M:%S'
+			logger.formatter = proc do |severity, datetime, progname, msg|
+				format("[%s] %s\n", severity.capitalize, msg)
+			end
+			return logger
+		end
+
+		def validate_constructor(client: nil, args: nil, required: nil, conflicts: nil, requires: nil, valid: {})
+			content = {}
+			errors = []
+			booleans = ['catch_errors', 'combine', 'comments', 'single', 'strict']
+			hashes = []
+			arrays = ['ignore']
+			ints = ['indent']
+			args = Hash[args.map{ |k, v| [k.to_s, v] }]
+			args.each do |k, v|
+				args.delete(k) if v == nil
+			end
+
+			if ((required - args.keys).length != 0)
+				errors.push(missing_opts_error(required - args.keys))
+			end
+
+			if conflicts.length > 0
+				conflicts.each do |conflict_item|
+					if (0 && (conflict_item & args.keys).length > 1)
+						errors.push(conflicting_opts_error(conflict_item))
+					end
+				end
+			end
+
+			if requires.keys.length > 0
+				requires.each do |key, required|
+					if args.keys.include?(key)
+						intersection = required & args.keys
+						unless (required & args.keys).length == required.length
+							missing = required - intersection
+							if missing.length > 0
+								errors.push(missing_requires_error(key, missing))
+							end
+						end
+					end
+				end
+			end
+
+			if valid['params']
+				valid['params'].each do |param|
+					if (args.has_key?(param)) and (valid['params'].include?(param))
+						if ints.include?(param)
+							begin
+								content[param.to_sym] = args[param].to_i
+							rescue
+								errors.push(format('%s must be an integer', param))
+							end
+						end
+
+						if booleans.include?(param)
+							if args[param].is_a?(TrueClass) or args[param].is_a?(FalseClass)
+								content[param.to_sym] = args[param] == true ? true : false
+							elsif args[param].is_a?(String)
+								content[param.to_sym] = args[param].downcase == 'true' ? true : false
+							else
+								content[param.to_sym] = false
+							end
+						end
+						content[param.to_sym] = args[param]
+					end
+				end
+			end
+
+			if errors.length > 0
+				raise CrossPlane::ConstructorError.new(errors: errors)
+			else
+				return content
+			end
+		end
+
+		private
+		def conflicting_opts_error(conflict)
+			return format('the following parameters are mutually exclusive: %s', conflict.join(', '))
+		end
+
+		def missing_requires_error(key, missing)
+			return format('if you specify "%s", you must also specify: (%s)', key, missing.join(', '))
+		end
+
+		def missing_opts_error(missing)
+			return format('the following required parameters are missing: %s', missing.join(', '))
+		end
+
+		def disallowed_opts_error(disallowed)
+			return format('the following disallowed parameters were specified in the constructor: %s', disallowed.join(', '))
+		end
+
+		def missing_optional_error(oneof)
+			return format('the constructor requires one of the following parameters: %s', oneof.join(', '))
+		end
+
+		def too_many_optional_error(oneof)
+			return format('the constructor will accept only one of the following parameters: %s', oneof.join(', '))
+		end
+	end
+end

data/lib/crossplane/version.rb

@@ -0,0 +1,3 @@
+module Crossplane
+  VERSION = '0.1.5'
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: crossplane
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- Gary Danko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-06-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.3
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+description: Quick and reliable way to convert NGINX configurations into JSON and
+  back. Based on the NGINX crossplane project at https://github.com/nginxinc/crossplane
+email:
+- gary_danko@intuit.com
+executables:
+- crossplane
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/crossplane
+- lib/crossplane/analyzer.rb
+- lib/crossplane/builder.rb
+- lib/crossplane/cli.rb
+- lib/crossplane/config.rb
+- lib/crossplane/errors.rb
+- lib/crossplane/globals.rb
+- lib/crossplane/lexer.rb
+- lib/crossplane/parser.rb
+- lib/crossplane/utils.rb
+- lib/crossplane/version.rb
+homepage: https://github.com/gdanko/crossplane
+licenses:
+- GPL-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Reliable and fast NGINX configuration file parser and builder
+test_files: []