lanes 0.0.1

data/npm-build/template.js

@@ -0,0 +1,33 @@
+var Lanes = ( global.Lanes || (global.Lanes = {}) );
+
+Lanes.Vendor = ( Lanes.Vendor || {} );
+
+Lanes.Vendor.Ampersand                = ( Lanes.Ampersand || {} );
+Lanes.Vendor.Ampersand.View           = require("ampersand-view");
+Lanes.Vendor.Ampersand.State          = require("ampersand-state");
+Lanes.Vendor.Ampersand.CollectionView = require("ampersand-collection-view");
+Lanes.Vendor.Ampersand.SubCollection  = require("ampersand-subcollection");
+Lanes.Vendor.Ampersand.RestCollection = require("ampersand-rest-collection");
+Lanes.Vendor.Ampersand.USCollection   = require('ampersand-collection-underscore-mixin');
+Lanes.Vendor.Ampersand.Collection     = require("ampersand-collection");
+Lanes.Vendor.Ampersand.Model          = require("ampersand-model");
+Lanes.Vendor.Ampersand.Router         = require("ampersand-router");
+Lanes.Vendor.AmpersandFormView        = require("ampersand-form-view");
+Lanes.Vendor.AmpersandInputView       = require("ampersand-input-view");
+Lanes.Vendor.KeyMaster                = require("keymaster");
+Lanes.Vendor.Moment                   = require("moment");
+Lanes.Vendor.RSVP                     = require('rsvp');
+Lanes.Promise                         = Lanes.Vendor.RSVP.Promise;
+Lanes.Deferred                        = Lanes.Vendor.RSVP.defer;
+
+
+var u        = require('underscore');
+var spf      = require('sprintf-js');
+
+u.getPath    = require('get-object-path');
+u.bigDecimal = require('big.js');
+u.dom        = require('ampersand-dom');
+u.sprintf    = spf.sprintf;
+u.vsprintf   = spf.vsprintf;
+
+global._ = u;

data/public/javascripts/jasmine_examples/Player.js

@@ -0,0 +1,22 @@
+function Player() {
+}
+Player.prototype.play = function(song) {
+  this.currentlyPlayingSong = song;
+  this.isPlaying = true;
+};
+
+Player.prototype.pause = function() {
+  this.isPlaying = false;
+};
+
+Player.prototype.resume = function() {
+  if (this.isPlaying) {
+    throw new Error("song is already playing");
+  }
+
+  this.isPlaying = true;
+};
+
+Player.prototype.makeFavorite = function() {
+  this.currentlyPlayingSong.persistFavoriteStatus(true);
+};

data/public/javascripts/jasmine_examples/Song.js

@@ -0,0 +1,7 @@
+function Song() {
+}
+
+Song.prototype.persistFavoriteStatus = function(value) {
+  // something complicated
+  throw new Error("not yet implemented");
+};

data/spec/api/javascript_processor_spec.rb

@@ -0,0 +1,107 @@
+require_relative "../spec_helper"
+
+class JavascriptProcessorTest < Lanes::TestCase
+
+SCRIPT = <<-EOS
+class NS.Baz
+    constructor: ->
+        alert("foo")
+    alert: (msg)->
+        alert(msg);
+
+class NS.Bar extends NS.Baz
+    squawk:->
+        this.alert("Hello World!")
+
+class Foo extends Bar
+    constructor: ->
+        this.called=true
+        super
+    aMethod: ->
+         @squawk("howdy!")
+
+EOS
+
+CLEANED=<<-EOS
+class NS.Baz
+    constructor: ->
+        alert("foo")
+    alert: (msg)->
+        alert(msg);
+
+class NS.Bar
+    constructor: -> super
+    squawk:->
+        this.alert("Hello World!")
+
+NS.Baz.extend(NS.Bar)
+
+class Foo
+    constructor: ->
+        this.called=true
+        super
+    aMethod: ->
+         @squawk("howdy!")
+
+Bar.extend(Foo)
+
+EOS
+
+JS=<<-EOS
+(function(Lanes, _, window, undefined) {
+var Foo;
+
+NS.Baz = (function() {
+  function Baz() {
+    alert("foo");
+  }
+
+  Baz.prototype.alert = function(msg) {
+    return alert(msg);
+  };
+
+  return Baz;
+
+})();
+
+NS.Bar = (function() {
+  function Bar() {
+    Bar.__super__.constructor.apply(this, arguments);
+  }
+
+  Bar.prototype.squawk = function() {
+    return this.alert("Hello World!");
+  };
+
+  return Bar;
+
+})();
+
+NS.Baz.extend(NS.Bar);
+
+Foo = (function() {
+  function Foo() {
+    this.called = true;
+    Foo.__super__.constructor.apply(this, arguments);
+  }
+
+  Foo.prototype.aMethod = function() {
+    return this.squawk("howdy!");
+  };
+
+  return Foo;
+
+})();
+
+Bar.extend(Foo);
+
+})(window.Lanes, window._, window);
+EOS
+
+
+    def test_coffeescript_generation
+        template = API::CoffeeScriptWrapper.new{ |t| SCRIPT }
+        assert_equal CLEANED, template.cleaned
+        assert_equal JS.chomp, template.render
+    end
+end

data/spec/api/user_spec.rb

@@ -0,0 +1,52 @@
+require_relative "../spec_helper"
+
+class ApiUserTest < Lanes::ApiTestCase
+
+    def test_query
+        get "/users/#{admin.id}.json"
+        refute_ok
+        login!
+        get "/users/#{admin.id}.json"
+        assert_ok
+        assert_equal admin.id, json_data.id
+    end
+
+    def test_create
+        login!
+        assert_difference ->{User.count}, 1 do
+            post "/users.json", {
+                login: "nas", name: "Nathan", email: "test@test.com", password: 'testing1234'
+            }
+            assert_ok
+        end
+    end
+
+    def test_update_by_self
+        user = lanes_users(:support)
+        login!(user)
+        assert User.can_write_attributes?({id: user.id, :foo=>1}, user)
+        put "/users/#{user.id}.json", { name: 'Updated Name', password: 'pass1234', email: 'sam@test.com' }
+        assert_ok
+        user.reload
+        assert_equal 'Updated Name', user.name
+        assert_equal 'sam@test.com', user.email
+    end
+
+    def test_updating_roles
+        login!
+        user = lanes_users(:support)
+        put "/users/#{user.id}.json", { name: 'Sam', role_names:['administrator'] }
+        assert_ok
+        user.reload
+        assert_equal 'Sam', user.name
+        assert_equal ['administrator'], user.role_names
+    end
+
+    def test_delete
+        login!
+        assert_difference ->{User.count}, -1 do
+            delete "/users/#{admin.id}.json"
+        end
+    end
+
+end

data/spec/client/component/ChoicesInputSpec.coffee

@@ -0,0 +1,12 @@
+describe "Choices Input Suite", ->
+
+    it "renders to a view", ->
+        roles = new Lanes.Data.Roles([
+            {id: 'one', name:'One'}
+            {id: 'two', name:'Two'}
+        ])
+        sf = new Lanes.Component.SelectField({
+            multiple: true, data: roles, mappings:{ title: 'name', selected: 'member' }
+        })
+        sf.render().el
+        expect( sf.$('option').length ).toEqual(2)

data/spec/client/component/foo_spec.coffee

@@ -0,0 +1,4 @@
+describe "Foo Input Suite", ->
+
+    it "one eq one", ->
+        expect(1).toEqual(1)

data/spec/client/support/jasmine.yml

@@ -0,0 +1,128 @@
+# 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:
+  - public/javascripts/**/*.{js,coffee}
+  - assets/lanes-workspace.js
+#  - assets/**/*.{js,coffee}
+
+
+# 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:
+  - stylesheets/**/*.css
+
+# helpers
+#
+# Return an array of filepaths relative to spec_dir to include before jasmine specs.
+# Default: ["helpers/**/*.js"]
+#
+# EXAMPLE:
+#
+# helpers:
+#   - helpers/**/*.js
+#
+helpers:
+  - 'helpers/**/*.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:
+  - "**/*[Ss]pec.{js,coffee}"
+
+
+# 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:
+
+# 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_helper
+#
+# Ruby file that Jasmine server will require before starting.
+# Returned relative to your root path
+# Default spec/javascripts/support/jasmine_helper.rb
+#
+# EXAMPLE:
+#
+# spec_helper: spec/javascripts/support/jasmine_helper.rb
+#
+spec_helper: spec/javascripts/support/jasmine_helper.rb
+
+# boot_dir
+#
+# Boot directory path. Your boot_files must be returned relative to this path.
+# Default: Built in boot file
+#
+# EXAMPLE:
+#
+# boot_dir: spec/javascripts/support/boot
+#
+boot_dir:
+
+# boot_files
+#
+# Return an array of filepaths relative to boot_dir to include in order to boot Jasmine
+# Default: Built in boot file
+#
+# EXAMPLE
+#
+# boot_files:
+#   - '**/*.js'
+#
+boot_files:
+
+# rack_options
+#
+# Extra options to be passed to the rack server
+# by default, Port and AccessLog are passed.
+#
+# This is an advanced options, and left empty by default
+#
+# EXAMPLE
+#
+# rack_options:
+#   server: 'thin'
+

data/spec/client/support/jasmine_helper.rb

@@ -0,0 +1,15 @@
+#Use this file to set/override Jasmine configuration options
+#You can remove it if you don't need it.
+#This file is loaded *after* jasmine.yml is interpreted.
+#
+#Example: using a different boot file.
+#Jasmine.configure do |config|
+#   config.boot_dir = '/absolute/path/to/boot_dir'
+#   config.boot_files = lambda { ['/absolute/path/to/boot_dir/file.js'] }
+#end
+#
+#Example: prevent PhantomJS auto install, uses PhantomJS already on your path.
+#Jasmine.configure do |config|
+#   config.prevent_phantom_js_auto_install = true
+#end
+#

data/spec/concerns/api_path_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../spec_helper'
+
+class ApiPathTest < Lanes::TestCase
+
+    include TestingModels
+
+    def test_path_generation
+        assert_equal 'test-models', TestModel.api_path
+    end
+
+    def testing_path_to_model
+        assert_equal TestModel, Lanes::Model.from_api_path('test-models')
+    end
+end

data/spec/concerns/association_extensions_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../spec_helper'
+
+
+class AssociationExtensionsTest < Lanes::TestCase
+
+    include TestingModels
+
+    def test_adding_event_listener_requires_inverse
+        err = assert_raise(ArgumentError) do
+            TestModel.has_one(:tmhm,:listen=>{:save=>:on_save})
+        end
+        assert_match( /does not have an inverse_of specified./, err.message )
+    end
+
+    def test_adds_listener
+        Tmhm.expects(:_add_event_listener).with(:save,is_a(Proc))
+        TestModel.has_one(:tmhm,:listen=>{:save=>:on_save}, :inverse_of=>:tm)
+    end
+
+    def test_exports_associations
+        TestModel.expects(:export_associations).with(:tmhm,{})
+        TestModel.has_one(:tmhm, export: true)
+    end
+
+    def test_does_not_allow_other_garbage
+        assert_raise(ArgumentError) do
+            TestModel.has_one(:tmhm,:blarg=>true)
+        end
+    end
+end

data/spec/concerns/attr_accessor_with_default_spec.rb

@@ -0,0 +1,57 @@
+require_relative '../spec_helper'
+
+class AttrAccessorWithDefaultTest < Lanes::TestCase
+
+    Shared = Struct.new(:value)
+
+    class AttrTestClass
+        include Lanes::Concerns::AttrAccessorWithDefault
+        attr_accessor_with_default :as_proc, Proc.new{ 42 }
+        attr_accessor_with_default :non_copying, ->{ "default string" }
+        attr_accessor_with_default :shared, Shared.new('default')
+        attr_accessor_with_default :non_shared, ->{ Shared.new('default') }
+    end
+
+    class Inherited<AttrTestClass
+        non_shared "Foo"
+    end
+
+    def test_access
+        a = AttrTestClass.new
+        b = AttrTestClass.new
+
+        assert_equal 42, b.as_proc
+
+        assert_equal "default string", b.non_copying
+
+        b.non_copying = "A new string"
+
+        assert_equal "default string", a.non_copying
+        a.non_copying = "third value"
+        assert_equal "A new string", b.non_copying
+
+
+        assert_equal "default", a.shared.value
+        assert_equal "default", b.shared.value
+
+        a.shared.value = "a new value"
+
+        assert_equal "a new value", a.shared.value
+        assert_equal "a new value", b.shared.value
+
+        a.non_shared.value = "a new value"
+        assert_equal "a new value", a.non_shared.value
+        assert_equal "default", b.non_shared.value
+    end
+
+    def test_inheritance
+        a = Inherited.new
+        b = AttrTestClass.new
+        assert_kind_of String, a.non_shared
+        assert_kind_of Shared, b.non_shared
+        assert_equal "Foo", a.non_shared
+        assert_equal "default", b.non_shared.value
+    end
+
+
+end

data/spec/concerns/code_identifier_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../spec_helper'
+
+
+class CodeIdentifierTest < Lanes::TestCase
+
+    class CodeIdentifierTestModel
+        class_attribute :blocks
+        attr_accessor :code
+
+        include Lanes::Concerns::CodeIdentifier
+
+        def self.before_validation( opts={}, &block )
+            self.blocks||=[]
+            self.blocks.push( block )
+        end
+
+        def self.validates( *opts )
+        end
+
+        def run_validations
+            self.class.blocks.each{ |b| self.instance_eval(&b) }
+        end
+
+        def [](name)
+            :name == name ? 'A Long String of Nonsense' : ''
+        end
+
+        has_code_identifier :from => :name
+    end
+
+    def test_that_it_uppercases
+        ci = CodeIdentifierTestModel.new
+        ci.code='test'
+        ci.run_validations
+        assert_equal 'TEST', ci.code
+    end
+
+    def test_that_it_generates
+        ci = CodeIdentifierTestModel.new
+        ci.run_validations
+        assert ci.code.present?, "Code wasn't auto-generated"
+        assert_equal 'ALOSTOFNON',  ci.code
+    end
+
+end

data/spec/concerns/export_associations_spec.rb

@@ -0,0 +1,7 @@
+require_relative '../spec_helper'
+
+
+class ExportAssociationsTest < Lanes::TestCase
+
+
+end

data/spec/concerns/export_methods_spec.rb

@@ -0,0 +1,43 @@
+require_relative '../spec_helper'
+
+class ExportMethodsTest < Lanes::TestCase
+    include TestingModels
+
+    def around(&block)
+        with_testing_models(&block)
+    end
+
+    def setup
+        # @model = TestModel.new
+        # @model.bt = TestModelBelongsTo.new
+    end
+
+    def teardown
+#        TestModel.send( :remove_method, :bt_description ) if User.new.respond_to?( :bt_description )
+    end
+
+
+    def test_simple_delegation
+
+
+        refute TestModel.new.respond_to? :bt_description
+
+        TestModel.send :delegate_and_export, "bt_description"
+
+        md = TestModel.new
+        assert md.respond_to? :bt_description, "Didn't add transaction_description method"
+        assert_nil md.bt_description
+        md.build_bt( description: "test123" )
+        assert_equal "test123", md.bt_description
+
+        assert TestModel.has_exported_method?( :bt_description, nil ), "Didn't export method"
+    end
+
+    def test_dependancy_calculation
+        TestModel.send :delegate_and_export, "bt_description"
+        TestModel.send :delegate_and_export, "bt_notes", optional: false
+        assert_includes TestModel.exported_method_dependancies([]), :bt
+        assert_includes TestModel.exported_method_dependancies(['bt_description']), :bt
+    end
+
+end

data/spec/concerns/export_scope_spec.rb

@@ -0,0 +1,15 @@
+require_relative '../spec_helper'
+
+class ExportScopeTest < Lanes::TestCase
+
+    def teardown
+        User.send( :remove_method, :big_query ) if User.respond_to?( :account_name )
+    end
+
+    def test_scope_method_creation
+        refute User.respond_to?(:big_query)
+        User.send( :export_scope, :big_query, ->{} )
+        assert User.respond_to?(:big_query)
+    end
+
+end

data/spec/concerns/exported_limits_spec.rb

@@ -0,0 +1,47 @@
+require_relative '../spec_helper'
+
+
+class ExportedLimitsTest < Lanes::TestCase
+
+    class LimitsTestingModel
+
+        include Lanes::Concerns::ExportScope
+        include Lanes::Concerns::ExportMethods
+
+        def self.scope(name, query)# act like ActiveRecord model
+        end
+
+        def secret_method( name, query )
+        end
+
+        def test_method( name, query )
+        end
+
+        export_methods :test_method, limit: lambda{ | user, type, name |
+            user == 'anon'
+        }
+
+        export_scope :admin_data, lambda{ | param |
+            param
+        }, limit: :only_admins
+
+        export_methods :secret_method, limit: :only_admins
+
+
+        def self.only_admins( user, type, name )
+            return user == 'admin'
+        end
+
+    end
+
+    def test_limits
+        assert LimitsTestingModel.has_exported_method?( 'test_method', 'anon' ), "anyone can retrieve no_limit data"
+
+        assert LimitsTestingModel.has_exported_scope?( 'admin_data', 'admin' ), "Admins can retrieve admin data"
+        refute LimitsTestingModel.has_exported_scope?( 'admin_data', 'non-admin' ), "Non-Admin cannot retrieve admin data"
+
+        assert LimitsTestingModel.has_exported_method?( 'secret_method', 'admin' ), "Public can retrieve public data"
+        refute LimitsTestingModel.has_exported_method?( 'secret_method', 'unk' ), "User must be admin to retrieve public data"
+    end
+
+end