general 1.5.0 → 2.0.0

data/lib/gtemplates/gio.rb

@@ -0,0 +1,143 @@
+# General is a templating system in ruby
+# Copyright (C) 2016  Anshul Kharbanda
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require_relative "gtemplate"
+require_relative "gmeta"
+require_relative "../gerror"
+require_relative "../gprepartials/gpretext"
+require_relative "../gprepartials/ginclude"
+require_relative "../gprepartials/gextend"
+require_relative "../gprepartials/gyield"
+
+# General is a templating system in ruby
+#
+# Author: Anshul Kharbanda
+# Created: 3 - 4 - 2016
+module General
+	# Implements the general IO writer template
+	#
+	# Author: Anshul Kharbanda
+	# Created: 3 - 4 - 2016
+	class GIO < GTemplate
+		# The general file extension
+		EXTENSION = ".general"
+
+		# Public read source
+		attr :source
+
+		# Loads a GIO from a file with the given path
+		#
+		# Parameter: path - the path of the file to load
+		#
+		# Return: GIO loaded from the file
+		def self.load path
+			# Get current working directory
+			cwd = Dir.getwd
+
+			# Change to path of file
+			Dir.chdir File.dirname(path)
+
+			# Read raw text
+			string = IO.read File.basename(path)
+
+			# Prepartial types
+			ptypes = [
+				General::GExtend,
+				General::GInclude,
+				General::GYield,
+				General::GPretext
+			]
+
+			# Breakdown algorithm
+			preparts = []
+			m = nil
+			while string.length > 0
+				# Match the front of the string to a preprocessor
+				prepart = ptypes.find { |ptype| m = ptype::REGEX.match(string) }
+
+				# Raise error if no matching prepart can be found
+				if prepart.nil?
+					Dir.chdir cwd # Make sure to change back to current directory
+					raise GError.new "Unmatched prepartial at #{(string.length <= 5 ? string : string[0..5] + "...").inspect}"
+				end
+
+				# Add the partial to the array
+				preparts << prepart.new(m)
+
+				# Trim the front of the string
+				string = string[m.end(0)..-1]
+			end
+
+			# Find an extend
+			extindex = preparts.index{ |prepart| prepart.is_a? General::GExtend }
+
+			# Run extend algorithm (throw error if extend is found elsewhere)
+			if extindex == 0
+				begin
+					preparts = GMeta.load(preparts[extindex].filename+General::GIO::EXTENSION).gextend(preparts[1..-1])
+				rescue GError => e
+					Dir.chdir cwd # Make sure to change back to current directory
+					raise e
+				end
+			elsif !extindex.nil?
+				Dir.chdir cwd # Make sure to change back to current directory
+				raise GError.new "@@extend prepartial needs to be at beginning of template."
+			end
+
+			# Find a yield
+			yindex = preparts.index{ |prepart| prepart.is_a? General::GYield }
+
+			# Raise error if yield is found
+			unless yindex.nil?
+				Dir.chdir cwd # Make sure to change back to current directory
+				raise GError.new "#{path} is a meta template and cannot be parsed. Must be extended by other GIO template"
+			end
+
+			# Combine text
+			text = preparts.collect{ |prepart| prepart.apply }.join
+
+			# Change to current directory
+			Dir.chdir cwd
+
+			# Return new GIO
+			return self.new text, path
+		end
+
+		# Creates a GIO with the given template string and source filename
+		#
+		# Parameter: string - the string being converted to a template
+		# Parameter: source - the name of the source file of the template
+		def initialize string, source=nil
+			super string
+			@source = source
+		end
+
+		# Writes the template with the given data applied to the target stream
+		#
+		# Parameter: ios  - if String, is the name of the file to write to
+		# 					if IO, is the stream to write to
+		# Parameter: data - the data to be applied (merges with defaults)
+		def write ios, data={}
+			if ios.is_a? String
+				IO.write ios, apply(data)
+			elsif ios.is_a? IO
+				ios.write apply(data)
+			else
+				raise TypeError.new "Expected IO or String, got: #{ios.class}"
+			end
+		end
+	end
+end

data/lib/gtemplates/gmeta.rb

@@ -0,0 +1,106 @@
+# General is a templating system in ruby
+# Copyright (C) 2016  Anshul Kharbanda
+# 
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+require_relative "gtemplate"
+
+# General is a templating system in ruby
+#
+# Author: Anshul Kharbanda
+# Created: 3 - 4 - 2016
+module General
+	# Represents an abstract meta file
+	#
+	# Author: Anshul Kharbanda
+	# Created: 1 - 31 - 2016
+	class GMeta < GTemplate
+		def self.load filename
+			# Read file
+			string = IO.read filename
+
+			# Prepartial types
+			ptypes = [
+				General::GExtend,
+				General::GInclude,
+				General::GYield,
+				General::GPretext
+			]
+
+			# Breakdown algorithm
+			preparts = []
+			m = nil
+			loop do
+				# Match the front of the string to a preprocessor
+				prepart = ptypes.find { |ptype| m = ptype::REGEX.match(string) }
+
+				# Raise error if no matching prepart can be found
+				raise GError.new("Unmatched prepartial at #{(string.length <= 5 ? string : string[0..5] + "...").inspect}") if prepart.nil?
+
+				# Add the partial to the array
+				preparts << prepart.new(m)
+
+				# Trim the front of the string
+				string = string[m.end(0)..-1]
+
+				# End when string is empty
+				break if string.length == 0
+			end
+
+			# Find an extend
+			extindex = preparts.index{ |prepart| prepart.is_a? General::GExtend }
+
+			# Run extend algorithm (throw error if extend is found elsewhere)
+			if extindex == 0
+				GMeta.load(extindex.filename).gextend(preparts)
+			elsif !extindex.nil? && extindex > 0
+				raise GError.new "@@extend prepartial needs to be at beginning of template."
+			end
+
+			# Check for multiple yields
+			yields = preparts.find_all{ |prepart| prepart.is_a? General::GYield  }
+			raise GError.new "@@yield prepartial can only appear ONCE!" if yields.length > 1
+
+			# Find the yield
+			yindex = preparts.index{ |prepart| prepart.is_a? General::GYield }
+
+			# Return a new meta file if yield is found. Else default is end.
+			unless yindex.nil?
+				return self.new preparts[0...yindex], preparts[(yindex + 1)..-1], filename
+			else
+				return self.new preparts, [], filename
+			end
+		end
+
+		# Creates a new GMeta
+		#
+		# Parameter: top    - the top end of the meta (in preparts)
+		# Parameter: bottom - the bottom end of the data (in preparts)
+		# Parameter: source - the source of the file
+		def initialize top, bottom, source=nil
+			@top    = top
+			@bottom = bottom
+			@source = source
+		end
+
+		# Extends the given preparts from the GMeta
+		#
+		# Parameter: preparts - the preparts array to extend
+		#
+		# Returns: the extended preparts
+		def gextend preparts
+			return @top + preparts + [General::GPretext.new("\r\n")] + @bottom
+		end
+	end
+end

data/lib/{templates → gtemplates}/gtemplate.rb

@@ -16,7 +16,10 @@
 
 require_relative "gbasetemplate"
 require_relative "../gpartials/gtext"
+require_relative "../gpartials/gspecial"
 require_relative "../gpartials/gplaceholder"
+require_relative "../gpartials/garrayplaceholder"
+require_relative "../gpartials/gfullplaceholder"
 
 # General is a templating system in ruby
 #
@@ -32,36 +35,13 @@ module General
 		#
 		# Parameter: string - the string being converted to a template
 		def initialize string
-			super(string)
-			@defaults = General::GDotHash.new
-
-			# The string gets split into partials by placeholder and array template
-			loop do
-				if match = General::GText::REGEX.match(string)
-					@partials << General::GText.new(match)
-				elsif match = General::GSpecial::REGEX.match(string)
-					@partials << General::GSpecial.new(match)
-				elsif match = General::GArrayPlaceholder::REGEX.match(string)
-					@partials << General::GArrayPlaceholder.new(match)
-				elsif match = General::GPlaceholder::REGEX.match(string)
-					@partials << General::GPlaceholder.new(match, @defaults)
-				else
-					return
-				end
-				string = string[match.end(0)..-1]
-			end
-		end
-
-		# Returns a string representation of the string
-		#
-		# Return: a string representation of the string
-		def to_s
-			first = Hash.new(true); str = ""
-			@partials.each do |part|
-				str += part.string(first[part.name])
-				first[part.name] &&= false
-			end
-			return str
+			super(string, [
+				General::GText,
+				General::GSpecial,
+				General::GArrayPlaceholder,
+				General::GPlaceholder,
+				General::GFullPlaceholder
+			])
 		end
 
 		# Returns the string as a regex

data/lib/{templates → gtemplates}/gtimeformat.rb

@@ -16,6 +16,7 @@
 
 require_relative "gbasetemplate"
 require_relative "../gpartials/gtext"
+require_relative "../gpartials/gspecial"
 require_relative "../gpartials/gtimeformatplaceholder"
 
 # General is a templating system in ruby
@@ -32,18 +33,11 @@ module General
 		#
 		# Parameter: string - the template string
 		def initialize string
-			super string
-
-			loop do
-				if match = General::GText::REGEX.match(string)
-					@partials << General::GText.new(match)
-				elsif match = General::GTimeFormatPlaceholder::REGEX.match(string)
-					@partials << General::GTimeFormatPlaceholder.new(match)
-				else
-					return
-				end
-				string = string[match.end(0)..-1]
-			end
+			super(string, [
+				General::GSpecial,
+				General::GText,
+				General::GTimeFormatPlaceholder
+			])
 		end
 
 		# Applies the given integer value to the template and returns the generated string

data/spec/gdothash_spec.rb

@@ -70,18 +70,14 @@ describe General::GDotHash do
 	# Parameter: key   - the key to set
 	# Parameter: value - the value to set
 	describe '#[]=' do
-		context 'if given position exists' do
-			it 'sets the position addressed by the given dot notation key to the given value' do
-				expect { @gdothash[@key1] = @newvalue1 }.not_to raise_error
-				expect(@gdothash[@key1]).to eql @newvalue1
-			end
+		it 'sets the position addressed by the given dot notation key (if it exists) to the given value' do
+			expect { @gdothash[@key1] = @newvalue1 }.not_to raise_error
+			expect(@gdothash[@key1]).to eql @newvalue1
 		end
 
-		context 'if given position does not exist' do
-			it 'creates position addressed by the given dot notation key in the given hash and sets it to the given value' do
-				expect { @gdothash[@key2] = @newvalue2 }.not_to raise_error
-				expect(@gdothash[@key2]).to eql @newvalue2
-			end
+		it 'creates position addressed by the given dot notation key (if it does not exist) and sets it to the given value' do
+			expect { @gdothash[@key2] = @newvalue2 }.not_to raise_error
+			expect(@gdothash[@key2]).to eql @newvalue2
 		end
 	end
 end

data/spec/goperations_spec.rb

@@ -39,41 +39,31 @@ describe General::GOperations do
 			@out_all   = "Joe Schmoe"
 		end
 
-		context 'with string argument given' do
+		context 'with no second argument given' do
 			it 'capitalizes the first letter in the string' do
 				expect(General::GOperations.capitalize(@input)).to eql @out_first
 			end
-		end
 
-		context 'with string argument and second string argument is given' do
-			context 'when the second argument is "first"' do
-				it 'capitalizes the first letter in the string' do
-					expect(General::GOperations.capitalize @input, "first").to eql @out_first
-				end
+			it 'raises GOperationError with no string argument' do
+				expect { General::GOperations.capitalize }.to raise_error General::GOperationError
 			end
 
-			context 'when the second argument is "all"' do
-				it 'capitalizes all words in the string' do
-					expect(General::GOperations.capitalize @input, "all").to eql @out_all
-				end
+			it 'raises GOperationError with argument of another type' do
+				expect { General::GOperations.capitalize(0) }.to raise_error General::GOperationError
 			end
+		end
 
-			context 'when the second argument is neither "first" or "all"' do
-				it 'raises TypeError' do
-					expect{General::GOperations.capitalize @input, "foo"}.to raise_error TypeError
-				end
+		context 'with string argument and second string argument is given' do
+			it 'capitalizes the first letter in the string when the second argument is "first"' do
+				expect(General::GOperations.capitalize @input, "first").to eql @out_first
 			end
-		end
 
-		context 'with no string argument' do
-			it 'raises Error' do
-				expect { General::GOperations.capitalize }.to raise_error ArgumentError
+			it 'capitalizes all words in the string when the second argument is "all"' do
+				expect(General::GOperations.capitalize @input, "all").to eql @out_all
 			end
-		end
 
-		context 'with argument of another type' do
-			it 'raises Error' do
-				expect { General::GOperations.capitalize(0) }.to raise_error TypeError
+			it 'raises GOperationError when the second argument is neither "first" or "all"' do
+				expect{General::GOperations.capitalize @input, "foo"}.to raise_error General::GOperationError
 			end
 		end
 	end
@@ -91,22 +81,16 @@ describe General::GOperations do
 			@output = "JOE SCHMOE"
 		end
 
-		context 'with string argument given' do
-			it 'converts the string to uppercase' do
-				expect(General::GOperations.uppercase @input).to eql @output
-			end
+		it 'converts the string to uppercase' do
+			expect(General::GOperations.uppercase @input).to eql @output
 		end
 
-		context 'with no string argument' do
-			it 'raises Error' do
-				expect { General::GOperations.uppercase }.to raise_error ArgumentError
-			end
+		it 'raises GOperationError with no string argument' do
+			expect { General::GOperations.uppercase }.to raise_error General::GOperationError
 		end
 
-		context 'with argument of another type' do
-			it 'raises Error' do
-				expect { General::GOperations.capitalize(0) }.to raise_error TypeError
-			end
+		it 'raises GOperationError with argument of another type' do
+			expect { General::GOperations.capitalize(0) }.to raise_error General::GOperationError
 		end
 	end
 
@@ -123,22 +107,16 @@ describe General::GOperations do
 			@output = "joe schmoe"
 		end
 
-		context 'with string argument given' do
-			it 'converts the string to lowercase' do
-				expect(General::GOperations.lowercase @input).to eql @output
-			end
+		it 'converts the string to lowercase' do
+			expect(General::GOperations.lowercase @input).to eql @output
 		end
 
-		context 'with no string argument' do
-			it 'raises Error' do
-				expect { General::GOperations.lowercase }.to raise_error ArgumentError
-			end
+		it 'raises GOperationError with no string argument' do
+			expect { General::GOperations.lowercase }.to raise_error General::GOperationError
 		end
 
-		context 'with argument of another type' do
-			it 'raises Error' do
-				expect { General::GOperations.capitalize(0) }.to raise_error TypeError
-			end
+		it 'raises GOperationError with argument of another type' do
+			expect { General::GOperations.capitalize(0) }.to raise_error General::GOperationError
 		end
 	end
 
@@ -162,37 +140,29 @@ describe General::GOperations do
 			@output4 = "-€3.44"
 		end
 
-		context 'with an integer value given' do
+		context 'with no second string value given' do
 			it 'formats the monetary value into USD' do
 				expect(General::GOperations.money @money1).to eql @output1
 				expect(General::GOperations.money @money2).to eql @output2
 			end
-		end
 
-		context 'with an integer value given and another string value given' do
-			context 'if string money value is supported' do
-				it 'formats the monetary value according the the money type' do
-					expect(General::GOperations.money @money1, "EUR").to eql @output3
-					expect(General::GOperations.money @money2, "EUR").to eql @output4
-				end
+			it 'raises GOperationError with no integer value given' do
+				expect { General::GOperations.money }.to raise_error General::GOperationError
 			end
 
-			context 'if string money value is not supported' do
-				it 'raises TypeError' do
-					expect { General::GOperations.money(@money1, "RUE") }.to raise_error TypeError
-				end
+			it 'raises GOperationError with argument of another type' do
+				expect { General::GOperations.money "" }.to raise_error General::GOperationError
 			end
 		end
 
-		context 'with no integer value given' do
-			it 'raises Error' do
-				expect { General::GOperations.money }.to raise_error ArgumentError
+		context 'with an integer value given and another string value given' do
+			it 'formats the monetary value according to the money type' do
+				expect(General::GOperations.money @money1, "EUR").to eql @output3
+				expect(General::GOperations.money @money2, "EUR").to eql @output4
 			end
-		end
 
-		context 'with argument of another type' do
-			it 'raises Error' do
-				expect { General::GOperations.money "" }.to raise_error TypeError
+			it 'raises GOperationError if the money type is not supported' do
+				expect { General::GOperations.money(@money1, "RUE") }.to raise_error General::GOperationError
 			end
 		end
 	end
@@ -219,28 +189,88 @@ describe General::GOperations do
 			@out2 = General::GTimeFormat.new(@formatter).apply(@time)
 		end
 
-		context 'with integer value given' do
-			it 'formats the given time value to the default time format' do
-				expect(General::GOperations.time(@time)).to eql @out1
-			end
+		it 'formats the given time value to the default time format' do
+			expect(General::GOperations.time(@time)).to eql @out1
 		end
 
-		context 'with integer value given and time format given' do
-			it 'formats the given time value to the given time format' do
-				expect(General::GOperations.time(@time, @formatter)).to eql @out2
-			end
+		it 'formats the given time value to the given time format' do
+			expect(General::GOperations.time(@time, @formatter)).to eql @out2
 		end
 
-		context 'with no integer value given' do
-			it 'raises Error' do
-				expect { General::GOperations.time }.to raise_error ArgumentError
-			end
+		it 'raises GOperationError with argument of another type' do
+			expect { General::GOperations.time "" }.to raise_error General::GOperationError
 		end
+	end
 
-		context 'with argument of another type' do
-			it 'raises Error' do
-				expect { General::GOperations.time "" }.to raise_error TypeError
-			end
+	#----------------------------------TO ARRAY OPERATIONS------------------------------------
+
+	# Splits the string by the given delimeter (or by newline if no delimeter is given)
+	#
+	# Parameter: string    - the string to split
+	# Parameter: delimeter - the delimeter to split by (defaults to newline)
+	#
+	# Return: the array containing the split string chunks
+	describe '::split' do
+		before(:all) do
+			@string1 = "Hello World\nI am dog"
+			@array1  = ["Hello World", "I am dog"]
+
+			@string2 = "Butter, Milk, Eggs, Bread"
+			@delim2  = ",\s*"
+			@array2  = ["Butter", "Milk", "Eggs", "Bread"]
+
+			@string4 = 3
+		end
+
+		it 'splits the string by whitespace if no delimeter is given' do
+			expect(General::GOperations.split(@string1)).to eql @array1
+		end
+
+		it 'splits the string using the given delimeter' do
+			expect(General::GOperations.split(@string2, @delim2)).to eql @array2
+		end
+
+		it 'raises GOperationError with no string value given' do
+			expect { General::GOperations.split }.to raise_error General::GOperationError
+		end
+
+		it 'raises GOperationError with value of other type given' do
+			expect { General::GOperations.split @string4 }.to raise_error General::GOperationError
+		end
+	end
+
+	# Splits a sequence by a set number of words (defaults to 10)
+	#
+	# Parameter: string - the string to split
+	# Parameter: words  - the number of words to split by (defaults to 10)
+	#
+	# Return: an array containing hashes representing the chunks of the string split by words
+	describe '::splitwords' do
+		before(:all) do
+			@string1 = "The number of words in this string is greater than ten!"
+			@array1  = ["The number of words in this string is greater than", "ten!"]
+
+			@string2 = "The number of words (in this string) is greater than five, so every \"fifth\" word is on Joe's new line!"
+			@words2  = 5
+			@array2  = ["The number of words (in", "this string) is greater than", "five, so every \"fifth\" word", "is on Joe's new line!"]
+
+			@string3 = 4
+		end
+
+		it 'splits the string by ten words if no word count is given' do
+			expect(General::GOperations.splitwords @string1).to eql @array1
+		end
+
+		it 'splits the string by the given number of words' do
+			expect(General::GOperations.splitwords @string2, @words2).to eql @array2
+		end
+
+		it 'raises GOperationError with no string value given' do
+			expect { General::GOperations.splitwords }.to raise_error General::GOperationError
+		end
+
+		it 'raises GOperationError with value of other type given' do
+			expect { General::GOperations.splitwords @string3 }.to raise_error General::GOperationError
 		end
 	end
 end