general 1.5.0 → 2.0.0

data/spec/gpartial_garrayplaceholder_spec.rb

@@ -0,0 +1,165 @@
+# 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 "spec_require"
+
+# Describe General::GArrayPlaceholder
+# 
+# Represents an array placeholder partial in a GTemplate
+#
+# Author:  Anshul Kharbanda
+# Created: 7 - 1 - 2016
+describe General::GArrayPlaceholder do
+	before :all do
+		# -----------DATA-----------
+
+		@arrayname1 = :arg1
+		@arrayname2 = :arg2
+		@arrayname3 = :arg3
+		@hash = {
+			arg1: [
+				{ subarg: "Eeeeyyy" },
+				{ subarg: "Oyyyeee" },
+				{ subarg: "Aaayyyy" }
+			],
+			arg2: "Butter Milk Eggs Bacon Cleaner",
+			arg3: "Buttered Bacon, Milked Eggs, Cleaning Butter"
+		}
+		
+		@delim = "\n"
+		@text1 = "Subarg: @(subarg)"
+		@text2 = "# @#"
+		@operation = :split
+		@arguments = [",\s*"]
+
+		# ---------------------------OUTPUT---------------------------
+		
+		@out1 = @hash[@arrayname1]
+				.collect{|e| "Subarg: #{e[:subarg]}"}
+				.join(General::GArrayPlaceholder::DEFAULT_DELIMETER)
+		@out2 = @hash[@arrayname1]
+				.collect{|e| "Subarg: #{e[:subarg]}"}
+				.join(@delim)
+		@out3 = General::GOperations.send(@operation, @hash[@arrayname2])
+				.collect{|e| "# #{e}"}
+				.join(@delim)
+		@out4 = General::GOperations.send(@operation, @hash[@arrayname3], *@arguments)
+				.collect{|e| "# #{e}"}
+				.join(@delim)
+
+		# ------------------------------------------PARTIALS------------------------------------------
+
+		@partial1 = General::GArrayPlaceholder.new name: @arrayname1, 
+												   text: @text1
+		@partial2 = General::GArrayPlaceholder.new name: @arrayname1, 
+												   text: @text1, 
+												   delimeter: @delim
+		@partial3 = General::GArrayPlaceholder.new name: @arrayname2, 
+												   text: @text2, 
+												   delimeter: @delim, 
+												   operation: @operation
+		@partial4 = General::GArrayPlaceholder.new name: @arrayname3, 
+												   text: @text2, 
+												   delimeter: @delim, 
+												   operation: @operation, 
+												   arguments: @arguments.collect{|a| " \"#{a}\""}.join
+
+		# -------------------------------------------STRING-------------------------------------------
+
+		@string1 = "@[#{@arrayname1}] #{@text1} @[#{General::GArrayPlaceholder::DEFAULT_DELIMETER.inspect[1...-1]}]"
+		@string2 = "@[#{@arrayname1}] #{@text1} @[#{@delim.inspect[1...-1]}]"
+		@string3 = "@[#{@arrayname2} -> #{@operation}] #{@text2} @[#{@delim.inspect[1...-1]}]"
+		@string4 = "@[#{@arrayname3} -> #{@operation} #{@arguments.collect{|s| "\"#{s}\""}.join(" ")}] #{@text2} @[#{@delim.inspect[1...-1]}]"
+	end
+
+	# Describe General::GArrayPlaceholder::new
+	# 
+	# Initializes the GPlaceholder with the given match
+	#
+	# Parameter: match - the match data from the string being parsed
+	describe '::new' do
+		it 'creates a new GArrayPlaceholder with the given input data' do
+			expect(@partial1).to be_an_instance_of General::GArrayPlaceholder
+			expect(@partial2).to be_an_instance_of General::GArrayPlaceholder
+			expect(@partial3).to be_an_instance_of General::GArrayPlaceholder
+			expect(@partial4).to be_an_instance_of General::GArrayPlaceholder
+		end
+	end
+
+	# Describe General::GArrayPlaceholder#apply
+	# 
+	# Returns the value of the array placeholder in the given data
+	# formatted by the given GArrayPlaceholder and joined by the given delimeter
+	#
+	# Parameter: data - the data being applied
+	#
+	# Return: the value of the array placeholder in the given data
+	# 		  formatted by the given GArrayPlaceholder and joined by the given delimeter
+	describe '#apply' do
+		it 'applies the given data array formatted according to the info in the GArrayPlaceholder' do
+			expect(@partial1.apply @hash).to eql @out1
+			expect(@partial2.apply @hash).to eql @out2
+			expect(@partial3.apply @hash).to eql @out3
+			expect(@partial4.apply @hash).to eql @out4
+		end
+	end
+
+	# Describe General::GArrayPlaceholder#string
+	#
+	# Returns the string representation of the GArrayPlaceholder
+	#
+	# Parameter: first - true if the GArrayPlaceholder is the first of it's time
+	#
+	# Returns: the string representation of the GArrayPlaceholder
+	describe '#string' do
+		it 'returns the string of the GArrayPlaceholder' do
+			expect(@partial1.string).to eql @string1
+			expect(@partial2.string).to eql @string2
+			expect(@partial3.string).to eql @string3
+			expect(@partial4.string).to eql @string4
+			expect(@partial1.string true).to eql @string1
+			expect(@partial2.string true).to eql @string2
+			expect(@partial3.string true).to eql @string3
+			expect(@partial4.string true).to eql @string4
+			expect(@partial1.string false).to eql @string1
+			expect(@partial2.string false).to eql @string2
+			expect(@partial3.string false).to eql @string3
+			expect(@partial4.string false).to eql @string4
+		end
+	end
+
+	# Describe General::GArrayPlaceholder#regex (depricated)
+	#
+	# Throws TypeError
+	# 
+	# Parameter: first - true if the placeholder is the first of it's kind
+	describe '#regex (depricated)' do
+		it 'raises TypeError' do
+			expect { @partial1.regex }.to raise_error TypeError
+			expect { @partial2.regex }.to raise_error TypeError
+			expect { @partial3.regex }.to raise_error TypeError
+			expect { @partial4.regex }.to raise_error TypeError
+			expect { @partial1.regex true }.to raise_error TypeError
+			expect { @partial2.regex true }.to raise_error TypeError
+			expect { @partial3.regex true }.to raise_error TypeError
+			expect { @partial4.regex true }.to raise_error TypeError
+			expect { @partial1.regex false }.to raise_error TypeError
+			expect { @partial2.regex false }.to raise_error TypeError
+			expect { @partial3.regex false }.to raise_error TypeError
+			expect { @partial4.regex false }.to raise_error TypeError
+		end
+	end
+end

data/spec/gpartial_gfullplaceholder_spec.rb

@@ -0,0 +1,82 @@
+# 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 "spec_require"
+
+# Inserts the full data value passed into the template
+#
+# Author:  Anshul Kharbanda
+# Created: 1 - 19 - 2016
+describe General::GFullPlaceholder do
+	before :all do
+		@full = General::GFullPlaceholder.new({})
+		@data1 = "Hello World!"
+	end
+
+	# Describing General::GFullPlaceholder#new
+	#
+	# Creates a new GFullPlaceholder with the given match
+	#
+	# Parameter: match - the match data from the string being parsed
+	describe '::new' do
+		it 'creates a new GFullPlaceholder' do
+			expect(@full).to be_an_instance_of General::GFullPlaceholder
+		end
+	end
+
+	# Describing General::GFullPlaceholder#apply
+	#
+	# Returns a string representation of the given data
+	# 
+	# Parameter: data - the data being applied
+	# 
+	# Returns: a string representation of the given data
+	describe '#apply' do
+		it 'returns a string representation of the entire data value given' do
+			expect(@full.apply @data1).to eql @data1
+		end
+	end
+
+	# Describing General::GFullPlaceholder#string
+	#
+	# Returns a string representation of the GFullPlaceholder
+	#
+	# Parameter: first - true if this is the first in a given template 
+	#
+	# Returns: a string representation of the GFullPlaceholder
+	describe '#string' do
+		it 'returns a string reprsentation of the GFullPlaceholder' do
+			expect(@full.string).to eql General::GFullPlaceholder::STRING
+			expect(@full.string true).to eql General::GFullPlaceholder::STRING
+			expect(@full.string false).to eql General::GFullPlaceholder::STRING
+		end
+	end
+
+	# Describing General::GFullPlaceholder#regex (depricated)
+	#
+	# Raises TypeError
+	#
+	# Parameter: first - true if this is the first in a given template 
+	#
+	# Raises: TypeError
+	describe '#regex (depricated)' do
+		it 'raises TypeError' do
+			expect{@full.regex}.to raise_error TypeError
+			expect{@full.regex true}.to raise_error TypeError
+			expect{@full.regex false}.to raise_error TypeError
+		end
+	end
+end

data/spec/gpartial_gplaceholder_spec.rb

@@ -0,0 +1,237 @@
+# 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 "spec_require"
+
+# Represents a placeholder partial in a GTemplate
+#
+# Author:  Anshul Kharbanda
+# Created: 7 - 1 - 2016
+describe General::GPlaceholder do
+	before :all do
+		# Placename
+		@placename1 = :plac1
+		@placename2 = :plac2
+		@placename3 = :plac3
+		@placename4 = :plac4
+		@placename5 = :"plac5.subarg"
+
+		# Hash
+		@hash = General::GDotHash.new
+		@hash[@placename1] = "foobar"
+		@hash[@placename3] = "barbaz"
+		@hash[@placename4] = "jujar"
+		@hash[@placename5] = "dudar"
+
+		# Default hash
+		@defaults = General::GDotHash.new
+		
+		# ------------PLACEHOLDER------------
+		@result1 = @hash[@placename1]
+		@partial1 = General::GPlaceholder.new [
+			[:name, @placename1]
+		].to_h, @defaults
+		@string1       = "@(#{@placename1})"
+		@string_first1 = "@(#{@placename1})"
+		@regex1        = "\\k<#{@placename1}>"
+		@regex_first1  = "(?<#{@placename1}>.*)"
+
+		# --------------DEFAULT--------------
+		@default2 = "foo2"
+		@result2  = "foo2"
+		@partial2 = General::GPlaceholder.new [
+			[:name,    @placename2],
+			[:default, @default2]
+		].to_h, @defaults
+		@string2       = "@(#{@placename2})"
+		@string_first2 = "@(#{@placename2}:" \
+					   + " #{@default2})"
+		@regex2        = "\\k<#{@placename2}>"
+		@regex_first2  = "(?<#{@placename2}>.*)"
+		
+		# -------------OPERATION-------------
+		@operation3 = "capitalize"
+		@result3  = General::GOperations.send(
+			@operation3.to_sym, 
+			@hash[@placename3]
+		)
+		@partial3 = General::GPlaceholder.new [
+			[:name, 	 @placename3],
+			[:operation, @operation3]
+		].to_h, @defaults
+		@string3       = "@(#{@placename3})"
+		@string_first3 = "@(#{@placename3}" \
+					   + " -> #{@operation3})"
+		@regex3        = "\\k<#{@placename3}>"
+		@regex_first3  = "(?<#{@placename3}>.*)"
+		
+		# -------------ARGUMENTS-------------
+		@operation4 = "capitalize"
+		@arguments4 = ["all"]
+		@result4 = General::GOperations.send(
+			@operation4.to_sym,
+			@hash[@placename4],
+			*@arguments4
+		)
+		@partial4 = General::GPlaceholder.new [
+			[:name, 	 @placename4],
+			[:operation, @operation4],
+			[:arguments, @arguments4.join(" ")]
+		].to_h, @defaults
+		@string4       = "@(#{@placename4})"
+		@string_first4 = "@(#{@placename4}" \
+					   + " -> #{@operation4} " \
+					   + "#{@arguments4.collect {|s| "\"#{s}\""}.join " "})"
+		@regex4        = "\\k<#{@placename4}>"
+		@regex_first4  = "(?<#{@placename4}>.*)"
+
+		# -----------DOT NOTATION------------
+		keys      = @placename5.to_s.split(".").collect(&:to_sym)
+		@result5  = @hash[keys[0]][keys[1]]
+		@partial5 = General::GPlaceholder.new [
+			[:name,  @placename5]
+		].to_h, @defaults
+		@string5       = "@(#{@placename5})"
+		@string_first5 = "@(#{@placename5})"
+		@regex5        = "\\k<#{@placename5}>"
+		@regex_first5  = "(?<#{@placename5}>.*)"
+	end
+
+	# Describe General::GPlaceholder::new
+	# 
+	# Initializes the GPlaceholder with the given match
+	# 
+	# Parameter: match - the match data from the string being parsed
+	describe '::new' do
+		it 'creaes a GPlaceholder with the given data' do
+			# -------------------------------------PLACEHOLDER---------------------------------------
+			expect(@partial1).to be_an_instance_of General::GPlaceholder
+			expect(@partial1.instance_variable_get :@name).to eql @placename1
+			expect(@partial1.instance_variable_get :@operation).to be_nil
+			expect(@partial1.instance_variable_get :@arguments).to be_empty
+
+			# ---------------------------------------DEFAULT-----------------------------------------
+			expect(@partial2).to be_an_instance_of General::GPlaceholder
+			expect(@partial2.instance_variable_get :@name).to eql @placename2
+			expect(@partial2.instance_variable_get :@operation).to be_nil
+			expect(@partial2.instance_variable_get :@arguments).to be_empty
+			expect(@defaults[@placename2]).to eql @default2
+
+			# --------------------------------------OPERATION----------------------------------------
+			expect(@partial3).to be_an_instance_of General::GPlaceholder
+			expect(@partial3.instance_variable_get :@name).to eql @placename3
+			expect(@partial3.instance_variable_get :@operation).to eql @operation3
+			expect(@partial3.instance_variable_get :@arguments).to be_empty
+
+			# --------------------------------------ARGUMENTS----------------------------------------
+			expect(@partial4).to be_an_instance_of General::GPlaceholder
+			expect(@partial4.instance_variable_get :@name).to eql @placename4
+			expect(@partial4.instance_variable_get :@operation).to eql @operation4
+			expect(@partial4.instance_variable_get :@arguments).to eql @arguments4
+
+			# -------------------------------------DOT NOTATION--------------------------------------
+			expect(@partial5).to be_an_instance_of General::GPlaceholder
+			expect(@partial5.instance_variable_get :@name).to eql @placename5
+			expect(@partial5.instance_variable_get :@operation).to be_nil
+			expect(@partial5.instance_variable_get :@arguments).to be_empty
+		end
+	end
+
+	# Describe General::GPlaceholder#apply
+	# 
+	# Returns the value of the placeholder in the given data 
+	# with the given operation performed on it
+	#
+	# Parameter: data - the data being applied
+	#
+	# Return: the value of the placeholder in the given data 
+	# 		  with the given operation performed on it
+	describe '#apply' do
+		it 'returns the value in the data/default at the name (with operation and arguments applied if given)' do
+			expect(@partial1.apply @hash).to eql @result1
+			expect(@partial2.apply @hash).to eql @result2
+			expect(@partial3.apply @hash).to eql @result3
+			expect(@partial4.apply @hash).to eql @result4
+			expect(@partial5.apply @hash).to eql @result5
+		end
+	end
+
+	# Describe General::GTemplate#string
+	#
+	# Returns the string representation of the placeholder
+	#
+	# Parameter: first - true if the placeholder is the first of its kind in the GTemplate
+	#
+	# Return: the string representation of the placeholder
+	describe '#string' do
+		# -------------------------------------NO FIRST---------------------------------------
+		it 'returns the first string representation of the placeholder by default' do
+			expect(@partial1.string).to eql @string_first1
+			expect(@partial2.string).to eql @string_first2
+			expect(@partial3.string).to eql @string_first3
+			expect(@partial4.string).to eql @string_first4
+		end
+
+		# ------------------------------------TRUE FIRST--------------------------------------
+		it 'returns the first string representation of the placeholder when first is true' do
+			expect(@partial1.string true).to eql @string_first1
+			expect(@partial2.string true).to eql @string_first2
+			expect(@partial3.string true).to eql @string_first3
+			expect(@partial4.string true).to eql @string_first4
+		end
+
+		# -----------------------------------FALSE FIRST--------------------------------------
+		it 'returns the string representation of the placeholder when first is false' do
+			expect(@partial1.string false).to eql @string1
+			expect(@partial2.string false).to eql @string2
+			expect(@partial3.string false).to eql @string3
+			expect(@partial4.string false).to eql @string4
+		end
+	end
+
+	# Describe General::GTemplate#regex (depricated)
+	#
+	# Returns the string as a regex
+	#
+	# Parameter: first - true if the placeholder is the first of its kind in the GTemplate
+	#
+	# Returns: the string as a regex
+	describe '#regex (depricated)' do
+		# -------------------------------------NO FIRST---------------------------------------
+		it 'returns the first regex representation of the placeholder by default' do
+			expect(@partial1.regex).to eql @regex_first1
+			expect(@partial2.regex).to eql @regex_first2
+			expect(@partial3.regex).to eql @regex_first3
+			expect(@partial4.regex).to eql @regex_first4
+		end
+
+		# ------------------------------------TRUE FIRST--------------------------------------
+		it 'returns the first regex representation of the placeholder when first is true' do
+			expect(@partial1.regex true).to eql @regex_first1
+			expect(@partial2.regex true).to eql @regex_first2
+			expect(@partial3.regex true).to eql @regex_first3
+			expect(@partial4.regex true).to eql @regex_first4
+		end
+
+		# -----------------------------------FALSE FIRST--------------------------------------
+		it 'returns the regex representation of the placeholder when first is false' do
+			expect(@partial1.regex false).to eql @regex1
+			expect(@partial2.regex false).to eql @regex2
+			expect(@partial3.regex false).to eql @regex3
+			expect(@partial4.regex false).to eql @regex4
+		end
+	end
+end

data/spec/gpartial_gspecial_spec.rb

@@ -0,0 +1,88 @@
+# 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 "spec_require"
+
+# Describe General::GSpecial
+# 
+# Represents a special character in a GTemplate
+#
+# Author:  Anshul Kharbanda
+# Created: 7 - 1 - 2016
+describe General::GSpecial do
+	before :all do
+		@key     = "at"
+		@text    = "@"
+		@regex   = /@/
+		@partial = General::GSpecial.new key: @key
+	end
+
+	# Describe General::GSpecial::new
+	# 
+	# Creates the GSpecial with the given match
+	#
+	# Parameter: match - the match object of the GSpecial
+	describe '::new' do
+		it 'creates the GSpecial with the given match object' do
+			expect(@partial).to be_an_instance_of General::GSpecial
+			expect(@partial.name).to eql General::GSpecial::PTNAME
+			expect(@partial.instance_variable_get :@text).to eql @text
+		end
+	end
+
+	# Describe General::GSpecial#regex
+	# 
+	# Returns the special character
+	#
+	# Parameter: data - the data to apply to the partial
+	#
+	# Returns: the special character
+	describe '#apply' do
+		it 'returns the special character' do
+			expect(@partial.apply({})).to eql @text
+		end
+	end
+
+	# Describe General::GSpecial#string
+	#
+	# Returns the string representation of the GSpecial
+	#
+	# Parameter: first - true if this partial is the first of it's kind in a GTemplate
+	#
+	# Returns: the string representation of the GSpecial
+	describe '#string' do
+		it 'returns the string representation of the GSpecial' do
+			expect(@partial.string).to eql "@#{@key};"
+			expect(@partial.string false).to eql "@#{@key};"
+			expect(@partial.string true).to eql "@#{@key};"
+		end
+	end
+
+	# Describe General::GSpecial#regex (depricated)
+	#
+	# Returns the GSpecial as a regex
+	#
+	# Parameter: first - true if this partial is the first of it's kind in a GTemplate
+	#
+	# Returns: the GSpecial as a regex
+	describe '#regex (depricated)' do
+		it 'returns the regex representation of the GSpecial' do
+			expect(@partial.regex).to eql @regex
+			expect(@partial.regex false).to eql @regex
+			expect(@partial.regex true).to eql @regex
+		end
+	end
+end

data/spec/gpartial_gtext_spec.rb

@@ -0,0 +1,87 @@
+# 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 "spec_require"
+
+# Describe General::GText
+# 
+# Represents a plain text partial in a GTemplate
+#
+# Author:  Anshul Kharbanda
+# Created: 7 - 1 - 2016
+describe General::GText do
+	before :all do
+		@text = "foobar"
+		@regex = "foobar"
+		@partial = General::GText.new @text
+	end
+
+	# Describe General::GText::new
+	# 
+	# Creates the GText with the given match
+	#
+	# Parameter: match - the match object of the GText
+	describe '::new' do
+		it 'creates the GText with the given to_s representable object' do
+			expect(@partial).to be_an_instance_of General::GText
+			expect(@partial.name).to eql General::GText::PTNAME
+			expect(@partial.instance_variable_get :@text).to eql @text
+		end
+	end
+
+	# Describe General::GText#apply
+	#
+	# Returns the text
+	#
+	# Parameter: data - the data to apply to the partial
+	#
+	# Returns: the text
+	describe '#apply' do
+		it 'returns the GText string, given a hash of data' do
+			expect(@partial.apply @hash).to eql @text
+		end
+	end
+
+	# Describe General::GText#string
+	#
+	# Returns the text as a string
+	#
+	# Parameter: first - true if this partial is the first of it's kind in a GTemplate
+	#
+	# Returns: the text as a string
+	describe '#string' do
+		it 'returns the string representation of the GText' do
+			expect(@partial.string).to eql @text
+			expect(@partial.string true).to eql @text
+			expect(@partial.string false).to eql @text
+		end
+	end
+
+	# Describe General::GText#regex (depricated)
+	# 
+	# Returns the text as a regex
+	#
+	# Parameter: first - true if this partial is the first of it's kind in a GTemplate
+	#
+	# Returns: the text as a regex
+	describe '#regex (depricated)' do
+		it 'returns the regex representation of the GText' do
+			expect(@partial.regex).to eql @regex
+			expect(@partial.regex true).to eql @regex
+			expect(@partial.regex false).to eql @regex
+		end
+	end
+end