general 1.4.2 → 1.5.0

data/README.md

@@ -0,0 +1,135 @@
+# General
+
+## Overview
+
+General is a simple templating system in ruby that allows you to create templates from both pure strings and files (with the extension .general), as well as create new strings and files with these created objects.
+
+## General Templates
+
+### Basic Templates
+
+A general template consists of regular text along with placeholders, which are defined as follows: `@(-name-)`. You can also specify default text as well like so: `@(-name-: -default text-)`.
+
+Here's an exmple of a general template text: `"Hello, I am @(name: Gordon Ramsay) and I like @(food: cat food)!"`
+
+To import all classes in the library, type `require 'general'`. You can then create a general template from a string within your ruby code using the GTemplate object:
+
+```ruby
+template = General::GTemplate.new "Hello, I am @(name: Gordon Ramsay) and I like @(food: cat food)!"
+```
+
+To generate a string from the template, use the "apply" method and add your data as named arguments.
+
+```ruby
+string = template.apply name: "Joe", food: "Joe's Schmoes"
+
+# string now equals "Hello, I am Joe and I like Joe's Schmoes"
+```
+
+If you don't specify a value for a particular placeholder, it will take on it's default value.
+
+```ruby
+string = template.apply food: "Joe's Schmoes"
+
+# string now equals "Hello, I am Gordon Ramsay and I like Joe's Schmoes"
+```
+
+If you have an array of data, you can use `apply_all` to apply the template to each individual element separately.
+
+```ruby
+array = template.apply_all [{name: "Joe", food: "Joe Schmoes"}, {name: "Jane", food: "Jane's Danes"}, {name: "Denny", food: "Denny's Fennies"}]
+
+#array now has these elements:
+#   - Hello, I am Joe and I like Joe's Schmoes
+#   - Hello, I am Jane and I like Jane's Danes
+#   - Hello, I am Denny and I like Denny's Fennies
+```
+
+### Placeholder Operations
+
+You can also specify operations to be performed on values passed to placeholders, akin to AngularJS's filters. For example: `@(name -> capitalize)` will capitalize whatever name is inputted before applying it to the text.
+
+The current placeholder operations are:
+
+| Operation  |                       Description                       |
+|:-----------|:--------------------------------------------------------|
+| capitalize | Capitalizes the first letter of each word in a string   |
+| uppercase  | Makes every letter in a string uppercase                |
+| lowercase  | Makes every letter in a string lowercase                |
+| dollars    | Formats an integer money amount (in cents) to dollars   |
+| time       | Formats an integer time (in seconds) to HH:MM:SS format |
+
+### Array Templates
+
+You can also make array templates within templates, which will format each value in an array of data according to a general template
+
+A general array template is as follows: `@[-name-] -general template for each value- @[]`. You can also specify the delimeter, which will be appended to the end of each element. The delimeter should be added in the end tag, like so: `@[-name-] -general template for each value- @[-delimeter-]`. If no delimeter is given, the default is a space. The start and end tags are invariant with atleast 1 whitespace or newline. So you can also define the template like such: 
+
+```
+@[-name-]
+-general template for each value-
+@[-delimeter-]
+```
+
+An example of an array template:
+
+```ruby
+template = General::GTemplate.new \
+"List of Film Crew:
+@[crew] 
+	@(name): @(role)
+@[\n]"
+```
+
+You can now specify an array of values for "crew" in template, and it will format the data accordingly:
+
+```ruby
+string = template.apply crew: [
+	{name: "Chris Nolan", role: "Director"}, 
+	{name: "Wally Pfister", role: "Director of Photography"}, 
+	{name: "Christian Bale", role: "Bruce Wayne/Batman"}, 
+	{name: "Michael Caine", role: "Alfred Pennyworth"}
+]
+
+# string now equals:
+# "List of Film Crew:
+#  		Chris Nolan: Director
+#		Wally Pfister: Director of Photography
+#		Christian Bale: Bruce Wayne/Batman
+#		Michael Caine: Alfred Pennyworth"
+```
+
+## General IO
+
+You can also write to files using io GIO, a general template capable of writing to files. You can create a GIO like a GTemplate:
+
+```ruby
+gio = General::GIO.new "Hello, I am @(name: Gordon Ramsay) and I like @(food: cat food)!"
+```
+
+You can also load a GIO from a file. For example, here's how you create a template file from the file "example.txt.general"
+
+```ruby
+gio = General::GFile.load "example.txt.general"
+```
+
+To write to a file, simply call the write method, pass in the file and the data to apply (like in GTemplate#apply):
+
+```ruby
+gio.write file, name: "Joe", food: "Joe's Schmoes"
+```
+
+Where `file` is the file you are writing to. You can also pass the name of the file to write to as well:
+
+```ruby
+gio.write "example.txt", name: "Joe", food: "Joe's Schmoes"
+```
+
+To get the original source filename of the GIO, just call `source`
+
+```ruby
+gio.source # == "example.txt.general"
+```
+
+-------------------------------------------------------------------------------------------------------------------------------------
+Anshul Kharbanda

data/Rakefile

@@ -0,0 +1,52 @@
+=begin 
+
+Program: Roject
+
+Roject is a programming project manager written in Ruby.
+With Roject, you can create and edit projects based on templates
+using simple commands without a heavy IDE.
+
+Author:  Anshul Kharbanda
+Created: 7 - 8 - 2016
+
+=end
+
+# Required libraries
+require "rspec/core/rake_task"
+require "rubygems/tasks"
+require "fileutils"
+
+# Directories
+SPECDIR = "spec"
+
+# Default Task
+task :default => :spec
+
+# RSpec Tasks
+RSpec::Core::RakeTask.new do |task|
+	task.pattern    = "#{SPECDIR}/*_spec.rb"
+	task.rspec_opts = "--format documentation --color"
+end
+
+# Gem Tasks
+Gem::Tasks.new
+
+# Git Tasks
+namespace :git do
+	desc "Push changes to remote"
+	task :push, [:message] => :commit do
+		sh "git push origin master"
+	end
+
+	desc "Commit changes"
+	task :commit, [:message] do |task, args|
+		sh "git add --all"
+		sh "git commit -m #{args[:message].inspect}"
+	end
+
+	desc "Soft git reset"
+	task :reset do sh "git reset" end
+
+	desc "Hard git reset"
+	task :reset_hard do sh "git reset --hard HEAD" end
+end

data/exp/future.general

@@ -0,0 +1,11 @@
+@@include sample
+
+@if(drives: true)
+
+@(name) drove to the store to get some @(food).
+
+@else
+
+@(name) walked thirty blocks uphil to the store to get some @(food)
+
+@end

data/exp/out.txt

@@ -0,0 +1 @@
+There once was a chef name Joe, and he loved eating Joe's Schmoes. He went to Kentucky.

data/exp/sample.general

@@ -0,0 +1 @@
+There once was a chef name @(name: gordon ramsay -> capitalize all), and he loved eating @(food: carrots). He went to @(place -> capitalize).

data/lib/gdothash.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/>.
+
+# General is a templating system in ruby
+#
+# Author: Anshul Kharbanda
+# Created: 3 - 4 - 2016
+module General
+	# Wrapper for hash objects which implements dot notation
+	#
+	# Author:  Anshul Kharbanda
+	# Created: 9 - 27 - 2016
+	class GDotHash
+		# Initializes the given GDotHash with the given hash
+		#
+		# Parameter: hash - the hash being manipulated
+		def initialize(hash={}); @hash = hash; end
+
+		# Returns the string representation of the hash
+		#
+		# Return: the string representation of the hash
+		def to_s; @hash.to_s; end
+
+		# Returns true if the GDotHash contains the given key
+		# 
+		# Parameter: key - the key to check
+		#
+		# Return: true if the GDotHash contains the given key
+		def has_key? key
+			# Split keys
+			subkeys = key.to_s.split(".").collect(&:to_sym)
+
+			# Check each subkey
+			sub = @hash
+			subkeys.each do |subkey|
+				# Return false if subhash doesn't contain key
+				# Else continue
+				if sub.is_a?(Hash) && sub.has_key?(subkey)
+					sub = sub[subkey]
+				else
+					return false
+				end
+			end
+
+			# Return true if passed
+			return true
+		end
+
+		# Gets the value at the given key
+		#
+		# Parameter: key - the key to return
+		#
+		# Return: the value at the given key
+		def [] key
+			# Split keys
+			subkeys = key.to_s.split(".").collect(&:to_sym)
+
+			# Travel down to value
+			get = @hash
+			subkeys.each do |subkey|
+				if get.is_a?(Hash) && get.has_key?(subkey)
+					get = get[subkey]
+				else
+					raise ArgumentError, "key is not defined in hash: #{key}"
+				end
+			end
+
+			# Return value
+			return get
+		end
+
+		# Sets the given key to the given value
+		# 
+		# Parameter: key   - the key to set
+		# Parameter: value - the value to set
+		def []= key, value
+			# Split subkeys
+			subkeys = key.to_s.split(".").collect(&:to_sym)
+
+			# Generate structure of new data
+			new_data = Hash.new
+			sub = new_data
+			subkeys[0...-1].each do |subkey|
+				sub[subkey] = Hash.new
+				sub = sub[subkey]
+			end
+			sub[subkeys[-1]] = value
+
+			# Merge hash with new data
+			@hash.merge! new_data
+		end
+	end
+end

data/lib/general.rb

@@ -14,6 +14,6 @@
 # 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 "gtimeformat"
-require_relative "gio"
+require_relative "template/gtemplate"
+require_relative "template/gtimeformat"
+require_relative "template/gio"

data/lib/goperations.rb

@@ -14,6 +14,8 @@
 # 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 "templates/gtimeformat"
+
 # General is a templating system in ruby
 #
 # Author: Anshul Kharbanda
@@ -24,6 +26,15 @@ module General
 	# Author: Anshul Kharbanda
 	# Created: 6 - 3 - 2016
 	module GOperations
+		# The money types used by the money operation
+		MONEY_TYPES = {
+			"USD" => "$",
+			"EUR" => "€"
+		}
+
+		# The default time format
+		DEFAULT_TIME = "@I:@MM:@SS @A"
+
 		#-----------------------------------STRING OPERATIONS------------------------------------
 
 		# Capitalizes every word in the string
@@ -31,8 +42,13 @@ module General
 		# Parameter: string - the string being capitalized
 		#
 		# Return: the capitalized string
-		def self.capitalize string
-			return string.split(' ').collect(&:capitalize).join(' ')
+		def self.capitalize string, what="first"
+			assert_type string, String
+			case what
+			when "all" then string.split(' ').collect(&:capitalize).join(' ')
+			when "first" then string.capitalize
+			else raise TypeError.new "Undefined second argument for operation capitalize: #{what}"
+			end
 		end
 
 		# Converts every letter in the string to uppercase
@@ -40,8 +56,9 @@ module General
 		# Parameter: string - the string being uppercased
 		#
 		# Return: the uppercased string
-		def self.uppercase string
-			return string.upcase
+		def self.uppercase(string)
+			assert_type string, String
+			string.upcase
 		end
 
 		# Converts every letter in the string to lowercase
@@ -49,47 +66,51 @@ module General
 		# Parameter: string - the string being lowercased
 		#
 		# Return: the lowercased string
-		def self.lowercase string
-			return string.downcase
+		def self.lowercase(string)
+			assert_type string, String
+			string.downcase
 		end
 
 		#-----------------------------------INTEGER OPERATIONS------------------------------------
 
-		# Returns the integer monetary value (in cents) formatted to USD
+		# Returns the integer monetary value formatted to the given money type
 		#
-		# Parameter: integer - the integer being formatted (representing the amount in cents)
+		# Parameter: integer - the monetary amount being formatted
+		# Parameter: type    - the type of money (defaults to USD)
 		#
-		# Return: the formatted USD amount
-		def self.dollars integer
-			if integer < 0
-				return "-$" + (integer * -0.01).to_s
+		# Return: the formatted money amount
+		def self.money integer, type="USD"
+			assert_type integer, Integer
+			if MONEY_TYPES[type]
+				(integer < 0 ? "-" : "") + MONEY_TYPES[type] + (integer * 0.01).abs.to_s
 			else
-				return '$' + (integer * 0.01).to_s
+				raise TypeError.new("Money type: #{type} is not supported!")
 			end
 		end
 
-		# Returns the integer time value (in seconds) formatted to I:MM:SS A
+		# 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 DEFAULT_TIME)
 		#
-		# Return: the formatted I:MM:SS A
-		def self.time integer
-			return format_time "I:MM:SS A", integer
+		# Return: the time formatted with the given formatter
+		def self.time integer, format=DEFAULT_TIME
+			assert_type integer, Integer
+			General::GTimeFormat.new(format).apply(integer)
 		end
 
 		private
 
-		def self.format_time formatter, value
-			return formatter
-				.sub(/II/, (value / 3600 % 12 + 1).to_s.rjust(2, '0'))
-				.sub(/HH/, (value / 3600).to_s.rjust(2, '0'))
-				.sub(/MM/, (value % 3600 / 60).to_s.rjust(2, '0'))
-				.sub(/SS/, (value % 3600 % 60).to_s.rjust(2, '0'))
-				.sub(/I/, (value / 3600 % 12 + 1).to_s)
-				.sub(/H/, (value / 3600).to_s)
-				.sub(/M/, (value % 3600 / 60).to_s)
-				.sub(/S/, (value % 3600 % 60).to_s)
-				.sub(/A/, value / 3600 > 12 ? 'PM' : 'AM')
+		# Raises TypeError if the given value is not one of the given types
+		#
+		# Parameter: value - the value to check
+		# Parameter: types - the types to check for
+		#
+		# Raises: TypeError - if the given value is not one of the given types
+		def self.assert_type value, *types
+			unless types.any? {|type| value.is_a? type}
+				raise TypeError.new "Unexpected value type #{value.class.name}. Expected #{types.collect(&:name).join(",")}"
+			end
 		end
 	end
 end

data/lib/gpartials/gpartial.rb

@@ -0,0 +1,43 @@
+# 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/>.
+
+# General is a templating system in ruby
+#
+# Author: Anshul Kharbanda
+# Created: 3 - 4 - 2016
+module General
+	# A unit of the GTemplate. Returns a string based on an argument hash
+	# When GTemplate is applied
+	#
+	# Author:  Anshul Kharbanda
+	# Created: 7 - 29 - 2016
+	class GPartial
+		protected
+
+		# Regular expression that matches placeholder names
+		NAME = /(?<name>[a-zA-Z]\w*(\.[a-zA-Z]\w*)*)/
+
+		public
+
+		# Get name
+		attr :name
+
+		# Initializes the GPartial with the given object
+		#
+		# Parameter: obj - the object containing information for the partial
+		def initialize(obj); @name = obj[:name].to_sym; end
+	end
+end

data/lib/gpartials/gplaceholder.rb

@@ -0,0 +1,156 @@
+# 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 "gpartial"
+require_relative "../goperations"
+
+# General is a templating system in ruby
+#
+# Author: Anshul Kharbanda
+# Created: 3 - 4 - 2016
+module General
+	# Represents a placeholder partial in a GTemplate
+	#
+	# Author:  Anshul Kharbanda
+	# Created: 7 - 1 - 2016
+	class GPlaceholder < GPartial
+		private
+
+		# Regular expression that matches a single placeholder
+		ARGUMENT = /(?<text>\w+)|((?<qtat>'|")(?<text>.*)\k<qtat>)/
+
+		# Regular expression that matches placeholder arguments
+		ARGUMENTS = /(?<arguments>(#{ARGUMENT}\s*)*)/
+
+		# Regular expression that matches placeholder operations
+		OPERATION = /(->\s*(?<operation>\w+))/
+
+		# Regular expression that matches placeholder defaults
+		DEFAULT = /(\:\s*(?<default>[^(\-\>)]+))/
+
+		public
+
+		# Regular expression that matches placeholders
+		REGEX = /@\(\s*#{NAME}\s*#{DEFAULT}?\s*(#{OPERATION}\s*#{ARGUMENTS}?)?\s*\)/
+
+		# Initializes the GPlaceholder with the given match
+		#
+		# Parameter: match    - the match data from the string being parsed
+		# Parameter: defaults - the hash of default data from the GTemplate
+		def initialize match, defaults
+			super match
+			@operation = match[:operation]
+			if match[:arguments]
+				@arguments = match[:arguments].gsub(ARGUMENT).collect { |arg|
+					ARGUMENT.match(arg)[:text]
+				}
+			else
+				@arguments = []
+			end
+			@defaults = defaults
+			@defaults[@name] = match[:default] unless @defaults.has_key? @name
+		end
+
+		# 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
+		def apply data
+			# Get value from either data or defaults
+			if data.has_key? @name
+				value = data[@name]
+			else
+				value = @defaults[@name]
+			end
+
+			# Return value (operation performed if one is defined)
+			return (@operation ? General::GOperations.send(@operation, value, *@arguments) : value).to_s
+		end
+
+		# 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
+		def regex(first=true); first ? "(?<#{@name.to_s}>.*)" : "\\k<#{@name.to_s}>"; end
+
+		# 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
+		def string first=true
+			str = "@(#{@name}"
+			if first
+				if @defaults[@name]
+					str += ": #{@defaults[@name]}"
+				end
+				if @operation
+					str += " -> #{@operation}"
+					unless @arguments.empty?
+						str += @arguments.collect {|s| " \"#{s}\""}.join
+					end
+				end
+			end
+			return str + ")"
+		end
+	end
+
+	# Represents an array placeholder partial in a GTemplate
+	#
+	# Author:  Anshul Kharbanda
+	# Created: 7 - 1 - 2016
+	class GArrayPlaceholder < GPartial
+		# Regular expression that matches array placeholders
+		REGEX = /\A@\[#{NAME}\]( +|\n+)?(?<text>.*?)( +|\n+)?@\[(?<delimeter>.+)?\]/m
+
+		# Default delimeter
+		DEFAULT_DELIMETER = " "
+
+		# Initializes the GPlaceholder with the given match
+		#
+		# Parameter: match - the match data from the string being parsed
+		def initialize match
+			super
+			@delimeter = match[:delimeter] || DEFAULT_DELIMETER
+			@template = General::GTemplate.new match[:text]
+		end
+
+		# Returns the value of the array placeholder in the given data
+		# formatted by the given GTemplate 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 GTemplate and joined by the given delimeter
+		def apply(data); @template.apply_all(data[@name]).join(@delimeter); end
+
+		# Throws TypeError
+		# 
+		# Parameter: first - true if the placeholder is the first of it's kind
+		def regex(first=true); raise TypeError.new("Array Templates cannot be matched."); end
+
+		# Returns the string representation of the array placeholder
+		#
+		# Parameter: first - true if the placeholder is the first of it's kind
+		#
+		# Return: the string representation of the array placeholder
+		def string(first=true); "@[#{@name}] #{@template.to_s} @[#{@delimeter.inspect[1...-1]}]"; end
+	end
+end