nail_polish 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 02093b432326e2623e61fc3bf74ba94d061c9039
+  data.tar.gz: 058bc41c0e48b1fa57ab187283305ecdfbbf743e
+SHA512:
+  metadata.gz: a01a5e64327c6ce39fd9d4c51833c38a197c34fbe0234ed28d173065dcc3d15f70956f682ddd2d08d84dec73542e0872f11b34db656b8eef1fd1f72806fc34fb
+  data.tar.gz: 304b28c76819afe5245e596dd4d96cb1211fbaa9e189b1db34fd583c14e5bc69646aa55654895a4b8d1b97d64f443620804da54771cb1c74a8da5cb179fbef75

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 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,29 @@
+= NailPolish: SocialChorus/SocialChorus OO FrontEnd
+
+NailPolish is a front-end framework used by the SocialCoder's a SocialChorus.
+
+SocialCoders use a modified version of OOCSS, and have an set of Backbone
+conventions.
+
+== TODO
+* Hogan compilation for performance
+* template in page render to prevent large resources
+* widgets
+  * Dropdown menu
+  * back button
+  * modal
+  * form view
+  * model view
+  * collection view
+* generators
+  - view
+  - template
+  - presenter
+  - specs for presenter and view
+* js models
+* simplified CSS
+
+== Development
+The current jasmine gem does not play well with engines.
+To modify and test javascript, go into the spec/dummy directory and then
+run `rake jasmine` or `rake jasmine:ci`.

data/Rakefile

@@ -0,0 +1,23 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'NailPolish'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+

data/app/assets/javascripts/nail_polish/app.js

@@ -0,0 +1,58 @@
+//specs to come
+NailPolish.App = function() {};
+NailPolish.App.extend = Backbone.Model.extend;
+
+_.extend(NailPolish.App.prototype, {
+  initialize: function(parent, opts) {
+    this.parent = parent;
+    this.opts = opts;
+    this.init(parent, opts);
+  },
+
+  start: function () {
+    this.repository = this.bootstrap();
+    this.route();
+    this.render();
+  },
+
+  route: function() {
+    this.router = new (this.routerClass())();
+    this.router.repository = this.repository;
+    Backbone.history.start();
+  },
+
+  render: function() {
+    _.each(this.subViews(), function(view) {
+      view.parent = view.parent || this.parent;
+      view.render();
+    }.bind(this));
+  },
+
+  bootstrapData: function() {
+    var data = data || JSON.parse($('#bootstrap-json').text());
+    return data;
+  },
+
+  //Stuff for YOU to configure
+
+  init: function() {
+    //your init stuff here
+  },
+
+  bootstrap: function() {
+    //override this if you want specific models in your repo
+    return this.bootstrapData();
+  },
+
+  subViews: function() {
+   //fill me in
+
+   //return [
+   // new View.That.I.Want.To.Render({model: model})
+   //]
+  },
+
+  routerClass: function () {
+    //set this, yo
+  }
+});

data/app/assets/javascripts/nail_polish/events/flasher.js

@@ -0,0 +1,17 @@
+NailPolish.Events.Flasher = function (view) {
+  this.view = view;
+};
+
+_.extend(NailPolish.Events.Flasher.prototype, {
+  subscribe: function () {
+    NailPolish.Events.subscribe('flash', this.perform, this);
+  },
+
+  perform: function (data) {
+    this.view.model = data;
+    this.view.show();
+  }
+});
+
+NailPolish.Events.Flasher.extend = Backbone.Model.extend;
+

data/app/assets/javascripts/nail_polish/events/redirector.js

@@ -0,0 +1,3 @@
+NailPolish.Events.Redirector = function (url) {
+  window.location = url;
+};

data/app/assets/javascripts/nail_polish/events.js

@@ -0,0 +1,28 @@
+NailPolish.Events = {
+  isTouch: function() {
+    // taken from Modernizr: http://modernizr.com/license
+    return (('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch);
+  },
+
+  isWindowsTouch: function() {
+    if (/Windows.NT.6/i.test(navigator.userAgent)){
+      return true;
+    }
+    return false;
+  },
+  startEvent: 'touchstart',
+
+  publisher: _.extend({}, Backbone.Events),
+
+  publish: function (event, args) {
+    this.publisher.trigger(event, args);
+  },
+
+  subscribe: function (event, callback, context) {
+    this.publisher.on(event, callback, context);
+  },
+
+  unsubscribe: function(event, callback, context) {
+    this.publisher.off(event, callback, context);
+  }
+};

data/app/assets/javascripts/nail_polish/nail_polish.js

@@ -0,0 +1,25 @@
+var NailPolish = {
+  apps: function () {
+    if (this._apps) return this._apps;
+    this._apps = [];
+    return this._apps;
+  },
+
+  add: function (app) {
+    if (this.apps().length <= 0) {
+      this.startServices();
+    }
+    if (!_.include(this.apps(), app)) {
+      this.apps().push(app);
+    }
+  },
+
+  startServices: function () {
+    Backbone.history.start();
+    _.each(this.subscriptions, function (callback, event) {
+      NailPolish.Events.subscribe(event, callback);
+    });
+  }
+};
+
+NailPolish.Widget = {};

data/app/assets/javascripts/nail_polish/overrides/auth_token_adder.js

@@ -0,0 +1,44 @@
+// Backbone does not send model data with delete requests ...
+// which means the authenticity token does not go there either.
+// It sucks, but we unpack the data before each request, and send the
+// token along
+
+NailPolish.AuthTokenAdder = function (args) {
+  this.args = args;
+  this.type = args.type.toLowerCase();
+  this.data = _.clone(args.data || {});
+  this.authenticityToken = $('meta[name="csrf-token"]').attr('content');
+};
+
+NailPolish.AuthTokenAdder.prototype.perform = function () {
+  this.handlePostPutPatch();
+  this.handleDelete();
+  return this.args;
+};
+
+NailPolish.AuthTokenAdder.prototype.handleDelete = function () {
+  if ( this.type != 'delete' ) { return; }
+
+  this.args.url = this.args.url +
+    "?authenticity_token=" +
+    encodeURIComponent(this.authenticityToken);
+};
+
+NailPolish.AuthTokenAdder.prototype.handlePostPutPatch = function () {
+  if ( this.type != 'post' && this.type != 'put' && this.type != 'patch' ) { return; }
+
+  if ( _.isString(this.data) ) {
+    this.repackageStringData();
+  }
+
+  this.addAuthToken();
+};
+
+NailPolish.AuthTokenAdder.prototype.repackageStringData = function () {
+  this.data = JSON.parse(this.data);
+};
+
+NailPolish.AuthTokenAdder.prototype.addAuthToken = function () {
+  data = _.extend(this.data, {authenticity_token: this.authenticityToken});
+  this.args.data = this.data = JSON.stringify(data);
+}

data/app/assets/javascripts/nail_polish/overrides/for_backbone.js

@@ -0,0 +1,14 @@
+Backbone.ajax = function() {
+  // adds the authenticity token
+  var args = _.map(arguments, function(a) {
+    return new NailPolish.AuthTokenAdder(a).perform();
+  });
+
+  // reads events from data, and does a global publish
+  args = _.map(args, function(a) {
+    return new NailPolish.GlobalPublisherAdder(a).perform();
+  });
+
+  return Backbone.$.ajax.apply(Backbone.$, args);
+};
+

data/app/assets/javascripts/nail_polish/overrides/function_bind.js

@@ -0,0 +1,6 @@
+Function.prototype.bind = Function.prototype.bind || function(context) {
+  var func = this;
+  return function() {
+    return func.apply(context, arguments);
+  };
+};

data/app/assets/javascripts/nail_polish/overrides/global_publisher_adder.js

@@ -0,0 +1,28 @@
+NailPolish.GlobalPublisherAdder = function (args) {
+  this.args = args;
+};
+
+_.extend(NailPolish.GlobalPublisherAdder.prototype, {
+  perform: function () {
+    this.args.complete = this.wrapComplete(this.args.complete);
+    return this.args;
+  },
+
+  wrapComplete: function (callback) {
+    return function(xhr, status) {
+      // call the original callback
+      callback && callback(xhr, status);
+
+      // extract the JSON data
+      
+      response = xhr.response || "{}"
+      var data = JSON.parse(response);
+      var publisher = NailPolish.Events;
+
+      // publish each event received
+      _.each(data.events, function (value, key) {
+        publisher.publish(key, value);
+      });
+    };
+  }
+});

data/app/assets/javascripts/nail_polish/presenter.js

@@ -0,0 +1,43 @@
+NailPolish.Presenter = function(presented) {
+  this.presented = presented || {};
+  this.initialize();
+  this.init();
+};
+
+NailPolish.Presenter.prototype.initialize = function () {
+  //Put your stuff here
+};
+
+NailPolish.Presenter.prototype.init = function () {
+  //Put your stuff here
+};
+
+NailPolish.Presenter.extend = Backbone.Model.extend;
+
+NailPolish.Presenter.prototype.presentedToJSON = function () {
+  var json;
+  if (this.presented && this.presented.toJSON) {
+    json = this.presented.toJSON();
+  }
+  return json || this.presented;
+};
+
+NailPolish.Presenter.prototype.inclusions = function () {
+  var inclusions = {};
+  _.each(this.include || [], function (prop) {
+     inclusions[prop] = this.inclusionFor(prop);
+  }.bind(this));
+  return inclusions;
+};
+
+NailPolish.Presenter.prototype.inclusionFor = function (attr) {
+  var prop = this[attr];
+  return _.isFunction(prop) ? prop.bind(this)() : prop;
+};
+
+NailPolish.Presenter.prototype.toJSON = function() {
+  var base = this.presentedToJSON();
+  var inclusions = this.inclusions();
+  return _.extend(base, inclusions);
+};
+

data/app/assets/javascripts/nail_polish/presenters/collection.js

@@ -0,0 +1,11 @@
+NailPolish.Presenter.Collection = NailPolish.Presenter.extend({
+  presentedToJSON: function () {
+    var json;
+    if (this.presented && this.presented.toJSON) {
+      json = this.presented.toJSON();
+    }
+    var returnValue = {};
+    returnValue[this.name] = (json || this.presented);
+    return returnValue;
+  }
+})

data/app/assets/javascripts/nail_polish/router.js

@@ -0,0 +1,78 @@
+NailPolish.Router = Backbone.Router.extend({
+  initialize: function ($layout) {
+    this.$layout = $layout;
+    this.history = [];
+    this.on('route:start', this.storeHistory, this);
+
+    this.init();
+  },
+
+  init: function () {},
+
+  // We are overriding this method to add some events before and after
+  // a route happens. Unfortunately, the anonymous function in the middle
+  // doesn't allow us to call super and change just that behavior.
+  route: function (route, name, callback) {
+    if (!_.isRegExp(route)) route = this._routeToRegExp(route);
+    if (_.isFunction(name)) {
+      callback = name;
+      name = '';
+    }
+    if (!callback) callback = this[name];
+
+    var router = this;
+    Backbone.history.route(route, function(fragment) {
+      var args = router._extractParameters(route, fragment);
+      router.trigger('route:start', fragment, args);
+      callback && callback.apply(router, args);
+      router.trigger.apply(router, ['route:' + name].concat(args));
+      router.trigger('route', name, args);
+      Backbone.history.trigger('route', router, name, args);
+    });
+
+    return this;
+  },
+
+  page: function (views) {
+    NailPolish.Events.publish('page:new');  
+    this.$layout.empty();
+    this.render(views);
+  },
+
+  render: function (args) {
+    _.each(args, function (view) {
+      view.parent = view.parent || this.$layout;
+      view.repository = view.repository || this.repository;
+      view.render();
+    }.bind(this));
+    this.afterRender();
+  },
+
+  afterRender: function(){
+    //put your after render stuff here
+  },
+
+  // this is usually used for NailPolish.Events to publish a redirect event!
+  redirect: function (path) {
+    window.location = path;
+  }, 
+
+  go: function(fragment) {
+    this.navigate(fragment, {trigger: true});
+  },
+
+  goReplacingLastHistory: function(fragment) {
+    this.history.pop();
+    this.navigate(fragment, { trigger: true, replace: true });
+  },
+
+  back: function () {
+    this.history.pop();
+    var fragment = _.last(this.history);
+    this.goReplacingLastHistory(fragment);
+  },
+
+  storeHistory: function () {
+    this.history.push(Backbone.history.fragment);
+  }
+});

data/app/assets/javascripts/nail_polish/utils/text.js

@@ -0,0 +1,36 @@
+NailPolish.TextUtils = {
+  camelize: function (word) {
+    return word
+      .replace(/^(\w)/, function(g) {
+        return g.toUpperCase();
+      }).replace(/(_\w)/g, function(g) {
+        return g[1].toUpperCase();
+      });
+  },
+
+  underscore: function (word) {
+    return word
+      .replace(/^(\w)/, function(g) {
+        return g.toLowerCase();
+      })
+      .replace(/([A-Z])/g, function (g) {
+        return "_" + g.toLowerCase();
+      });
+  },
+
+  shorten: function(text, n) {
+    if (!text || !n) { return; }
+
+    if (text.length > n) {
+      text = text.substr(0, n) + '...';
+    }
+    return text;
+  },
+
+  stripTags: function (text) {
+    return text
+      .replace(/<(?:.|\n)*?>/gm, ' ')
+      .replace(/\s+/g, ' ')
+      .replace(/^\s/, '');
+  }
+};

data/app/assets/javascripts/nail_polish/view/parent_finder.js

@@ -0,0 +1,46 @@
+NailPolish.View.ParentFinder = function (parent, selector, method) {
+  this.parent = parent;
+  this.selector = selector;
+  this.method = method;
+};
+
+_.extend(NailPolish.View.ParentFinder.prototype, {
+  perform: function () {
+    if (this.parent) {
+      // If it is a backbone view, use the $el for parent
+      if (this.parent.$el) { this.parent = this.parent.$el; }
+
+      if(this.selector) {
+        //pretends it is jquery
+        if (this.parentIsAttachable() && this.parentIsFindable()) {
+          return this.findLocally()
+        }
+      } else {
+        // is parent, no selector
+        return this.parent;
+      }
+    } else {
+      // no parent, but there is a selector
+      return this.findGlobally();
+    }
+  },
+
+  findLocally: function() {
+    var found = this.parent.find(this.selector)
+    if (found.length) { return found }
+  },
+
+  findGlobally: function() {
+    if (!this.selector || !$(this.selector).length) { return; }
+
+    return $(this.selector);
+  },
+
+  parentIsAttachable: function () {
+    return !!(this.parent && this.parent[this.method]);
+  },
+
+  parentIsFindable: function () {
+    return !!(this.parent && this.parent['find']);
+  }
+});

data/app/assets/javascripts/nail_polish/view.js

@@ -0,0 +1,80 @@
+NailPolish.View = Backbone.View.extend({
+  addListeners: {},
+  presenterClass: function () {
+    return NailPolish.Presenter;
+  },
+
+  initialize: function (opts) {
+    opts = opts || {};
+    this.parent = opts.parent;
+    this.repository = opts.repository;
+    this.attachmentMethod = this.attachmentMethod || 'append';
+    this.init(opts);
+  },
+
+  init: function (opts) {
+    // override in classes
+  },
+
+  render: function () {
+    this.renderTemplate();
+    this.renderSubviews();
+    this.attachToParent();
+    this.afterRender();
+  },
+
+  subviews: function () {
+    return [];
+  },
+
+  renderSubviews: function () {
+    _.each(this.subviews(), function (view) {
+      view.parent = this;
+      view.render();
+    }.bind(this));
+  },
+
+  attachToParent: function () {
+    var $parent = new NailPolish.View.ParentFinder(
+      this.parent, this.parentSelector, this.attachmentMethod
+    ).perform();
+    $parent && $parent[this.attachmentMethod](this.el);
+  },
+
+  afterRender: function () { /* template method hook ! */
+  },
+
+  events: function () {
+    if (NailPolish.Events.isTouch() && !NailPolish.Events.isWindowsTouch()) {
+      var eventSet = {};
+
+      _.each(_.keys(this.addListeners), function (eventKey) {
+        var key = eventKey.replace('click', NailPolish.Events.startEvent);
+        eventSet[key] = this.addListeners[eventKey];
+      }.bind(this));
+
+      return eventSet;
+    }
+    return this.addListeners;
+  },
+
+  renderTemplate: function () {
+    var template = HoganTemplates[this.templateName];
+    if (!template) {
+      return;
+    }
+    var rendered = template.render(this.presenter(), this.partials());
+    this.$el.html(rendered);
+  },
+
+  presenter: function () {
+    var presented = this.model || this.collection || {};
+    var presenter = new (this.presenterClass())(presented);
+    return presenter.toJSON();
+  },
+
+  partials: function () {
+    // override with own partials if necessary
+    return {};
+  }
+});

data/app/assets/javascripts/nail_polish/widget/flash.js

@@ -0,0 +1,36 @@
+NailPolish.Widget.Flash = NailPolish.View.extend({
+  templateName: 'flash',
+  className: 'flash',
+  parentSelector: '#flash-container',
+  attachmentMethod: 'html',
+  animationLength: 500,
+  showFor: 2000,
+
+  addListeners: {
+    'click .close': 'hide'
+  },
+
+  perform: function (model) {
+    this.model = model;
+    this.render();
+  },
+
+  afterRender: function () {
+    this.show();
+  },
+
+  show: function () {
+    window.scrollTo(0, 0);
+    this.$el.css('opacity', 0);
+    this.$el.show();
+    this.$el.animate({opacity: 1}, this.animationLength);
+
+    setTimeout(this.hide.bind(this), this.showFor);
+  },
+
+  hide: function () {
+    this.$el.animate(
+      {opacity: 0}, this.animationLength, this.$el.hide.bind(this.$el)
+    );
+  }
+});