bootstrap-for-ember-rails 0.0.2

data/lib/bootstrap-for-ember-rails/bootstrap-for-ember/app/scripts/components/BsBadgeComponent.coffee

@@ -0,0 +1,8 @@
+Bootstrap.BsBadgeComponent = Ember.Component.extend(Bootstrap.TypeSupport,
+    layoutName: 'components/bs-badge'
+    tagName: 'span'
+    classNames: ['badge']
+    classTypePrefix: 'badge'
+)
+
+Ember.Handlebars.helper 'bs-badge', Bootstrap.BsBadgeComponent

data/lib/bootstrap-for-ember-rails/bootstrap-for-ember/app/scripts/components/BsBreadcrumbs.coffee

@@ -0,0 +1,65 @@
+###
+Breadcrumbs component.
+###
+Bootstrap.BsBreadcrumbsItem = Bootstrap.ItemView.extend(
+    tagName: ['li']
+    classNameBindings: ["isActive:active"]
+    template: Ember.Handlebars.compile '{{#unless view.isActive}}{{#if view.content.model}}{{#link-to view.content.route model.id}}{{view.content.name}}{{/link-to}}{{else}}{{#link-to view.content.route}}{{view.content.name}}{{/link-to}}{{/if}}{{else}}{{view.content.name}}{{/unless}}'
+
+    isActive: (->
+        @get('content.active')
+    ).property('content.active')
+)
+
+Bootstrap.BsBreadcrumbs = Bootstrap.ItemsView.extend(Bootstrap.WithRouter,
+    tagName: ['ol']
+    classNames: ['breadcrumb']
+    currentPathObserver: (->
+        #FIXME: without touching routing the observer in some latest versions of ember doesn't response
+        @get('router');
+        @send('updateCrumbsByRoute')
+    ).observes('router.url').on('init')
+    content: []
+    itemViewClass: Bootstrap.BsBreadcrumbsItem
+    nameDictionary: undefined
+    dictionaryNamePrefix: 'breadcrumbs'
+
+    actions:
+        currentPathDidChange: ->
+            @send 'updateCrumbsByRoute'
+
+        updateCrumbsByRoute: ->
+            @get('content').clear()
+
+            routes = @get('container').lookup 'router:main'
+            routes.get('router.currentHandlerInfos').forEach (route, i, arr) =>
+                name = route.name
+                return if name.indexOf('.index') isnt -1 || name is 'application'
+                return if route.handler.breadcrumbs?.hidden
+
+                routeName = route.handler.routeName
+                if route.handler.breadcrumbs?.name
+                    displayName = route.handler.breadcrumbs.name
+                else if @get('nameDictionary')?["#{@dictionaryNamePrefix}.#{routeName}"]
+                    displayName = @get('nameDictionary')["#{@dictionaryNamePrefix}.#{routeName}"]
+                else
+                    displayName = route.handler.routeName.split('.').pop()
+                    displayName = displayName[0].toUpperCase() + displayName[1..-1].toLowerCase()
+
+                crumb = Ember.Object.create
+                    route: route.handler.routeName
+                    name: displayName
+                    model: null
+
+                crumb.set('icon', 'fa fa-home home-icon') if @get('content').length is 0
+
+                if route.isDynamic
+                    crumb.setProperties
+                        model: route.handler.context
+                        name: route.handler.context.get('name')
+
+                @get('content').pushObject crumb
+            @get('content.lastObject').set 'active', true
+)
+
+Ember.Handlebars.helper 'bs-breadcrumbs', Bootstrap.BsBreadcrumbs

data/lib/bootstrap-for-ember-rails/bootstrap-for-ember/app/scripts/components/BsBtnGroup.coffee

@@ -0,0 +1,19 @@
+###
+Button Group.
+
+In its simple form, each item in the button group is a Bootstrap.Button component,
+In case this is a Radio, each item is rendered as a label.
+###
+Bootstrap.BsBtnGroup = Bootstrap.ItemsView.extend(Bootstrap.SizeSupport, Bootstrap.ItemsSelection,
+    classTypePrefix: ['btn-group']
+    classNames: ['btn-group']
+    classNameBindings: ['vertical:btn-group-vertical']
+    itemViewClass: Bootstrap.BsButtonComponent.extend(Bootstrap.ItemValue, Bootstrap.ItemSelection,
+        init: ->
+            @_super()
+            @set('icon_active', @get('parentView.icon_active'))
+            @set('icon_inactive', @get('parentView.icon_inactive'))
+    )
+)
+
+Ember.Handlebars.helper 'bs-btn-group', Bootstrap.BsBtnGroup

data/lib/bootstrap-for-ember-rails/bootstrap-for-ember/app/scripts/components/BsBtnToolbarComponent.coffee

@@ -0,0 +1,11 @@
+###
+Button Toolbar.
+
+A collection of button groups
+###
+Bootstrap.BsBtnToolbarComponent = Ember.Component.extend(
+    layoutName: 'components/bs-btn-toolbar'
+    classNames: ['btn-toolbar']
+)
+
+Ember.Handlebars.helper 'bs-btn-toolbar', Bootstrap.BsBtnToolbarComponent

data/lib/bootstrap-for-ember-rails/bootstrap-for-ember/app/scripts/components/BsButtonComponent.coffee

@@ -0,0 +1,45 @@
+Bootstrap.BsButtonComponent = Ember.Component.extend(Bootstrap.TypeSupport, Bootstrap.SizeSupport,
+    layoutName: 'components/bs-button'
+    tagName: 'button'
+    classNames: ['btn']
+    classNameBindings: ['blockClass']
+    classTypePrefix: 'btn'
+    clickedParam: null
+    block: null
+    attributeBindings: ['disabled', 'dismiss:data-dismiss', '_type:type', 'style']
+    _type: 'button'
+    bubbles: true
+    allowedProperties: ['title', 'type', 'size', 'block', 'disabled', 'clicked', 'dismiss', 'class']
+    icon_active: undefined
+    icon_inactive: undefined
+
+   init: ->
+       @_super()
+       # If content is an object (may happen when a button is the view class of a collectionView), then assign allowed properties to the button component.
+       if @get('content')? and Ember.typeOf(@get('content')) is 'instance'
+           c = @get('content')
+           @set key, c[key] for key in @get('allowedProperties') when c[key]?
+       else
+           if not @get('title')?
+               @set('title', @get('content'))
+       @attributeBindings.pushObject attr for attr of @ when attr.match(/^data-[\w-]*$/)?
+
+    blockClass: ( ->
+        if @block then "#{@classTypePrefix}-block" else null
+    ).property('block').cacheable()
+
+    click: (evt) ->
+        evt.stopPropagation() unless @get('bubbles')
+        @sendAction('clicked', @get('clickedParam'))
+
+    loadingChanged: (->
+        loading = if @get('loading') isnt null then @get('loading') else "reset"
+        Ember.$("##{@elementId}").button(loading)
+    ).observes('loading')
+
+    icon: (->
+        if @get('isActive') then @get('icon_active') else @get('icon_inactive')
+    ).property('isActive')
+)
+
+Ember.Handlebars.helper 'bs-button', Bootstrap.BsButtonComponent

data/lib/bootstrap-for-ember-rails/bootstrap-for-ember/app/scripts/components/BsItemsActionBar.coffee

@@ -0,0 +1,45 @@
+Bootstrap.ItemsActionBar = Ember.CollectionView.extend
+    classNames: 'btn-toolbar'
+    classNameBindings: 'rtl:pull-right'
+    role: 'toolbar'
+    selectedItems: []
+    rtl: false
+
+    selection: (->
+        items = @get('selectedItems')
+        return [] if not items?
+
+        if Array.isArray items
+            return items
+        else
+            [items]
+    ).property('selectedItems')
+
+    itemViewClass: Ember.CollectionView.extend
+        tagName: ['div']
+        classNames: ['btn-group']
+        itemViewClass: Ember.View.extend
+            tagName: 'button'
+            classNames: ['btn', 'btn-default']
+            attributeBindings: ['disabled']
+            #FIXME: if transitionTo exist we render the link-to as an inner div coz we need some tag but this will cause
+            #only the internal div to be clickable, not the outer 'button' tag so part of the button area wont be clickable
+            template: Ember.Handlebars.compile("
+                {{#if view.content.transitionTo}}
+                    {{link-to view.content.title view.content.transitionTo tagName='div'}}
+                {{else}}
+                    {{view.content.title}}
+                {{/if}}
+            ")
+
+            disabled: (->
+                @get('content.disabled')?(@get('parentView.parentView.selection'))
+            ).property('parentView.parentView.selection.@each', 'parentView.parentView.selection')
+
+            click: ->
+                if @get('content.clickActionName')?
+                    @get('controller').send @get('content.clickActionName'), @get('parentView.parentView.selection')
+                else if @get('content.click')
+                    @get('content.click')(@get('parentView.parentView.selection'))
+
+Ember.Handlebars.helper 'bs-items-action-bar', Bootstrap.ItemsActionBar

data/lib/bootstrap-for-ember-rails/bootstrap-for-ember/app/scripts/components/BsLabelComponent.coffee

@@ -0,0 +1,8 @@
+Bootstrap.BsLabelComponent = Ember.Component.extend(Bootstrap.TypeSupport,
+    layoutName: 'components/bs-label'
+    tagName: 'span'
+    classNames: ['label']
+    classTypePrefix: 'label'
+)
+
+Ember.Handlebars.helper 'bs-label', Bootstrap.BsLabelComponent

data/lib/bootstrap-for-ember-rails/bootstrap-for-ember/app/scripts/components/BsListGroupComponent.coffee

@@ -0,0 +1,34 @@
+Bootstrap.BsListGroupComponent = Bootstrap.ItemsView.extend(
+    tagName: 'ul'
+    classNames: ['list-group']
+    itemViewClass: Bootstrap.ItemView.extend(Bootstrap.ItemSelection,
+        classNames: ['list-group-item']
+        template: Ember.Handlebars.compile '''
+            {{#if view.badge}}
+                {{bs-badge contentBinding="view.badge"}}
+            {{/if}}
+            {{#if view.sub}}
+                <h4 class="list-group-item-heading">{{view.title}}</h4>
+                <p class="list-group-item-text">{{view.sub}}</p>
+            {{else}}
+                {{view.title}}
+            {{/if}}
+        '''
+
+        badge: (->
+            #TODO: Consolidate with ItemView
+            content = @get('content')
+            return null unless Ember.typeOf(content ) is 'instance' or Ember.canInvoke(content, 'get')
+            content.get 'badge'
+        ).property('content')
+
+        sub: (->
+            #TODO: Consolidate with ItemView
+            content = @get('content')
+            return null unless Ember.typeOf(content ) is 'instance' or Ember.canInvoke(content, 'get')
+            content.get 'sub'
+        ).property('content')
+    )
+)
+
+Ember.Handlebars.helper('bs-list-group', Bootstrap.BsListGroupComponent)

data/lib/bootstrap-for-ember-rails/bootstrap-for-ember/app/scripts/components/BsModalComponent.coffee

@@ -0,0 +1,204 @@
+###
+Modal component.
+###
+Bootstrap.BsModalComponent = Ember.Component.extend(Ember.Evented,
+    layoutName: 'components/bs-modal'
+    classNames: ['modal']
+    classNameBindings: ['fade', 'isVis:in']
+    attributeBindings: ['role', 'aria-labelledby', 'isAriaHidden:aria-hidden', "ariaLabelledBy:aria-labelledby"]
+    isAriaHidden: (->
+        "#{@get('isVisible')}"
+    ).property('isVisible')
+    modalBackdrop: '<div class="modal-backdrop fade in"></div>'
+    role: 'dialog'
+    footerViews: []
+
+    #--Defaults--
+    backdrop: true
+    title: null
+    isVisible: false
+    manual: false
+    isVis: false
+    fullSizeButtons: false
+    fade: true
+    
+    didInsertElement: ->
+        @._super()
+        @setupBinders()
+        #Register modal in the modal manager
+        name = @get('name')
+        Ember.assert("Modal name is required for modal view #{@get('elementId')}", @get('name'))
+        name?= @get('elementId')
+        Bootstrap.ModalManager.add(name, @)
+
+        if @manual
+            @show()
+
+    becameVisible: ->
+        Em.$('body').addClass('modal-open')
+        @appendBackdrop() if @get("backdrop")
+
+    becameHidden: ->
+        Em.$('body').removeClass('modal-open')
+        @_backdrop.remove() if @_backdrop
+
+    appendBackdrop: ->
+        parentElement = @$().parent()
+        @_backdrop = Em.$(@modalBackdrop).appendTo(parentElement)
+
+    show: ->
+        @set 'isVisible', true
+        current = this
+        setTimeout (->
+            current.set 'isVis', true
+            return
+        ), 15
+        return
+
+    hide: ->
+        @set 'isVis', false
+        current = this
+        @$().one 'webkitTransitionEnd', (e) ->
+            current.set 'isVisible', false
+            return
+        false
+
+    toggle: ->
+        @toggleProperty 'isVisible'
+
+    click: (event) ->
+        target = event.target
+        targetDismiss = target.getAttribute("data-dismiss")
+        if targetDismiss is 'modal'
+            @close()
+
+    keyPressed: (event) ->
+        #Handle ESC
+        if event.keyCode is 27
+            @close event
+
+    close: (event) ->
+        @set 'isVis', false
+        current = this
+        @$().one 'webkitTransitionEnd', (e) ->
+            if current.get('manual') then current.destroy() else current.hide()
+            return
+         @trigger 'closed'
+        
+
+    #Invoked automatically by ember when the view is destroyed, giving us a chance to perform cleanups
+    willDestroyElement: ->
+        Em.$('body').removeClass('modal-open')
+        @removeHandlers()
+        name = @get('name')
+        name?= @get('elementId')
+        Bootstrap.ModalManager.remove(name, @)
+        @_backdrop.remove() if @_backdrop
+
+    removeHandlers: ->
+        #Remove key press
+        jQuery(window.document).unbind "keyup", @_keyUpHandler
+
+    setupBinders: ->
+        #Key press
+        handler = (event) =>
+            @keyPressed event
+        jQuery(window.document).bind "keyup", handler
+        @_keyUpHandler = handler
+)
+
+###
+Bootstrap.BsModalComponent = Bootstrap.BsModalComponent.reopenClass(
+    build: (options) ->
+        options = {}  unless options
+        options.manual = true
+        modalPane = @create(options)
+        modalPane.append()
+)
+###
+
+Bootstrap.ModalManager = Ember.Object.create(
+    add: (name, modalInstance) ->
+        @set name, modalInstance
+
+    register: (name, modalInstance) ->
+        @add(name, modalInstance);
+        modalInstance.appendTo(modalInstance.get('targetObject').namespace.rootElement)
+
+    remove: (name) ->
+        @set name, null
+
+    close: (name) ->
+        @get(name).close()
+
+    hide: (name) ->
+        @get(name).hide()
+
+    show: (name) ->
+        @get(name).show()
+
+    toggle: (name) ->
+        @get(name).toggle()
+
+    confirm: (controller, title, message, confirmButtonTitle = "Confirm", confirmButtonEvent = "modalConfirmed",confirmButtonType = null, cancelButtonTitle = "Cancel", cancelButtonEvent = "modalCanceled",cancelButtonType = null, targetObj = controller, fade = true, fullSizeButtons = false) ->
+        body = Ember.View.extend(
+            template: Ember.Handlebars.compile(message || "Are you sure you would like to perform this action?")
+        )
+        buttons = [
+            Ember.Object.create({title: confirmButtonTitle, clicked: confirmButtonEvent, type: confirmButtonType, dismiss: 'modal'})
+            Ember.Object.create({title: cancelButtonTitle, clicked: cancelButtonEvent, type: cancelButtonType, dismiss: 'modal'})
+        ]
+        @open('confirm-modal', title || 'Confirmation required!', body, buttons, controller, fade, fullSizeButtons, targetObj)
+		
+	okModal: (controller, title, message, okButtonTitle = "OK", okButtonEvent = "okModal", okButtonType = null, targetObj = controller, fade = true, fullSizeButtons = false) ->
+        body = Ember.View.extend(
+            template: Ember.Handlebars.compile(message || "Are you sure you would like to perform this action?")
+        )
+        buttons = [
+            Ember.Object.create({title: okButtonTitle, clicked:okButtonEvent, type: okButtonType, dismiss: 'modal'})
+        ]
+        @open('ok-modal', title || 'Confirmation required!', body, buttons, controller, fade, fullSizeButtons, targetObj)
+
+    openModal: (modalView, options = {}) ->
+        rootElement = options.rootElement or '.ember-application'
+        instance = modalView.create options
+        instance.appendTo rootElement
+
+    open: (name, title, view, footerButtons, controller, fade , fullSizeButtons = false, targetObj = controller) ->
+        cl = controller.container.lookup 'component-lookup:main'
+        modalComponent = cl.lookupFactory('bs-modal', controller.get('container')).create()
+
+        modalComponent.setProperties(
+            name: name
+            title: title
+            manual: true
+            footerButtons: footerButtons
+            targetObject: targetObj
+            fade: fade
+            fullSizeButtons: fullSizeButtons
+        )
+
+        if Ember.typeOf(view) is 'string'
+            template = controller.container.lookup("template:#{view}")
+            Ember.assert("Template #{view} was specified for Modal but template could not be found.", template)
+            if template
+                modalComponent.setProperties(
+                    body: Ember.View.extend(
+                        template: template,
+                        controller: controller
+                    )
+                )
+        else if Ember.typeOf(view) is 'class'
+            modalComponent.setProperties(
+                body: view,
+                controller: controller
+            )
+
+        modalComponent.appendTo(controller.namespace.rootElement)
+)
+
+
+Ember.Application.initializer
+    name: 'bs-modal'
+    initialize: (container, application) ->
+        container.register 'component:bs-modal', Bootstrap.BsModalComponent