romo-av 0.1.0

data/assets/js/romo-av/video.js

@@ -0,0 +1,619 @@
+$.fn.romoVideo = function() {
+  return $.map(this, function(element) {
+    return new RomoVideo(element);
+  });
+}
+
+var RomoVideo = function(element) {
+  this.elem     = $(element);
+  this.videoObj = this.elem[0];
+
+  this._bindFullscreen();
+  this._bindVideo();
+
+  this.doInit();
+  this._loadState();
+
+  this.durationTime   = undefined;
+  this.durationFrames = undefined;
+  this.elem.on('loadedmetadata', $.proxy(function(e) {
+    this.durationTime   = this.getDurationTime();
+    this.durationFrames = this.getDurationFrames();
+  }, this));
+
+  this.elem.trigger('video:ready', [this.video, this]);
+}
+
+RomoVideo.prototype.doInit = function() {
+  // override as needed
+}
+
+// Playback methods
+
+RomoVideo.prototype.doPlay = function() {
+  this.videoObj.play();
+}
+
+RomoVideo.prototype.doPause = function() {
+  this.videoObj.pause();
+}
+
+RomoVideo.prototype.doTogglePlay = function() {
+  if (this.videoObj.paused) {
+    this.videoObj.play();
+  } else {
+    this.videoObj.pause();
+  }
+}
+
+RomoVideo.prototype.doSetPlaybackToTime = function(secondNum) {
+  this._setPlayback(secondNum);
+}
+
+RomoVideo.prototype.doSetPlaybackToFrame = function(frameNum) {
+  if(this.fpsEnabled !== true){ return; }
+  this._setPlayback(this._frameNumToSecondNum(frameNum));
+}
+
+RomoVideo.prototype.doSetPlaybackToPercent = function(percent) {
+  this._setPlayback(this._percentToSecondNum(percent));
+}
+
+RomoVideo.prototype.doModPlaybackByTime = function(secondsCount) {
+  this._setPlayback(this.videoObj.currentTime + secondsCount);
+}
+
+RomoVideo.prototype.doModPlaybackByFrames = function(frameCount) {
+  if(this.fpsEnabled !== true){ return; }
+  this._setPlayback(this.videoObj.currentTime + this._frameNumToSecondNum(frameCount));
+}
+
+RomoVideo.prototype.doModPlaybackByPercent = function(percent) {
+  this._setPlayback(this.videoObj.currentTime + this._percentToSecondNum(percent));
+}
+
+// Settings methods
+
+RomoVideo.prototype.doMute = function() {
+  this.videoObj.muted = true;
+  this.elem.trigger('video:volumechange', [this.videoObj, this]);
+}
+
+RomoVideo.prototype.doUnmute = function() {
+  this.videoObj.muted = false;
+  this.elem.trigger('video:volumechange', [this.videoObj, this]);
+}
+
+RomoVideo.prototype.doToggleMute = function() {
+  this.videoObj.muted = !this.videoObj.muted;
+  this.elem.trigger('video:volumechange', [this.videoObj, this]);
+}
+
+RomoVideo.prototype.getLoop = function() {
+  return this.elem.prop('loop');
+}
+
+RomoVideo.prototype.doLoop = function() {
+  this.elem.prop('loop', true);
+  this.elem.trigger('video:loop',       [this.videoObj, this]);
+  this.elem.trigger('video:loopChange', [true, this.videoObj, this]);
+}
+
+RomoVideo.prototype.doNoLoop = function() {
+  this.elem.prop('loop', false);
+  this.elem.trigger('video:noloop',     [this.videoObj, this]);
+  this.elem.trigger('video:loopChange', [false, this.videoObj, this]);
+}
+
+RomoVideo.prototype.doToggleLoop = function() {
+  if (this.getLoop() !== true) {
+    this.doLoop();
+  } else {
+    this.doNoLoop();
+  }
+}
+
+RomoVideo.prototype.doSetVolumeToPercent = function(percent) {
+  this._setVolume(percent / 100);
+}
+
+RomoVideo.prototype.doModVolumeByPercent = function(percent) {
+  this._setVolume(this.videoObj.volume + (percent / 100));
+}
+
+RomoVideo.prototype.doSetPlaybackToRate = function(rate) {
+  this.videoObj.playbackRate = rate;
+}
+
+RomoVideo.prototype.doModPlaybackByRate = function(rate) {
+  this.videoObj.playbackRate = this.videoObj.playbackRate + rate;
+}
+
+// Fullscreen methods
+
+RomoVideo.prototype.doEnterFullscreen = function() {
+  this._requestFullscreen();
+}
+
+RomoVideo.prototype.doExitFullscreen = function() {
+  this._exitFullscreen();
+}
+
+RomoVideo.prototype.doToggleFullscreen = function() {
+  if (this.fullScreen === true) {
+    this._exitFullscreen();
+  } else {
+    this._requestFullscreen();
+  }
+}
+
+// Status methods
+
+RomoVideo.prototype.getPlaybackTime = function() {
+  return this.videoObj.currentTime;
+}
+
+RomoVideo.prototype.getPlaybackFrame = function() {
+  return this.getVideoTimeInFrames(this.getPlaybackTime());
+}
+
+RomoVideo.prototype.getPlaybackPercent = function() {
+  return this.getVideoTimeInPercent(this.getPlaybackTime());
+}
+
+RomoVideo.prototype.getDurationTime = function() {
+  if (this.durationTime !== undefined) {
+    return this.durationTime;
+  } else if (isNaN(parseInt(this.videoObj.duration)) === true) {
+    return 0.0;
+  } else {
+    return this.videoObj.duration;
+  }
+}
+
+RomoVideo.prototype.getDurationFrames = function() {
+  if (this.durationFrames !== undefined) {
+    return this.durationFrames;
+  } else if (this.fpsEnabled !== true) {
+    return 0;
+  } else {
+    return Math.round(this.getDurationTime() * this.fps);
+  }
+}
+
+RomoVideo.prototype.getDurationPercent = function() {
+  return 100;
+}
+
+RomoVideo.prototype.getTotalBufferedTime = function() {
+  return this.getTotalBufferedTuples().reduce(function(prev, curr) {
+    return prev + (curr[1] - curr[0]);
+  }, 0.0);
+}
+
+RomoVideo.prototype.getTotalBufferedFrames = function() {
+  return this.getVideoTimeInFrames(this.getTotalBufferedTime());
+}
+
+RomoVideo.prototype.getTotalBufferedPercent = function() {
+  return this.getVideoTimeInPercent(this.getTotalBufferedTime());
+}
+
+RomoVideo.prototype.getTotalBufferedTuples = function() {
+  var tuples   = [];
+  var buffered = this.videoObj.buffered;
+  for (i = 0; i < buffered.length; i++) {
+    tuples.push([buffered.start(i), buffered.end(i)]);
+  }
+  return tuples;
+}
+
+RomoVideo.prototype.getVolumeValue = function() {
+  if (this.videoObj.muted === true) {
+    return 0;
+  } else {
+    return this.videoObj.volume;
+  }
+}
+
+RomoVideo.prototype.getVolumePercent = function() {
+  return this.getVolumeValue() * 100;
+}
+
+RomoVideo.prototype.getVolumeMuted = function() {
+  return this.videoObj.muted === true || this.getVolumePercent() === 0;
+}
+
+// Load methods
+
+RomoVideo.prototype.doLoad = function() {
+  this.doPause();
+  this._loadState();
+  this.videoObj.load();
+}
+
+RomoVideo.prototype.doModSource = function(source) {
+  this.videoObj.src = source;
+
+  this.durationTime   = undefined;
+  this.durationFrames = undefined;
+}
+
+// Helper methods
+
+RomoVideo.prototype.getVideoTimeInFrames = function(time) {
+  return this.getVideoPercentInFrames(this.getVideoTimeInPercent(time));
+}
+RomoVideo.prototype.getVideoTimeInPercent = function(time) {
+  if (this.getDurationTime() === 0.0) {
+    return 0;
+  } else {
+    return (time / this.getDurationTime()) * 100;
+  }
+}
+RomoVideo.prototype.getVideoFramesInTime = function(frameCount) {
+  return this.getVideoPercentInTime(this.getVideoFramesInPercent(frameCount));
+}
+RomoVideo.prototype.getVideoFramesInPercent = function(frameCount) {
+  if (this.fpsEnabled !== true) {
+    return 0;
+  } else {
+    return (frameCount / this.getDurationFrames()) * 100;
+  }
+}
+RomoVideo.prototype.getVideoPercentInTime = function(percent) {
+  return (percent / 100) * this.getDurationTime();
+}
+RomoVideo.prototype.getVideoPercentInFrames = function(percent) {
+  if (this.fpsEnabled !== true) {
+    return 0;
+  } else {
+    var framesCalc = (percent / 100) * this.getDurationFrames();
+    if (framesCalc >= 0) {
+      return Math.ceil(framesCalc);
+    } else {
+      return Math.floor(framesCalc);
+    }
+  }
+}
+
+RomoVideo.prototype.getVideoFormattedTime = function(seconds) {
+  if (isNaN(parseInt(seconds)) === true || seconds === 0) {
+    if (this.showMs !== false) {
+      return '00:00.000';
+    } else {
+      return '00:00';
+    }
+  }
+
+  var abs  = Math.abs(seconds);
+  var hrs  = Math.floor(abs / 3600);
+  var mins = Math.floor((abs - (hrs * 3600)) / 60);
+  var secs = Math.floor(abs % 60);
+
+  var t = (hrs ? hrs + ':' : '') +
+          (mins < 10 ? '0' : '') + mins + ':' +
+          (secs < 10 ? '0' : '') + secs;
+  if (this.showMs !== false) {
+    t += (abs - Math.floor(abs)).toFixed(3).slice(1);
+  }
+
+  if (seconds > 0){ return t; }
+  else{ return '-'+t; }
+}
+
+// private
+
+RomoVideo.prototype._setPlayback = function(newSecondNum) {
+  var durationTime = this.getDurationTime();
+  if (newSecondNum > durationTime) {
+    if (this.elem.prop('loop') === true){
+      this.videoObj.currentTime = newSecondNum - durationTime;
+    } else {
+      this.videoObj.currentTime = durationTime;
+    }
+  } else if (newSecondNum < 0) {
+    if (this.elem.prop('loop') === true){
+      this.videoObj.currentTime = (durationTime - (0 - newSecondNum));
+    } else {
+      this.videoObj.currentTime = 0;
+    }
+  } else {
+    this.videoObj.currentTime = newSecondNum;
+  }
+}
+
+RomoVideo.prototype._frameNumToSecondNum = function(frameNum) {
+  return frameNum / this.fps;
+}
+
+RomoVideo.prototype._percentToSecondNum = function(percent) {
+  return (percent / 100) * this.getDurationTime();
+}
+
+RomoVideo.prototype._setVolume = function(value) {
+  if (value > 1) {
+    this.videoObj.volume = 1;
+  } else if (value < 0) {
+    this.videoObj.volume = 0;
+  } else {
+    this.videoObj.volume = value;
+  }
+  this.doUnmute();
+}
+
+RomoVideo.prototype._loadState = function() {
+  this.fps = this.elem.data('romo-video-fps');
+  if (this.fps && this.fps > 0) {
+    this.fpsEnabled = true;
+  } else {
+    this.fpsEnabled = false;
+  }
+  this.showMs = this.elem.data('romo-video-show-ms');
+}
+
+RomoVideo.prototype._bindFullscreen = function() {
+  var fullscreenElem = this.elem.closest(this.elem.data('romo-video-fullscreen-elem'));
+  if (fullscreenElem[0] !== undefined) {
+    this.fullscreenElem = fullscreenElem;
+  } else {
+    this.fullscreenElem = this.elem;
+  }
+
+  this._browserRequestFullscreen = this._getBrowserRequestFullscreen(this.fullscreenElem);
+  this._browserExitFullscreen    = this._getBrowserExitFullscreen();
+
+  $(document).on('fullscreenchange',       $.proxy(this._onDocumentFullscreenChange, this));
+  $(document).on('mozfullscreenchange',    $.proxy(this._onDocumentFullscreenChange, this));
+  $(document).on('msfullscreenchange',     $.proxy(this._onDocumentFullscreenChange, this));
+  $(document).on('webkitfullscreenchange', $.proxy(this._onDocumentFullscreenChange, this));
+}
+
+RomoVideo.prototype._bindVideo = function() {
+  this._bindVideoElemEvents();
+  this._bindVideoTriggerEvents();
+}
+
+RomoVideo.prototype._bindVideoElemEvents = function() {
+  // playback events
+
+  this.elem.on('play', $.proxy(function(e) {
+    this.elem.trigger('video:play', [this.videoObj, this]);
+  }, this));
+  this.elem.on('pause', $.proxy(function(e) {
+    this.elem.trigger('video:pause', [this.videoObj, this]);
+  }, this));
+
+  // state events
+
+  this.elem.on('playing', $.proxy(function(e) {
+    this.elem.trigger('video:playing', [this.videoObj, this]);
+  }, this));
+  this.elem.on('waiting', $.proxy(function(e) {
+    this.elem.trigger('video:waiting', [this.videoObj, this]);
+  }, this));
+  this.elem.on('ended',  $.proxy(function(e) {
+    this.elem.trigger('video:ended', [this.videoObj, this]);
+  }, this));
+  this.elem.on('emptied', $.proxy(function(e) {
+    this.elem.trigger('video:emptied', [this.videoObj, this]);
+  }, this));
+  this.elem.on('error', $.proxy(function(e) {
+    this.elem.trigger('video:error', [this.videoObj, this]);
+  }, this));
+  this.elem.on('stalled', $.proxy(function(e) {
+    this.elem.trigger('video:stalled', [this.videoObj, this]);
+  }, this));
+  this.elem.on('suspend', $.proxy(function(e) {
+    this.elem.trigger('video:suspend', [this.videoObj, this]);
+  }, this));
+
+  // status events
+
+  this.elem.on('progress', $.proxy(function(e) {
+    this.elem.trigger('video:progress', [this.videoObj, this]);
+  }, this));
+  this.elem.on('timeupdate', $.proxy(function(e) {
+    this.elem.trigger('video:timeupdate', [this.videoObj, this]);
+  }, this));
+
+  // settings events
+
+  this.elem.on('volumechange', $.proxy(function(e) {
+    this.elem.trigger('video:volumechange', [this.videoObj, this]);
+  }, this));
+  this.elem.on('durationchange', $.proxy(function(e) {
+    this.elem.trigger('video:durationchange', [this.videoObj, this]);
+  }, this));
+  this.elem.on('ratechange', $.proxy(function(e) {
+    this.elem.trigger('video:ratechange', [this.videoObj, this]);
+  }, this));
+
+  // load events
+
+  this.elem.on('loadstart', $.proxy(function(e) {
+    this.elem.trigger('video:loadstart', [this.videoObj, this]);
+  }, this));
+  this.elem.on('loadedmetadata', $.proxy(function(e) {
+    this.elem.trigger('video:loadedmetadata', [this.videoObj, this]);
+  }, this));
+  this.elem.on('loadeddata', $.proxy(function(e) {
+    this.elem.trigger('video:loadeddata', [this.videoObj, this]);
+  }, this));
+  this.elem.on('canplay', $.proxy(function(e) {
+    this.elem.trigger('video:canplay', [this.videoObj, this]);
+  }, this));
+  this.elem.on('canplaythrough', $.proxy(function(e) {
+    this.elem.trigger('video:canplaythrough', [this.videoObj, this]);
+  }, this));
+}
+
+RomoVideo.prototype._bindVideoTriggerEvents = function() {
+  // playback triggers
+
+  this.elem.on('video:triggerPlay', $.proxy(function(e) {
+    this.doPlay(); return false;
+  }, this));
+  this.elem.on('video:triggerPause', $.proxy(function(e) {
+    this.doPause(); return false;
+  }, this));
+  this.elem.on('video:triggerTogglePlay', $.proxy(function(e) {
+    this.doTogglePlay(); return false;
+  }, this));
+  this.elem.on('video:triggerSetPlaybackToTime', $.proxy(function(e, secondNum) {
+    this.doSetPlaybackToTime(secondNum); return false;
+  }, this));
+  this.elem.on('video:triggerSetPlaybackToFrame', $.proxy(function(e, frameNum) {
+    this.doSetPlaybackToFrame(frameNum); return false;
+  }, this));
+  this.elem.on('video:triggerSetPlaybackToPercent', $.proxy(function(e, percent) {
+    this.doSetPlaybackToPercent(percent); return false;
+  }, this));
+  this.elem.on('video:triggerModPlaybackByTime', $.proxy(function(e, secondsCount) {
+    this.doModPlaybackByTime(secondsCount); return false;
+  }, this));
+  this.elem.on('video:triggerModPlaybackByFrames', $.proxy(function(e, frameCount) {
+    this.doModPlaybackByFrames(frameCount); return false;
+  }, this));
+  this.elem.on('video:triggerModPlaybackByPercent', $.proxy(function(e, percent) {
+    this.doModPlaybackByPercent(percent); return false;
+  }, this));
+
+  // settings triggers
+
+  this.elem.on('video:triggerMute', $.proxy(function(e) {
+    this.doMute(); return false;
+  }, this));
+  this.elem.on('video:triggerUnmute', $.proxy(function(e) {
+    this.doUnmute(); return false;
+  }, this));
+  this.elem.on('video:triggerToggleMute', $.proxy(function(e) {
+    this.doToggleMute(); return false;
+  }, this));
+  this.elem.on('video:triggerSetVolumeToPercent', $.proxy(function(e, percent) {
+    this.doSetVolumeToPercent(percent); return false;
+  }, this));
+  this.elem.on('video:triggerModVolumeByPercent', $.proxy(function(e, percent) {
+    this.doModVolumeByPercent(percent); return false;
+  }, this));
+  this.elem.on('video:triggerSetPlaybackRate', $.proxy(function(e, rate) {
+    this.doSetPlaybackToRate(rate); return false;
+  }, this));
+  this.elem.on('video:triggerModPlaybackRate', $.proxy(function(e, rate) {
+    this.doModPlaybackByRate(rate); return false;
+  }, this));
+
+  // fullscreen triggers
+
+  this.elem.on('video:triggerEnterFullscreen', $.proxy(function(e) {
+    this.doEnterFullscreen(); return false;
+  }, this));
+  this.elem.on('video:triggerExitFullscreen', $.proxy(function(e) {
+    this.doExitFullscreen(); return false;
+  }, this));
+  this.elem.on('video:triggerToggleFullscreen', $.proxy(function(e) {
+    this.doToggleFullscreen(); return false;
+  }, this));
+
+  // load triggers
+
+  this.elem.on('video:triggerLoad', $.proxy(function(e) {
+    this.doLoad(); return false;
+  }, this));
+  this.elem.on('video:triggerModSource', $.proxy(function(e, source) {
+    this.doModSource(source); return false;
+  }, this));
+
+}
+
+RomoVideo.prototype._onDocumentFullscreenChange = function(e) {
+  if (this._getCurrentFullscreenElem() === this.fullscreenElem[0]) {
+    this.fullScreen = true;
+    this.elem.trigger('video:enterFullscreen', [this.videoObj, this]);
+    this.elem.trigger('video:fullscreenChange', [this.videoObj, this]);
+  } else if (this.fullScreen === true) {
+    this.fullScreen = false;
+    this.elem.trigger('video:exitFullscreen', [this.videoObj, this]);
+    this.elem.trigger('video:fullscreenChange', [this.videoObj, this]);
+  }
+}
+
+RomoVideo.prototype._getCurrentFullscreenElem = function() {
+  return document.fullscreenElement        ||
+         document.mozFullScreenElement     ||
+         document.msFullscreenElement      ||
+         document.webkitFullscreenElement;
+}
+
+RomoVideo.prototype._requestFullscreen = function() {
+  if (this._canFullscreen()) {
+    this._browserRequestFullscreen.apply(this.fullscreenElem[0]);
+  } else {
+    return false;
+  }
+}
+
+RomoVideo.prototype._exitFullscreen = function() {
+  if (this._canFullscreen()) {
+    this._browserExitFullscreen.apply(document);
+  } else {
+    return false;
+  }
+}
+
+RomoVideo.prototype._canFullscreen = function() {
+  if (this._browserRequestFullscreen === undefined || this._browserExitFullscreen === undefined) {
+    return false;
+  }
+
+  if (document.fullscreenEnabled !== undefined) {
+    return document.fullscreenEnabled;
+  } else if (document.mozFullScreenEnabled !== undefined) {
+    return document.mozFullScreenEnabled;
+  } else if (document.msFullscreenEnabled !== undefined) {
+    return document.msFullscreenEnabled;
+  } else if (document.webkitFullscreenEnabled !== undefined) {
+    return document.webkitFullscreenEnabled;
+  } else {
+    return false;
+  }
+}
+
+RomoVideo.prototype._getBrowserRequestFullscreen = function(fullscreenElem) {
+  // look for the browser-specific requestFullscreen function and return it
+
+  if (fullscreenElem[0].requestFullscreen) {
+    return fullscreenElem[0].requestFullscreen;
+  } else if (fullscreenElem[0].mozRequestFullScreen) {
+    return fullscreenElem[0].mozRequestFullScreen;
+  } else if (fullscreenElem[0].msRequestFullscreen) {
+    return fullscreenElem[0].msRequestFullscreen;
+  } else if (fullscreenElem[0].webkitRequestFullscreen) {
+    return this.fullscreenElem[0].webkitRequestFullscreen;
+  } else {
+    return undefined;
+  }
+}
+
+RomoVideo.prototype._getBrowserExitFullscreen = function(fullscreenElem) {
+  // look for the browser-specific exitFullscreen function and return it
+  // we use the document because any non-video fullscreen containers will not
+  // have this function, calling the document function will exit anything that
+  // has been fullscreened
+
+  if (document.exitFullscreen) {
+    return document.exitFullscreen;
+  } else if (document.mozCancelFullScreen) {
+    return document.mozCancelFullScreen;
+  } else if (document.msExitFullscreen) {
+    return document.msExitFullscreen;
+  } else if (document.webkitExitFullscreen) {
+    return document.webkitExitFullscreen;
+  } else {
+    return undefined;
+  }
+}
+
+Romo.onInitUI(function(e) {
+  Romo.initUIElems(e, '[data-romo-video-auto="true"]').romoVideo();
+});

data/lib/romo-av/dassets.rb

@@ -0,0 +1,38 @@
+require 'dassets'
+require 'romo-av'
+
+module Romo::Av; end
+module Romo::Av::Dassets
+
+  # This assumes you are using 'js/romo-{audio|video}.js' as part of a larger
+  # combination or are loading romo's modal/dropdown js components before
+  # loading this combination.
+
+  def self.configure!
+    Dassets.configure do |c|
+      c.source Romo::Av.gem_assets_path do |s|
+        s.filter{ |paths| paths.reject{ |p| File.basename(p) =~ /^_/ } }
+      end
+
+      # just audio
+      c.combination "js/romo-av-audio.js", [
+        'js/romo-av/audio.js'
+      ]
+
+      # just video
+      c.combination "js/romo-av-video.js", [
+        'js/romo-av/video.js',
+        'js/romo-av/modal_video.js',
+        'js/romo-av/dropdown_video.js'
+      ]
+
+      # both audio and video
+      c.combination "js/romo-av.js", [
+        'js/romo-av-audio.js',
+        'js/romo-av-video.js'
+      ]
+
+    end
+  end
+
+end

data/lib/romo-av/version.rb

@@ -0,0 +1,4 @@
+module Romo; end
+module Romo::Av
+  VERSION = "0.1.0"
+end

data/lib/romo-av.rb

@@ -0,0 +1,14 @@
+require 'romo'
+require "romo-av/version"
+
+module Romo::Av
+
+  def self.gem_assets_path; self.gem_path.join('assets'); end
+
+  private
+
+  def self.gem_path
+    @gem_path ||= Pathname(Gem.loaded_specs['romo-av'].full_gem_path)
+  end
+
+end

data/romo-av.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "romo-av/version"
+
+Gem::Specification.new do |gem|
+  gem.name        = "romo-av"
+  gem.version     = Romo::Av::VERSION
+  gem.authors     = ["Kelly Redding", "Collin Redding"]
+  gem.email       = ["kelly@kellyredding.com", "collin.redding@me.com"]
+  gem.description = %q{Romo audio/video components.}
+  gem.summary     = %q{Romo audio/video components.}
+  gem.homepage    = "http://github.com/redding/romo-av"
+  gem.license     = 'MIT'
+
+  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("assert", ["~> 2.15"])
+
+  gem.add_dependency("romo", ["~> 0.11"])
+end