neat-rails 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0917bb29396d40820cd7ea76add02769a75ebf06
+  data.tar.gz: 215afdec3ef8a2ea45eed909282ce24b33cb573a
+SHA512:
+  metadata.gz: 881a5a3ee3673cf59dcb969c1fb92be12f0cc1851e238f7ab4842191ff28bd60667427c97d7479b5665ecd0b8e540412118e9aab8ee8f8741a843671f875a3c4
+  data.tar.gz: a383cfcdfcf454b35d9a5d2d4486a127f2482de763ae076b6472338e05eb3455bc89ece97427f6af4e0fcfe2e7891c753c72a5185608fa179751fce892f66e33

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in neat-rails.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Robert Lail
+
+MIT License
+
+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.md

@@ -0,0 +1,29 @@
+# Neat::Rails
+
+It's like FreightTrain for Backbone. That's pretty neat!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'neat-rails'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install neat-rails
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/neat/rails/engine.rb

@@ -0,0 +1,7 @@
+# Configure Rails 3.1 to have assets in the load path
+module Neat
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/neat/rails/version.rb

@@ -0,0 +1,5 @@
+module Neat
+  module Rails
+    VERSION = "0.0.2"
+  end
+end

data/lib/neat-rails.rb

@@ -0,0 +1,7 @@
+require "neat/rails/version"
+require "neat/rails/engine"
+
+module Neat
+  module Rails
+  end
+end

data/neat-rails.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'neat/rails/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "neat-rails"
+  gem.version       = Neat::Rails::VERSION
+  gem.authors       = ["Bob Lail", "Luke Booth"]
+  gem.email         = ["bob.lailfamily@gmail.com", "luke.booth@cph.org"]
+  gem.description   = %q{It allows editing collections and models inline}
+  gem.summary       = %q{It's like FreightTrain for Backbone. That's pretty neat!}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  
+  gem.add_development_dependency "rake"
+end

data/vendor/assets/javascripts/neat/collection_editor.coffee

@@ -0,0 +1,215 @@
+KEYS = {
+  13: "RETURN",
+  27: "ESC",
+  38: "UP",
+  40: "DOWN"
+}
+
+# Classes that inherit from EditableCollectionView
+# must define one property:
+#   resource
+#
+# Can optionally define
+#   modelView - by default this is set to {Resource}View
+#   template - by default this is set to #{resource}/index
+#   viewPath - by default this is set to resource
+#
+class window.Neat.CollectionEditor extends Backbone.View
+  sortedBy: 'name'
+  sortOrder: 'asc'
+  sortAliases: {}
+  templateOptions: {}
+  pageSize: 30
+  
+  keyDownHandlers:
+    ESC:    -> @viewInEdit?.cancelEdit()
+    RETURN: -> @viewInEdit?.save()
+    UP:     -> @edit @prevView()
+    DOWN:   -> @edit @nextView()
+  
+  initialize: ->
+    @viewPath = @viewPath ? @resource
+    @singular = inflect.singularize(@resource) # e.g. "calendar"
+    @modelView = @modelView ? (()=>
+      viewName = inflect.camelize(@singular) + "View" # e.g. "CalendarView"
+      @debug "expects viewName to be #{viewName}"
+      window[viewName])() # e.g. window["CalendarView"]
+    
+    @debug "looking for template at #{"#{@viewPath}/index"}"
+    @template = @template ? Neat.template["#{@viewPath}/index"]
+    
+    @paginator = new window.Lail.PaginatedList [],
+      page_size: if window.Neat.forPrint then Infinity else @pageSize
+      always_show: false
+    @paginator.onPageChange _.bind(@renderPage, @)
+    
+    @collection.bind 'reset',  @render, @
+    @collection.bind 'add',    @rerenderPage, @
+    @collection.bind 'remove', @rerenderPage, @
+    
+    # We need to rerender the page if a model's attributes
+    # have changed just in case this would affect how the
+    # models are sorted.
+    #
+    # !todo: perhaps we can be smarter here and only listen
+    # for changes to the attribute the view is sorted on.
+    #
+    # We don't want to redraw the page every time a model
+    # has changed. If an old transaction is deleted, a very
+    # large number of more recent transactions' running
+    # balances could be updated very rapidly. Redrawing the
+    # page will slow things down dramatically.
+    #
+    # Instead, redraw the page 500ms after a model has changed.
+    #
+    # This allows us to wait for activity to die down
+    # and to redraw the page when it's more likely the system
+    # has settled into new state.
+    #
+    @delayedRerender = new Lail.DelayedAction(_.bind(@rerenderPage, @), delay: 500)
+    @collection.bind 'change', @delayedRerender.trigger
+    
+    # If the view's headers are 'a' tags, this view will try
+    # to sort the collection using the header tags.
+    $(@el).delegate '.header a', 'click', _.bind(@sort, @)
+    $(@el).delegate '.editor', 'keydown', _.bind(@onKeyDown, @)
+    
+    @views = []
+    @viewInEdit = null
+    @templateOptions = {}
+  
+  repaginate: ->
+    @rerenderPage(1)
+  
+  rerenderPage: (page)->
+    page = @paginator.getCurrentPage() unless _.isNumber(page)
+    sortField = @sortField(@sortedBy)
+    items = @collection.sortBy (model)->
+      val = model.get(sortField) || ''
+      if _.isString(val) then val.toLowerCase() else val
+    items.reverse() if @sortOrder == 'desc'
+    @paginator.init items, page
+  
+  
+  render: ->
+    $el = $(@el)
+    $el.html @template(collection: @collection)
+    $el.cssHover '.row.interactive'
+    
+    @afterRender()
+    
+    @updateSortStyle() if @sortedBy
+    
+    @paginator.renderPaginationIn($el.find('.pagination'))
+    @repaginate()
+    @
+  
+  afterRender: ->
+    @
+  
+  renderPage: ->
+    alt = false
+    $ul = $(@el).find("##{@resource}").empty() # e.g. $('#calendars')
+    @views = []
+    self = @
+    
+    $(@el).find('.extended-pagination').html(@paginator.renderExtendedPagination())
+    
+    for model in @paginator.getCurrentSet()
+      view = new @modelView # e.g. window.CalendarView
+        resource: @resource
+        viewPath: @viewPath
+        model: model
+        templateOptions: @templateOptions
+      view.bind 'edit:begin', -> self.beforeEdit.call(self, @)
+      view.bind 'edit:end', -> self.afterEdit.call(self, @)
+      
+      @views.push(view)
+      
+      $el = $(view.render().el)
+      $el.toggleClass 'alt', !(alt = !alt)
+      $ul.append $el
+    @
+  
+  
+  
+  beforeEdit: (view)->
+    if @viewInEdit
+      @debug "cancelling edit for ##{$(@viewInEdit.el).attr('id')} (#{@indexOfViewInEdit()})"
+      @viewInEdit.cancelEdit()
+    @viewInEdit = view
+    @debug "beginning edit for ##{$(@viewInEdit.el).attr('id')} (#{@indexOfViewInEdit()})"
+  
+  afterEdit: (view)->
+    @viewInEdit = null if @viewInEdit == view
+  
+  
+  
+  sort: (e)->
+    e.preventDefault()
+    e.stopImmediatePropagation()
+    sortBy = $(e.target).closest('a').attr('class').substring(@singular.length + 1)
+    @log "sort by #{sortBy} [#{@sortField(sortBy)}]"
+    if @sortedBy == sortBy
+      @sortOrder = if @sortOrder == 'asc' then 'desc' else 'asc'
+    else
+      @removeSortStyle @sortedBy
+      @sortedBy = sortBy
+    @repaginate()
+    @updateSortStyle()
+    false
+  
+  removeSortStyle: (field)->
+    
+  updateSortStyle: ()->
+    @removeSortStyle @sortedBy
+  
+  getHeader: (field)->
+    $(@el).find(".header > .#{@singular}-#{field}")
+  
+  sortField: (field)->
+    @sortAliases[field] ? field
+  
+  
+  
+  onKeyDown: (e)->
+    keyName = @identifyKey(e.keyCode)
+    handler = @keyDownHandlers[keyName]
+    if handler && !@ignoreKeyEventsForTarget(e.target)
+      e.preventDefault()
+      handler.apply(@)
+  
+  identifyKey: (code)->
+    KEYS[code]
+  
+  ignoreKeyEventsForTarget: (target)->
+    # i.e. return true if target is in a dropdown control like Chosen
+    false
+  
+  
+  
+  nextView: ->
+    @views[@indexOfViewInEdit() + 1]
+  
+  prevView: ->
+    @views[@indexOfViewInEdit() - 1]
+  
+  indexOfViewInEdit: ->
+    _.indexOf @views, @viewInEdit
+  
+  edit: (view)->
+    if view
+      @viewInEdit?.save()
+      view.edit()
+      @viewInEdit = view
+  
+  cancelEdit: ->
+    @viewInEdit?.cancelEdit()
+  
+  
+  
+  debug: (o...)->
+    @log(o...) if Neat.debug
+  
+  log: (o...)->
+    Neat.logger.log "[#{@viewPath}] ", o...

data/vendor/assets/javascripts/neat/lib/delayed_action.js

@@ -0,0 +1,49 @@
+var Lail; if(!Lail) Lail={};
+Lail.DelayedAction = function(callback, options) {
+  // !todo: paste John Resig's code
+  
+  options = options || {};
+  var self           = this,
+      delay          = options.delay || 1000,
+      steps          = options.steps || 10,
+      intervalPeriod = delay / steps,
+      counter        = 0,
+      _params,
+      _interval;
+  
+  this.trigger = function(params) {
+    _params = params;
+    restartCountdown();
+  }
+  
+  function restartCountdown() {
+    counter = steps;
+    if(!_interval) {
+      _interval = setInterval(countdown, intervalPeriod);
+    }
+  }
+  
+  function countdown() {
+    if(counter > 0) {
+      counter = counter - 1;
+    } else {
+      stopCountdown()
+      fireCallback();
+    }
+  }
+  
+  function stopCountdown() {
+    if(_interval) {
+      clearInterval(_interval);
+      _interval = null;
+    }
+  }
+  
+  function fireCallback() {
+    try {
+      callback(_params);
+    } catch(e) {
+      App.debug(e);
+    }
+  }
+}