gokart 0.0.1

data/assets/Gemfile

@@ -0,0 +1,24 @@
+source 'http://rubygems.org'
+
+gem 'rack'
+
+group :development do
+  gem 'sass'
+  gem 'coffee-script'
+  gem 'therubyracer'
+  gem 'sprockets'
+  gem 'guard'
+  gem 'guard-coffeescript'
+  gem 'guard-jasmine'
+  gem 'guard-sass'
+  gem 'guard-rake'
+  gem 'guard-livereload'
+  gem 'guard-shell'
+  gem 'jasmine'
+  gem 'yui-compressor'
+  gem 'uglifier'
+  
+  gem 'rb-inotify', :require => false
+  gem 'rb-fsevent', :require => false
+  gem 'rb-fchange', :require => false
+end

data/assets/Guardfile

@@ -0,0 +1,37 @@
+# More info at https://github.com/guard/guard#readme
+
+load File.dirname(__FILE__) + '/config.rb'
+
+guard 'coffeescript', :input => 'src/www/spec/coffee', :output => 'spec/javascripts', :hide_success => true
+
+guard 'shell' do
+  watch(%r{^src/server/.+\.go$}) do
+    `GOPATH="#{ROOT}" go install #{GO_APP_NAME} 1>&2`
+  end
+end
+
+guard 'rake', :task => 'app:www:compile' do
+  watch(%r{^src/www/app/coffee/.+$})
+  watch(%r{^src/www/app/sass/.+$})
+end
+
+guard 'rake', :task => 'app:www:compile_templates' do
+  watch(%r{^src/www/app/templates/.+$})
+end
+
+guard 'rake', :task => 'app:www:vendor' do
+  watch(%r{^src/www/vendor/.+$})
+end
+
+guard 'rake', :task => 'app:www:images' do
+  watch(%r{^src/www/app/images/.+$})
+end
+
+guard 'rake', :task => 'app:www:partials' do
+  watch(%r{^src/www/app/partials/.+$})
+end
+
+guard 'livereload', :apply_js_live => false do
+  watch(%r{bin/assets/www/javascripts/.+$})
+  watch(%r{spec/javascripts/.+$})
+end

data/assets/Rakefile

@@ -0,0 +1,5 @@
+require 'rake'
+
+load File.dirname(__FILE__) + '/config.rb'
+
+Dir["#{File.dirname(__FILE__)}/tasks/**/*.rake"].sort.each { |ext| load ext }

data/assets/config.rb

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'bundler'
+
+Bundler.require
+
+if !defined? ROOT
+  ROOT = Pathname(File.dirname(__FILE__))
+
+  ASSET_BUNDLES = %w( application.css application.js )
+  GO_APP_NAME =   'server'
+  GO_BUILD_PATH = ROOT.join('bin')
+
+  ASSETS_PATH =     ROOT.join('bin', 'assets')
+  TMPL_BUILD_PATH = ASSETS_PATH.join('templates')
+  MIN_WWW_PATH =    ASSETS_PATH.join('www-min')
+  DEBUG_WWW_PATH =  ASSETS_PATH.join('www-debug')
+
+  WWW_SPEC_PATH = ROOT.join('spec', 'javascripts')
+
+  WWW_SRC_ROOT_PATH =   ROOT.join('src', 'www')
+  WWW_SRC_APP_PATH =    WWW_SRC_ROOT_PATH.join('app')
+  WWW_SRC_VENDOR_PATH = WWW_SRC_ROOT_PATH.join('vendor')
+  WWW_SRC_SPEC_PATH =   WWW_SRC_ROOT_PATH.join('spec')
+end

data/assets/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,76 @@
+# src_files
+#
+# Return an array of filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# src_files:
+#   - lib/source1.js
+#   - lib/source2.js
+#   - dist/**/*.js
+#
+src_files:
+    - js/libs/mod_loader.js
+    - js/libs/deferred.js
+    - js/helpers/**/*.js
+
+# stylesheets
+#
+# Return an array of stylesheet filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# stylesheets:
+#   - css/style.css
+#   - stylesheets/*.css
+#
+stylesheets:
+
+# helpers
+#
+# Return an array of filepaths relative to spec_dir to include before jasmine specs.
+# Default: ["helpers/**/*.js"]
+#
+# EXAMPLE:
+#
+# helpers:
+#   - helpers/**/*.js
+#
+helpers:
+    - mocks.js
+
+# spec_files
+#
+# Return an array of filepaths relative to spec_dir to include.
+# Default: ["**/*[sS]pec.js"]
+#
+# EXAMPLE:
+#
+# spec_files:
+#   - **/*[sS]pec.js
+#
+spec_files:
+
+# src_dir
+#
+# Source directory path. Your src_files must be returned relative to this path. Will use root if left blank.
+# Default: project root
+#
+# EXAMPLE:
+#
+# src_dir: public
+#
+src_dir: bin/assets/www-debug
+
+# spec_dir
+#
+# Spec directory path. Your spec_files must be returned relative to this path.
+# Default: spec/javascripts
+#
+# EXAMPLE:
+#
+# spec_dir: spec/javascripts
+#
+spec_dir: spec/javascripts

data/assets/spec/javascripts/support/jasmine_config.rb

@@ -0,0 +1,23 @@
+module Jasmine
+  class Config
+
+    # Add your overrides or custom config code here
+
+  end
+end
+
+
+# Note - this is necessary for rspec2, which has removed the backtrace
+module Jasmine
+  class SpecBuilder
+    def declare_spec(parent, spec)
+      me = self
+      example_name = spec["name"]
+      @spec_ids << spec["id"]
+      backtrace = @example_locations[parent.description + " " + example_name]
+      parent.it example_name, {} do
+        me.report_spec(spec["id"])
+      end
+    end
+  end
+end

data/assets/spec/javascripts/support/jasmine_runner.rb

@@ -0,0 +1,32 @@
+$:.unshift(ENV['JASMINE_GEM_PATH']) if ENV['JASMINE_GEM_PATH'] # for gem testing purposes
+
+require 'rubygems'
+require 'jasmine'
+jasmine_config_overrides = File.expand_path(File.join(File.dirname(__FILE__), 'jasmine_config.rb'))
+require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
+if Jasmine::Dependencies.rspec2?
+  require 'rspec'
+else
+  require 'spec'
+end
+
+jasmine_config = Jasmine::Config.new
+spec_builder = Jasmine::SpecBuilder.new(jasmine_config)
+
+should_stop = false
+
+if Jasmine::Dependencies.rspec2?
+  RSpec.configuration.after(:suite) do
+    spec_builder.stop if should_stop
+  end
+else
+  Spec::Runner.configure do |config|
+    config.after(:suite) do
+      spec_builder.stop if should_stop
+    end
+  end
+end
+
+spec_builder.start
+should_stop = true
+spec_builder.declare_suites

data/assets/src/server/http_handler.go

@@ -0,0 +1,139 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+)
+
+// HTTP Error Enumerables
+type HttpError struct {
+	ErrorString string
+	CodeNum     int
+}
+
+func (h HttpError) Error() string                { return h.ErrorString }
+func (h HttpError) Code() int                    { return h.CodeNum }
+func (h HttpError) Report(w http.ResponseWriter) { http.Error(w, h.ErrorString, h.CodeNum) }
+
+var (
+	ErrHttpResourceNotFound = &HttpError{ErrorString: "Not found", CodeNum: 404}
+	ErrHttpMethodNotAllowed = &HttpError{ErrorString: "Method not allowed", CodeNum: 405}
+	ErrHttpBadRequeset      = &HttpError{ErrorString: "Bad request", CodeNum: 400}
+	ErrHttpInternalError    = &HttpError{ErrorString: "Internal failure", CodeNum: 500}
+)
+
+type HttpHandler struct {
+	RootURLPath    string
+	TmplPath       string
+	WwwPath        string
+	Addr           string
+	Port           uint
+	Debug          bool
+	ServStatic     bool
+	templates      *Templates
+	rootURLPathLen int
+	wwwURLPathLen  int
+}
+
+// Load all the temmplates into memeory
+func (h *HttpHandler) loadTemplates() {
+	h.templates = &Templates{}
+	h.templates.LoadTemplates(h.TmplPath)
+}
+
+// Configures the http connection and starts the listender
+func (h *HttpHandler) HandleHttpConnection() {
+	h.rootURLPathLen = len(h.RootURLPath + "/")
+	h.wwwURLPathLen = len(h.RootURLPath + "/assets/")
+
+	h.loadTemplates()
+
+	h.initServeHomeHndlr(h.RootURLPath + "/")
+	if h.Debug || h.ServStatic {
+		h.initServeStaticHndlr(h.RootURLPath + "/assets/")
+	}
+
+	// Build the address with port if it's provided
+	address := h.Addr
+	if h.Port != 0 {
+		address = fmt.Sprintf("%s:%d", h.Addr, h.Port)
+	}
+
+	err := http.ListenAndServe(address, nil)
+	if err != nil {
+		log.Fatal("ListenAndServe: ", err)
+	}
+}
+
+// Network event handler for HTTP trafic. Serves up the 
+// home.html file which will allow connection to the websocket
+func (h *HttpHandler) initServeHomeHndlr(path string) {
+	regProps := &CommonProps{
+		Title:   "Go + WWW + Rake test app",
+		Debug:   h.Debug,
+		RootURL: h.RootURLPath,
+		Host:    "",
+	}
+
+	hostPortRep := regexp.MustCompile(":\\d+$")
+
+	http.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != h.RootURLPath+"/" {
+			ErrHttpResourceNotFound.Report(w)
+			return
+		}
+		if r.Method != "GET" {
+			ErrHttpMethodNotAllowed.Report(w)
+			return
+		}
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+
+		// Normalalize http host
+		if len(regProps.Host) == 0 {
+			regProps.Host = r.Host
+			if (h.Debug || h.ServStatic) && h.Port != 0 {
+				if strings.Contains(r.Host, ":") {
+					regProps.Host = hostPortRep.ReplaceAllString(r.Host, fmt.Sprintf(":%d", h.Port))
+				} else {
+					regProps.Host = fmt.Sprintf("%s:%d", r.Host, h.Port)
+				}
+			}
+		}
+
+		if h.Debug { // Force reloading of the template for each request in debug mode
+			h.loadTemplates()
+		}
+
+		b, err := h.templates.Render("home", regProps, nil)
+		if err != nil {
+			log.Println("Failed to render template, home")
+			return
+		}
+
+		w.Write(b)
+	})
+}
+
+// Simple handler for serving static files
+func (h *HttpHandler) initServeStaticHndlr(path string) {
+	http.HandleFunc(path, func(w http.ResponseWriter, r *http.Request) {
+		asset := r.URL.Path[h.wwwURLPathLen:]
+		fullAssetPath := h.WwwPath + "/" + asset
+
+		file, err := os.Open(fullAssetPath)
+		if err != nil {
+			ErrHttpResourceNotFound.Report(w)
+			return
+		}
+		stat, err := file.Stat()
+		if err != nil {
+			ErrHttpInternalError.Report(w)
+			return
+		}
+		http.ServeContent(w, r, asset, stat.ModTime(), file)
+	})
+}

data/assets/src/server/main.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"flag"
+	"log"
+)
+
+var addr = flag.String("addr", "", "IP address the server is to run on")
+var port = flag.Uint("port", 0, "Port address to run the server on")
+var rootURLPath = flag.String("root", "", "URL Path root of the webapp")
+var tmplPath = flag.String("tmpl", "assets/templates", "Specifies the directory to use for template assets.")
+var wwwPath = flag.String("www", "assets/www-debug", "Specifies the directory to use for web assest.")
+var debug = flag.Bool("debug", false, "Enable debug mode where extra loging is produce, each request will reload templates, and all assets are served from non-concaticated files.")
+var static = flag.Bool("static", false, "Enables serving up static content from disk")
+
+func main() {
+	flag.Parse()
+
+	httpHndlr := &HttpHandler{
+		Addr:        *addr,
+		Port:        *port,
+		RootURLPath: *rootURLPath,
+		TmplPath:    *tmplPath,
+		WwwPath:     *wwwPath,
+		Debug:       *debug,
+		ServStatic:  *static,
+	}
+
+	httpHndlr.HandleHttpConnection()
+	log.Println("")
+}

data/assets/src/server/my_test.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"testing"
+)
+
+func Test_Add2Plus1(t *testing.T) {
+	if 2+1 != 3 {
+		t.Error("Adding 2+1 didn't work as expected")
+	} else {
+		t.Log("2+1 test passed.")
+	}
+}

data/assets/src/server/templates.go

@@ -0,0 +1,42 @@
+package main
+
+import (
+	"bytes"
+	"html/template"
+	"log"
+)
+
+type Templates struct {
+	tmpls *template.Template
+}
+
+// Object defining what all template data will use
+type TmplProps struct {
+	Common   *CommonProps
+	Contents interface{}
+}
+
+// Generic properties shared by all templates
+type CommonProps struct {
+	Title   string
+	Debug   bool
+	RootURL string
+	Host    string
+}
+
+// Loads the templates from disk and returns them loaded
+// into memory.
+func (t *Templates) LoadTemplates(path string) {
+	t.tmpls = template.Must(template.ParseGlob(path + "/*.gotmpl"))
+}
+
+// Renders a template and returns the byte array for it
+func (t *Templates) Render(tmplName string, common *CommonProps, contents interface{}) ([]byte, error) {
+	buf := bytes.NewBuffer(nil)
+	err := t.tmpls.ExecuteTemplate(buf, tmplName, &TmplProps{Common: common, Contents: contents})
+	if err != nil {
+		log.Println("Error: failed to execute template", tmplName, ", because", err)
+	}
+
+	return buf.Bytes(), err
+}

data/assets/src/www/app/coffee/application.js.coffee

@@ -0,0 +1,6 @@
+
+#= require libs/mod_loader
+#= require libs/deferred
+#= require libs/logger
+#= require helpers/properties
+#= require main

data/assets/src/www/app/coffee/helpers/properties.js.coffee

@@ -0,0 +1,19 @@
+modLoader.define 'helpers/properties', (require,exports)->
+
+  _buildProp = (cont, propStore, isStatic)->
+    return (value) ->
+      if value != undefined && !isStatic
+        cont[propStore] = value
+      else if value != undefined && isStatic
+        console.error('unable to set static property '+propStore+' to:',value)
+
+      return cont[propStore]
+
+  exports.add = (cont, props)->
+    for own prop,rules of props
+      propStore = '__auto__'+prop
+      cont[propStore] = if rules.value != undefined then rules.value else null
+      cont[prop] = _buildProp(cont, propStore, rules.static)
+    return
+
+  return

data/assets/src/www/app/coffee/libs/deferred.js.coffee

@@ -0,0 +1,92 @@
+modLoader.define 'libs/deferred', (require, exports)=>
+
+  context = @
+
+  class Promise
+    constructor: ->
+      @_dones = []
+      @_fails = []
+      @_pendingFinish = false
+      return
+
+    _doDone: (data)->
+      for done in @_dones
+        done.apply(context, data)
+      return
+
+    _doFail: (data)->
+      for fail in @_fails
+        fail.apply(context, data)
+      return
+
+    doFinish: (isResolved, data)->
+      @_pendingFinish = {isResolved: isResolved, data: data}
+
+      if isResolved then @_doDone(data) else @_doFail(data)
+      return
+
+    done: (doneCb)->
+      @_dones.push(doneCb)
+
+      _pending = @_pendingFinish
+      if _pending && _pending.isResolved
+        @doFinish(_pending.isResolved, _pending.data)
+
+      return @
+
+    fail: (failCb)->
+      @_fails.push(failCb)
+
+      _pending = @_pendingFinish
+      if _pending && !_pending.isResolved
+        @doFinish(_pending.isResolved, _pending.data)
+      return @
+
+    then: (doneCb, failCb)->
+      @_dones.push(doneCb) if doneCb?
+      @_fails.push(failCb) if failCb?
+
+      _pending = @_pendingFinish
+      if _pending
+        @doFinish(_pending.isResolved, _pending.data)
+      return @
+
+
+  class Deferred
+    constructor: ->
+      @_promise = null
+      @_pendingFinish = null
+      @_isFinished = false
+      return
+
+    _finish: (isResolved, data)->
+      if @_isFinished
+        return
+      @_isFinished = true
+
+      _promise = @_promise
+      if _promise?
+        _promise.doFinish(isResolved, data)
+      else
+        @_pendingFinish = {isResolved: isResolved, data: data}
+      return
+      
+    resolve: (data...)->
+      return @_finish(true, data)
+
+    reject: (data...)->
+      return @_finish(false, data)
+
+    promise: ->
+      promise = new Promise()
+      @_promise = promise
+      @_isFinished = false
+      _pending = @_pendingFinish
+      @_finish(_pending.isResolved, _pending.data) if _pending?
+      return promise
+
+
+  exports.create = ->
+    return new Deferred()
+
+  return

data/assets/src/www/app/coffee/libs/logger.js.coffee

@@ -0,0 +1,40 @@
+modLoader.define 'libs/logger', (require,exports)->
+
+  @appLoggerInstance = null
+
+  logger = ->
+    log = (args...)->
+      console.log(args)
+      return
+
+    warn = (args...)->
+      console.log(args)
+      return
+
+    debug = (args...)->
+      console.error(args)
+      return
+
+    error = (args...)->
+      console.error(args)
+      return
+
+    return {
+      log: log
+      warn: warn
+      debug: debug
+      error: error
+    }
+
+  _initLogger = =>
+    @appLoggerInstance = logger()
+    return
+
+  exports.getInstance = (name) =>
+    _initLogger() if !@appLoggerInstance
+    return @appLoggerInstance
+
+  exports.reset = =>
+    delete @appLoggerInstance
+
+  return

data/assets/src/www/app/coffee/libs/mod_loader.js.coffee

@@ -0,0 +1,44 @@
+# Builds a module loader tool which pulls in functions only once
+# and returns the exports for each time it is required after that
+
+@modLoader = (->
+  _modules = {}
+
+  require = (name)->
+    mod = _modules[name]
+
+    if !mod
+      console.error 'Failed to load module '+name+', as it does exist.'
+      return {}
+
+    exports = mod.exports
+    if !exports
+      exports = mod.exports = {}
+      mod.builder(require, exports)
+
+    return exports
+
+  define = (name, builder)->
+    _modules[name] =
+      builder: builder
+      exports: null
+    return
+
+  isDefined = (name)->
+    return _modules[name]?
+
+  isLoaded = (name)->
+    return _modules[name]? && _modules[name].exports
+
+  clearAll = ->
+    _modules = {}
+    return
+
+  return {
+    require:  require
+    define:   define
+    isDefined: isDefined
+    isLoaded: isLoaded
+    clearAll: clearAll
+  }
+)()

data/assets/src/www/app/coffee/main.js.coffee

@@ -0,0 +1,10 @@
+
+# Application main entry point
+
+Logger = modLoader.require 'libs/logger'
+  
+# This function runs once the page is loaded
+onDocLoaded = ->
+  return
+
+window.addEventListener("load",onDocLoaded,false)