general 1.4.2 → 1.5.0

data/spec/goperations_spec.rb

@@ -0,0 +1,246 @@
+# 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::GOperations
+#
+# Implements placeholder operations
+#
+# Author: Anshul Kharbanda
+# Created: 6 - 3 - 2016
+describe General::GOperations do
+	#-----------------------------------STRING OPERATIONS------------------------------------
+
+	# Describe General::GOperations::capitalize
+	# 
+	# Capitalizes every word in the string
+	#
+	# Parameter: string - the string being capitalized
+	#
+	# Return: the capitalized string
+	describe '::capitalize' do
+		before(:all) do
+			@input     = "joe schmoe"
+			@out_first = "Joe schmoe"
+			@out_all   = "Joe Schmoe"
+		end
+
+		context 'with string 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
+			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
+			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
+			end
+		end
+
+		context 'with no string argument' do
+			it 'raises Error' do
+				expect { General::GOperations.capitalize }.to raise_error ArgumentError
+			end
+		end
+
+		context 'with argument of another type' do
+			it 'raises Error' do
+				expect { General::GOperations.capitalize(0) }.to raise_error TypeError
+			end
+		end
+	end
+
+	# Describe General::GOperations::uppercase
+	# 
+	# Converts every letter in the string to uppercase
+	#
+	# Parameter: string - the string being uppercased
+	#
+	# Return: the uppercased string
+	describe '::uppercase' do
+		before :all do
+			@input = "Joe Schmoe"
+			@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
+		end
+
+		context 'with no string argument' do
+			it 'raises Error' do
+				expect { General::GOperations.uppercase }.to raise_error ArgumentError
+			end
+		end
+
+		context 'with argument of another type' do
+			it 'raises Error' do
+				expect { General::GOperations.capitalize(0) }.to raise_error TypeError
+			end
+		end
+	end
+
+	# Describe General::GOperations::lowercase
+	# 
+	# Converts every letter in the string to lowercase
+	#
+	# Parameter: string - the string being lowercased
+	#
+	# Return: the lowercased string
+	describe '::lowercase' do
+		before :all do
+			@input = "Joe Schmoe"
+			@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
+		end
+
+		context 'with no string argument' do
+			it 'raises Error' do
+				expect { General::GOperations.lowercase }.to raise_error ArgumentError
+			end
+		end
+
+		context 'with argument of another type' do
+			it 'raises Error' do
+				expect { General::GOperations.capitalize(0) }.to raise_error TypeError
+			end
+		end
+	end
+
+	#-----------------------------------INTEGER OPERATIONS------------------------------------
+
+	# Describe General::GOperations::money
+	# 
+	# Returns the integer monetary value formatted to the given money type
+	#
+	# Parameter: integer - the monetary amount being formatted
+	# Parameter: type    - the type of money (defaults to USD)
+	#
+	# Return: the formatted money amount
+	describe '::money' do
+		before :all do
+			@money1 = 233
+			@money2 = -344
+			@output1 = "$2.33"
+			@output2 = "-$3.44"
+			@output3 = "€2.33"
+			@output4 = "-€3.44"
+		end
+
+		context 'with an integer 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
+			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
+			end
+		end
+
+		context 'with no integer value given' do
+			it 'raises Error' do
+				expect { General::GOperations.money }.to raise_error ArgumentError
+			end
+		end
+
+		context 'with argument of another type' do
+			it 'raises Error' do
+				expect { General::GOperations.money "" }.to raise_error TypeError
+			end
+		end
+	end
+
+	# Describe General::GOperations::time
+	# 
+	# Returns the integer time value (in seconds) formatted with the given formatter
+	#
+	# Parameter: integer - the integer being formatted (representing the time in seconds)
+	# Parameter: format  - the format being used (defaults to @I:@MM:@SS @A)
+	#
+	# Return: the time formatted with the given formatter
+	describe '::time' do
+		before :all do
+			@formatter = '@SS <- @MM <- @HH'
+			@hrs = 3
+			@min = 14
+			@sec = 12
+			@pm = true
+
+			@time = (((@pm ? 11 : 0) + @hrs)*3600 + @min*60 + @sec)
+			
+			@out1 = General::GTimeFormat.new(General::GOperations::DEFAULT_TIME).apply(@time)
+			@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
+		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
+		end
+
+		context 'with no integer value given' do
+			it 'raises Error' do
+				expect { General::GOperations.time }.to raise_error ArgumentError
+			end
+		end
+
+		context 'with argument of another type' do
+			it 'raises Error' do
+				expect { General::GOperations.time "" }.to raise_error TypeError
+			end
+		end
+	end
+end

data/spec/gpartial_spec.rb

@@ -0,0 +1,54 @@
+# 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::GPartial
+# 
+# A unit of the GTemplate. Returns a string based on an argument hash
+# When GTemplate is applied
+#
+# Author:  Anshul Kharbanda
+# Created: 7 - 29 - 2016
+describe General::GPartial do
+	before :all do
+		@name = :partial_name
+		@partial = General::GPartial.new name: @name
+	end
+
+	# Describe General::GPartial::new
+	#
+	# Creates the GPartial with the given object
+	#
+	# Parameter: obj - the object containing information for the partial
+	describe '::new' do
+		it 'creates the GPartial wih the given object' do
+			expect(@partial).to be_an_instance_of General::GPartial
+			expect(@partial.instance_variable_get :@name).to eql @name
+		end
+	end
+
+	# Describe General::GPartial#name
+	#
+	# Returns the name of the partial
+	#
+	# Return: the name of the partial
+	describe '#name' do
+		it 'returns the name of the GPartial' do
+			expect(@partial.name).to eql @name
+		end
+	end
+end

data/spec/gplaceholder_spec.rb

@@ -0,0 +1,300 @@
+# 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
+		# -------------------------------------PLACEHOLDER---------------------------------------
+		context 'with name given' do
+			it 'creaes a GPlaceholder with the given name' do
+				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
+			end
+		end
+
+		# ---------------------------------------DEFAULT-----------------------------------------
+		context 'with name and default in match object' do
+			it 'creates a GPlaceholder with the given name and default' do
+				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
+			end
+		end
+
+		# --------------------------------------OPERATION----------------------------------------
+		context 'with name, default, and operation in match object' do
+			it 'creates a GPlaceholder with the given name and operation' do
+				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
+			end
+		end
+
+		# --------------------------------------ARGUMENTS----------------------------------------
+		context 'with name, default, operation, and arguments in match object' do
+			it 'creates a GPlaceholder with the given name, operation, and arguments' do
+				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
+			end
+		end
+
+		# --------------------------------------ARGUMENTS----------------------------------------
+		context 'with dot notation name' do
+			it 'creates a GPlaceholder with the given dot notation name' do
+				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
+	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
+		# -------------------------------------PLACEHOLDER---------------------------------------
+		context 'when name is defined in given data' do
+			it 'returns the value in the data at the name' do
+				expect(@partial1.apply @hash).to eql @result1
+			end
+		end
+
+		# ---------------------------------------DEFAULT-----------------------------------------
+		context 'when name is not defined in given data, but defined in defaults' do
+			it 'returns the value in the default at the name' do
+				expect(@partial2.apply @hash).to eql @result2
+			end
+		end
+
+		# --------------------------------------OPERATION----------------------------------------
+		context 'when an operation is defined' do
+			it 'returns the value in the data/default at the name with the operation applied' do
+				expect(@partial3.apply @hash).to eql @result3
+			end
+		end
+
+		# --------------------------------------ARGUMENTS----------------------------------------
+		context 'when an operation and arguments are defined' do
+			it 'returns the value in the data/default at the name with the operation and arguments applied' do
+				expect(@partial4.apply @hash).to eql @result4
+			end
+		end
+
+		# -------------------------------------DOT NOTATION--------------------------------------
+		context 'when dot notation name is given' do
+			it 'returns the value in the data/default at the dot notation name' do
+				expect(@partial5.apply @hash).to eql @result5
+			end
+		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---------------------------------------
+		context 'when no first argument specified' do
+			it 'returns the first string representation of the placeholder' 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
+		end
+
+		# --------------------------------------FIRST-----------------------------------------
+		context 'when first argument is specified' do
+			# --------------------------------TRUE--------------------------------
+			context 'when first is true' do
+				it 'returns the first string representation of the placeholder' 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
+			end
+
+			# --------------------------------FALSE-------------------------------
+			context 'when first is false' do
+				it 'returns the string representation of the placeholder' 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
+		end
+	end
+
+	# Describe General::GTemplate#regex
+	#
+	# 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' do
+		# -------------------------------------NO FIRST---------------------------------------
+		context 'when no first argument specified' do
+			it 'returns the first regex representation of the placeholder' 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
+		end
+
+		# --------------------------------------FIRST-----------------------------------------
+		context 'when first argument is specified' do
+			# --------------------------------TRUE--------------------------------
+			context 'when first is true' do
+				it 'returns the first regex representation of the placeholder' 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
+			end
+
+			# --------------------------------FALSE-------------------------------
+			context 'when first is false' do
+				it 'returns the regex representation of the placeholder' 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
+	end
+end