awe-rails 0.1.0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+## 0.1.(3 February 2012)
+
+  - First version
+  - Based on the awe-rails gem at https://github.com/indirect/awe-rails
+  - Layered onto a jeweler generated gem 
+  

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+gem "rails", ">= 3.1"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", "~> 2.8.0"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.8.3"
+  gem "simplecov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,109 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.0)
+      actionpack (= 3.2.0)
+      mail (~> 2.4.0)
+    actionpack (3.2.0)
+      activemodel (= 3.2.0)
+      activesupport (= 3.2.0)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.0)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.1)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.2)
+    activemodel (3.2.0)
+      activesupport (= 3.2.0)
+      builder (~> 3.0.0)
+    activerecord (3.2.0)
+      activemodel (= 3.2.0)
+      activesupport (= 3.2.0)
+      arel (~> 3.0.0)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.0)
+      activemodel (= 3.2.0)
+      activesupport (= 3.2.0)
+    activesupport (3.2.0)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.0)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    git (1.2.5)
+    hike (1.2.1)
+    i18n (0.6.0)
+    jeweler (1.8.3)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+      rdoc
+    journey (1.0.0)
+    json (1.6.5)
+    mail (2.4.1)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.17.2)
+    multi_json (1.0.4)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.1)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.2.0)
+      actionmailer (= 3.2.0)
+      actionpack (= 3.2.0)
+      activerecord (= 3.2.0)
+      activeresource (= 3.2.0)
+      activesupport (= 3.2.0)
+      bundler (~> 1.0)
+      railties (= 3.2.0)
+    railties (3.2.0)
+      actionpack (= 3.2.0)
+      activesupport (= 3.2.0)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.6)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    simplecov (0.5.4)
+      multi_json (~> 1.0.3)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
+    sprockets (2.1.2)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.14.6)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.31)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.8.3)
+  rails (>= 3.1)
+  rdoc (~> 3.12)
+  rspec (~> 2.8.0)
+  simplecov

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Artefact Group LLC
+
+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,28 @@
+= awe-rails
+
+* This gem adds a single generator to Rails 3.1, awe:install.
+* Running the generator will install AWE for Rails.
+* See https://github.com/sambaker/awe-core
+* AWE is installed into the rails asset pipeline.
+* These lines will be added to the file `app/assets/javascripts/application.js` by default:
+
+    //= require awe
+
+== Installation
+
+In your Gemfile, add this line:
+
+    gem "awe-rails"
+
+Then, run bundle install. To invoke the generator, run:
+
+    rails generate awe:install
+    
+You're done!
+
+== Copyright
+
+Copyright (c) 2012 Artefact Group LLC. 
+
+See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "awe-rails"
+  gem.homepage = "http://www.artefactgroup.com"
+  gem.license = "MIT"
+  gem.summary = %Q{Gem for integrating AWE into the rails asset pipeline}
+  gem.description = %Q{Modeled after the jquery-rails gem. Installs the AWE files into the rails 3.1 asset pipeline}
+  gem.email = "shyam.habarakada@gmail.com"
+  gem.authors = ["Shyam Habarakada"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "awe-rails #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/awe-rails.gemspec

@@ -0,0 +1,74 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "awe-rails"
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Shyam Habarakada"]
+  s.date = "2012-02-04"
+  s.description = "Modeled after the jquery-rails gem. Installs the AWE files into the rails 3.1 asset pipeline"
+  s.email = "shyam.habarakada@gmail.com"
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".rspec",
+    "CHANGELOG.md",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "awe-rails-1.0.17.gem",
+    "awe-rails.gemspec",
+    "lib/awe-rails.rb",
+    "lib/awe/rails.rb",
+    "lib/awe/rails/engine.rb",
+    "lib/generators/awe/install/install_generator.rb",
+    "spec/awe-rails_spec.rb",
+    "spec/lib/awe-rails_spec.rb",
+    "spec/spec_helper.rb",
+    "vendor/assets/javascripts/awe-core.js",
+    "vendor/assets/javascripts/awe-state-machine.js"
+  ]
+  s.homepage = "http://www.artefactgroup.com"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.10"
+  s.summary = "Gem for integrating AWE into the rails asset pipeline"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, [">= 3.1"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+    else
+      s.add_dependency(%q<rails>, [">= 3.1"])
+      s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rails>, [">= 3.1"])
+    s.add_dependency(%q<rspec>, ["~> 2.8.0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+  end
+end
+

data/lib/awe/rails/engine.rb

@@ -0,0 +1,12 @@
+# Configure Rails
+module Awe
+  module Rails
+
+    class Engine < ::Rails::Engine
+      config.before_configuration do
+        # nothing to do here (yet)
+      end
+    end
+
+  end
+end

data/lib/awe/rails.rb

@@ -0,0 +1,5 @@
+module Awe
+  module Rails
+    require 'awe/rails/engine'
+  end
+end

data/lib/awe-rails.rb

@@ -0,0 +1 @@
+require 'awe/rails'

data/lib/generators/awe/install/install_generator.rb

@@ -0,0 +1,20 @@
+require 'rails'
+
+module Awe
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+
+      desc "This generator installs AWE (Artefact Web Extensions) into the rails asset pipeline"
+      source_root File.expand_path('../../../../../vendor/assets/javascripts', __FILE__)
+
+      def copy_awe
+        say_status("copying", "awe-core", :green)
+        copy_file "awe-core.js", "public/javascripts/awe-core.js"
+        say_status("copying", "awe-state-machine", :green)
+        copy_file "awe-state-machine.js", "public/javascripts/awe-state-machine.js"
+      end
+
+    end
+  end
+end
+

data/spec/awe-rails_spec.rb

@@ -0,0 +1,5 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "AweRails" do
+  it "should probably test something but I am not sure what either"
+end

data/spec/lib/awe-rails_spec.rb

@@ -0,0 +1,3 @@
+require 'spec_helper'
+
+it "should probably test something, but I'm damned if I know what"

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+<<<<<<< HEAD
+<<<<<<< HEAD
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'awe-rails'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end
+=======
+=======
+>>>>>>> ccf863516cd6c75a59a22dde092099839482274b
+# Set up RSpec
+require 'webmock/rspec'
+
+Spec::Runner.configure do |config|
+  config.include WebMock::API
+end
+
+# Set up generator tests
+require 'rails/all'
+require 'rails/generators'
+require 'rails/generators/test_case'
+
+class TestApp < Rails::Application
+  config.root = File.dirname(__FILE__)
+end
+Rails.application = TestApp
+
+module Rails
+  def self.root
+    @root ||= File.expand_path("../../tmp/rails", __FILE__)
+  end
+end
+Rails.application.config.root = Rails.root
+
+# Call configure to load the settings from
+# Rails.application.config.generators to Rails::Generators
+Rails::Generators.configure!
+
+
+<<<<<<< HEAD
+>>>>>>> ccf863516cd6c75a59a22dde092099839482274b
+=======
+>>>>>>> ccf863516cd6c75a59a22dde092099839482274b

data/vendor/assets/javascripts/awe-core.js

@@ -0,0 +1,537 @@
+/*
+ * Artefact Web Extensions
+ *
+ * Copyright 2012, Artefact Group LLC
+ * Licensed under MIT.
+ */
+(function(global, document, namespace, undefined) {
+  namespace = namespace || "Awe";
+
+  // Create and export Awe
+  var Awe = {}
+
+  // Helpers
+  Awe.isArray = function(o) {
+    return o && o.constructor == Array.prototype.constructor;
+  }
+
+  Awe.isArrayOrString = function(o) {
+    return o && o.constructor == Array.prototype.constructor || o.constructor == String.prototype.constructor;
+  }
+
+  Awe.isType = function(o, type) {
+    return o && o.constructor == type.prototype.constructor;
+  }
+  
+  Awe.isFunction = function(o) {
+    return o && o.constructor == Function.prototype.constructor;
+  }
+
+  // Environment-specific vars
+  Awe.env = {};
+  Awe.env.inputTouch = "ontouchstart" in global;
+  Awe.env.inputMouse = !Awe.env.inputTouch;
+  
+  Awe.env.eventDragStart = Awe.env.inputTouch ? "touchstart" : "mousedown";
+  Awe.env.eventDragMove = Awe.env.inputTouch ? "touchmove" : "mousemove";
+  Awe.env.eventDragEnd = Awe.env.inputTouch ? "touchend" : "mouseup";
+  Awe.env.eventClick = Awe.env.inputTouch ? "touchend" : "click";
+  
+  // Clamp a number between min/max
+  Awe.clamp = function(n, min, max) {
+    return Math.min(Math.max(n, min), max);
+  }
+
+  // Clamp a number between -1 and 1 before passing to Math.acos to prevent an exception.
+  // Ensure that this makes sense for your parameters - it is assumed they will be close to
+  // the clamped range but allows computational errors to be safely ignored.
+  Awe.acosSafe = function(rad) {
+    return Math.acos(Awe.clamp(rad, -1, 1));
+  }
+
+  // Get a query string parameter value by name
+  Awe.getQueryParam = function(name, url) {
+    url = url || global.location.href;
+    name = name.replace(/[\[]/,"\\\[").replace(/[\]]/,"\\\]");
+    var regexS = "[\\?&]"+name+"=([^&#]*)";
+    var regex = new RegExp( regexS );
+    var results = regex.exec( url );
+    if (!results)
+      return "";
+    return results[1];
+  }
+
+  if (Array.prototype.forEach) {
+    Awe.forEach = function(array, callback, thisArg) {
+      array.forEach(callback, thisArg);
+    }
+  } else {
+    Awe.forEach = function(array, callback, thisArg) {
+      var length = array.length;
+      var i = 0;
+      while (i < length) {
+        callback.call(thisArg, array[i], i);
+        ++i;
+      }
+    }
+  }
+  
+  // Create an HTML element of the given type and attach to the given parent if not null.
+  // The config object can contain styles, attrs, a class and a background sprite to apply
+  // to the element
+  Awe.createElement = function(type, parent, config) {
+    var k;
+    var el = document.createElement(type);
+    config = config || {};
+    if (config.backgroundSprite) {
+      // TODO:
+      throw("TODO:");
+      //setBackgroundSprite(el, config.backgroundSprite);
+    }
+    for (k in (config.styles || {})) {
+      el.style[k] = config.styles[k];
+    }
+    for (k in (config.attrs || {})) {
+      el[k] = config.attrs[k];
+    }
+    for (k in (config.setAttrs || {})) {
+      el.setAttribute(k, config.setAttrs[k]);
+    }
+  
+    if (parent)
+      parent.appendChild(el);
+  
+    if (config.className)
+      el.className = config.className;
+      
+    return el;
+  }
+
+  /*
+   * method: Awe.enableDrag
+   * 
+   * purpose: enable drag on a DOM element
+   *
+   */
+   
+  Awe.enableDrag = function(el, config) {
+  
+    config = config || {};
+    var filters = config.filters;
+    var updater = config.updater || new Awe.DragUpdaterTopLeft();
+    
+    // Convert a single drag filter
+    if (filters) {
+      if (!Awe.isArray(filters)) {
+        filters = [filters];
+      }
+    } else {
+      filters = [];
+    }
+  
+    // Drag state
+    var touch = {};
+
+    function getClientPos(evt)
+    {
+      var p;
+      if (Awe.env.inputTouch)
+      {
+        // TODO: Use correct touch (lookup by touch start ID instead of always using index 0)
+        p = { x: evt.changedTouches[0].clientX, y: evt.changedTouches[0].clientY };
+      } else {
+        p = { x: evt.clientX, y: evt.clientY };
+      }
+      p.x += touch.anchor.x;
+      p.y += touch.anchor.y;
+      return p
+    }
+  
+    function processDrag(clientPos, pos, start) {
+      if (touch.now) {
+        touch.maxDistanceSquared = Math.max(touch.maxDistanceSquared, (touch.now.x - touch.start.x) * (touch.now.x - touch.start.x) + (touch.now.y - touch.start.y) * (touch.now.y - touch.start.y));
+      } else {
+        touch.maxDistanceSquared = 0;
+      }
+  
+      // Create the new drag state
+      var newDrag = {
+        clientPos: { x: clientPos.x, y: clientPos.y },
+        pos: { x: pos.x, y: pos.y },
+        dragTime: (Date.now() - touch.startTime) * 0.001,
+        maxDistanceSquared: touch.maxDistanceSquared
+      }
+      if (touch.lastDrag) {
+        newDrag.clientDelta = {
+          x: newDrag.clientPos.x - touch.lastDrag.clientPos.x,
+          y: newDrag.clientPos.y - touch.lastDrag.clientPos.y
+        }
+        newDrag.delta = {
+          x: newDrag.pos.x - touch.lastDrag.pos.x,
+          y: newDrag.pos.y - touch.lastDrag.pos.y
+        }
+      } else {
+        newDrag.clientDelta = { x: 0, y: 0 };
+        newDrag.delta = { x: 0, y: 0 };
+      }
+      
+      // Copy current drag state to last
+      touch.lastDrag = {
+        clientPos: { x: newDrag.clientPos.x, y: newDrag.clientPos.y },
+        pos: { x: newDrag.pos.x, y: newDrag.pos.y },
+        delta: { x: newDrag.delta.x, y: newDrag.delta.y },
+        clientDelta: { x: newDrag.clientDelta.x, y: newDrag.clientDelta.y },
+        dragTime: newDrag.dragTime,
+        maxDistanceSquared: newDrag.maxDistanceSquared
+      }
+      
+      return newDrag;
+    }
+    
+    function updateDrag() {
+      return touch.lastDrag && {
+        clientPos: touch.lastDrag.clientPos,
+        pos: touch.lastDrag.pos,
+        clientDelta: { x: 0, y: 0 },
+        delta: { x: 0, y: 0 },
+        dragTime: (Date.now() - touch.startTime) * 0.001,
+        maxDistanceSquared: touch.lastDrag.maxDistanceSquared
+      }
+    }
+    
+    // Per-frame updates
+    function dragUpdate(evt) {
+      var clientPos = touch.now || touch.start;
+      clientPos = { x: clientPos.x, y: clientPos.y };
+      var pos;
+      Awe.forEach(filters, function(filter) {
+        if (!pos && filter.animating) {
+          pos = filter.animate();
+        }
+      });
+      if (pos) {
+        updater.move(el, pos);
+        config.onChange(processDrag(clientPos, pos));
+      }
+      if (config.onUpdate) {
+        var drag = updateDrag();
+        drag && config.onUpdate(drag);
+      }
+    }
+      
+    function dragMove(evt) {
+      Awe.cancelEvent(evt);
+      touch.now = getClientPos(evt);
+      var pos = applyFilters(touch.now);
+      var drag = processDrag(touch.now, pos);
+      if (config.onChange) {
+        config.onChange(drag);
+      }
+    }
+    
+    function dragEnd(evt) {
+      if (!touch.dragging) {
+        return;
+      }
+      evt && Awe.cancelEvent(evt);
+      xRemoveEventListener(Awe.env.inputTouch ? el : document, Awe.env.eventDragMove, dragMove);
+      xRemoveEventListener(Awe.env.inputTouch ? el : document, Awe.env.eventDragEnd, dragEnd);
+      // TODO Check for animating filters before cancelling event bits
+      Awe.forEach(filters, function(filter) {
+        if (filter.end) {
+          filter.end();
+        }
+      });
+      if (updater.end) {
+        updater.end();
+      }
+      if (config.onRelease && evt) {
+        var pos = getClientPos(evt);
+        config.onRelease(processDrag(pos, pos));
+      }
+      if (touch.updateIntervalId) {
+        clearInterval(touch.updateIntervalId);
+        touch.updateIntervalId = null;
+      }
+    }
+    
+    function applyFilters(pos) {
+      Awe.forEach(filters, function(filter) {
+        pos = filter.move(el, pos) || pos;
+      });
+      return pos;
+    }
+    
+    function dragStart(evt) {
+      Awe.cancelEvent(evt);
+      touch.dragging = true;
+      touch.anchor = { x: 0, y: 0 }
+      // Calculate the position without the anchor
+      touch.now = getClientPos(evt);
+      // Calculate the anchor position
+      if (config.anchor) {
+        touch.anchor = config.anchor.getAnchor(el, touch.now);
+        // Get the client position again, taking the anchor into account
+        touch.now = getClientPos(evt);
+      }
+      touch.lastDrag = null;
+      touch.start = getClientPos(evt);
+      touch.startTime = Date.now();
+      touch.maxDistanceSquared = 0;
+      
+      var pos = touch.start;
+      Awe.forEach(filters, function(filter) {
+        pos = filter.start(el, pos) || pos;
+      });
+      if (updater.start) {
+        updater.start(el, pos);
+      }
+  
+      var pos = applyFilters(touch.now);
+      
+      var drag = processDrag(touch.now, pos);
+      xAddEventListener(Awe.env.inputTouch ? el : document, Awe.env.eventDragMove, dragMove);
+      xAddEventListener(Awe.env.inputTouch ? el : document, Awe.env.eventDragEnd, dragEnd);
+      if (config.onUpdate) {
+        touch.updateIntervalId = setInterval(dragUpdate, config.dragUpdateInterval || 33);
+      }
+    }
+    
+    xAddEventListener(el, Awe.env.eventDragStart, dragStart);
+    
+    el._disableDrag = function() {
+      xRemoveEventListener(el, Awe.env.eventDragStart, dragStart);
+      // Make sure any in-progress drags have their listeners removed
+      dragEnd();
+    }
+  }
+  
+  /*
+   * method: Awe.disableDrag
+   * 
+   * purpose: disable drag on a DOM element
+   *
+   */
+  Awe.disableDrag = function(el) {
+    if (el._disableDrag) {
+      el._disableDrag();
+      el._disableDrag = null;
+    }
+  }
+  
+  Awe.DragAnchorTopLeft = function() {
+    var _i = this;
+    
+    _i.getAnchor = function(el, pos) {
+      return { x: xLeft(el) - pos.x, y: xTop(el) - pos.y }
+    }
+  }
+  
+  Awe.DragFilterLimitAxes = function(minX, maxX, minY, maxY) {
+    var _i = this;
+    
+    _i.start = function(el, pos) {
+    }
+    
+    _i.move = function(el, pos) {
+      var x = Awe.clamp(pos.x, minX, maxX);
+      var y = Awe.clamp(pos.y, minY, maxY);
+      return { x: x, y: y };
+    }
+  }
+  
+  // To be continued...
+  /*
+  Awe.DragFilterMomentum = function() {
+    var _i = this;
+    
+    _i.start = function(el, pos) {
+    }
+    
+    _i.move = function(el, pos) {
+      _i.animating = true;
+      return { x: x, y: y };
+    }
+    
+    _i.animate = function() {
+      // Apply velocity and acceleration
+      if (vel == 0) {
+        _i.animating = false;
+    }
+  }
+  */
+  
+  Awe.DragUpdaterTopLeft = function() {
+    var _i = this;
+    
+    _i.start = function(el, pos) {
+    }
+    
+    _i.move = function(el, pos) {
+      var left = pos.x;
+      var top = pos.y;
+      el.style.left = left + "px";
+      el.style.top = top + "px";
+      
+      return pos;
+    }
+  }
+
+  /*
+   * method: Awe.objectToString
+   * 
+   * purpose: convert an arbitrary object to string representation for logging
+   *
+   */
+  Awe.objectToString = function(o) {
+    // Do something more interesting in the future?
+    return JSON.stringify(o);
+  }
+
+  var requestAnimationFrameShim = (function() {
+    return  global.requestAnimationFrame       ||
+            global.webkitRequestAnimationFrame || 
+            global.mozRequestAnimationFrame    || 
+            global.oRequestAnimationFrame      || 
+            global.msRequestAnimationFrame     || 
+            function( callback ){
+              global.setTimeout(callback, 1000 / 60);
+            };
+  })();
+  
+  // Specify a callback
+  Awe.addAnimationCallback = function(callback, interval) {
+    var startTime = Date.now();
+    var lastTime = startTime;
+    if (interval === undefined) {
+      requestAnimationFrameShim(function wrapper() {
+        time = Date.now();
+        if (!callback(time - lastTime, time - startTime)) {
+          requestAnimationFrameShim(wrapper);
+        }
+        lastTime = time;
+      })
+    } else {
+      var intervalId = setInterval(function () {
+        time = Date.now();
+        if (callback(time - lastTime, time - startTime)) {
+          clearInterval(intervalId);
+        }
+        lastTime = time;
+      }, interval);
+    }
+  }
+
+  // Cancels an event to stop propogation. Use this to swallow events in listeners.
+  Awe.cancelEvent = function(e) {
+    if (e == null) {
+      e = global.event;
+    }
+  
+    if (!e) {
+      return;
+    }
+  
+    if (!global.attachEvent) {
+
+      if (e.stopPropagation) {
+        e.stopPropagation();
+      }
+      e.preventDefault();    
+      return false
+    }
+    
+    e.cancelBubble = true;
+    e.returnValue = false;
+    
+    return false;
+  }
+
+  var _nextGuid = 0;
+  
+  // Returns a string unique to this session
+  Awe.getGuid = function() {
+    return "_guid_" + ++_nextGuid;
+  }
+  
+  // Returns a unique positive integral number > 0
+  Awe.getGuidNumeric = function() {
+    return ++_nextGuid;
+  }
+
+  // Classes
+  var hexToInt = {
+    "0":0,
+    "1":1,
+    "2":2,
+    "3":3,
+    "4":4,
+    "5":5,
+    "6":6,
+    "7":7,
+    "8":8,
+    "9":9,
+    "a":10,"A":10,
+    "b":11,"B":11,
+    "c":12,"C":12,
+    "d":13,"D":13,
+    "e":14,"E":14,
+    "f":15,"F":15,
+  }
+  
+  // Color class parses CSS color specs in different formats ("#rrggbb", "rgb(r, g, b)" or "rgba(r, g, b, a)") and provides
+  // accessors to r/g/b/a components and CSS color strings.
+  Awe.Color = function(color) {
+    var _i = this;
+    
+    _i.toHex = function() {
+      return _i.hex;
+    }
+  
+    _i.toRGBA = function(alpha) {
+      if (alpha == undefined) {
+        alpha = _i.a;
+      }
+      return "rgba("+_i.r+","+_i.g+","+_i.b+","+alpha+")";
+    }
+  
+    _i.toRGB = function() {
+      return "rgba("+_i.r+","+_i.g+","+_i.b+")";
+    }
+        
+    if (color[0] == "#") {
+      _i.hex = color;
+      _i.r = (hexToInt[color[1]] << 4) + hexToInt[color[2]];
+      _i.g = (hexToInt[color[3]] << 4) + hexToInt[color[4]];
+      _i.b = (hexToInt[color[5]] << 4) + hexToInt[color[6]];
+      _i.a = 1;
+    } else {
+      if (color.indexOf('rgb(') == 0) {
+        color = color.substring(4,color.length-1);
+      } else if (color.indexOf('rgba(') == 0) {
+        color = color.substring(5,color.length-1);
+      }
+      var i;
+      _i.r = parseInt(color);
+      color = color.substring(color.indexOf(',')+1);
+      _i.g = parseInt(color);
+      color = color.substring(color.indexOf(',')+1);
+      _i.b = parseInt(color);
+      color = color.substring(color.indexOf(',')+1);
+      if (color) {
+        _i.a = parseFloat(color);
+      } else {
+        _i.a = 1;
+      }
+    }
+  }
+
+  // Allow the script URL to override the namespace, naming the library Monkey instead of Awe etc
+  // NOTE: This is not likely to ever be necessary, but it's an interesting theoretical exercise
+  var scripts = document.getElementsByTagName('script');
+  var scriptUrl = scripts && scripts.length && scripts[scripts.length - 1].src;
+  var overrideNamespace = scriptUrl && Awe.getQueryParam("namespace", scriptUrl);
+
+  global[overrideNamespace || namespace] = Awe;
+
+})(this, document)

data/vendor/assets/javascripts/awe-state-machine.js

@@ -0,0 +1,128 @@
+/*
+ * Artefact Web Extensions
+ *
+ * Copyright 2012, Artefact Group LLC
+ * Licensed under MIT.
+ */
+(function(Awe, global, document, undefined) {
+
+  // State contains any of:
+  //  allowOnly - array with 0 or more states (or null)
+  //  doNotAllow - array with 1 or more states (or null)
+  //  start function (or null)
+  //  update function (or null)
+  //  end function (or null)
+  
+  var StateMachine = Awe.StateMachine = function(name, stateMap, initialStateId) {
+    var _i = this;
+    
+    StateMachine.stateMachines.push(_i);
+  
+    _i.name = name;
+    _i.states = stateMap || [];
+    _i.currentStateId = null;
+      
+    _i.addState = function(id, state) {
+      if (_i.states[id]) {
+        throw "Duplicate state added!";
+      }
+      _i.states[id] = state;
+    }
+    
+    _i.getCurrentStateId = function() {
+      return _i.currentStateId;
+    }
+  
+    // Request a state that is assumed to be a transitional state and call the supplied callback on completion.
+    // The callback will not be called if the transition state is interrupted, but you can prevent this by making
+    // the transition state uninterruptable: pass an empty array in the transition states allowOnly field, which will
+    // disallow any transitions while the state is active. The transitionCompleteCallback should then change state
+    // once the transition is complete.
+    _i.requestTransitionState = function(id) {
+      
+      if (typeof(arguments[arguments.length - 1]) != "function") {
+        throw "Last argument of StateMachine.requestTransitionState must be an on-complete callback"
+      }
+      
+      if (_i.requestState.apply(_i, arguments)) {
+        _i.transitionCompleteCallback = arguments[arguments.length - 1];
+  
+        if (!_i.states[_i.currentStateId].update) {
+          throw "ERROR: Transition states must have an update method, otherwise they will never be able to complete.";
+        }
+        return true;
+      }
+      
+      // Remove the transition complete callback if the switch to the transition state was refused.
+      _i.transitionCompleteCallback = null;
+      return false;
+    }
+    
+    // Request a change to the supplied state. If a current state exists that will be checked for any conditions that
+    // disallow transition to the new state.
+    _i.requestState = function(id) {
+      
+      var nextState = id && _i.states[id];
+      
+      if (id && !nextState) {
+        return false;
+      }
+      
+      if (_i.currentStateId) {
+        var currentState = _i.states[_i.currentStateId];
+        
+        if (!_i.currentStateDone && currentState.allowOnly && !currentState.allowOnly.indexOf(id)) {
+          return false;
+        }
+        if (!_i.currentStateDone && currentState.doNotAllow && currentState.doNotAllow.indexOf(id)) {
+          return false;
+        }
+        
+        if (currentState.end) {
+          currentState.end.call(currentState, id);
+        }
+      }
+      
+      if (nextState) {
+        nextState._startTime = Date.now();
+        nextState.runTime = 0;
+        if (nextState.start) {
+          nextState.start.apply(nextState, [_i.currentState && _i.currentState.id].concat(Array.prototype.slice.call(arguments,1)));
+        }
+      }
+      
+      _i.currentStateId = id;
+      
+      return true;
+    }
+    
+    _i.update = function() {
+      var currentState = _i.states[_i.currentStateId];
+      currentState.runTime = (Date.now() - currentState._startTime) * 0.001;
+      if (currentState && currentState.update) {
+        // Update the current state and if it's a transition state, call the transition state callback once the
+        // transition state's update returns true to signify completion
+        if (currentState.update.call(currentState) && _i.transitionCompleteCallback) {
+          var callback = _i.transitionCompleteCallback;
+          _i.transitionCompleteCallback = null;
+          _i.currentStateDone = true;
+          callback();
+          _i.currentStateDone = false;
+        }
+      }
+    }
+      
+    if (initialStateId) {
+      _i.requestState(initialStateId);
+    }
+  
+    return _i;
+  }
+  
+  StateMachine.stateMachines = []
+  StateMachine.update = function() {
+    for (var i = 0; i < StateMachine.stateMachines.length; ++i) {
+      StateMachine.stateMachines[i].update();
+    }
+  }
+})(Awe, this, document)

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification
+name: awe-rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Shyam Habarakada
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70279789265900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70279789265900
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70279789265020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *70279789265020
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &70279789264460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: *70279789264460
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70279789263860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70279789263860
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70279789263300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *70279789263300
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70279789262680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70279789262680
+description: Modeled after the jquery-rails gem. Installs the AWE files into the rails
+  3.1 asset pipeline
+email: shyam.habarakada@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- awe-rails-1.0.17.gem
+- awe-rails.gemspec
+- lib/awe-rails.rb
+- lib/awe/rails.rb
+- lib/awe/rails/engine.rb
+- lib/generators/awe/install/install_generator.rb
+- spec/awe-rails_spec.rb
+- spec/lib/awe-rails_spec.rb
+- spec/spec_helper.rb
+- vendor/assets/javascripts/awe-core.js
+- vendor/assets/javascripts/awe-state-machine.js
+homepage: http://www.artefactgroup.com
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4385544839732221746
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Gem for integrating AWE into the rails asset pipeline
+test_files: []