nakor 0.0.7 → 0.0.8

data/.gitignore

@@ -1,4 +1,6 @@
 *.gem
+*.swp
 .bundle
 Gemfile.lock
 pkg/*
+tmp/*

data/README.md

@@ -0,0 +1,36 @@
+# Nakor
+
+Nakor is a Ruby gem for generating a template application for Corona SDK. It creates a template app with a splash screen, a menu with four buttons (Play, Settings, Help, About), and one scene for each of the four buttons. It uses Corona SDK's built-in Storyboard to manage scenes.
+
+The generated app also includes [RadLib](https://github.com/radamanthus/radlib), a library of utility Lua functions to support Corona SDK development.
+
+# Installation
+
+    gem install nakor
+
+
+# Usage
+
+    nakor generate awesome_app
+
+This will create the *awesome_app* directory in the current directory. To run it in Corona simulator:
+
+    cd awesome_app
+    /Applications/CoronaSDK/simulator awesome_app
+
+The generated project directory structure looks like this:
+
+    appname
+      +-- assets
+      +-- appname
+      +-- doc
+      +-- server
+
+The directory structure follows my personal convention for mobile projects:
+
+- All mobile app code is in appname/appname.
+- If this has a server component, the server app source code is in appname/server
+- Game assets (e.g. Illustrator .ai files) are in appname/assets, finished PNGs are copied over to appname/appname because that's where Corona SDK expects them to be.
+- The game design document (yes you should have one) and all other documentation are in appname/doc
+
+

data/Rakefile

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

data/features/generate.feature

@@ -1,12 +1,18 @@
 Feature: Generate
   In order to make the world a better place
-  As a CLI
+  As a Corona SDK programmer
   I want to be able to generate new apps
 
-  Scenario: Generate a new app in a non-existing folder
-    When I run `../../bin/nakor generate awesome_game`
+  Scenario: Generate a new app in a non-existent folder
+    When I run `../../bin/nakor generate 'awesome_game'`
     Then the output should contain "Successfully generated 'awesome_game'"
     And the following files should exist:
       | awesome_game/main.lua   |
 
   Scenario: Warn the user when generating an app will overwrite an existing folder
+
+  Scenario: Run the generated app
+    When I run `../../bin/nakor generate 'awesome_game'`
+    And I run `simulator awesome_game` interactively
+    Then the "awesome_game" app should run without errors
+

data/features/step_definitions/generate_steps.rb

@@ -0,0 +1,4 @@
+Then /^the "([^"]*)" app should run without errors$/ do |app_name|
+  # How do we test this?
+  pending
+end

data/features/update.feature

@@ -0,0 +1,19 @@
+Feature: Generate
+  In order to make the world a better place
+  As a Corona SDK programmer
+  I want to be able to update my apps to the latest version of RadLib
+
+  Scenario: Refuse to update a non-existen app
+
+  Scenario: Update RadLib inside an existing app
+    When I run `../../bin/nakor update_radlib 'awesome_game'`
+    Then the output should contain "Successfully updated 'awesome_game'"
+    And the following files should exist:
+      | awesome_game/main.lua   |
+
+  Scenario: Run the generated app
+    When I run `../../bin/nakor update_radlib 'awesome_game'`
+    And I run `simulator awesome_game` interactively
+    Then the "awesome_game" app should run without errors
+
+

data/lib/nakor/cli.rb

@@ -7,5 +7,10 @@ module Nakor
     def generate(app_name)
       Nakor::Generators::App.start([app_name])
     end
+
+    desc "update_radlib APP_DIR", "updates radlib inside an existing application"
+    def update_radlib(app_dir)
+      Nakor::Utilities::UpdateRadLib.execute([app_dir])
+    end
   end
 end

data/lib/nakor/generators/app.rb

@@ -17,19 +17,23 @@ module Nakor
 
       TEMPLATE_FILES = %W{
         about.lua
+        active_record.lua
         build.settings
         config.lua
+        geometry.lua
         help.lua
         init_buttons.lua
         io_ext.lua
         loadmenu.lua
         main.lua
         menu.lua
+        middleclass.lua
         orm.lua
         play.lua
         radlib.lua
         README
         settings.lua
+        sql.lua
         string_ext.lua
         table_ext.lua
         time_ext.lua
@@ -46,24 +50,37 @@ module Nakor
       end
 
       def create_group
-        empty_directory(app_name)
+        # Create the top-level app directory
+        empty_directory app_name
+
+        # Create the subdirectories
+        create_subdirectory app_name
+        create_subdirectory "server"
+        create_subdirectory "assets"
+        create_subdirectory "doc"
       end
 
       def copy_source_files
         TEMPLATE_FILES.each do |template_file|
-          template template_file, "#{app_name}/#{template_file}"
+          template template_file, "#{app_name}/#{app_name}/#{template_file}"
         end
       end
 
       def copy_asset_files
         ASSET_FILES.each do |asset_file|
-          copy_file asset_file, "#{app_name}/#{asset_file}"
+          copy_file asset_file, "#{app_name}/#{app_name}/#{asset_file}"
         end
       end
 
       def done
         puts "Successfully generated '#{app_name}'"
       end
+
+      private
+
+      def create_subdirectory(subdir)
+        empty_directory(File.join app_name, subdir)
+      end
     end
   end
 end

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

@@ -0,0 +1,155 @@
+-- USAGE
+--
+-- Create a Lua file for your module. The file should look like this:
+--
+-- require 'ActiveRecord'
+-- Product = ActiveRecord:subclass('ActiveRecord')
+-- Product.tableName = 'products'
+-- Product.tableFields = {
+--  id = {type = 'integer', flags = {'primary_key', 'autoincrement', 'not_null'} },
+--  name = {type = 'string', flags = {'not_null'} }
+-- }
+--
+-- If the table does not yet exist, you can create it in your app initialization with this call:
+--
+-- orm.initialize()
+-- Product.createTable()
+--
+-- Sample API calls
+--
+-- local products = Product.findAll
+--
+-- p = Product.new{id = 1, name = 'test', description = ''} (NOT YET IMPLEMENTED)
+-- p.save
+--
+-- p.updateAttribute('name', 'newName')
+-- p.updateAttributes{name = 'newName', description = 'newDescription'} (NOT YET IMPLEMENTED)
+--
+-- p = Product.find(1)
+-- test_products = Product.where("name = 'test'")
+--
+-- numberOfProducts = Product.count()
+--
+
+require 'middleclass'
+local orm = require 'orm'
+local sql = require 'sql'
+
+ActiveRecord = class('ActiveRecord')
+
+------------------------------------------------------------------------------
+-- CLASS (STATIC) METHODS - START
+------------------------------------------------------------------------------
+function ActiveRecord:initialize(newRecord)
+  for k,v in pairs(newRecord) do
+    self[k] = v
+  end
+end
+
+------------------------------------------------------------------------------
+-- Returns the number of rows in the table
+------------------------------------------------------------------------------
+function ActiveRecord.static:count()
+  return orm.getTableRowCount(self.tableName)
+end
+
+------------------------------------------------------------------------------
+-- Creates the table
+-- TODO: If options.recreate = true, it drops the table if it already exists
+------------------------------------------------------------------------------
+function ActiveRecord.static:createTable(options)
+  local createSql = sql.generateCreateTable(self.tableName, self.tableFields)
+  db:exec( createSql )
+end
+
+------------------------------------------------------------------------------
+-- Returns the record matching the given id. Returns nil if no match is found.
+--
+-- NOTE: Until I figure out how to determine the caller's class,
+-- I'll have to resort to this ugliness of using the klass parameter
+------------------------------------------------------------------------------
+function ActiveRecord.static:find(klass, id)
+  local record = orm.selectOne(klass.tableName, 'id', id)
+  if not( record == nil ) then
+    result = klass:new(record)
+  end
+  return result
+end
+
+------------------------------------------------------------------------------
+-- Returns all rows in the table that match the given filter
+------------------------------------------------------------------------------
+function ActiveRecord.static:findAll( filter, orderBy )
+  local result = nil
+  if filter == nil then
+    result = orm.selectAll( self.tableName, {order = orderBy} )
+  else
+    result = orm.selectWhere( self.tableName, {where = filter, order = orderBy} )
+  end
+  return result
+end
+
+------------------------------------------------------------------------------
+-- Updates all rows in the table that match the given filter
+------------------------------------------------------------------------------
+function ActiveRecord.static:updateAll( updateSql, filter )
+  if filter == nil then
+    orm.updateAll( self.tableName, updateSql )
+  else
+    orm.updateWhere( self.tableName, updateSql, filter )
+  end
+end
+
+------------------------------------------------------------------------------
+-- CLASS (STATIC) METHODS - END
+------------------------------------------------------------------------------
+
+
+------------------------------------------------------------------------------
+-- INSTANCE METHODS - START
+------------------------------------------------------------------------------
+
+------------------------------------------------------------------------------
+-- Reloads the record values from the database
+------------------------------------------------------------------------------
+function ActiveRecord:reload()
+  local updatedRecord = orm.selectOne( self.class.tableName, 'id', self.id )
+  for k,v in pairs(updatedRecord) do
+    self[k] = v
+  end
+end
+
+------------------------------------------------------------------------------
+-- Saves the content of the object to the database.
+-- If a matching record already exists in the database, an UPDATE is done.
+-- Otherwise an INSERT is done.
+------------------------------------------------------------------------------
+function ActiveRecord:save()
+  local updateTable = {}
+  for k in pairs(self.class.tableFields) do
+    updateTable[k] = self[k]
+  end
+  orm.createOrUpdate( self.class.tableName, updateTable )
+end
+
+------------------------------------------------------------------------------
+-- Updates one column value
+------------------------------------------------------------------------------
+function ActiveRecord:updateAttribute( columnName, columnValue )
+  local filter = "id = " .. self.id
+  orm.updateAttribute( self.class.tableName, filter, columnName, columnValue )
+end
+
+------------------------------------------------------------------------------
+-- Updates an array of columns
+------------------------------------------------------------------------------
+function ActiveRecord:updateAttributes( updateTable )
+  print("IMPLEMENTATION PENDING...")
+end
+
+------------------------------------------------------------------------------
+-- INSTANCE METHODS - END
+------------------------------------------------------------------------------
+
+
+

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

@@ -0,0 +1,76 @@
+local M = {}
+
+------------------------------------------------------------
+-- Public: checks if the given point is inside the given container
+--
+-- Assumptions:
+-- The container has the properties: top, left, bottom, right
+-- The point has the properties x, y
+--
+-- Returns:
+--  true if the point is inside the container
+--  false if not
+------------------------------------------------------------
+local pointIsInside = function(point, rectangle)
+  if (
+    (point.x >= rectangle.left) and
+    (point.x <= rectangle.right) and
+    (point.y >= rectangle.top) and
+    (point.y <= rectangle.bottom)
+    ) then
+    return true
+  else
+    return false
+  end
+end
+M.pointIsInside = pointIsInside
+
+------------------------------------------------------------
+-- Public: checks if the given rectangle is completely
+-- inside the given rectangular container
+--
+-- Assumptions:
+-- Both container and object have the properties: top, left, bottom, right
+--
+-- Returns:
+--  true if the both (top,left) and (bottom,right)
+--  of the rectangle are inside the container
+--  false otherwise
+------------------------------------------------------------
+local rectIsInside = function(object, container)
+  if pointIsInside({x = object.left, y = object.top}, container) and
+    pointIsInside({x = object.right, y = object.bottom}, container) then
+    return true
+  else
+    return false
+  end
+end
+M.rectIsInside = rectIsInside
+
+------------------------------------------------------------
+-- Public: checks if the given rectangle is at at least partially
+-- inside the given rectangular container
+--
+-- Assumption:
+-- Both container and object have the properties: top, left, bottom, right
+--
+-- Returns:
+--  true if at least one of the corners of the rectangle
+--  is inside the container
+--  false otherwise
+------------------------------------------------------------
+local rectIsPartiallyInside = function(object, container)
+  if pointIsInside({x = object.left, y = object.top}, container) or
+    pointIsInside({x = object.right, y = object.top}, container) or
+    pointIsInside({x = object.left, y = object.bottom}, container) or
+    pointIsInside({x = object.right, y = object.bottom}, container) then
+    return true
+  else
+    return false
+  end
+end
+M.rectIsPartiallyInside = rectIsPartiallyInside
+
+return M
+
+

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

@@ -0,0 +1,139 @@
+-- middleclass.lua - v2.0 (2011-09)
+-- Copyright (c) 2011 Enrique García Cota
+-- 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.
+-- Based on YaciCode, from Julien Patte and LuaObject, from Sebastien Rocca-Serra
+
+local _classes = setmetatable({}, {__mode = "k"})
+
+local function _setClassDictionariesMetatables(klass)
+  local dict = klass.__instanceDict
+  dict.__index = dict
+
+  local super = klass.super
+  if super then
+    local superStatic = super.static
+    setmetatable(dict, super.__instanceDict)
+    setmetatable(klass.static, { __index = function(_,k) return dict[k] or superStatic[k] end })
+  else
+    setmetatable(klass.static, { __index = function(_,k) return dict[k] end })
+  end
+end
+
+local function _setClassMetatable(klass)
+  setmetatable(klass, {
+    __tostring = function() return "class " .. klass.name end,
+    __index    = klass.static,
+    __newindex = klass.__instanceDict,
+    __call     = function(self, ...) return self:new(...) end
+  })
+end
+
+local function _createClass(name, super)
+  local klass = { name = name, super = super, static = {}, __mixins = {}, __instanceDict={} }
+  klass.subclasses = setmetatable({}, {__mode = "k"})
+
+  _setClassDictionariesMetatables(klass)
+  _setClassMetatable(klass)
+  _classes[klass] = true
+
+  return klass
+end
+
+local function _createLookupMetamethod(klass, name)
+  return function(...)
+    local method = klass.super[name]
+    assert( type(method)=='function', tostring(klass) .. " doesn't implement metamethod '" .. name .. "'" )
+    return method(...)
+  end
+end
+
+local function _setClassMetamethods(klass)
+  for _,m in ipairs(klass.__metamethods) do
+    klass[m]= _createLookupMetamethod(klass, m)
+  end
+end
+
+local function _setDefaultInitializeMethod(klass, super)
+  klass.initialize = function(instance, ...)
+    return super.initialize(instance, ...)
+  end
+end
+
+local function _includeMixin(klass, mixin)
+  assert(type(mixin)=='table', "mixin must be a table")
+  for name,method in pairs(mixin) do
+    if name ~= "included" and name ~= "static" then klass[name] = method end
+  end
+  if mixin.static then
+    for name,method in pairs(mixin.static) do
+      klass.static[name] = method
+    end
+  end
+  if type(mixin.included)=="function" then mixin:included(klass) end
+  klass.__mixins[mixin] = true
+end
+
+Object = _createClass("Object", nil)
+
+Object.static.__metamethods = { '__add', '__call', '__concat', '__div', '__le', '__lt',
+                                '__mod', '__mul', '__pow', '__sub', '__tostring', '__unm' }
+
+function Object.static:allocate()
+  assert(_classes[self], "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
+  return setmetatable({ class = self }, self.__instanceDict)
+end
+
+function Object.static:new(...)
+  local instance = self:allocate()
+  instance:initialize(...)
+  return instance
+end
+
+function Object.static:subclass(name)
+  assert(_classes[self], "Make sure that you are using 'Class:subclass' instead of 'Class.subclass'")
+  assert(type(name) == "string", "You must provide a name(string) for your class")
+
+  local subclass = _createClass(name, self)
+  _setClassMetamethods(subclass)
+  _setDefaultInitializeMethod(subclass, self)
+  self.subclasses[subclass] = true
+  self:subclassed(subclass)
+
+  return subclass
+end
+
+function Object.static:subclassed(other) end
+
+function Object.static:include( ... )
+  assert(_classes[self], "Make sure you that you are using 'Class:include' instead of 'Class.include'")
+  for _,mixin in ipairs({...}) do _includeMixin(self, mixin) end
+  return self
+end
+
+function Object:initialize() end
+
+function Object:__tostring() return "instance of " .. tostring(self.class) end
+
+function class(name, super, ...)
+  super = super or Object
+  return super:subclass(name, ...)
+end
+
+function instanceOf(aClass, obj)
+  if not _classes[aClass] or type(obj) ~= 'table' or not _classes[obj.class] then return false end
+  if obj.class == aClass then return true end
+  return subclassOf(aClass, obj.class)
+end
+
+function subclassOf(other, aClass)
+  if not _classes[aClass] or not _classes[other] or aClass.super == nil then return false end
+  return aClass.super == other or subclassOf(other, aClass.super)
+end
+
+function includes(mixin, aClass)
+  if not _classes[aClass] then return false end
+  if aClass.__mixins[mixin] then return true end
+  return includes(mixin, aClass.super)
+end

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

@@ -1,3 +1,4 @@
+local sql = require 'sql'
 local sqlite3 = require "sqlite3"
 local radlib = require "radlib"
 
@@ -9,9 +10,9 @@ local M = {}
 ------------------------------------------------------------------------------
 local initialize = function( dbPath )
   if dbPath ~= nil then
-    db = sqlite3.open( dbPath )
+    _G.db = sqlite3.open( dbPath )
   else
-    db = sqlite3.open_memory()
+    _G.db = sqlite3.open_memory()
   end
   return db
 end
@@ -21,16 +22,21 @@ M.initialize = initialize
 -- Close the database
 ------------------------------------------------------------------------------
 local close = function()
-  db:close()
+  _G.db:close()
 end
 M.close = close
 
 ------------------------------------------------------------------------------
 -- Return all the contents of an SQLite table as a table structure
 ------------------------------------------------------------------------------
-local selectAll = function(tableName)
+local selectAll = function( tableName, params )
   local result = {}
-  for row in db:nrows("SELECT * FROM " .. tableName) do
+  local s = sql.generateSelect({
+    tableName = tableName,
+    order = params.order,
+    limit = params.limit
+  })
+  for row in _G.db:nrows(s) do
     result[#result+1] = row
   end
   return result
@@ -41,9 +47,15 @@ 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 selectWhere = function(tableName, params )
   local result = {}
-  for row in db:nrows("SELECT * FROM " .. tableName .. " WHERE " .. whereClause) do
+  local s = sql.generateSelect({
+    tableName = tableName,
+    where = params.where,
+    order = params.order,
+    limit = params.limit
+  })
+  for row in _G.db:nrows(s) do
     result[#result+1] = row
   end
   return result
@@ -56,10 +68,12 @@ M.selectWhere = selectWhere
 ------------------------------------------------------------------------------
 local selectOne = function(tableName, key, keyValue)
   local result = {}
-  for row in db:nrows(
-		"SELECT * FROM " .. tableName ..
-		" WHERE " .. key .. " = " .. keyValue ..
-		" LIMIT 1") do
+  local s = sql.generateSelect({
+    tableName = tableName,
+    where = key .. " = " .. keyValue,
+    limit = 1
+  })
+  for row in _G.db:nrows(s) do
     result[1] = row
     break
   end
@@ -72,7 +86,7 @@ M.selectOne = selectOne
 ------------------------------------------------------------------------------
 local getTableRowCount = function(tableName)
   local rowCount = 0
-  for row in db:nrows("SELECT COUNT(*) as rowcount FROM " .. tableName) do
+  for row in _G.db:nrows("SELECT COUNT(*) as rowcount FROM " .. tableName) do
     rowCount = row.rowcount
   end
   return rowCount
@@ -107,8 +121,7 @@ local insertRow = function( tableName, row )
   local sql = "INSERT INTO " .. tableName .. columnList .. valuesList
 
   -- execute the SQL command for inserting the row
-  print("Running INSERT SQL: " .. sql)
-  db:exec( sql )
+  _G.db:exec( sql )
 end
 M.insertRow = insertRow
 
@@ -134,7 +147,6 @@ local updateRow = function( tableName, recordData )
   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
@@ -153,6 +165,16 @@ local createOrUpdate = function( tableName, recordData )
 end
 M.createOrUpdate = createOrUpdate
 
+------------------------------------------------------------------------------
+-- Updates all rows in the given table
+------------------------------------------------------------------------------
+local updateAll = function( tablename, updateSql )
+  local str = "UPDATE " .. tablename ..
+    " SET " .. updateSql
+  db:exec( str )
+end
+M.updateAll = updateAll
+
 ------------------------------------------------------------------------------
 -- Updates one column for one row in a given table
 ------------------------------------------------------------------------------
@@ -163,7 +185,6 @@ local updateAttribute = function( tablename, filter, columnName, columnValue )
   local updateStr = "UPDATE " .. tablename ..
     " SET " .. columnName .. " = " .. columnValue ..
     " WHERE " .. filter
-  print("UPDATE SQL: " .. updateStr )
   db:exec( updateStr )
 end
 M.updateAttribute = updateAttribute
@@ -185,7 +206,6 @@ local updateAttributes = function( tablename, filter, columns, columnValues )
       updateStr = updateStr .. ", "
     end
   end
-  print("UPDATE SQL: " .. updateStr)
   db:exec(
     "UPDATE " .. tablename .. " SET " ..
     updateStr ..
@@ -194,5 +214,17 @@ local updateAttributes = function( tablename, filter, columns, columnValues )
 end
 M.updateAttributes = updateAttributes
 
+------------------------------------------------------------------------------
+-- Updates all rows that match the filter in the given table
+------------------------------------------------------------------------------
+local updateWhere = function( tablename, updateSql, filter )
+  local str = "UPDATE " .. tablename ..
+    " SET " .. updateSql ..
+    " WHERE " .. filter
+  db:exec( str )
+end
+M.updateWhere = updateWhere
+
+
 return M
 

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

@@ -2,6 +2,9 @@
 
 local M = {}
 
+local geometry = require "geometry"
+M.geometry = geometry
+
 local ioExt = require "io_ext"
 M.io = ioExt
 
@@ -14,7 +17,6 @@ M.table = tableExt
 local timeExt = require "time_ext"
 M.time = timeExt
 
-
 local debug = function( msg )
   native.showAlert("DEBUG", msg, {"OK"})
 end

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

@@ -0,0 +1,79 @@
+------------------------------------------------------------------------------
+-- Module for SQL generation
+------------------------------------------------------------------------------
+local _ = require 'underscore'
+local string_ext = require 'string_ext'
+
+local M = {}
+------------------------------------------------------------------------------
+-- Generate the sql for the given field def flags
+------------------------------------------------------------------------------
+local sqlForFieldFlags = function(fieldDef)
+  if fieldDef.flags ~= nil then
+    return _.join(fieldDef.flags, ' '):upper()
+  else
+    return ''
+  end
+end
+M.sqlForFieldFlags = sqlForFieldFlags
+
+------------------------------------------------------------------------------
+-- Generate a CREATE TABLE IF NOT EXISTS statement
+-- for the given tablename and tablefield definitions
+------------------------------------------------------------------------------
+local generateCreateTable = function(tableName, tableFields)
+  local result = ''
+  result = 'CREATE TABLE IF NOT EXISTS ' .. tableName .. '('
+  for fieldName,fieldDef in pairs(tableFields) do
+    result = result .. string_ext.doubleQuote(fieldName) .. ' ' .. fieldDef.dataType:upper()
+    result = result .. ' ' .. M.sqlForFieldFlags(fieldDef)
+    result = result .. ','
+  end
+  result = string.sub( result, 1, result:len()-1 )
+  result = result .. ')'
+  return result
+end
+M.generateCreateTable = generateCreateTable
+
+------------------------------------------------------------------------------
+-- Generate a SELECT statement
+--
+-- Parameters:
+--   tableName
+--   columns
+--   where
+--   order
+--   limit
+------------------------------------------------------------------------------
+local generateSelect = function(params)
+  local tableName = ''
+  if params.tableName == nil or params.tableName == '' then
+    return ''
+  else
+    tableName = params.tableName
+  end
+
+  local columns = ''
+  if params.columns == nil or params.columns == '' then
+    columns = '*'
+  else
+    columns = params.columns
+  end
+
+  local result = ''
+  result = 'SELECT ' .. columns .. ' FROM ' .. tableName
+  if params.where ~= nil and params.where ~= '' then
+    result = result .. ' WHERE ' .. params.where
+  end
+  if params.order ~= nil and params.order ~= '' then
+    result = result .. ' ORDER BY ' .. params.order
+  end
+  if params.limit ~= nil and params.limit ~= '' then
+    result = result .. ' LIMIT ' .. params.limit
+  end
+  return result
+end
+M.generateSelect = generateSelect
+
+
+return M

data/lib/nakor/utilities/update_rad_lib.rb

@@ -0,0 +1,9 @@
+require 'thor/group'
+module Nakor
+  module Utilities
+    module UpdateRadLib
+      def execute(options=[])
+      end
+    end
+  end
+end

data/lib/nakor/version.rb

@@ -1,3 +1,3 @@
 module Nakor
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

data/nakor.gemspec

@@ -32,6 +32,5 @@ 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.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-21 00:00:00.000000000 Z
+date: 2012-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &70361459079340 !ruby/object:Gem::Requirement
+  requirement: &70127996041500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70361459079340
+  version_requirements: *70127996041500
 - !ruby/object:Gem::Dependency
   name: aruba
-  requirement: &70361459078220 !ruby/object:Gem::Requirement
+  requirement: &70127996040980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70361459078220
+  version_requirements: *70127996040980
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &70361459076920 !ruby/object:Gem::Requirement
+  requirement: &70127996040480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,21 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70361459076920
-- !ruby/object:Gem::Dependency
-  name: metric_fu
-  requirement: &70361594269960 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *70361594269960
+  version_requirements: *70127996040480
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70361594269540 !ruby/object:Gem::Requirement
+  requirement: &70127996039980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +54,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70361594269540
+  version_requirements: *70127996039980
 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
@@ -79,16 +68,20 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - Gemfile
+- README.md
 - Rakefile
 - bin/nakor
 - features/generate.feature
+- features/step_definitions/generate_steps.rb
 - features/support/setup.rb
+- features/update.feature
 - lib/nakor.rb
 - lib/nakor/app.rb
 - lib/nakor/cli.rb
 - lib/nakor/generators/app.rb
 - lib/nakor/generators/corona-game-template/README
 - lib/nakor/generators/corona-game-template/about.lua
+- lib/nakor/generators/corona-game-template/active_record.lua
 - lib/nakor/generators/corona-game-template/bk_default.png
 - lib/nakor/generators/corona-game-template/btn_about.png
 - lib/nakor/generators/corona-game-template/btn_about_over.png
@@ -100,22 +93,26 @@ files:
 - lib/nakor/generators/corona-game-template/btn_settings_over.png
 - lib/nakor/generators/corona-game-template/build.settings
 - lib/nakor/generators/corona-game-template/config.lua
+- lib/nakor/generators/corona-game-template/geometry.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/middleclass.lua
 - 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/sql.lua
 - 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/utilities/update_rad_lib.rb
 - lib/nakor/version.rb
 - nakor.gemspec
 - spec/app_spec.rb
@@ -139,11 +136,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: nakor
-rubygems_version: 1.8.10
+rubygems_version: 1.8.17
 signing_key: 
 specification_version: 3
 summary: Nakor is a gem that encapsulates the corona-game-template project.
 test_files:
 - features/generate.feature
+- features/step_definitions/generate_steps.rb
 - features/support/setup.rb
+- features/update.feature
 - spec/app_spec.rb