spinebox 0.0.1

data/lib/spinebox/templates/app/assets/javascripts/lib/spine/spine.coffee

@@ -0,0 +1,537 @@
+Events =
+  bind: (ev, callback) ->
+    evs   = ev.split(' ')
+    calls = @hasOwnProperty('_callbacks') and @_callbacks or= {}
+
+    for name in evs
+      calls[name] or= []
+      calls[name].push(callback)
+    this
+
+  one: (ev, callback) ->
+    @bind ev, ->
+      @unbind(ev, arguments.callee)
+      callback.apply(@, arguments)
+
+  trigger: (args...) ->
+    ev = args.shift()
+
+    list = @hasOwnProperty('_callbacks') and @_callbacks?[ev]
+    return unless list
+
+    for callback in list
+      if callback.apply(@, args) is false
+        break
+    true
+
+  unbind: (ev, callback) ->
+    unless ev
+      @_callbacks = {}
+      return this
+
+    list = @_callbacks?[ev]
+    return this unless list
+
+    unless callback
+      delete @_callbacks[ev]
+      return this
+
+    for cb, i in list when cb is callback
+      list = list.slice()
+      list.splice(i, 1)
+      @_callbacks[ev] = list
+      break
+    this
+
+Log =
+  trace: true
+
+  logPrefix: '(App)'
+
+  log: (args...) ->
+    return unless @trace
+    if @logPrefix then args.unshift(@logPrefix)
+    console?.log?(args...)
+    this
+
+moduleKeywords = ['included', 'extended']
+
+class Module
+  @include: (obj) ->
+    throw('include(obj) requires obj') unless obj
+    for key, value of obj when key not in moduleKeywords
+      @::[key] = value
+    obj.included?.apply(@)
+    this
+
+  @extend: (obj) ->
+    throw('extend(obj) requires obj') unless obj
+    for key, value of obj when key not in moduleKeywords
+      @[key] = value
+    obj.extended?.apply(@)
+    this
+
+  @proxy: (func) ->
+    => func.apply(@, arguments)
+
+  proxy: (func) ->
+    => func.apply(@, arguments)
+
+  constructor: ->
+    @init?(arguments...)
+
+class Model extends Module
+  @extend Events
+
+  @records: {}
+  @crecords: {}
+  @attributes: []
+
+  @configure: (name, attributes...) ->
+    @className  = name
+    @records    = {}
+    @crecords   = {}
+    @attributes = attributes if attributes.length
+    @attributes and= makeArray(@attributes)
+    @attributes or=  []
+    @unbind()
+    this
+
+  @toString: -> "#{@className}(#{@attributes.join(", ")})"
+
+  @find: (id) ->
+    record = @records[id]
+    if !record and ("#{id}").match(/c-\d+/)
+      return @findCID(id)
+    throw('Unknown record') unless record
+    record.clone()
+
+  @findCID: (cid) ->
+    record = @crecords[cid]
+    throw('Unknown record') unless record
+    record.clone()
+
+  @exists: (id) ->
+    try
+      return @find(id)
+    catch e
+      return false
+
+  @refresh: (values, options = {}) ->
+    if options.clear
+      @records  = {}
+      @crecords = {}
+
+    records = @fromJSON(values)
+    records = [records] unless isArray(records)
+
+    for record in records
+      record.id           or= record.cid
+      @records[record.id]   = record
+      @crecords[record.cid] = record
+
+    @resetIdCounter()
+
+    @trigger('refresh', @cloneArray(records))
+    this
+
+  @select: (callback) ->
+    result = (record for id, record of @records when callback(record))
+    @cloneArray(result)
+
+  @findByAttribute: (name, value) ->
+    for id, record of @records
+      if record[name] is value
+        return record.clone()
+    null
+
+  @findAllByAttribute: (name, value) ->
+    @select (item) ->
+      item[name] is value
+
+  @each: (callback) ->
+    for key, value of @records
+      callback(value.clone())
+
+  @all: ->
+    @cloneArray(@recordsValues())
+
+  @first: ->
+    record = @recordsValues()[0]
+    record?.clone()
+
+  @last: ->
+    values = @recordsValues()
+    record = values[values.length - 1]
+    record?.clone()
+
+  @count: ->
+    @recordsValues().length
+
+  @deleteAll: ->
+    for key, value of @records
+      delete @records[key]
+
+  @destroyAll: ->
+    for key, value of @records
+      @records[key].destroy()
+
+  @update: (id, atts, options) ->
+    @find(id).updateAttributes(atts, options)
+
+  @create: (atts, options) ->
+    record = new @(atts)
+    record.save(options)
+
+  @destroy: (id, options) ->
+    @find(id).destroy(options)
+
+  @change: (callbackOrParams) ->
+    if typeof callbackOrParams is 'function'
+      @bind('change', callbackOrParams)
+    else
+      @trigger('change', callbackOrParams)
+
+  @fetch: (callbackOrParams) ->
+    if typeof callbackOrParams is 'function'
+      @bind('fetch', callbackOrParams)
+    else
+      @trigger('fetch', callbackOrParams)
+
+  @toJSON: ->
+    @recordsValues()
+
+  @fromJSON: (objects) ->
+    return unless objects
+    if typeof objects is 'string'
+      objects = JSON.parse(objects)
+    if isArray(objects)
+      (new @(value) for value in objects)
+    else
+      new @(objects)
+
+  @fromForm: ->
+    (new this).fromForm(arguments...)
+
+  # Private
+
+  @recordsValues: ->
+    result = []
+    for key, value of @records
+      result.push(value)
+    result
+
+  @cloneArray: (array) ->
+    (value.clone() for value in array)
+
+  @idCounter: 0
+
+  @resetIdCounter: ->
+    ids        = (model.id for model in @all()).sort((a, b) -> a > b)
+    lastID     = ids[ids.length - 1]
+    lastID     = lastID?.replace?(/^c-/, '') or lastID
+    lastID     = parseInt(lastID, 10)
+    @idCounter = (lastID + 1) or 0
+
+  @uid: (prefix = '') ->
+    prefix + @idCounter++
+
+  # Instance
+
+  constructor: (atts) ->
+    super
+    @load atts if atts
+    @cid or= @constructor.uid('c-')
+
+  isNew: ->
+    not @exists()
+
+  isValid: ->
+    not @validate()
+
+  validate: ->
+
+  load: (atts) ->
+    for key, value of atts
+      if typeof @[key] is 'function'
+        @[key](value)
+      else
+        @[key] = value
+    this
+
+  attributes: ->
+    result = {}
+    for key in @constructor.attributes when key of this
+      if typeof @[key] is 'function'
+        result[key] = @[key]()
+      else
+        result[key] = @[key]
+    result.id = @id if @id
+    result
+
+  eql: (rec) ->
+    !!(rec and rec.constructor is @constructor and
+        (rec.cid is @cid) or (rec.id and rec.id is @id))
+
+  save: (options = {}) ->
+    unless options.validate is false
+      error = @validate()
+      if error
+        @trigger('error', error)
+        return false
+
+    @trigger('beforeSave', options)
+    record = if @isNew() then @create(options) else @update(options)
+    @trigger('save', options)
+    record
+
+  updateAttribute: (name, value, options) ->
+    @[name] = value
+    @save(options)
+
+  updateAttributes: (atts, options) ->
+    @load(atts)
+    @save(options)
+
+  changeID: (id) ->
+    records = @constructor.records
+    records[id] = records[@id]
+    delete records[@id]
+    @id = id
+    @save()
+
+  destroy: (options = {}) ->
+    @trigger('beforeDestroy', options)
+    delete @constructor.records[@id]
+    delete @constructor.crecords[@cid]
+    @destroyed = true
+    @trigger('destroy', options)
+    @trigger('change', 'destroy', options)
+    @unbind()
+    this
+
+  dup: (newRecord) ->
+    result = new @constructor(@attributes())
+    if newRecord is false
+      result.cid = @cid
+    else
+      delete result.id
+    result
+
+  clone: ->
+    createObject(@)
+
+  reload: ->
+    return this if @isNew()
+    original = @constructor.find(@id)
+    @load(original.attributes())
+    original
+
+  toJSON: ->
+    @attributes()
+
+  toString: ->
+    "<#{@constructor.className} (#{JSON.stringify(@)})>"
+
+  fromForm: (form) ->
+    result = {}
+    for key in $(form).serializeArray()
+      result[key.name] = key.value
+    @load(result)
+
+  exists: ->
+    @id && @id of @constructor.records
+
+  # Private
+
+  update: (options) ->
+    @trigger('beforeUpdate', options)
+    records = @constructor.records
+    records[@id].load @attributes()
+    clone = records[@id].clone()
+    clone.trigger('update', options)
+    clone.trigger('change', 'update', options)
+    clone
+
+  create: (options) ->
+    @trigger('beforeCreate', options)
+    @id          = @cid unless @id
+
+    record       = @dup(false)
+    @constructor.records[@id]   = record
+    @constructor.crecords[@cid] = record
+
+    clone        = record.clone()
+    clone.trigger('create', options)
+    clone.trigger('change', 'create', options)
+    clone
+
+  bind: (events, callback) ->
+    @constructor.bind events, binder = (record) =>
+      if record && @eql(record)
+        callback.apply(@, arguments)
+    @constructor.bind 'unbind', unbinder = (record) =>
+      if record && @eql(record)
+        @constructor.unbind(events, binder)
+        @constructor.unbind('unbind', unbinder)
+    binder
+
+  one: (events, callback) ->
+    binder = @bind events, =>
+      @constructor.unbind(events, binder)
+      callback.apply(@, arguments)
+
+  trigger: (args...) ->
+    args.splice(1, 0, @)
+    @constructor.trigger(args...)
+
+  unbind: ->
+    @trigger('unbind')
+
+class Controller extends Module
+  @include Events
+  @include Log
+
+  eventSplitter: /^(\S+)\s*(.*)$/
+  tag: 'div'
+
+  constructor: (options) ->
+    @options = options
+
+    for key, value of @options
+      @[key] = value
+
+    @el = document.createElement(@tag) unless @el
+    @el = $(@el)
+
+    @el.addClass(@className) if @className
+    @el.attr(@attributes) if @attributes
+
+    @events = @constructor.events unless @events
+    @elements = @constructor.elements unless @elements
+
+    @delegateEvents(@events) if @events
+    @refreshElements() if @elements
+
+    super
+
+  release: =>
+    @el.remove()
+    @unbind()
+    @trigger 'release'
+
+  $: (selector) -> $(selector, @el)
+
+  delegateEvents: (events) ->
+    for key, method of events
+
+      unless typeof(method) is 'function'
+        # Always return true from event handlers
+        method = do (method) => =>
+          @[method].apply(this, arguments)
+          true
+
+      match      = key.match(@eventSplitter)
+      eventName  = match[1]
+      selector   = match[2]
+
+      if selector is ''
+        @el.bind(eventName, method)
+      else
+        @el.delegate(selector, eventName, method)
+
+  refreshElements: ->
+    for key, value of @elements
+      @[value] = @$(key)
+
+  delay: (func, timeout) ->
+    setTimeout(@proxy(func), timeout || 0)
+
+  html: (element) ->
+    @el.html(element.el or element)
+    @refreshElements()
+    @el
+
+  append: (elements...) ->
+    elements = (e.el or e for e in elements)
+    @el.append(elements...)
+    @refreshElements()
+    @el
+
+  appendTo: (element) ->
+    @el.appendTo(element.el or element)
+    @refreshElements()
+    @el
+
+  prepend: (elements...) ->
+    elements = (e.el or e for e in elements)
+    @el.prepend(elements...)
+    @refreshElements()
+    @el
+
+  replace: (element) ->
+    [previous, @el] = [@el, $(element.el or element)]
+    previous.replaceWith(@el)
+    @delegateEvents(@events)
+    @refreshElements()
+    @el
+
+# Utilities & Shims
+
+$ = window?.jQuery or window?.Zepto or (element) -> element
+
+createObject = Object.create or (o) ->
+  Func = ->
+  Func.prototype = o
+  new Func()
+
+isArray = (value) ->
+  Object::toString.call(value) is '[object Array]'
+
+isBlank = (value) ->
+  return true unless value
+  return false for key of value
+  true
+
+makeArray = (args) ->
+  Array::slice.call(args, 0)
+
+# Globals
+
+Spine = @Spine   = {}
+module?.exports  = Spine
+
+Spine.version    = '1.0.6'
+Spine.isArray    = isArray
+Spine.isBlank    = isBlank
+Spine.$          = $
+Spine.Events     = Events
+Spine.Log        = Log
+Spine.Module     = Module
+Spine.Controller = Controller
+Spine.Model      = Model
+
+# Global events
+
+Module.extend.call(Spine, Events)
+
+# JavaScript compatability
+
+Module.create = Module.sub =
+  Controller.create = Controller.sub =
+    Model.sub = (instances, statics) ->
+      class result extends this
+      result.include(instances) if instances
+      result.extend(statics) if statics
+      result.unbind?()
+      result
+
+Model.setup = (name, attributes = []) ->
+  class Instance extends this
+  Instance.configure(name, attributes...)
+  Instance
+
+Module.init = Controller.init = Model.init = (a1, a2, a3, a4, a5) ->
+  new this(a1, a2, a3, a4, a5)
+
+Spine.Class = Module

data/lib/spinebox/templates/app/assets/stylesheets/application.css.scss

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+*/

data/lib/spinebox/templates/config/config.rb

@@ -0,0 +1,7 @@
+Spinebox.config do |config|
+  
+  # Setup Sprockets paths
+  config.assets.append_path 'app/assets/javascripts'
+  config.assets.append_path 'app/assets/stylesheets'
+  
+end

data/lib/spinebox/templates/config/routes.rb

@@ -0,0 +1,13 @@
+Spinebox::Routes.draw do
+  
+  # Assets
+  map '/assets' do
+    run Spinebox.assets
+  end
+  
+  # Root
+  map '/' do
+    run Rack::File.new "public/index.html"
+  end
+  
+end

data/lib/spinebox/templates/config.ru

@@ -0,0 +1,3 @@
+require 'spinebox'
+
+run Spinebox.app

data/lib/spinebox/templates/public/index.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Spinebox</title>
+  <link href="/assets/application.css" media="all" rel="stylesheet" type="text/css">
+  <script src="/assets/application.js" type="text/javascript"></script>
+</head>
+<body>
+
+<h1>Spinebox</h1>
+<p>Is working!</p>
+
+</body>
+</html>

data/lib/spinebox/version.rb

@@ -0,0 +1,3 @@
+module Spinebox
+  VERSION = "0.0.1"
+end

data/lib/spinebox.rb

@@ -0,0 +1,19 @@
+require "sprockets"
+require "rack"
+require 'coffee_script'
+require 'eco'
+require 'sass'
+require "ostruct"
+
+require "spinebox/version"
+require "spinebox/base"
+require "spinebox/command"
+require "spinebox/config"
+require "spinebox/routes"
+require "spinebox/generator"
+
+module Spinebox
+  class << self
+    include Spinebox::Base
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,9 @@
+require_relative "./helpers"
+
+describe Spinebox::Base do
+  
+  it "should return the root url of the gem" do
+    File.exists?("#{Spinebox.root}/version.rb").should be_true
+  end
+  
+end

data/spec/command_spec.rb

@@ -0,0 +1,23 @@
+require_relative "./helpers"
+
+describe Spinebox::Command do
+
+  it "should store commands" do
+    Spinebox::Command.dispatch do
+      on "--test, -t", "A test case", :if => proc { true } do
+        
+      end
+      
+      on "--test2, -t2", "A test case 2", :if => proc { true } do
+        
+      end
+    end
+    
+    Spinebox::Command.commands.should have(2).command
+  end
+  
+  it "should execute commands" do
+    Spinebox::Command.execute
+  end
+  
+end

data/spec/config_spec.rb

@@ -0,0 +1,29 @@
+require_relative "./helpers"
+
+describe Spinebox do
+  
+  it "should offer a block style config method" do
+    Spinebox.config do |config|
+      config.should be_a OpenStruct
+      config.assets.should be_a Sprockets::Environment
+    end
+  end
+  
+  it "should offer a normal configuration" do
+    Spinebox.config.should be_a OpenStruct
+    Spinebox.config.assets.should be_a Sprockets::Environment
+  end
+  
+  it "should offer straight access to the assets" do
+    Spinebox.assets.should be_a Sprockets::Environment
+  end
+  
+  it "should load the config from the default path" do
+    Dir.chdir "#{Spinebox.root}/templates"
+    
+    Spinebox.config.assets.paths.should have(0).paths
+    Spinebox.load_config!
+    Spinebox.config.assets.paths.should have_at_least(2).paths
+  end
+  
+end

data/spec/generator_spec.rb

@@ -0,0 +1,25 @@
+require_relative "./helpers"
+
+describe Spinebox::Generator do
+  
+  before(:each) do
+    Dir.chdir(File.dirname(__FILE__))
+    FileUtils.rm_rf("tmp")
+    FileUtils.mkdir("tmp")
+    Dir.chdir "tmp"
+  end
+  
+  after(:each) do
+    Dir.chdir ".."
+    FileUtils.rm_rf("tmp")
+  end
+  
+  it "should generate app with name" do
+    File.directory?("box").should_not be_true
+    
+    generator = Spinebox::Generator.new "box"
+    File.directory?(generator.root).should be_true
+    Dir["#{generator.root}/**/*"].should have_at_least(5).files
+  end
+  
+end