candle 0.0.1

data/lib/candle/generators/lua/wax/lib/stdlib/luaspec/luaspec.lua

@@ -0,0 +1,377 @@
+spec = {
+  contexts = {}, passed = 0, failed = 0, pending = 0, current = nil
+}
+
+Report = {}
+Report.__index = Report
+
+function Report:new(spec)
+  local report = {    
+    num_passed = spec.passed,
+    num_failed = spec.failed,
+    num_pending = spec.pending,
+    total = spec.passed + spec.failed + spec.pending,
+    results = {}
+  }
+  
+  report.percent = report.num_passed/report.total*100
+    
+  local contexts = spec.contexts
+  
+  for index = 1, #contexts do
+    report.results[index] = {
+      name = contexts[index],      
+      spec_results = contexts[contexts[index]]
+    }
+  end    
+  
+  return report    
+end
+
+function spec:report(verbose)
+  local report = Report:new(self)
+
+  if report.num_failed ~= 0 or verbose then
+    for i, result in pairs(report.results) do
+      print(("\n%s\n================================"):format(result.name))
+    
+      for description, r in pairs(result.spec_results) do
+        local outcome = r.passed and 'pass' or "FAILED"
+
+        if verbose or not (verbose and r.passed) then
+          print(("%-70s [ %s ]"):format(" - " .. description, outcome))
+
+          table.foreach(r.errors, function(index, error)
+            print("   " .. index ..". Failed expectation : " .. error.message .. "\n   "..error.trace)
+          end)
+        end
+      end
+    end
+  end
+
+  local summary = [[
+
+========== %s =============
+%s Failed
+%s Passed
+--------------------------------
+%s Run, %.2f%% Success rate
+]]
+
+  print(summary:format(report.num_failed == 0 and "Success" or "Failure", report.num_failed, report.num_passed, report.total, report.percent))
+end
+
+function spec:add_results(success, message, trace)
+  if self.current.passed then
+    self.current.passed = success
+  end
+
+  if success then
+    self.passed = self.passed + 1
+  else
+    table.insert(self.current.errors, { message = message, trace = trace })
+    self.failed = self.failed + 1
+  end
+end
+
+function spec:add_context(name)  
+  self.contexts[#self.contexts+1] = name
+  self.contexts[name] = {}  
+end
+
+function spec:add_spec(context_name, spec_name)
+  local context = self.contexts[context_name]
+  context[spec_name] = { passed = true, errors = {} }
+  self.current = context[spec_name]
+end
+
+function spec:add_pending_spec(context_name, spec_name, pending_description)
+end
+
+-- create tables to support pending specifications
+local pending = {}
+
+function pending.__newindex() error("You can't set properties on pending") end
+
+function pending.__index(_, key) 
+  if key == "description" then 
+    return nil 
+  else
+    error("You can't get properties on pending") 
+  end
+end
+
+function pending.__call(_, description)
+  local o = { description = description}
+  setmetatable(o, pending)
+  return o
+end  
+
+setmetatable(pending, pending)
+
+--
+
+-- define matchers
+
+matchers = {
+  should_be = function(value, expected)
+    if value ~= expected then
+      return false, "expecting "..tostring(expected)..", not ".. tostring(value)
+    end
+    return true
+  end;
+  
+  should_not_be = function(value, expected)
+    if value == expected then
+      return false, "should not be "..tostring(value)
+    end
+    return true
+  end;
+  
+  should_be_greater_than = function(value, expected)
+    if expected >= value then
+      return false, "got " .. tostring(value) .. " expecting value > " .. tostring(expected)
+    end
+    return true
+  end;
+
+  should_be_less_than = function(value, expected)
+    if expected <= value then
+      return false, "got " .. tostring(value) .. " expecting value < " .. tostring(expected)
+    end
+    return true
+  end;
+  
+  should_error = function(f)
+    if pcall(f) then
+      return false, "expecting an error but received none"
+    end
+    return true
+  end;
+
+  should_match = function(value, pattern) 
+    if type(value) ~= 'string' then
+      return false, "type error, should_match expecting target as string"
+    end
+
+    if not string.match(value, pattern) then
+      return false, value .. "doesn't match pattern ".. pattern
+    end
+    return true
+  end;
+  
+  should_be_kind_of = function(value, class)
+    if type(value) == "userdata" then
+
+      if not value:isKindOfClass(class) then
+        return false, tostring(value) .. " is not a " .. tostring(class)
+      end
+    elseif type(value) ~= class then
+      return false, type(value) .. " is not a " .. tostring(class)
+    end
+    
+    return true
+  end;
+  
+  should_exist = function(value)
+    if not value then
+      return false, tostring(value) .. " evaluates to false."
+    else
+      return true
+    end
+  end;
+  
+  should_not_exist = function(value)
+    if value then
+      return false, value .. " evaluates to true."
+    else
+      return true
+    end
+  end;
+}
+ 
+matchers.should_equal = matchers.should_be
+
+--
+
+-- expect returns an empty table with a 'method missing' metatable
+-- which looks up the matcher.  The 'method missing' function
+-- runs the matcher and records the result in the current spec
+local function expect(target)
+  return setmetatable({}, { 
+    __index = function(_, matcher)
+      return function(...)
+        local success, message = matchers[matcher](target, ...)
+        spec:add_results(success, message, debug.traceback())
+      end
+    end
+  })
+end
+
+
+--
+
+Context = {}
+Context.__index = Context
+
+function Context:new(context)
+  for i, child in ipairs(context.children) do
+    child.parent = context
+  end
+  return setmetatable(context, self)
+end
+
+function Context:run_befores(env)
+  if self.parent then
+    self.parent:run_befores(env)
+  end
+  if self.before then
+    setfenv(self.before, env)
+    self.before()
+  end
+end
+
+function Context:run_afters(env)
+  if self.after then
+    setfenv(self.after, env)
+    self.after()
+  end
+  if self.parent then
+    self.parent:run_afters(env)
+  end
+end
+
+function Context:run()
+  -- run all specs
+  for spec_name, spec_func in pairs(self.specs) do
+    if getmetatable(spec_func) == pending then
+    else
+      spec:add_spec(self.name, spec_name)
+  
+      local mocks = {}
+  
+      -- setup the environment that the spec is run in, each spec is run in a new environment
+      local env = {
+        track_error = function(f)
+          local status, err = pcall(f)
+          return err
+        end,
+    
+        expect = expect,
+    
+        mock = function(table, key, mock_value)      
+          mocks[{ table = table, key = key }] = table[key]  -- store the old value
+          table[key] = mock_value or Mock:new()
+          return table[key]
+        end
+      }
+      setmetatable(env, { __index = _G })
+
+      -- run each spec with proper befores and afters
+      self:run_befores(env)
+  
+      setfenv(spec_func, env)
+      local message
+      local traceback
+      local success = xpcall(spec_func, function(err)
+        message = err
+        traceback = debug.traceback("", 2)
+      end)
+
+      self:run_afters(env)
+    
+      if not success then
+        io.write("x")
+        spec:add_results(false, message, traceback)
+      else
+        io.write(".")
+      end  
+      io.flush()  
+    
+      -- restore stored values for mocks
+      for key, old_value in pairs(mocks) do
+        key.table[key.key] = old_value
+      end
+    end
+  end
+  
+  for i, child in pairs(self.children) do
+    child:run()
+  end
+end
+
+-- dsl for creating contexts
+
+local function make_it_table()
+  -- create and set metatables for 'it'
+  local specs = {}
+  local it = {}
+  setmetatable(it, {
+    -- this is called when it is assigned a function (e.g. it["spec name"] = function() ...)
+    __newindex = function(_, spec_name, spec_function)
+      specs[spec_name] = spec_function
+    end
+  })
+  
+  return it, specs
+end
+
+local make_describe_table
+
+-- create an environment to run a context function in as well as the tables to collect 
+-- the subcontexts and specs
+local function create_context_env()
+  local it, specs = make_it_table()
+  local describe, sub_contexts = make_describe_table()
+
+  -- create an environment to run the function in
+  local context_env = {
+    it = it,
+    describe = describe,
+    pending = pending
+  }
+  
+  return context_env, sub_contexts, specs
+end
+
+-- Note: this is declared locally earlier so it is still local
+function make_describe_table(auto_run)
+  local describe = {}
+  local contexts = {}
+  local describe_mt = {
+    
+    -- This function is called when a function is assigned to a describe table 
+    -- (e.g. describe["context name"] = function() ...)
+    __newindex = function(_, context_name, context_function)
+    
+      spec:add_context(context_name)
+
+      local context_env, sub_contexts, specs = create_context_env()
+      
+      -- set the environment
+      setfenv(context_function, context_env)
+      
+      -- run the context function which collects the data into context_env and sub_contexts
+      context_function()      
+      
+      -- store the describe function in contexts
+      contexts[#contexts+1] = Context:new { 
+        name = context_name,
+        before = context_env.before, 
+        after = context_env.after, 
+        specs = specs, 
+        children = sub_contexts 
+      }
+      
+      if auto_run then
+        contexts[#contexts]:run()
+      end
+    end
+  }
+  
+  setmetatable(describe, describe_mt)
+  
+  return describe, contexts
+end
+
+describe = make_describe_table(true)

data/lib/candle/generators/lua/wax/lib/stdlib/repl.lua

@@ -0,0 +1,9 @@
+local input
+
+repeat
+  io.write("wax> ")
+  input = io.read()
+  local success, e = wax.eval(input)
+
+  if not success then print("Error: " .. e) end
+until not input

data/lib/candle/generators/lua/wax/lib/stdlib/structs.lua

@@ -0,0 +1,11 @@
+wax.struct.create("CGSize", "ff", "width", "height")
+wax.struct.create("CGPoint", "ff", "x", "y")
+wax.struct.create("UIEdgeInsets", "ffff", "top", "left", "bottom", "right")
+wax.struct.create("CGRect", "ffff", "x", "y", "width", "height")
+
+wax.struct.create("NSRange", "II", "location", "length")
+
+wax.struct.create("CLLocationCoordinate2D", "dd", "latitude", "longitude")
+wax.struct.create("MKCoordinateSpan", "dd", "latitudeDelta", "longitudeDelta")
+wax.struct.create("MKCoordinateRegion", "dddd", "latitude", "longitude", "latitudeDelta", "longitudeDelta")
+wax.struct.create("CGAffineTransform", "ffffff", "a", "b", "c", "d", "tx", "ty")

data/lib/candle/generators/lua/wax/lib/stdlib/waxClass.lua

@@ -0,0 +1,42 @@
+function waxClass(options)
+  local class = waxInlineClass(options)
+  setfenv(2, class._M)
+  return class
+end
+
+-- So you can create a class without screwing with the function environment
+function waxInlineClass(options)
+  local className = options[1]
+  local superclassName = options[2]
+  local class = wax.class(className, superclassName)
+  class.className = className
+
+  if options.protocols then
+    if type(options.protocols) ~= "table" then options.protocols = {options.protocols} end
+    if #options.protocols == 0 then error("\nEmpty protocol table for class " .. className .. ".\n Make sure you are defining your protocols with a string and not a variable. \n ex. protocols = {\"UITableViewDelegate\"}\n\n") end
+  end
+
+  for i, protocol in ipairs(options.protocols or {}) do
+    wax.class.addProtocols(class, protocol)
+  end
+
+  class._M = setmetatable({
+      self = class,
+    },
+    {
+      __newindex = function(self, key, value)
+        class[key] = value
+      end,
+
+      __index = function(self, key)
+        return class[key] or _G[key]
+      end,
+
+    }
+  )
+
+  _G[className] = class
+  package.loaded[className] = class
+
+  return class
+end

data/lib/candle/generators/lua/wax/lib/wax.h

@@ -0,0 +1,16 @@
+//  Created by ProbablyInteractive.
+//  Copyright 2009 Probably Interactive. All rights reserved.
+
+#import <Foundation/Foundation.h>
+#import "lua.h"
+
+#define WAX_VERSION 0.93
+
+void wax_setup();
+void wax_start(char *initScript, lua_CFunction extensionFunctions, ...);
+void wax_startWithServer();
+void wax_end();
+
+lua_State *wax_currentLuaState();
+
+void luaopen_wax(lua_State *L);