eggshell 0.8.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7a48d71b9acc52446c52cbadca553afd4243db7
-  data.tar.gz: 3b1ec8bc1780691e2441bec34f693b6871d6a153
+  metadata.gz: 8e4e19e3f5d40c57dfd10437821105c1cb38d836
+  data.tar.gz: d96074a2df9b741327a3a7ebe626afdcab7a27d8
 SHA512:
-  metadata.gz: 66988afe180033c03dbeb032eab24559c5bfc6c368b9fe753560894fbf2ae5779d92e5b7bb905ce025b5cc10fd6c7c1611b3f223f88957ab9099cddaa187c440
-  data.tar.gz: 7b652c3a9ad4acc6c6aec68f89a3080d4312134c9a4ff22c78579c93c024f4bfa7b5c9ff43cba68295fe72ee6e061e4d9c351e9bee25d407845df6be588425b9
+  metadata.gz: a4664c527b16f16c3fe1ad8f908e67e05cc3b11c8b7012fc0224571a184a33d889c2767064da38aca52c48aac2b1d6e520b185af13f7e7d72d104c5df62d705a
+  data.tar.gz: 55e1c0cfc1ec5788ce799446bfd717e9fcd18b211b6fb80ac6453d2c6627246a1abf16de726383a7dcd55434064d6db139f8c488c34bab8e993076e7abe09ea6

data/bin/eggshell

@@ -1,4 +1,17 @@
 #!/usr/bin/ruby
+helptext = """
+Process Eggshell files from the command line:
+
+eggshell <source> # outputs to console
+eggshell <source> out=filename
+eggshell <source> format=format_hint
+
+Note that 'format' parameter hints at the source file (e.g. supplying 'md' loads the markdown support libraries)
+"""
+
+# @todo parse args
+# @todo set output redirect
+
 require_relative '../lib/eggshell.rb'
 
 f = ARGV[0]

data/lib/eggshell/block-handler.rb

@@ -1,4 +1,34 @@
+# A block handler handles one or more lines as a unit as long as all the lines
+# conform to the block's expectations.
+#
+# Blocks are either identified explicitly:
+#
+# pre. block_name. some content
+# \
+# block_name({}). some content
+#
+# Or, through some non-alphanumeric character:
+#
+# pre. |table|start|inferred
+# |another|row|here
+#
+# When a handler can handle a line, it sets an internal block type (retrieved 
+# with {{current_type()}}). Subsequent lines are passed to {{continue_with()}}
+# which returns `true` if the line conforms to the current type or `false` to
+# close the block.
+#
+# The line or lines are finally passed to {{process()}} to generate the output.
+#
+# h2. Block Standards
+#
+# When explicitly calling a block and passing a parameter, always expect the first
+# argument to be a hash of various attributes:
+#
+# pre. p({'class': '', 'id': '', 'attributes': {}}, other, arguments, ...). paragraph start
 module Eggshell::BlockHandler
+	include Eggshell::BaseHandler
+	include Eggshell::ProcessHandler
+
 	# Indicates that subsequent lines should be collected.
 	COLLECT = :collect
 
@@ -15,35 +45,43 @@ module Eggshell::BlockHandler
 	# started.
 	RETRY = :retry
 
-	def set_processor(proc)
-	end
-	
-	def set_block_params(name)
-		@block_params = {} if !@block_params
-		@block_params[name] = @proc.get_block_params(name)
+	def set_processor(proc, opts = nil)
+		@eggshell = proc
+		@eggshell.add_block_handler(self, *@block_types)
+		@vars = @eggshell.vars
+		@vars[:block_params] = {} if !@vars[:block_params]
 	end
-	
-	def create_tag(tag, attribs, open = true)
-		# @todo escape val?
-		abuff = []
-		attribs.each do |key,val|
-			if val == nil
-				abuff << key
-			else
-				abuff << "#{key}='#{val}'"
-			end
-		end
-		"<#{tag} #{abuff.join(' ')}#{open ? '>' : '/>'}"
+
+	# Resets state of line inspection.
+	def reset
+		@block_type = nil
 	end
 
-	def start(name, line, buffer, indents = '', indent_level = 0)
+	# Returns the handler's current type.
+	def current_type
+		@block_type
 	end
 
-	def collect(line, buffer, indents = '', indent_level = 0)
+	# Sets the type based on the line given, and returns one of the following:
+	#
+	# - {{RETRY}}: doesn't handle this line;
+	# - {{COLLECT}}: will collect lines following normal processing.
+	# - {{COLLECT_RAW}}: will collect lines before macro/block checks can take place.
+	# - {{DONE}}: line processed, no need to collect more lines.
+	def can_handle(line)
+		RETRY
 	end
-	
-	# For exception handling, optional information to provide context about error
-	def offsets
+
+	# Determines if processing for the current type ends (e.g. a blank line usually
+	# terminates the block).
+	# @return Symbol {{RETRY}} if not handled at all; {{COLLECT}} to collect and
+	# continue; {{DONE}} to collect this line but end the block.
+	def continue_with(line)
+		if line != nil && line != ''
+			COLLECT
+		else
+			RETRY
+		end
 	end
 
 	module Defaults
@@ -51,4 +89,104 @@ module Eggshell::BlockHandler
 			include Eggshell::BlockHandler
 		end
 	end
+
+	# Block parameters are default parameters given to a block type (e.g. setting a class).
+	# The parameters should be a map. Any keys are allowed, but for HTML, the standard keys
+	# that blocks will generally use are:
+	#
+	# - {{CLASS}}: string
+	# - {{ID}}: string
+	# - {{STYLE}}: string or map of styles.
+	# - {{ATTRIBUTES}}: map of extra tag attributes.
+	# 
+	# This module has pre-filled methods to make it is to drop in the functionality
+	# wherever it's needed. The assumption is that {{@vars}} is a hash.
+	module BlockParams
+		CLASS = 'class'
+		ID = 'id'
+		STYLE = 'style'
+		ATTRIBUTES = 'attributes'
+		KEYS = [CLASS, ID, STYLE, ATTRIBUTES].freeze
+
+		# Sets the default parameters for a block type.
+		def set_block_params(name, params)
+			params = {} if !params.is_a?(Hash)
+			@vars[:block_params][name] = params
+		end
+
+		# Gets the block params for a block type, merging in any defaults
+		# with the passed in parameters.
+		# 
+		# For the key {{ATTRIBUTES}}, individual keys within that are 
+		# compared to the default param's {{ATTRIBUTES}}.
+		def get_block_params(name, params = {})
+			params = {} if !params.is_a?(Hash)
+			bparams = @vars[:block_params][name]
+			if bparams
+				bparams.each do |key, val|
+					if key == ATTRIBUTES
+						if !params[key].is_a?(Hash)
+							params[key] = val
+						else
+							val.each do |akey, aval|
+								if !params[key].has_key?(akey)
+									params[key][akey] = aval
+								end
+							end
+						end
+					elsif !params.has_key?(key)
+						params[key] = val
+					end
+				end
+			end
+			params
+		end
+	end
+
+	# Useful methods for generating HTML tags
+	module HtmlUtils
+		def create_tag(tag, attribs, open = true)
+			nattribs = attribs.is_a?(Hash) ? attribs.clone : {}
+			if nattribs[BlockParams::STYLE].is_a?(Hash)
+				nattribs[BlockParams::STYLE] = css_string(nattribs[BlockParams::STYLE])
+			end
+
+			"<#{tag}#{attrib_string(nattribs, BlockParams::KEYS)}#{open ? '' : '/'}>"
+		end
+
+		def attrib_string(map, keys = nil)
+			keys = map.keys if !keys
+			buff = []
+			keys.each do |key|
+				val = map[key]
+				if val.is_a?(Hash)
+					buff << attrib_string(val)
+				elsif val && key[0] != '@'
+					buff << " #{key}='#{html_escape(val)}'"
+				end
+			end
+			buff.join()
+		end
+
+		def css_string(map)
+			css = []
+			map.each do |s,v|
+				css << "#{s}: #{html_escape(v)};"
+			end
+			css.join(' ')
+		end
+
+		HASH_HTML_ESCAPE = {
+			"'" => '&#039;',
+			'"' => '&quot;',
+			'<' => '&lt;',
+			'>' => '&gt;',
+			'&' => '&amp;'
+		}.freeze
+
+		# @todo more chars
+		def html_escape(str)
+			return str.gsub(/("|'|<|>|&)/, HASH_HTML_ESCAPE)
+		end
+	end	
 end

data/lib/eggshell/block.rb

@@ -1,9 +1,10 @@
 # For multiline macros, the block collects lines specific to the block (including other nested macros).
 # This allows for proper execution when dealing with loops and branches.
 class Eggshell::Block
-	def initialize(macro, handler, args, depth, delim = nil)
+	def initialize(macro, handler, args, depth, line_count, delim = nil)
 		@stack = [self]
 		@lines = []
+		@line_count = line_count
 		@macro = macro
 		@handler = handler
 		@args = args
@@ -27,7 +28,7 @@ class Eggshell::Block
 	end
 
 	# Adds a nested block to collect lines into.
-	def push(block)
+	def push(block, line_count = -1)
 		@stack[-1].lines << block
 		@stack << block
 	end