nakor 0.0.4 → 0.0.5

data/Rakefile

@@ -1 +1,3 @@
 require "bundler/gem_tasks"
+
+require "metric_fu"

data/lib/nakor/app.rb

@@ -1,11 +1,4 @@
 module Nakor
   class App
-    def self.portray(food)
-      if food.downcase == "broccoli"
-        "Gross!"
-      else
-        "Delicious!"
-      end
-    end
   end
 end

data/lib/nakor/generators/app.rb

@@ -45,14 +45,14 @@ module Nakor
       end
 
       def copy_source_files
-        TEMPLATE_FILES.each do |f|
-          template f, "#{app_name}/#{f}"
+        TEMPLATE_FILES.each do |template_file|
+          template f, "#{app_name}/#{template_file}"
         end
       end
 
       def copy_asset_files
-        ASSET_FILES.each do |f|
-          copy_file f, "#{app_name}/#{f}"
+        ASSET_FILES.each do |asset_file|
+          copy_file f, "#{app_name}/#{asset_file}"
         end
       end
 

data/lib/nakor/generators/corona-game-template/io_ext.lua

@@ -0,0 +1,34 @@
+local http = require("socket.http")
+local ltn12 = require("ltn12")
+
+local M = {}
+
+require "json"
+local parseJson = function( filename )
+  local file = io.open( filename, "r" )
+  if file then
+    local contents = file:read( "*a" )
+    result = json.decode( contents )
+    io.close( file )
+    return result
+  else
+    return {}
+  end
+end
+M.parseJson = parseJson
+
+local parseRemoteJson = function( remoteUrl )
+  local tempFilename = system.pathForFile( "temp.json", system.TemporaryDirectory )
+  local tempFile = io.open( tempFilename, "w+b" )
+
+  http.request {
+    url = remoteUrl,
+    sink = ltn12.sink.file( tempFile )
+  }
+
+  return parseJson( tempFilename )
+end
+M.parseRemoteJson = parseRemoteJson
+
+return M
+

data/lib/nakor/generators/corona-game-template/orm.lua

@@ -0,0 +1,198 @@
+local sqlite3 = require "sqlite3"
+local radlib = require "radlib"
+
+
+local M = {}
+
+------------------------------------------------------------------------------
+-- Initialize the database connection
+------------------------------------------------------------------------------
+local initialize = function( dbPath )
+  if dbPath ~= nil then
+    db = sqlite3.open( dbPath )
+  else
+    db = sqlite3.open_memory()
+  end
+  return db
+end
+M.initialize = initialize
+
+------------------------------------------------------------------------------
+-- Close the database
+------------------------------------------------------------------------------
+local close = function()
+  db:close()
+end
+M.close = close
+
+------------------------------------------------------------------------------
+-- Return all the contents of an SQLite table as a table structure
+------------------------------------------------------------------------------
+local selectAll = function(tableName)
+  local result = {}
+  for row in db:nrows("SELECT * FROM " .. tableName) do
+    result[#result+1] = row
+  end
+  return result
+end
+M.selectAll = selectAll
+
+------------------------------------------------------------------------------
+-- Return contents of an SQLite table filtered by a WHERE query
+-- Return value is a table structure
+------------------------------------------------------------------------------
+local selectWhere = function(tableName, whereClause)
+  local result = {}
+  for row in db:nrows("SELECT * FROM " .. tableName .. " WHERE " .. whereClause) do
+    result[#result+1] = row
+  end
+  return result
+end
+M.selectWhere = selectWhere
+
+------------------------------------------------------------------------------
+-- Return the row from the given table,
+-- selected from the given key/keyValue pair
+------------------------------------------------------------------------------
+local selectOne = function(tableName, key, keyValue)
+  local result = {}
+  for row in db:nrows(
+		"SELECT * FROM " .. tableName ..
+		" WHERE " .. key .. " = " .. keyValue ..
+		" LIMIT 1") do
+    result[1] = row
+    break
+  end
+  return result[1]
+end
+M.selectOne = selectOne
+
+------------------------------------------------------------------------------
+-- Returns the number of rows for the given table
+------------------------------------------------------------------------------
+local getTableRowCount = function(tableName)
+  local rowCount = 0
+  for row in db:nrows("SELECT COUNT(*) as rowcount FROM " .. tableName) do
+    rowCount = row.rowcount
+  end
+  return rowCount
+end
+M.getTableRowCount = getTableRowCount
+
+------------------------------------------------------------------------------
+-- Inserts a row into the given table
+------------------------------------------------------------------------------
+local insertRow = function( tableName, row )
+  -- temporary holding variables
+  local columnList = " ( "
+  local valuesList = " VALUES("
+
+  -- format column values into SQL-safe strings
+  -- then concatenate them together
+  for i,v in pairs(row) do
+    local colName = i
+    local colValue = v
+    if type(v) == 'string' then
+      colValue = radlib.string.toSqlString(v)
+    end
+    columnList = columnList .. colName .. ","
+    valuesList = valuesList .. colValue .. ","
+  end
+
+  -- strip off the trailing comma and add a closing parentheses
+  columnList = string.sub( columnList, 1, columnList:len()-1 ) .. ')'
+  valuesList = string.sub( valuesList, 1, valuesList:len()-1 ) .. ')'
+
+  -- prepare the complete SQL command
+  local sql = "INSERT INTO " .. tableName .. columnList .. valuesList
+
+  -- execute the SQL command for inserting the row
+  print("Running INSERT SQL: " .. sql)
+  db:exec( sql )
+end
+M.insertRow = insertRow
+
+------------------------------------------------------------------------------
+-- Updates a row on the given table
+------------------------------------------------------------------------------
+local updateRow = function( tableName, recordData )
+  -- format column values into SQL-safe strings
+  -- then concatenate them together
+  local updateStr = ''
+  for i,v in pairs(recordData) do
+    if i ~= 'id' then
+      local colName = i
+      local colValue = v
+      if type(v) == 'string' then
+        colValue = radlib.string.toSqlString(v)
+      end
+      updateStr = updateStr .. colName .. " = " .. colValue .. ","
+    end
+  end
+
+  -- remove the trailing comma
+  updateStr = string.sub( updateStr, 1, #updateStr-1 )
+
+  local sql = "UPDATE " .. tableName .. " SET " .. updateStr .. " WHERE id = " .. recordData.id
+  print( "UPDATE SQL: " .. sql )
+  db:exec( sql )
+end
+M.updateRow = updateRow
+
+------------------------------------------------------------------------------
+-- If a matching id already exists in the database, do an update
+-- otherwise do an insert
+------------------------------------------------------------------------------
+local createOrUpdate = function( tableName, recordData )
+  local existingRecord = M.selectOne( tableName, 'id', recordData.id )
+  if existingRecord == nil then
+    M.insertRow( tableName, recordData )
+  else
+    M.updateRow( tableName, recordData )
+  end
+end
+M.createOrUpdate = createOrUpdate
+
+------------------------------------------------------------------------------
+-- Updates one column for one row in a given table
+------------------------------------------------------------------------------
+local updateAttribute = function( tablename, filter, columnName, columnValue )
+  if type(columnValue) == 'string' then
+    columnValue = radlib.string.toSqlString( columnValue )
+  end
+  local updateStr = "UPDATE " .. tablename ..
+    " SET " .. columnName .. " = " .. columnValue ..
+    " WHERE " .. filter
+  print("UPDATE SQL: " .. updateStr )
+  db:exec( updateStr )
+end
+M.updateAttribute = updateAttribute
+
+------------------------------------------------------------------------------
+-- Updates multiple columns for one row in a given table
+------------------------------------------------------------------------------
+local updateAttributes = function( tablename, filter, columns, columnValues )
+  local updateStr = ''
+  local newValue = nil
+  for i,v in ipairs(columns) do
+    if type(v) == 'string' then
+      newValue = radlib.string.toSqlString( columnValues[i] )
+    else
+      newValue = columnValues[i]
+    end
+    updateStr = updateStr .. v .. " = " .. newValue
+    if i < #columns then
+      updateStr = updateStr .. ", "
+    end
+  end
+  print("UPDATE SQL: " .. updateStr)
+  db:exec(
+    "UPDATE " .. tablename .. " SET " ..
+    updateStr ..
+    " WHERE " .. filter
+  )
+end
+M.updateAttributes = updateAttributes
+
+return M
+

data/lib/nakor/generators/corona-game-template/radlib.lua

@@ -1,67 +1,19 @@
 -- Rad's Library of awesome Lua functions to complement the awesome Corona SDK
 
 local M = {}
-M.io = {}
-M.table = {}
 
-require "json"
+local ioExt = require "io_ext"
+M.io = ioExt
 
-local parseJson = function( filename )
-  local file = io.open( filename, "r" )
-  if file then
-    local contents = file:read( "*a" )
-    result = json.decode( contents )
-    io.close( file )
-    return result
-  else
-    return {}
-  end
-end
-M.io.parseJson = parseJson
+local stringExt = require "string_ext"
+M.string = stringExt
 
--- From: http://stackoverflow.com/questions/1283388/lua-merge-tables
-local tableMerge = function(t1, t2)
-  for k,v in pairs(t2) do
-    if type(v) == "table" then
-      if type(t1[k] or false) == "table" then
-        table.merge(t1[k] or {}, t2[k] or {})
-      else
-        t1[k] = v
-      end
-    else
-      t1[k] = v
-    end
-  end
-  return t1
-end
-M.table.merge = tableMerge
+local tableExt = require "table_ext"
+M.table = tableExt
 
--- Similar to Ruby's Enumerable#select
--- Given an input table and a function, return only those rows where fx(row) returns true
-local tableFindAll = function( t, fx )
-  local result = {}
-  for i,v in ipairs(t) do
-    if fx(v) then
-      result[#result + 1] = v
-    end
-  end
-  return result
-end
-M.table.findAll = tableFindAll
+local timeExt = require "time_ext"
+M.time = timeExt
 
-local tablePrint = function( t )
-  for i,v in pairs(t) do
-    if "table" == type(v) then
-      print(i .. " = [table]: ")
-      print("---")
-      table.print(v)
-      print("---")
-    else
-      print(i .. " = " .. v)
-    end
-  end
-end
-M.table.print = tablePrint
 
 local debug = function( msg )
   native.showAlert("DEBUG", msg, {"OK"})
@@ -71,3 +23,4 @@ M.debug = debug
 return M
 
 
+

data/lib/nakor/generators/corona-game-template/string_ext.lua

@@ -0,0 +1,21 @@
+local M = {}
+M.string = {}
+
+local doubleQuote = function( str )
+  return '"' .. str .. '"'
+end
+M.doubleQuote = doubleQuote
+
+local singleQuote = function( str )
+  return "'" .. str .. "'"
+end
+M.singleQuote = singleQuote
+
+local toSqlString = function( str )
+  local result = string.gsub( str, "'", "'''")
+  result = singleQuote( result )
+  return result
+end
+M.toSqlString = toSqlString
+
+return M

data/lib/nakor/generators/corona-game-template/table_ext.lua

@@ -0,0 +1,53 @@
+local M = {}
+
+------------------------------------------------------------------------------
+-- Merge two tables
+-- From: http://stackoverflow.com/questions/1283388/lua-merge-tables
+------------------------------------------------------------------------------
+local merge = function(t1, t2)
+  for k,v in pairs(t2) do
+    if type(v) == "table" then
+      if type(t1[k] or false) == "table" then
+        table.merge(t1[k] or {}, t2[k] or {})
+      else
+        t1[k] = v
+      end
+    else
+      t1[k] = v
+    end
+  end
+  return t1
+end
+M.merge = merge
+
+------------------------------------------------------------------------------
+-- Print the contents of a table
+------------------------------------------------------------------------------
+local tablePrint = function( t )
+  for i,v in pairs(t) do
+    if "table" == type(v) then
+      print(i .. " = [table]: ")
+      print("---")
+      M.print(v)
+      print("---")
+    else
+      print(i .. " = " .. v)
+    end
+  end
+end
+M.print = tablePrint
+
+------------------------------------------------------------------------------
+-- Wrap the values of a table inside single quotes
+------------------------------------------------------------------------------
+local quoteValues = function( t )
+  local result = {}
+  for i,v in pairs(t) do
+    result[i] = "'" .. v .. "'"
+  end
+  return result
+end
+M.quoteValues = quoteValues
+
+
+return M

data/lib/nakor/generators/corona-game-template/time_ext.lua

@@ -0,0 +1,20 @@
+local M = {}
+
+------------------------------------------------------------------------------
+-- Given a time duration in seconds, returns it in HH::MM::SS format
+-- Assumes that duration is less than 24 hours
+------------------------------------------------------------------------------
+local formatTimeDuration = function( duration )
+  local d = duration
+  local hours = math.floor( duration / 3600 )
+  d = d - ( hours * 3600 )
+  local minutes = math.floor( d / 60 )
+  d = d - ( minutes * 60 )
+  local seconds = d
+
+  return string.format( "%02d:%02d:%02d", hours, minutes, seconds )
+end
+M.formatTimeDuration = formatTimeDuration
+
+return M
+

data/lib/nakor/generators/corona-game-template/underscore.lua

@@ -0,0 +1,425 @@
+-- Copyright (c) 2009 Marcus Irven
+--  
+-- Permission is hereby granted, free of charge, to any person
+-- obtaining a copy of this software and associated documentation
+-- files (the "Software"), to deal in the Software without
+-- restriction, including without limitation the rights to use,
+-- copy, modify, merge, publish, distribute, sublicense, and/or sell
+-- copies of the Software, and to permit persons to whom the
+-- Software is furnished to do so, subject to the following
+-- conditions:
+--  
+-- The above copyright notice and this permission notice shall be
+-- included in all copies or substantial portions of the Software.
+--  
+-- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+-- EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+-- OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+-- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+-- HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+-- WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+-- FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+-- OTHER DEALINGS IN THE SOFTWARE.
+
+--- Underscore is a set of utility functions for dealing with 
+-- iterators, arrays, tables, and functions.
+
+local Underscore = { funcs = {} }
+Underscore.__index = Underscore
+
+function Underscore.__call(_, value)
+	return Underscore:new(value)
+end
+
+function Underscore:new(value, chained)
+	return setmetatable({ _val = value, chained = chained or false }, self)
+end
+
+function Underscore.iter(list_or_iter)
+	if type(list_or_iter) == "function" then return list_or_iter end
+	
+	return coroutine.wrap(function() 
+		for i=1,#list_or_iter do
+			coroutine.yield(list_or_iter[i])
+		end
+	end)
+end
+
+function Underscore.range(start_i, end_i, step)
+	if end_i == nil then
+		end_i = start_i
+		start_i = 1
+	end
+	step = step or 1
+	local range_iter = coroutine.wrap(function() 
+		for i=start_i, end_i, step do
+			coroutine.yield(i)
+		end
+	end)
+	return Underscore:new(range_iter)
+end
+
+--- Identity function. This function looks useless, but is used throughout Underscore as a default.
+-- @name _.identity
+-- @param value any object
+-- @return value
+-- @usage _.identity("foo")
+-- => "foo"
+function Underscore.identity(value)
+	return value
+end
+
+-- chaining
+
+function Underscore:chain()
+	self.chained = true
+	return self
+end
+
+function Underscore:value()
+	return self._val
+end
+
+-- iter
+
+function Underscore.funcs.each(list, func)
+	for i in Underscore.iter(list) do
+		func(i)
+	end
+	return list
+end
+
+function Underscore.funcs.map(list, func)
+	local mapped = {}
+	for i in Underscore.iter(list) do
+		mapped[#mapped+1] = func(i)
+	end	
+	return mapped
+end
+
+function Underscore.funcs.reduce(list, memo, func)	
+	for i in Underscore.iter(list) do
+		memo = func(memo, i)
+	end	
+	return memo
+end
+
+function Underscore.funcs.detect(list, func)
+	for i in Underscore.iter(list) do
+		if func(i) then return i end
+	end	
+	return nil	
+end
+
+function Underscore.funcs.select(list, func)
+	local selected = {}
+	for i in Underscore.iter(list) do
+		if func(i) then selected[#selected+1] = i end
+	end
+	return selected
+end
+
+function Underscore.funcs.reject(list, func)
+	local selected = {}
+	for i in Underscore.iter(list) do
+		if not func(i) then selected[#selected+1] = i end
+	end
+	return selected
+end
+
+function Underscore.funcs.all(list, func)
+	func = func or Underscore.identity
+	
+	-- TODO what should happen with an empty list?
+	for i in Underscore.iter(list) do
+		if not func(i) then return false end
+	end
+	return true
+end
+
+function Underscore.funcs.any(list, func)
+	func = func or Underscore.identity
+
+	-- TODO what should happen with an empty list?	
+	for i in Underscore.iter(list) do
+		if func(i) then return true end
+	end	
+	return false
+end
+
+function Underscore.funcs.include(list, value)
+	for i in Underscore.iter(list) do
+		if i == value then return true end
+	end	
+	return false
+end
+
+function Underscore.funcs.invoke(list, function_name, ...)
+	local args = {...}
+	Underscore.funcs.each(list, function(i) i[function_name](i, unpack(args)) end)
+	return list
+end
+
+function Underscore.funcs.pluck(list, propertyName)
+	return Underscore.funcs.map(list, function(i) return i[propertyName] end)
+end
+
+function Underscore.funcs.min(list, func)
+	func = func or Underscore.identity
+	
+	return Underscore.funcs.reduce(list, { item = nil, value = nil }, function(min, item) 
+		if min.item == nil then
+			min.item = item
+			min.value = func(item)
+		else
+			local value = func(item)
+			if value < min.value then
+				min.item = item
+				min.value = value
+			end
+		end
+		return min
+	end).item
+end
+
+function Underscore.funcs.max(list, func)
+	func = func or Underscore.identity
+	
+	return Underscore.funcs.reduce(list, { item = nil, value = nil }, function(max, item) 
+		if max.item == nil then
+			max.item = item
+			max.value = func(item)
+		else
+			local value = func(item)
+			if value > max.value then
+				max.item = item
+				max.value = value
+			end
+		end
+		return max
+	end).item
+end
+
+function Underscore.funcs.to_array(list)
+	local array = {}
+	for i in Underscore.iter(list) do
+		array[#array+1] = i
+	end	
+	return array
+end
+
+function Underscore.funcs.reverse(list)
+	local reversed = {}
+	for i in Underscore.iter(list) do
+		table.insert(reversed, 1, i)
+	end	
+	return reversed
+end
+
+function Underscore.funcs.sort(iter, comparison_func)
+	local array = iter
+	if type(iter) == "function" then
+		array = Underscore.funcs.to_array(iter)
+	end
+	table.sort(array, comparison_func)
+	return array
+end
+
+-- arrays
+
+function Underscore.funcs.first(array, n)
+	if n == nil then
+		return array[1]
+	else
+		local first = {}
+		n = math.min(n,#array)
+		for i=1,n do
+			first[i] = array[i]			
+		end
+		return first
+	end
+end
+
+function Underscore.funcs.rest(array, index)
+	index = index or 2
+	local rest = {}
+	for i=index,#array do
+		rest[#rest+1] = array[i]
+	end
+	return rest
+end
+
+function Underscore.funcs.slice(array, start_index, length)
+	local sliced_array = {}
+	
+	start_index = math.max(start_index, 1)
+	local end_index = math.min(start_index+length-1, #array)
+	for i=start_index, end_index do
+		sliced_array[#sliced_array+1] = array[i]
+	end
+	return sliced_array
+end
+
+function Underscore.funcs.flatten(array)
+	local all = {}
+	
+	for ele in Underscore.iter(array) do
+		if type(ele) == "table" then
+			local flattened_element = Underscore.funcs.flatten(ele)
+			Underscore.funcs.each(flattened_element, function(e) all[#all+1] = e end)
+		else
+			all[#all+1] = ele
+		end
+	end
+	return all
+end
+
+function Underscore.funcs.push(array, item)
+	table.insert(array, item)
+	return array
+end
+
+function Underscore.funcs.pop(array)
+	return table.remove(array)
+end
+
+function Underscore.funcs.shift(array)
+	return table.remove(array, 1)
+end
+
+function Underscore.funcs.unshift(array, item)
+	table.insert(array, 1, item)
+	return array
+end
+
+function Underscore.funcs.join(array, separator)
+	return table.concat(array, separator)
+end
+
+-- objects
+
+function Underscore.funcs.keys(obj)
+	local keys = {}
+	for k,v in pairs(obj) do
+		keys[#keys+1] = k
+	end
+	return keys
+end
+
+function Underscore.funcs.values(obj)
+	local values = {}
+	for k,v in pairs(obj) do
+		values[#values+1] = v
+	end
+	return values
+end
+
+function Underscore.funcs.extend(destination, source)
+	for k,v in pairs(source) do
+		destination[k] = v
+	end	
+	return destination
+end
+
+function Underscore.funcs.is_empty(obj)
+	return next(obj) == nil
+end
+
+-- Originally based on penlight's deepcompare() -- http://luaforge.net/projects/penlight/
+function Underscore.funcs.is_equal(o1, o2, ignore_mt)
+	local ty1 = type(o1)
+	local ty2 = type(o2)
+	if ty1 ~= ty2 then return false end
+	
+	-- non-table types can be directly compared
+	if ty1 ~= 'table' then return o1 == o2 end
+	
+	-- as well as tables which have the metamethod __eq
+	local mt = getmetatable(o1)
+	if not ignore_mt and mt and mt.__eq then return o1 == o2 end
+	
+	local is_equal = Underscore.funcs.is_equal
+	
+	for k1,v1 in pairs(o1) do
+		local v2 = o2[k1]
+		if v2 == nil or not is_equal(v1,v2, ignore_mt) then return false end
+	end
+	for k2,v2 in pairs(o2) do
+		local v1 = o1[k2]
+		if v1 == nil then return false end
+	end
+	return true
+end
+
+-- functions
+
+function Underscore.funcs.compose(...)
+	local function call_funcs(funcs, ...)
+		if #funcs > 1 then
+			return funcs[1](call_funcs(_.rest(funcs), ...))
+		else
+			return funcs[1](...)
+		end
+	end
+	
+	local funcs = {...}
+	return function(...)
+		return call_funcs(funcs, ...)
+	end
+end
+
+function Underscore.funcs.wrap(func, wrapper)
+	return function(...)
+		return wrapper(func, ...)
+	end
+end
+
+function Underscore.funcs.curry(func, argument)
+	return function(...)
+		return func(argument, ...)
+	end
+end
+
+function Underscore.functions() 
+	return Underscore.keys(Underscore.funcs)
+end
+
+-- add aliases
+Underscore.methods = Underscore.functions
+
+Underscore.funcs.for_each = Underscore.funcs.each
+Underscore.funcs.collect = Underscore.funcs.map
+Underscore.funcs.inject = Underscore.funcs.reduce
+Underscore.funcs.foldl = Underscore.funcs.reduce
+Underscore.funcs.filter = Underscore.funcs.select
+Underscore.funcs.every = Underscore.funcs.all
+Underscore.funcs.some = Underscore.funcs.any
+Underscore.funcs.head = Underscore.funcs.first
+Underscore.funcs.tail = Underscore.funcs.rest
+
+local function wrap_functions_for_oo_support()
+	local function value_and_chained(value_or_self)
+		local chained = false
+		if getmetatable(value_or_self) == Underscore then 
+			chained = value_or_self.chained
+			value_or_self = value_or_self._val 
+		end
+		return value_or_self, chained
+	end
+
+	local function value_or_wrap(value, chained)
+		if chained then value = Underscore:new(value, true) end
+		return value
+	end
+
+	for fn, func in pairs(Underscore.funcs) do
+		Underscore[fn] = function(obj_or_self, ...)
+			local obj, chained = value_and_chained(obj_or_self)	
+			return value_or_wrap(func(obj, ...), chained)		
+		end	 
+	end
+end
+
+wrap_functions_for_oo_support()
+
+return Underscore:new()

data/lib/nakor/version.rb

@@ -1,3 +1,3 @@
 module Nakor
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/nakor.gemspec

@@ -32,5 +32,6 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency "aruba"
   s.add_development_dependency "cucumber"
+  s.add_development_dependency "metric_fu"
   s.add_development_dependency "rspec"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nakor
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-04 00:00:00.000000000Z
+date: 2012-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &70270858535080 !ruby/object:Gem::Requirement
+  requirement: &70236708170220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70270858535080
+  version_requirements: *70236708170220
 - !ruby/object:Gem::Dependency
   name: aruba
-  requirement: &70270858534520 !ruby/object:Gem::Requirement
+  requirement: &70236708167960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70270858534520
+  version_requirements: *70236708167960
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &70270858533920 !ruby/object:Gem::Requirement
+  requirement: &70236711984180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,21 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70270858533920
+  version_requirements: *70236711984180
+- !ruby/object:Gem::Dependency
+  name: metric_fu
+  requirement: &70236711983760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70236711983760
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70270858533300 !ruby/object:Gem::Requirement
+  requirement: &70236711983340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +65,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70270858533300
+  version_requirements: *70236711983340
 description: ! "\n    To create a new Corona SDK game using nakor, just run:\n\n    nakor
   generate awesome_game\n\n    This will create an awesome_game directory in the current
   directory, and copy all corona game template files into it.\n\n    To run the generated
@@ -92,15 +103,20 @@ files:
 - lib/nakor/generators/corona-game-template/director.lua
 - lib/nakor/generators/corona-game-template/help.lua
 - lib/nakor/generators/corona-game-template/init_buttons.lua
+- lib/nakor/generators/corona-game-template/io_ext.lua
 - lib/nakor/generators/corona-game-template/loadmenu.lua
 - lib/nakor/generators/corona-game-template/main.lua
 - lib/nakor/generators/corona-game-template/menu.lua
-- lib/nakor/generators/corona-game-template/newgame.rb
+- lib/nakor/generators/corona-game-template/orm.lua
 - lib/nakor/generators/corona-game-template/play.lua
 - lib/nakor/generators/corona-game-template/radlib.lua
 - lib/nakor/generators/corona-game-template/settings.lua
 - lib/nakor/generators/corona-game-template/splash_screen.png
+- lib/nakor/generators/corona-game-template/string_ext.lua
+- lib/nakor/generators/corona-game-template/table_ext.lua
+- lib/nakor/generators/corona-game-template/time_ext.lua
 - lib/nakor/generators/corona-game-template/ui.lua
+- lib/nakor/generators/corona-game-template/underscore.lua
 - lib/nakor/version.rb
 - nakor.gemspec
 - spec/app_spec.rb

data/lib/nakor/generators/corona-game-template/newgame.rb

@@ -1,56 +0,0 @@
-require 'fileutils'
-
-# Creates a new game at the parent directory.
-# Usage:
-#   macruby newgame <appname>
-# For example, if this template is on /Users/rad/Documents/games/corona-game-template,
-# running "macruby newgame mygame"
-# will create the directory /Users/rad/Documents/games/mygame
-# and copy all files from the template to that directory
-
-def generate_new_app(appname)
-  app_dir = "../#{appname}"
-  code_dir = "#{app_dir}/#{appname}"
-  assets_dir = "#{app_dir}/assets"
-  doc_dir = "#{app_dir}/doc"
-
-  # create the app directories
-  FileUtils.mkdir_p app_dir
-  FileUtils.mkdir_p code_dir
-  FileUtils.mkdir_p assets_dir
-  FileUtils.mkdir_p doc_dir
-  
-  # copy the files to the app code directory
-  FileUtils.cp_r './.', code_dir
-
-  # copy README
-  FileUtils.cp_r 'README', app_dir
-
-  # Remove support files used only for corona-game-template development
-  FileUtils.rm_r "#{code_dir}/.git"
-  FileUtils.rm_r "#{code_dir}/README"
-  FileUtils.rm "#{code_dir}/newgame.rb"
-end
-
-def show_help
-  print %{
-    Creates a new game at the parent directory.
-    Usage:
-      macruby newgame.rb <appname>
-    For example, if this template is on /Users/rad/Documents/games/corona-game-template,
-    running "macruby newgame mygame"
-    will create the directory /Users/rad/Documents/games/mygame
-    and copy all files from the template to that directory    
-  }
-end
-
-def main
-  appname = ARGV[0]
-  if appname && appname.strip != ''
-    generate_new_app(appname)
-  else
-    show_help
-  end
-end
-
-main()