alpha-simprini-engine 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2011 YOURNAME
+
+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.

data/README.rdoc

@@ -0,0 +1,3 @@
+= AlphaSimpriniEngine
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,38 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'AlphaSimpriniEngine'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task :default => :test

data/app/assets/javascripts/alpha_simprini.coffee

@@ -0,0 +1,15 @@
+#= require bundle
+#= require ./lib/string
+#= require ./lib/module
+#= require ./alpha_simprini/mixin
+#= require ./alpha_simprini/delegate
+#= require ./alpha_simprini/event
+#= require ./alpha_simprini/event
+#= require ./alpha_simprini/html
+#= require ./alpha_simprini/view
+#= require_tree ./alpha_simprini/coffee_kup
+#= require ./alpha_simprini/views/panel
+#= require_tree ./alpha_simprini/views
+#= require_tree ./alpha_simprini
+
+

data/app/assets/javascripts/alpha_simprini/application.coffee

@@ -0,0 +1,22 @@
+module "AS", ->
+  class @Application
+    AS.Event.extends(this)
+
+    constructor: (args) ->
+      @template_source = @template_source()
+      for name, template of @template_source
+        @template_source[name] = CoffeeKup.compile(template, locals:yes, hardcode:AS.TemplateHelpers)
+      
+      $ => @initialize?()
+
+    template_source: -> @Templates
+
+    view: (constructor, options={}) ->
+      options.application = this
+      new constructor options
+
+    render: (template_name, locals={}) ->
+      data = {context: this, locals:locals}
+      @template_source[template_name](data)
+    
+    

data/app/assets/javascripts/alpha_simprini/coffee_kup/binding.coffee

@@ -0,0 +1,119 @@
+module "AS.CK", ->
+  @Binding =
+    binding: (model, property, getter) ->
+      id = AS.CK.Helpers.autoId()
+      model.bind "destroy", -> id.query().remove()
+      if getter
+        model.bind "change:#{property}", -> id.query().text getter.call(this, model.get(property)) || ""
+        span id: id.string, -> getter.call(this, model.get(property))      
+      else
+        model.bind "change:#{property}", -> id.query().text model.get(property) || ""
+        span id: id.string, -> model.get(property)
+
+    bound_input: (model, property, options={}) ->
+      id = AS.CK.Helpers.autoId()
+      model.bind "change:#{property}", -> id.query().val model.get(property)
+      id.query().live 'change', ->
+        data = {}
+        data[property] = id.query().val()
+        model.set data
+      id.query().live 'keyup', -> 
+        data = {}
+        data[property] = id.query().val()
+        model.set data
+      input _.extend(options, id: id.string, value: model.get property)
+    
+    bind_collection: (container_tag, collection, templateName) ->
+      # DONT FORGET TO COMBINE LOCALS AS NEEDED
+      
+      id = AS.CK.Helpers.autoId()
+      
+      # Unbind before you rebind, or you'll be very :(
+      # As you will have a lot of templates being added EVERYWHERE
+      
+      collection.unbind "add.#{templateName}-bind_collection"
+      collection.bind "add.#{templateName}-bind_collection", (item) =>
+        not_wanted = id.query().find("[data-cid=#{item.cid}]")
+        if not_wanted[0]
+          debugger
+          console.error "Why u add", item, "to", collection, "again?"
+          return
+        if _.isFunction(templateName)
+          console.error "ADDING w/o named template unimplemented sucka"
+        else
+          content = @context.render(templateName, _.extend(data.locals, item:item))
+          index = collection.indexOf(item)
+          container = id.query()
+          siblings = container.children()
+          if siblings.get(0) is undefined or siblings.get(index) is undefined
+            container.append(content)
+          else
+            $(siblings.get(index)).before(content)
+
+      collection.unbind "remove.#{templateName}-bind_collection"  
+      collection.bind "remove.#{templateName}-bind_collection", (item) ->
+        console.log "remove", item, "from", collection
+        not_wanted = id.query().find("[data-cid=#{item.cid}]")
+        if not_wanted[0] is undefined
+          console.error "Could not find element to remove."
+        not_wanted.remove()
+      
+      if container_tag.constructor is String
+        container_tag = [container_tag, id:id.string]
+      else
+        container_tag[1] ?= {}
+        container_tag[1].id = id.string
+      
+      if _.isFunction(templateName)
+        container_tag.push -> 
+          for item in collection.models
+            templateName(item)
+      else      
+        container_tag.push ->
+          for item in collection.models
+            # Combine locals
+            text @context.render(templateName, _.extend(data.locals, item:item))
+      
+      tag.apply this, container_tag
+    
+    bound_select: (model, property, options, option_value_key, config={}) ->
+      id = AS.CK.Helpers.autoId()
+      model.bind "change:#{property}", ->
+        id.query().val model.get(property).cid
+        
+      id.query().live "change", ->
+        data = {}
+        data[property] = options.getByCid(id.query().val())
+        model.set data
+      
+      options.bind "change:#{option_value_key}", (_option) ->
+        id.query().find("[value=#{_option.cid}]").text _option.get(option_value_key)
+        
+      options.bind "add", (_option) =>
+        console.error "FIXME: add option at correct position"
+        
+        # THIS HERE IS A LITTLE :(
+        template = ->
+          bound_select_option(_option, option_value_key)
+          
+        compiled = CoffeeKup.compile template, locals: yes, hardcode: AS.TemplateHelpers
+        @locals ?={}
+        @locals.option_value_key = option_value_key
+        @locals._option = _option
+        # YES IT IS, BUT IT ALSO WORKS :)
+        
+        id.query().append compiled this
+      
+      options.bind "remove", (_option) ->
+        id.query().find("[value=#{_option.cid}]").remove()
+        id.query().change()
+        
+      selection = model.get(property)
+      select id: id.string, ->
+        (option -> config.blank) if config.blank
+        bound_select_option(_option, option_value_key, _option == selection) for _option in options.models
+
+    bound_select_option: (model, property, selected) ->
+      id = AS.CK.Helpers.autoId()
+      model.bind "change:#{property}", -> id.query().text model.get(property)
+      option id: id.string, value: model.cid, selected: selected, -> model.get(property)

data/app/assets/javascripts/alpha_simprini/coffee_kup/helpers.coffee

@@ -0,0 +1,17 @@
+module "AS.CK", ->
+  @Helpers =
+    shy: (string="") ->
+      string.replace(/([a-z])([A-Z])/g, (a, b, c) -> b + "­" + c)
+    
+    incr: 0
+    
+    autoId: ->
+      id = "CoffeeKup-#{@incr++}"
+      query_function = -> @node = jQuery "##{id}"
+      return string: id, query: _.bind(query_function, {})
+    
+    _cycles: {}
+    
+
+    
+      

data/app/assets/javascripts/alpha_simprini/coffee_kup/tags.coffee

@@ -0,0 +1,7 @@
+module "AS.CK", ->
+  @Tags =
+    model_tag: (model, options={}, fn) ->
+      [options, fn] = [{}, options] if options.constructor is Function
+      tagname = options.tagname or "div"
+      delete options.tagname
+      tag tagname, _.extend(options, id: model.cid), fn

data/app/assets/javascripts/alpha_simprini/collection.coffee

@@ -0,0 +1,62 @@
+class module("AS").Collection
+  AS.Delegate.extends(this)
+  AS.Event.extends(this)
+  
+  @delegate "first", "rest", "last", "compact", "flatten", "without", "union", 
+            "intersection", "difference", "uniq", "zip", "indexOf", "find", "detect", "at",
+            "lastIndexOf", "range", "include",  "each", "map", "reject","all", "toArray", to: "models"
+  
+  @model: -> AS.Model
+
+  constructor: (@models=[]) ->
+    @initialize()
+
+  initialize: () ->
+    given_models = @models
+    @length = 0
+    @byId = {}
+    @byCid = {}
+    @models = _([]).chain()
+    @add(model) for model in given_models
+  
+  add: (model={}, options={}) ->
+    throw new Error("Cannot add model to collection twice.") if @models.include(model).value()
+    
+    unless model instanceof AS.Model
+      model = @build(model)
+    
+    @_add(model, options)
+    
+    model
+  
+  _add: (model, options={}) ->
+    options.at ?= this.length
+    index = options.at
+    @byCid[model.cid] = @byId[model.id] = model
+    @models.splice index, 0, model
+    @length++
+    model.bind("all", @_on_model_event, this)
+    model.trigger "add", this, options
+  
+  remove: (model, options) -> @_remove(model, options)
+    
+  _remove: (model, options) ->
+    @length--
+    delete @byId[model.id]
+    delete @byCid[model.cid]
+    @models = @models.chain().without(model)
+    model.trigger("remove", this, options)
+    model.unbind("all", @_on_model_event)
+  
+  build: (model) ->
+    if model._type
+      ctor = module(model._type)
+    else
+      ctor = @constructor.model()
+    new ctor(model)
+  
+  # When an event is triggered from a model, it is bubbled up through the collection.
+  _on_model_event: (event, model, collection, options) ->
+    return if (event is "add" or event is "remove") and (this isnt collection)
+    @_remove(model, options) if event is "destroy"
+    @trigger.apply(this, arguments)

data/app/assets/javascripts/alpha_simprini/delegate.coffee

@@ -0,0 +1,21 @@
+module("AS").Delegate = new AS.Mixin
+  class_methods:
+    delegate: (delegated_methods..., options) ->
+      delegatee = options.to
+      callOrReturn = (object, fn_or_object, args) ->
+        if _.isFunction(fn_or_object)
+          fn_or_object.apply(object, args)
+        else
+          object
+          
+      _(delegated_methods).chain().flatten().each (method) =>
+        if _.isString(delegatee)
+          @::[method] = -> 
+            _delegatee = @[delegatee]
+            callOrReturn _delegatee, _delegatee[method], arguments
+        else if _.isFunction(delegatee)
+          @::[method] = -> 
+            _delegatee = delegatee()
+            callOrReturn _delegatee, _delegatee[method], arguments
+        else
+          @::[method] = -> callOrReturn delegatee, delegatee[method], arguments

data/app/assets/javascripts/alpha_simprini/event.coffee

@@ -0,0 +1,75 @@
+@module "AS", ->
+  @Event = new AS.Mixin
+    instance_methods: 
+      _eventNamespacer: /\.([\w-_]+)$/
+      bind: (ev, callback, context) ->
+        if match = ev.match @_eventNamespacer
+          [ev, namespace] = ev.split(".")
+        namespace ?= 'none'
+    
+        calls = @_callbacks ?= {}
+        list = calls[ev] ?= { none: [] }
+    
+        list[namespace] ?= []
+        list[namespace].push [callback, context]
+        this
+    
+      unbind: (ev, callback) ->
+        if !ev
+          delete @_callbacks
+        else if calls = @_callbacks
+          if !callback
+            if ev[0] is "."
+              namespace = ev.slice(1)
+              for event, namespaces of calls
+                namespaces[namespace] = []
+            else
+              return this unless calls[ev.split(".")[0]]
+              if match = ev.match @_eventNamespacer
+                [ev, namespace] = ev.split(".")
+                calls[ev][namespace] = []
+              else
+                calls[ev] = { none: [] }
+          else
+            for key, handlers of calls[ev]
+              calls[ev][key] = _(handlers).reject (handler) -> handler[0] is callback
+              # for handler, index in handlers
+              #   delete handlers[index] if handler[0] is callback
+              #   break
+              # # Delete leaves around [undefined] nonsense
+              # cals[ev][key] = _.compact(handlers)
+            
+        this
+
+      trigger: (eventName) ->
+        return this unless calls = @_callbacks
+        if eventName.match @_eventNamespacer
+          [eventName, namespace] = eventName.split(".")
+        both = 2
+        while both--
+          ev = if both
+            eventName
+          else
+            'all'
+          if list = calls[ev]
+            if namespace and ev isnt 'all'
+              if list[namespace]
+                for handler in list[namespace]
+                  args = if both
+                    Array::slice.call(arguments, 1)
+                  else
+                    arguments
+                  handler[0].apply(handler[1] || this, args)            
+            else
+              for key, handlers of list
+                for handler in handlers
+                  args = if both
+                    Array::slice.call(arguments, 1)
+                  else
+                    arguments
+                  handler[0].apply(handler[1] || this, args)
+        this
+
+# _.extend(Backbone.Model::, EventExtensions)
+# _.extend(Backbone.Collection::, EventExtensions)
+# _.extend(Backbone.View::, EventExtensions)

data/app/assets/javascripts/alpha_simprini/html.coffee

@@ -0,0 +1,56 @@
+class module("AS").HTML
+  @elements: _('a abbr address article aside audio b bdi bdo blockquote body button
+    canvas caption cite code colgroup datalist dd del details dfn div dl dt em
+    fieldset figcaption figure footer form h1 h2 h3 h4 h5 h6 head header hgroup
+    html i iframe ins kbd label legend li map mark menu meter nav noscript object
+    ol optgroup option output p pre progress q rp rt ruby s samp script section
+    select small span strong style sub summary sup table tbody td textarea tfoot
+    th thead time title tr u ul video area base br col command embed hr img input keygen link meta param
+    source track wbr'.split(" ")).chain().compact()
+  
+  constructor: (args) ->
+    # body...
+
+  text: (text_content) ->
+    @span text_content
+  
+  raw: (html) ->
+    $(@span()).html(html)
+  
+  tag: (name, attrs, content) ->
+    @current_node ?= document.createDocumentFragment()
+
+    if _.isFunction(attrs)
+      content = attrs
+      attrs = undefined
+    if _.isString(attrs)
+      text_content = attrs
+      attrs = undefined
+    
+    # TODO: use jQuery for better compatibility / less performance
+    node = document.createElement(name)
+    node.setAttribute(key, value) for key, value of attrs unless attrs is undefined
+    @current_node.appendChild node
+    
+    if text_content
+      $(node).text text_content
+    else if content
+      @within_node node, ->
+        last = content.call(this)
+        if _.isString(last)
+          @text(last)
+
+    node
+  
+  within_node: (node, fn) ->
+    node = node[0] if node?.jquery
+    prior_node = @current_node
+    @current_node = node
+    content = fn.call(this)
+    @current_node = prior_node
+    content
+  
+  dangling_content: (fn) -> @within_node(null, fn)
+  
+AS.HTML.elements.each (element) ->
+  AS.HTML::[element] = -> @tag.apply this, _(arguments).unshift(element)