eggshell 1.0.3 → 1.1.1

data/lib/eggshell/processor.rb

@@ -1,10 +1,13 @@
 module Eggshell
 	class Processor
-		BLOCK_MATCH = /^([a-z0-9_-]+\.)/
-		BLOCK_MATCH_PARAMS = /^([a-z0-9_-]+)\(/
+		BLOCK_MATCH = /^([a-zA-Z_][a-z0-9_-]*\.)/
+		BLOCK_MATCH_PARAMS = /^([a-zA-Z_][a-z0-9_-]*)\s*\(/
+		
+		@@ee = Eggshell::ExpressionEvaluator.new
 
-		def initialize
-			@context = Eggshell::ProcessorContext.new
+		def initialize(context = nil)
+			@context = context
+			@context = Eggshell::ProcessorContext.new if !context.is_a?(Eggshell::ProcessorContext)
 			@vars = @context.vars
 			@funcs = @context.funcs
 			@macros = @context.macros
@@ -14,6 +17,9 @@ module Eggshell
 			@expr_cache = @context.expr_cache
 			@fmt_handlers = @context.fmt_handlers
 			@ee = Eggshell::ExpressionEvaluator.new(@vars, @funcs)
+			
+			@vars[:include_paths] = [] if !@vars[:include_paths]
+			@vars[:include_paths] << File.realdirpath(Dir.pwd())
 
 			@noop_macro = Eggshell::MacroHandler::Defaults::NoOpHandler.new
 			@noop_block = Eggshell::BlockHandler::Defaults::NoOpHandler.new
@@ -29,6 +35,10 @@ module Eggshell
 			end
 		end
 		
+		def get_block_handler(name)
+			@blocks_map[name]
+		end
+		
 		def rem_block_handler(*names)
 			_trace "rem_block_handler: #{names.inspect}"
 			names.each do |name|
@@ -44,6 +54,10 @@ module Eggshell
 			end
 		end
 		
+		def get_macro_handler(name)
+			@macros[name]
+		end
+		
 		def rem_macro_handler(*names)
 			_trace "rem_macro_handler: #{names.inspect}"
 			names.each do |name|
@@ -51,17 +65,8 @@ module Eggshell
 			end
 		end
 
-		# Registers a function for embedded expressions. Functions are grouped into namespaces,
-		# and a handler can be assigned to handle all function calls within that namespace, or
-		# a specific set of functions within the namespace. The root namespace is a blank string.
-		#
-		# @param String func_key In the form `ns` or `ns:func_name`. For functions in the 
-		# root namespace, do `:func_name`.
-		# @param Object handler
-		# @param Array func_names If `func_key` only refers to a namespace but the handler
-		# needs to only handle a subset of functions, supply the list of function names here.
-		def register_functions(func_key, handler, func_names = nil)
-			@ee.register_functions(func_key, handler, func_names)
+		def register_functions(handler, names = nil, ns = '')
+			@ee.register_functions(handler, names, ns)
 		end
 
 		def _error(msg)
@@ -90,7 +95,7 @@ module Eggshell
 		attr_reader :vars
 
 		def expr_eval(struct)
-			return Eggshell::ExpressionEvaluator.expr_eval(struct, @vars, @funcs)
+			return @ee.evaluate(struct)
 		end
 
 		# Expands expressions (`\${}`) and macro calls (`\@@macro\@@`).
@@ -135,7 +140,7 @@ module Eggshell
 						struct = @expr_cache[expr_str]
 
 						if !struct
-							struct = Eggshell::ExpressionEvaluator.struct(expr_str)
+							struct = @ee.parse(expr_str)
 							@expr_cache[expr_str] = struct
 						end
 
@@ -188,41 +193,6 @@ module Eggshell
 		TAB = "\t"
 		TAB_SPACE = '    '
 
-		# @param Boolean is_default If true, associates these parameters with the 
-		# `block_type` used in `get_block_param()` or explicitly in third parameter.
-		# @param String block_type
-		def set_block_params(params, is_default = false, block_type = nil)
-			if block_type && is_default
-				@block_params[block_type] = params
-			else
-				@block_params[:pending] = params
-				@block_param_default = is_default
-			end
-		end
-
-		# Gets the block parameters for a block type, and merges default values if available.
-		def get_block_params(block_type)
-			bp = @block_params.delete(:pending)
-			if @block_params_default
-				if block_type && bp
-					@block_params[block_type] = bp if bp
-				end
-				@block_params_default = false
-				bp = {} if !bp
-			else
-				bp = {} if !bp
-				default = @block_params[block_type]
-				if default
-					default.each do |key,val|
-						if !bp.has_key?(key) && val
-							bp[key] = val.clone
-						end
-					end
-				end
-			end
-			return bp
-		end
-
 		# Sets the default output object. Must support {{<<}} and {{join(String)}}.
 		#
 		# If {{out}} is a `Class`, must support empty initialization.
@@ -337,11 +307,18 @@ module Eggshell
 						stat = parse_tree.collect(line_norm)
 						next if stat != BH::RETRY
 						parse_tree.push_block
+					elsif parse_tree.mode == :macro_raw
+						if !parse_tree.macro_delim_match(line_norm, line_count)
+							parse_tree.collect_macro_raw(line_norm)
+						end
+						next
 					end
 
 					# macro processing
 					if line[0] == '@'
-						parse_tree.new_macro(line_norm, line_count)
+						macro, args, delim = parse_macro_start(line)
+						mhandler = get_macro_handler(macro)
+						parse_tree.new_macro(line_norm, line_count, macro, args, delim, mhandler ? mhandler.collection_type(macro) : nil)
 						next
 					elsif parse_tree.macro_delim_match(line_norm, line_count)
 						next
@@ -367,7 +344,7 @@ module Eggshell
 						stat = handler.can_handle(line)
 						next if stat == BH::RETRY
 						
-						parse_tree.new_block(handler, handler.current_type, line_norm, stat, line_count)
+						parse_tree.new_block(handler, handler.current_type, line_norm, stat, line_count, self)
 						found = true
 						_trace "(#{handler.current_type}->#{handler}) #{line} -> #{stat}"
 						break
@@ -375,7 +352,7 @@ module Eggshell
 
 					if !found
 						@blocks_map['p'].can_handle('p.')
-						parse_tree.new_block(@blocks_map['p'], 'p', line_norm, BH::COLLECT, line_count)
+						parse_tree.new_block(@blocks_map['p'], 'p', line_norm, BH::COLLECT, line_count, self)
 					end
 				end
 				parse_tree.push_block
@@ -417,11 +394,11 @@ module Eggshell
 			joiner = opts[:join] || "\n"
 
 			parse_tree = parse_tree.tree if parse_tree.is_a?(Eggshell::ParseTree)
-			raise Exception.new("input not an array or ParseTree (depth=#{call_depth}") if !parse_tree.is_a?(Array)
-			# @todo defer process to next unit so macro can inject lines back into previous block
-			
+			raise Exception.new("input not an array or ParseTree (depth=#{call_depth})") if !parse_tree.is_a?(Array)
+
 			last_type = nil
 			last_line = 0
+			last_macro = nil
 			deferred = nil
 
 			parse_tree.each do |unit|
@@ -445,13 +422,12 @@ module Eggshell
 					args_o = unit[2] || []
 					args = []
 					args_o.each do |arg|
-						args << expr_eval(arg)
+						args << (arg.is_a?(Array) ? @@ee.evaluate([:array, arg]) : arg)
 					end
-						
+
 					lines = unit[ParseTree::IDX_LINES]
 					lines_start = unit[ParseTree::IDX_LINES_START]
 					lines_end = unit[ParseTree::IDX_LINES_END]
-
 					_handler, _name, _args, _lines = deferred
 
 					if unit[0] == :block
@@ -522,7 +498,7 @@ module Eggshell
 
 		def process(lines, line_count = 0, call_depth = 0)
 			parse_tree = preprocess(lines, line_count)
-			assemble(parse_tree.tree, call_depth)
+			assemble(Eggshell::ParseTree.condense(self, parse_tree.tree), call_depth)
 		end
 
 		# Register inline format handlers with opening and closing tags.
@@ -612,21 +588,22 @@ module Eggshell
 			buff.join('')
 		end
 
-		def self.parse_block_start(line)
+		def parse_block_start(line)
 			block_type = nil
 			args = []
 
 			bt = line.match(BLOCK_MATCH_PARAMS)
 			if bt
 				idx0 = bt[0].length
-				idx1 = line.index(').', idx0)
+				idx1 = line.index(')', idx0)
 				if idx1
 					block_type = line[0..idx0-2]
 					params = line[0...idx1+1].strip
 					line = line[idx1+2..line.length] || ''
 					if params != ''
-						struct = ExpressionEvaluator.struct(params)
+						struct = @ee.parse(params)
 						args = struct[0][2]
+						#args = @ee.evaluate([[:array, struct[0][2]]])
 					end
 				end
 			else
@@ -644,7 +621,7 @@ module Eggshell
 			[block_type, args, line]
 		end
 
-		def self.parse_macro_start(line)
+		def parse_macro_start(line)
 			macro = nil
 			args = []
 			delim = nil
@@ -652,11 +629,12 @@ module Eggshell
 			# either macro is a plain '@macro' or it has parameters/opening brace
 			if line.index(' ') || line.index('(') || line.index('{')
 				# since the macro statement is essentially a function call, parse the line as an expression to get components
-				expr_struct = ExpressionEvaluator.struct(line)
+				expr_struct = @ee.parse(line)
 				fn = expr_struct.shift
-				if fn.is_a?(Array) && (fn[0] == :fn || fn[0] == :var)
-					macro = fn[1][1..fn[1].length]
-					args = fn[2]
+
+				if fn.is_a?(Array) && (fn[0] == :func || fn[0] == :var)
+					macro = fn[1]
+					args = fn[2] # @@ee.evaluate([:array, fn[2]])
 					if expr_struct[-1].is_a?(Array) && expr_struct[-1][0] == :brace_op
 						delim = expr_struct[-1][1]
 					end

data/lib/eggshell/stream.rb

@@ -0,0 +1,43 @@
+# Interfaces and helper classes to have processor-friendly streams.
+module Eggshell; module Stream;
+	def <<(str)
+	end
+	
+	def join(str)
+	end
+	
+	def write(str)
+	end
+	
+	def [](index)
+	end
+	
+	class IOWrapper
+		include Stream
+		
+		def initialize(stream)
+			@stream = stream
+			@buff = []
+		end
+		
+		def <<(str)
+			@buff << str
+		end
+		
+		def write(str)
+			@stream.write(str)
+		end
+		
+		def join(str)
+			@buff.join(str)
+		end
+		
+		def [](index)
+			@buff[index]
+		end
+		
+		def flush
+			@stream.write(@buff.join("\n"))
+		end
+	end
+end; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eggshell
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.1.1
 platform: ruby
 authors:
 - Kaiser Shahid
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-20 00:00:00.000000000 Z
+date: 2017-08-16 00:00:00.000000000 Z
 dependencies: []
 description: From fast and basic HTML to complex decouments and more, Eggshell aims
   to provide you with all the document generation power you need through simple markup.
@@ -22,15 +22,21 @@ files:
 - lib/eggshell/block-handler.rb
 - lib/eggshell/block.rb
 - lib/eggshell/bundles.rb
+- lib/eggshell/bundles/basic-functions.rb
 - lib/eggshell/bundles/basics-old.rb
 - lib/eggshell/bundles/basics.rb
 - lib/eggshell/bundles/loader.rb
+- lib/eggshell/compiler.rb
 - lib/eggshell/expression-evaluator.rb
+- lib/eggshell/expression-evaluator/evaluator.rb
+- lib/eggshell/expression-evaluator/lexer.rb
+- lib/eggshell/expression-evaluator/parser.rb
 - lib/eggshell/format-handler.rb
 - lib/eggshell/macro-handler.rb
 - lib/eggshell/parse-tree.rb
 - lib/eggshell/processor-context.rb
 - lib/eggshell/processor.rb
+- lib/eggshell/stream.rb
 homepage: https://acmedinotech.com/products/eggshell
 licenses:
 - MIT