gocart 0.0.1 → 0.0.2

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,86 @@
+# 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/vendor/jquery-1.6.4.min
+    - js/vendor/ICanHaz.min.js
+    - js/vendor/phonegap-1.1.0.js
+    - js/vendor/iscroll-min.js
+    - js/libs/mod_loader.js
+    - js/libs/deferred.js
+    - js/libs/3rdparty.js
+    - js/libs/logger.js
+    - js/helpers/**/*.js
+    - js/models/**/*.js
+    - js/adapters/**/*.js
+    - js/services/**/*.js
+    - js/controllers/**/*.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,136 @@
+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)
+				}
+			}
+		}
+
+		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
+		log.Println(fullAssetPath)
+
+		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/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
+}