luca 0.9.76 → 0.9.89

data/lib/luca/rails/version.rb

@@ -1,6 +1,5 @@
 module Luca
   module Rails
-    VERSION = "0.9.76"
+    VERSION = '0.9.89' 
   end
 end
-

data/lib/luca/stylesheet.rb

@@ -0,0 +1,36 @@
+module Luca
+  class Stylesheet
+    attr_accessor :path, :source, :compiler
+
+    def initialize(path)
+      @source = @path = path
+      @compiler = AssetCompiler.new(file: path, type: type)
+    end
+
+    def to_change_notification
+      as_json
+    end
+
+    # TODO: Add support for less, sass, etc
+    def type
+      "scss"
+    end
+
+    def compiled
+      @compiler.compiled rescue ""
+    end
+
+    def as_json options={}
+      {
+        defined_in_file:  source, 
+        type:             "stylesheet", 
+        compiled:         compiled,
+        source_file_contents:  IO.read(source),
+        name:             File.basename(source),
+        # temp
+        path:             source.gsub(::Rails.root.to_s, '.'),
+        id:               source.gsub(::Rails.root.to_s, '.').gsub('/','__')
+      }
+    end
+  end  
+end

data/lib/luca/template.rb

@@ -1,3 +1,5 @@
+# DEPRECATED
+
 require 'tilt'
 
 module Luca

data/lib/luca/template_asset.rb

@@ -0,0 +1,64 @@
+module Luca
+  class TemplateAsset
+    attr_accessor :path, :compiler, :contents
+
+    def initialize(path)  
+      @path = path
+      @contents = IO.read(path)
+      @compiler = AssetCompiler.new(input:contents, type: type, file: path)
+    end
+
+    def to_change_notification
+      as_json
+    end
+
+    def as_json options={}
+      id = "#{ template_prefix }/#{ template_name }".gsub('/','__')
+
+      {
+        type:             type, 
+        contents:         compiled,
+        name:             template_name,
+        id:               id, 
+        template_prefix:  template_prefix,
+        defined_in_file:  source,
+        source_file_contents:  IO.read(source)
+      }
+    end
+
+    def to_json
+      as_json.to_json
+    end
+
+    def type
+      "template"
+    end
+
+    def source
+      path
+    end
+
+    def template_prefix
+      path.gsub(/^.*app\/assets\/javascripts\//,'').split('.').first
+    end
+
+    def template_name
+      File.basename(path).split('.').first
+    end
+
+    def type
+      return 'mustache' if path.match(/.mustache/)
+      'template'
+    end
+
+    def compiled
+      begin
+        output = @compiler.compiled
+        needle = @compiler.filename.gsub(/\..*$/,'')
+        output.gsub(needle, "#{ template_prefix }")
+      rescue
+        ""
+      end
+    end
+  end
+end  

data/lib/railties/luca/tasks.rake

@@ -0,0 +1,38 @@
+namespace :luca do
+  desc "Create a Luca::Project for this app"
+  task :project => :environment do |t, args|
+    current_folder = Rails.root
+    name = ENV['name'] 
+    Luca::Project.find_or_create_by_name(name, :path => current_folder.to_s )
+  end
+
+  desc "Download the vendor dependencies for a luca app"
+  task :dependencies do
+    base = 'https://raw.github.com/datapimp/luca/master/assets/javascripts/dependencies/'
+
+    scripts = [
+      'underscore-min.js',
+      'underscore-string.min.js',
+      'bootstrap.min.js',
+      'backbone-min.js',
+      'backbone-query.min.js'
+    ]
+
+    scripts.each do |script|
+      puts "Downloading #{ script } from #{ base + script }"
+      `wget -q #{ base + script } > #{ Rails.root }/vendor/assets/javascripts/#{ script }` 
+    end
+
+    style_base =  "https://raw.github.com/datapimp/luca/master/assets/stylesheets/"
+
+    stylesheets = [
+      'bootstrap.min.css',
+      'bootstrap-responsive.min.css'
+    ]
+
+    stylesheets.each do |stylesheet|
+      puts "Downloading #{ stylesheet } from #{ style_base + stylesheet }"
+      `wget -q #{ style_base + stylesheet } > #{ Rails.root }/vendor/assets/dependencies/#{ stylesheet }` 
+    end  
+  end
+end

data/spec/{components → javascripts/components}/controller_spec.coffee

@@ -50,6 +50,10 @@ describe 'The Controller Component', ->
     @controller.navigate_to("two")
     expect( @controller.activePage() ).toEqual 'two'
 
+  it "should track controller activation events", ->
+    two = @controller.navigate_to("two")
+    expect( two.activatedByController ).toBeTruthy()
+
   it "should define a controllerPath method on each page", ->
     expect( @controller.activeComponent().controllerPath ).toBeDefined()
 

data/spec/javascripts/components/form_view_spec.coffee

@@ -0,0 +1,162 @@
+describe 'The Form View', ->
+  beforeEach ->
+    FormView = Luca.components.FormView.extend
+      components:[
+        ctype: 'hidden_field'
+        name: 'id'
+      ,
+
+        ctype: "text_field",
+        label: "Field Two"
+        name: "field2"
+      ,
+        ctype: "text_field",
+        label: "Field One"
+        name: "field1"
+      ,
+        ctype: "checkbox_field"
+        label: "Field Three"
+        name: "field3"
+      ,
+        name: "field4"
+        label: "Field Four"
+        ctype: "text_area_field"
+      ,
+        name: "field5"
+        ctype: "button_field"
+        label: "Click Me"
+      ]
+
+    Model = Backbone.Model.extend
+      schema:
+        field0: "hidden"
+        field2: "text"
+        field1: "text"
+        field3: "boolean"
+        field4: "blob"
+        field5:
+          collection: "sample"
+
+    @form = new FormView()
+    @model = new Model(field0:1,field1:"jonathan",field3:true,field4:"what up player?")
+
+  afterEach ->
+    @form = undefined
+    @model = undefined
+
+  it "should create a form", ->
+    expect( @form ).toBeDefined()
+
+  it "should have access to all of the fields", ->
+    @form.render()
+    expect( @form.getFields().length ).toEqual 6
+
+  it "should load the model", ->
+    @form.loadModel(@model)
+    expect( @form.currentModel() ).toEqual @model
+
+  it "should set the field values from the model when loaded", ->
+    @form.render()
+    @form.loadModel(@model)
+    values = @form.getValues()
+    expect( values.field1 ).toEqual "jonathan"
+
+  it "should render the components within the body element", ->
+    @form.render()
+    expect( @form.$bodyEl().is('.form-view-body') ).toEqual true
+
+  it "should assign the components to render inside of the body", ->
+    @form.render()
+    expect( @form.$bodyEl().html() ).toContain "Field Four"
+
+  it "should allow me to set the values of the form fields with a hash", ->
+    @form.render()
+    @form.setValues(field1:"yes",field2:"no")
+    values = @form.getValues()
+
+    expect( values.field1 ).toEqual "yes"
+    expect( values.field2 ).toEqual "no"
+
+  it "should sync the model with the form field values", ->
+    @form.render()
+    @form.loadModel(@model)
+    @form.setValues(field1:"yes")
+    expect( @form.getValues().field1 ).toEqual "yes"
+
+describe 'Dirty Tracking', ->
+  Luca.register("Luca.components.DirtyForm").extends("Luca.components.FormView").defines
+    trackDirtyState: true
+    components:[
+      type: "text"
+      name: "dirty_field"
+    ]
+
+  beforeEach -> 
+    (@dirtyForm = new Luca.components.DirtyForm()).render()
+
+
+  it "should be stateful", ->
+    expect( @dirtyForm.state ).toBeDefined()
+    expect( @dirtyForm.state.set('dirty', true) )
+    expect( @dirtyForm ).toHaveTriggered("state:change:dirty")
+
+  it "should start off in a clean state", ->
+    dirty = @dirtyForm.isDirty()
+    expect( dirty ).not.toBeTruthy()
+
+  it "should become dirty if a field changes", ->
+    @dirtyForm.getField('dirty_field').trigger("on:change")
+    dirty = @dirtyForm.isDirty()
+    expect( dirty ).toBeTruthy()
+
+  it "should trigger a state change event", ->
+    @dirtyForm.getField('dirty_field').trigger("on:change")
+    expect( @dirtyForm ).toHaveTriggered('state:change:dirty')
+  
+  it "should bubble up field change events", ->  
+    @dirtyForm.getField('dirty_field').trigger("on:change")
+    expect( @dirtyForm ).toHaveTriggered('field:change')
+
+  it "should become clean on a reset", ->
+    @dirtyForm.getField('dirty_field').trigger("on:change")
+    @dirtyForm.reset()
+    dirty = @dirtyForm.isDirty()
+    expect( dirty ).not.toBeTruthy()
+
+describe 'Model Binding', ->
+  Luca.register("Luca.FormModel").extends("Luca.Model").defines(defaults:model_field:"value")
+
+  form = Luca.register('Luca.components.ModelBoundForm')
+
+  form.extends("Luca.components.FormView")
+
+  form.defines
+    trackModelChanges: true
+    components:[
+      type: "text"
+      name: "model_field"
+    ]
+
+  beforeEach ->
+    @modelForm = new Luca.components.ModelBoundForm()
+    @formModel = new Luca.FormModel()
+    @modelForm.render()
+    @modelForm.loadModel(@formModel)
+
+  it "should trigger a state change event", ->
+    expect( @modelForm ).toHaveTriggered("state:change:currentModel")
+
+  it "should not bind to model changes by default", ->
+    expect( Luca.components.FormView::trackModelChanges ).not.toBeTruthy()
+
+  it "should be setup to track model changes", ->
+    expect( @modelForm.trackModelChanges ).toBeTruthy()
+
+  it "should change the model's value when the form applies itself", ->
+    @modelForm.setValues('model_field':"smooth, baby")
+    @modelForm.applyFormValuesToModel()
+    expect( @modelForm.getField('model_field').getValue() ).toEqual 'smooth, baby'
+
+  it "should change the field's value when the underlying model changes", ->
+    @formModel.set('model_field', 'haha')
+    expect( @modelForm.getValues().model_field ).toEqual 'haha'

data/spec/javascripts/concerns/collection_event_bindings_spec.coffee

@@ -0,0 +1,15 @@
+describe 'Collection Event Bindings', ->
+  view = Luca.register("Luca.components.CollectionBindingView")
+  view.extends "Luca.View"
+  view.mixesIn  "CollectionEventBindings"
+  view.defines 
+    collection: new Luca.Collection()
+
+  xit "should allow me to bind to collection manager events"
+
+  it "should setup event relaying from the collection", ->
+    view = new Luca.components.CollectionBindingView()
+    for eventId in ["reset","add","remove","change"]
+      view.collection.trigger(eventId)
+      expect( view ).toHaveTriggered("collection:#{ eventId }")
+        

data/spec/{concerns → javascripts/concerns}/dom_helpers_spec.coffee

@@ -6,11 +6,11 @@ describe 'The DOM Helpers module', ->
 
   describe "Auto Assigning Class Names", ->
     it "should apply the class of the component all the way up its hierarchy", ->
-      c = new Luca.core.Container()
+      c = new Luca.Container()
       expect( c.$el.is(".luca-container") ).toBeTruthy()
       expect( c.$el.is(".luca-panel") ).toBeTruthy()
 
     it "should leave out backbone and luca view classes", ->
-      c = new Luca.core.Container()
+      c = new Luca.Container()
       expect( c.$el.is(".luca-view") ).not.toBeTruthy()
       expect( c.$el.is(".backbone-view") ).not.toBeTruthy()

data/spec/{concerns → javascripts/concerns}/filterable_spec.coffee

@@ -10,6 +10,9 @@ describe 'The Filterable Plugin', ->
     it 'should generate a Backbone.QueryCollection query payload', ->
       expect( @view.getFilterState().toQuery() ).toBeDefined()
 
+    it 'should generate a Backbone.QueryCollection options payload', ->
+      expect( @view.getFilterState().toOptions() ).toBeDefined()
+
     it "should have a toRemote method which merges params", ->
       expect( @view.getFilterState().toRemote() ).toBeDefined()
       
@@ -17,9 +20,6 @@ describe 'The Filterable Plugin', ->
       @view.applyFilter(filter:"value")
       expect( @view.getFilterState().toQuery().filter ).toEqual('value')
 
-    it 'should generate a Backbone.QueryCollection options payload', ->
-      expect( @view.getFilterState().toOptions() ).toBeDefined()
-
     it "should trigger a refresh event on filter change", ->
       @view.applyFilter(filter:"value")
-      expect( @view ).toHaveTriggered("refresh")
+      expect( @view ).toHaveTriggered("data:refresh")

data/spec/javascripts/concerns/state_model_spec.coffee

@@ -0,0 +1,55 @@
+describe 'The State Model Concern', ->
+  view = Luca.register  "Luca.components.StatefulView"
+  view.extends          "Luca.View"
+  view.mixesIn          "StateModel"
+  view.defines
+    stateful:
+      key1: "val1"
+      key2: "val2"
+
+  it "should create a state model on the view", ->
+    view = new Luca.components.StatefulView()
+    expect( view.state ).toBeDefined()
+    expect( Luca.isBackboneModel(view.state) ).toEqual true
+
+  it "should delegate the get method on the state model to the view", ->
+    view = new Luca.components.StatefulView()
+    expect( view.get ).toBeDefined()
+    expect( view.get('key1') ).toEqual 'val1' 
+
+  it "should delegate the set method on the state model to the view", ->
+    view = new Luca.components.StatefulView()
+    view.set('key1','boom') 
+    expect( view.state.get('key1') ).toEqual 'boom' 
+
+  it "should apply the default state attributes", ->
+    view = new Luca.components.StatefulView()
+    expect( view.state.toJSON() ).toEqual key1:"val1", key2: "val2"
+
+  it "should define a get/set method on the view which effect state", ->
+    view = new Luca.components.StatefulView()
+    view.set('testsetter', 'works')
+    expect( view.get('testsetter') ).toEqual('works')
+
+  describe 'State Change Event Bindings', ->
+    it "should trigger state change events on the view", ->
+      view = new Luca.components.StatefulView()
+      view.set('key1','boom')
+      expect( view ).toHaveTriggered("state:change")
+
+    it "should trigger individual attribute change events on the view", ->
+      view = new Luca.components.StatefulView()
+      view.set('key1','boom')
+      expect( view ).toHaveTriggered("state:change:key1")
+
+    it "should respond to @stateChangeEvents configuration", ->
+      view = new Luca.components.StatefulView
+        onKeyChange: sinon.spy()
+        blah: sinon.spy()
+        stateChangeEvents:
+          "key1" : "onKeyChange" 
+          "key2" : "blah"
+
+      view.set('key1','boom')
+      expect( view.blah ).not.toHaveBeenCalled()
+      expect( view.onKeyChange ).toHaveBeenCalled()