active-model-adapter-source 0.1.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YzUwYzQ2MjM4ZmZhNzlhNzNlNmNjOTEyZTQ2Yjg0ZmRlNGRmZGRkNQ==
+  data.tar.gz: !binary |-
+    ZTdjZDlmOWFhZWM3YTg0NGYxYzA2MjkzN2JmZTQ2NWQ3OWE0NjlhZQ==
+SHA512:
+  metadata.gz: !binary |-
+    MjJlNmU4MDBkMWEyM2U1Y2RmZmU2YzE2NTliNjFjY2QzNWU1NzFhYTA1ZDQz
+    N2Y5MTkyMzJiODQxYWQ5MjdmZTk3YzhiYWM4NWRmYzRjYzEyZTFkZjA5ODk4
+    YzkzNzg2ZTM3ZDM2NGI4OGNkYjg0Y2JjNDQxMzdkNzdhMzU0NjQ=
+  data.tar.gz: !binary |-
+    ZTAwMTg3ODRlNTA4Nzk1Y2ZhYTc4YmVlM2E0NDk1OWYxYWRjYjc0Nzg5MGU4
+    YzNhZDhlNGE5NmU4YzQxOTNlMTJmODk3Yjg0NzhiYmY4YmQ1MGE3ZTE2Y2Rl
+    YTM4NGRkNGRjZGI4ZmU2YmFmNDEwMDlkMjM3Y2E2N2EzMzIzOTc=

data/dist/active-model-adapter.js

@@ -0,0 +1,718 @@
+/*!
+ * @overview  ActiveModelAdapter
+ * @copyright Copyright 2011-2015 Tilde Inc. and contributors
+ *            Portions Copyright 2006-2011 Strobe Inc.
+ *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
+ * @license   Licensed under MIT license
+ *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
+ * @version   0.1.3
+ */
+
+(function() {
+
+var define, requireModule, require, requirejs;
+
+(function() {
+
+  var _isArray;
+  if (!Array.isArray) {
+    _isArray = function (x) {
+      return Object.prototype.toString.call(x) === "[object Array]";
+    };
+  } else {
+    _isArray = Array.isArray;
+  }
+
+  var registry = {}, seen = {};
+  var FAILED = false;
+
+  var uuid = 0;
+
+  function tryFinally(tryable, finalizer) {
+    try {
+      return tryable();
+    } finally {
+      finalizer();
+    }
+  }
+
+  function unsupportedModule(length) {
+    throw new Error("an unsupported module was defined, expected `define(name, deps, module)` instead got: `" + length + "` arguments to define`");
+  }
+
+  var defaultDeps = ['require', 'exports', 'module'];
+
+  function Module(name, deps, callback, exports) {
+    this.id       = uuid++;
+    this.name     = name;
+    this.deps     = !deps.length && callback.length ? defaultDeps : deps;
+    this.exports  = exports || { };
+    this.callback = callback;
+    this.state    = undefined;
+    this._require  = undefined;
+  }
+
+
+  Module.prototype.makeRequire = function() {
+    var name = this.name;
+
+    return this._require || (this._require = function(dep) {
+      return require(resolve(dep, name));
+    });
+  }
+
+  define = function(name, deps, callback) {
+    if (arguments.length < 2) {
+      unsupportedModule(arguments.length);
+    }
+
+    if (!_isArray(deps)) {
+      callback = deps;
+      deps     =  [];
+    }
+
+    registry[name] = new Module(name, deps, callback);
+  };
+
+  // we don't support all of AMD
+  // define.amd = {};
+  // we will support petals...
+  define.petal = { };
+
+  function Alias(path) {
+    this.name = path;
+  }
+
+  define.alias = function(path) {
+    return new Alias(path);
+  };
+
+  function reify(mod, name, seen) {
+    var deps = mod.deps;
+    var length = deps.length;
+    var reified = new Array(length);
+    var dep;
+    // TODO: new Module
+    // TODO: seen refactor
+    var module = { };
+
+    for (var i = 0, l = length; i < l; i++) {
+      dep = deps[i];
+      if (dep === 'exports') {
+        module.exports = reified[i] = seen;
+      } else if (dep === 'require') {
+        reified[i] = mod.makeRequire();
+      } else if (dep === 'module') {
+        mod.exports = seen;
+        module = reified[i] = mod;
+      } else {
+        reified[i] = requireFrom(resolve(dep, name), name);
+      }
+    }
+
+    return {
+      deps: reified,
+      module: module
+    };
+  }
+
+  function requireFrom(name, origin) {
+    var mod = registry[name];
+    if (!mod) {
+      throw new Error('Could not find module `' + name + '` imported from `' + origin + '`');
+    }
+    return require(name);
+  }
+
+  function missingModule(name) {
+    throw new Error('Could not find module ' + name);
+  }
+  requirejs = require = requireModule = function(name) {
+    var mod = registry[name];
+
+
+    if (mod && mod.callback instanceof Alias) {
+      mod = registry[mod.callback.name];
+    }
+
+    if (!mod) { missingModule(name); }
+
+    if (mod.state !== FAILED &&
+        seen.hasOwnProperty(name)) {
+      return seen[name];
+    }
+
+    var reified;
+    var module;
+    var loaded = false;
+
+    seen[name] = { }; // placeholder for run-time cycles
+
+    tryFinally(function() {
+      reified = reify(mod, name, seen[name]);
+      module = mod.callback.apply(this, reified.deps);
+      loaded = true;
+    }, function() {
+      if (!loaded) {
+        mod.state = FAILED;
+      }
+    });
+
+    var obj;
+    if (module === undefined && reified.module.exports) {
+      obj = reified.module.exports;
+    } else {
+      obj = seen[name] = module;
+    }
+
+    if (obj !== null &&
+        (typeof obj === 'object' || typeof obj === 'function') &&
+          obj['default'] === undefined) {
+      obj['default'] = obj;
+    }
+
+    return (seen[name] = obj);
+  };
+
+  function resolve(child, name) {
+    if (child.charAt(0) !== '.') { return child; }
+
+    var parts = child.split('/');
+    var nameParts = name.split('/');
+    var parentBase = nameParts.slice(0, -1);
+
+    for (var i = 0, l = parts.length; i < l; i++) {
+      var part = parts[i];
+
+      if (part === '..') {
+        if (parentBase.length === 0) {
+          throw new Error('Cannot access parent module of root');
+        }
+        parentBase.pop();
+      } else if (part === '.') { continue; }
+      else { parentBase.push(part); }
+    }
+
+    return parentBase.join('/');
+  }
+
+  requirejs.entries = requirejs._eak_seen = registry;
+  requirejs.clear = function(){
+    requirejs.entries = requirejs._eak_seen = registry = {};
+    seen = state = {};
+  };
+})();
+
+define("ember", ["exports"], function (exports) {
+  exports["default"] = Ember;
+});
+define("ember-data", ["exports"], function (exports) {
+  exports["default"] = DS;
+});
+define('active-model-adapter', ['exports', 'ember', 'ember-data'], function (exports, _ember, _emberData) {
+
+  /**
+    @module active-model-adapter
+  */
+
+  var decamelize = _ember["default"].String.decamelize;
+  var underscore = _ember["default"].String.underscore;
+  var pluralize = _ember["default"].String.pluralize;
+  var RESTAdapter = _emberData["default"].RESTAdapter;
+  var InvalidError = _emberData["default"].InvalidError;
+
+  /**
+    The ActiveModelAdapter is a subclass of the RESTAdapter designed to integrate
+    with a JSON API that uses an underscored naming convention instead of camelCasing.
+    It has been designed to work out of the box with the
+    [active\_model\_serializers](http://github.com/rails-api/active_model_serializers)
+    Ruby gem. This Adapter expects specific settings using ActiveModel::Serializers,
+    `embed :ids, embed_in_root: true` which sideloads the records.
+  
+    This adapter extends the DS.RESTAdapter by making consistent use of the camelization,
+    decamelization and pluralization methods to normalize the serialized JSON into a
+    format that is compatible with a conventional Rails backend and Ember Data.
+  
+    ## JSON Structure
+  
+    The ActiveModelAdapter expects the JSON returned from your server to follow
+    the REST adapter conventions substituting underscored keys for camelcased ones.
+  
+    Unlike the DS.RESTAdapter, async relationship keys must be the singular form
+    of the relationship name, followed by "_id" for DS.belongsTo relationships,
+    or "_ids" for DS.hasMany relationships.
+  
+    ### Conventional Names
+  
+    Attribute names in your JSON payload should be the underscored versions of
+    the attributes in your Ember.js models.
+  
+    For example, if you have a `Person` model:
+  
+    ```js
+    App.FamousPerson = DS.Model.extend({
+      firstName: DS.attr('string'),
+      lastName: DS.attr('string'),
+      occupation: DS.attr('string')
+    });
+    ```
+  
+    The JSON returned should look like this:
+  
+    ```js
+    {
+      "famous_person": {
+        "id": 1,
+        "first_name": "Barack",
+        "last_name": "Obama",
+        "occupation": "President"
+      }
+    }
+    ```
+  
+    Let's imagine that `Occupation` is just another model:
+  
+    ```js
+    App.Person = DS.Model.extend({
+      firstName: DS.attr('string'),
+      lastName: DS.attr('string'),
+      occupation: DS.belongsTo('occupation')
+    });
+  
+    App.Occupation = DS.Model.extend({
+      name: DS.attr('string'),
+      salary: DS.attr('number'),
+      people: DS.hasMany('person')
+    });
+    ```
+  
+    The JSON needed to avoid extra server calls, should look like this:
+  
+    ```js
+    {
+      "people": [{
+        "id": 1,
+        "first_name": "Barack",
+        "last_name": "Obama",
+        "occupation_id": 1
+      }],
+  
+      "occupations": [{
+        "id": 1,
+        "name": "President",
+        "salary": 100000,
+        "person_ids": [1]
+      }]
+    }
+    ```
+  
+    @class ActiveModelAdapter
+    @constructor
+    @namespace DS
+    @extends DS.RESTAdapter
+  **/
+
+  var ActiveModelAdapter = RESTAdapter.extend({
+    defaultSerializer: '-active-model',
+    /**
+      The ActiveModelAdapter overrides the `pathForType` method to build
+      underscored URLs by decamelizing and pluralizing the object type name.
+       ```js
+        this.pathForType("famousPerson");
+        //=> "famous_people"
+      ```
+       @method pathForType
+      @param {String} modelName
+      @return String
+    */
+    pathForType: function (modelName) {
+      var decamelized = decamelize(modelName);
+      var underscored = underscore(decamelized);
+      return pluralize(underscored);
+    },
+
+    /**
+      The ActiveModelAdapter overrides the `ajaxError` method
+      to return a DS.InvalidError for all 422 Unprocessable Entity
+      responses.
+       A 422 HTTP response from the server generally implies that the request
+      was well formed but the API was unable to process it because the
+      content was not semantically correct or meaningful per the API.
+       For more information on 422 HTTP Error code see 11.2 WebDAV RFC 4918
+      https://tools.ietf.org/html/rfc4918#section-11.2
+       @method ajaxError
+      @param {Object} jqXHR
+      @return error
+    */
+    ajaxError: function (jqXHR) {
+      var error = this._super.apply(this, arguments);
+
+      if (jqXHR && jqXHR.status === 422) {
+        var response = _ember["default"].$.parseJSON(jqXHR.responseText);
+        return new InvalidError(response);
+      } else {
+        return error;
+      }
+    }
+  });
+
+  exports["default"] = ActiveModelAdapter;
+});
+define('active-model-serializer', ['exports', 'ember', 'ember-data'], function (exports, _ember, _emberData) {
+  var forEach = _ember["default"].EnumerableUtils.forEach;
+  var _Ember$String = _ember["default"].String;
+  var singularize = _Ember$String.singularize;
+  var camelize = _Ember$String.camelize;
+  var classify = _Ember$String.classify;
+  var decamelize = _Ember$String.decamelize;
+  var underscore = _Ember$String.underscore;
+  var RESTSerializer = _emberData["default"].RESTSerializer;
+
+  /**
+    The ActiveModelSerializer is a subclass of the RESTSerializer designed to integrate
+    with a JSON API that uses an underscored naming convention instead of camelCasing.
+    It has been designed to work out of the box with the
+    [active\_model\_serializers](http://github.com/rails-api/active_model_serializers)
+    Ruby gem. This Serializer expects specific settings using ActiveModel::Serializers,
+    `embed :ids, embed_in_root: true` which sideloads the records.
+  
+    This serializer extends the DS.RESTSerializer by making consistent
+    use of the camelization, decamelization and pluralization methods to
+    normalize the serialized JSON into a format that is compatible with
+    a conventional Rails backend and Ember Data.
+  
+    ## JSON Structure
+  
+    The ActiveModelSerializer expects the JSON returned from your server
+    to follow the REST adapter conventions substituting underscored keys
+    for camelcased ones.
+  
+    ### Conventional Names
+  
+    Attribute names in your JSON payload should be the underscored versions of
+    the attributes in your Ember.js models.
+  
+    For example, if you have a `Person` model:
+  
+    ```js
+    App.FamousPerson = DS.Model.extend({
+      firstName: DS.attr('string'),
+      lastName: DS.attr('string'),
+      occupation: DS.attr('string')
+    });
+    ```
+  
+    The JSON returned should look like this:
+  
+    ```js
+    {
+      "famous_person": {
+        "id": 1,
+        "first_name": "Barack",
+        "last_name": "Obama",
+        "occupation": "President"
+      }
+    }
+    ```
+  
+    Let's imagine that `Occupation` is just another model:
+  
+    ```js
+    App.Person = DS.Model.extend({
+      firstName: DS.attr('string'),
+      lastName: DS.attr('string'),
+      occupation: DS.belongsTo('occupation')
+    });
+  
+    App.Occupation = DS.Model.extend({
+      name: DS.attr('string'),
+      salary: DS.attr('number'),
+      people: DS.hasMany('person')
+    });
+    ```
+  
+    The JSON needed to avoid extra server calls, should look like this:
+  
+    ```js
+    {
+      "people": [{
+        "id": 1,
+        "first_name": "Barack",
+        "last_name": "Obama",
+        "occupation_id": 1
+      }],
+  
+      "occupations": [{
+        "id": 1,
+        "name": "President",
+        "salary": 100000,
+        "person_ids": [1]
+      }]
+    }
+    ```
+  
+    @class ActiveModelSerializer
+    @namespace DS
+    @extends DS.RESTSerializer
+  */
+  var ActiveModelSerializer = RESTSerializer.extend({
+    // SERIALIZE
+
+    /**
+      Converts camelCased attributes to underscored when serializing.
+       @method keyForAttribute
+      @param {String} attribute
+      @return String
+    */
+    keyForAttribute: function (attr) {
+      return decamelize(attr);
+    },
+
+    /**
+      Underscores relationship names and appends "_id" or "_ids" when serializing
+      relationship keys.
+       @method keyForRelationship
+      @param {String} relationshipModelName
+      @param {String} kind
+      @return String
+    */
+    keyForRelationship: function (relationshipModelName, kind) {
+      var key = decamelize(relationshipModelName);
+      if (kind === 'belongsTo') {
+        return key + '_id';
+      } else if (kind === 'hasMany') {
+        return singularize(key) + '_ids';
+      } else {
+        return key;
+      }
+    },
+
+    /**
+     `keyForLink` can be used to define a custom key when deserializing link
+     properties. The `ActiveModelSerializer` camelizes link keys by default.
+      @method keyForLink
+     @param {String} key
+     @param {String} kind `belongsTo` or `hasMany`
+     @return {String} normalized key
+    */
+    keyForLink: function (key, relationshipKind) {
+      return camelize(key);
+    },
+
+    /*
+      Does not serialize hasMany relationships by default.
+    */
+    serializeHasMany: _ember["default"].K,
+
+    /**
+     Underscores the JSON root keys when serializing.
+       @method payloadKeyFromModelName
+      @param {String} modelName
+      @return {String}
+    */
+    payloadKeyFromModelName: function (modelName) {
+      return underscore(decamelize(modelName));
+    },
+
+    /**
+      Serializes a polymorphic type as a fully capitalized model name.
+       @method serializePolymorphicType
+      @param {DS.Snapshot} snapshot
+      @param {Object} json
+      @param {Object} relationship
+    */
+    serializePolymorphicType: function (snapshot, json, relationship) {
+      var key = relationship.key;
+      var belongsTo = snapshot.belongsTo(key);
+      var jsonKey = underscore(key + '_type');
+
+      if (_ember["default"].isNone(belongsTo)) {
+        json[jsonKey] = null;
+      } else {
+        json[jsonKey] = classify(belongsTo.modelName).replace(/(\/)([a-z])/g, function (match, separator, chr) {
+          return match.toUpperCase();
+        }).replace('/', '::');
+      }
+    },
+
+    // EXTRACT
+
+    /**
+      Add extra step to `DS.RESTSerializer.normalize` so links are normalized.
+       If your payload looks like:
+       ```js
+      {
+        "post": {
+          "id": 1,
+          "title": "Rails is omakase",
+          "links": { "flagged_comments": "api/comments/flagged" }
+        }
+      }
+      ```
+       The normalized version would look like this
+       ```js
+      {
+        "post": {
+          "id": 1,
+          "title": "Rails is omakase",
+          "links": { "flaggedComments": "api/comments/flagged" }
+        }
+      }
+      ```
+       @method normalize
+      @param {subclass of DS.Model} typeClass
+      @param {Object} hash
+      @param {String} prop
+      @return Object
+    */
+    normalize: function (typeClass, hash, prop) {
+      this.normalizeLinks(hash);
+      return this._super(typeClass, hash, prop);
+    },
+
+    /**
+      Convert `snake_cased` links  to `camelCase`
+       @method normalizeLinks
+      @param {Object} data
+    */
+
+    normalizeLinks: function (data) {
+      if (data.links) {
+        var links = data.links;
+
+        for (var link in links) {
+          var camelizedLink = camelize(link);
+
+          if (camelizedLink !== link) {
+            links[camelizedLink] = links[link];
+            delete links[link];
+          }
+        }
+      }
+    },
+
+    /**
+      Normalize the polymorphic type from the JSON.
+       Normalize:
+      ```js
+        {
+          id: "1"
+          minion: { type: "evil_minion", id: "12"}
+        }
+      ```
+       To:
+      ```js
+        {
+          id: "1"
+          minion: { type: "evilMinion", id: "12"}
+        }
+      ```
+       @param {Subclass of DS.Model} typeClass
+      @method normalizeRelationships
+      @private
+    */
+    normalizeRelationships: function (typeClass, hash) {
+
+      if (this.keyForRelationship) {
+        typeClass.eachRelationship(function (key, relationship) {
+          var payloadKey, payload;
+          if (relationship.options.polymorphic) {
+            payloadKey = this.keyForAttribute(key, 'deserialize');
+            payload = hash[payloadKey];
+            if (payload && payload.type) {
+              payload.type = this.modelNameFromPayloadKey(payload.type);
+            } else if (payload && relationship.kind === 'hasMany') {
+              var self = this;
+              forEach(payload, function (single) {
+                single.type = self.modelNameFromPayloadKey(single.type);
+              });
+            }
+          } else {
+            payloadKey = this.keyForRelationship(key, relationship.kind, 'deserialize');
+            if (!hash.hasOwnProperty(payloadKey)) {
+              return;
+            }
+            payload = hash[payloadKey];
+          }
+
+          hash[key] = payload;
+
+          if (key !== payloadKey) {
+            delete hash[payloadKey];
+          }
+        }, this);
+      }
+    },
+    modelNameFromPayloadKey: function (key) {
+      var convertedFromRubyModule = camelize(singularize(key)).replace(/(^|\:)([A-Z])/g, function (match, separator, chr) {
+        return match.toLowerCase();
+      }).replace('::', '/');
+      return this._super(convertedFromRubyModule);
+    }
+  });
+
+  exports["default"] = ActiveModelSerializer;
+});
+/**
+  @module active-model-adapter
+*/
+define('index', ['exports', './active-model-adapter', './active-model-serializer'], function (exports, _activeModelAdapter, _activeModelSerializer) {
+  exports["default"] = _activeModelAdapter["default"];
+  exports.ActiveModelAdapter = _activeModelAdapter["default"];
+  exports.ActiveModelSerializer = _activeModelSerializer["default"];
+});
+define("initializers/active-model-adapter", ["exports", "active-model-adapter", "active-model-serializer"], function (exports, _activeModelAdapter, _activeModelAdapterActiveModelSerializer) {
+  exports["default"] = {
+    name: "active-model-adapter",
+    initialize: function (registry, application) {
+      registry.register("adapter:-active-model", _activeModelAdapter["default"]);
+      registry.register("serializer:-active-model", _activeModelAdapterActiveModelSerializer["default"]);
+    }
+  };
+});
+define('instance-initializers/active-model-adapter', ['exports', 'active-model-adapter', 'active-model-serializer'], function (exports, _activeModelAdapter, _activeModelAdapterActiveModelSerializer) {
+  exports["default"] = {
+    name: 'active-model-adapter',
+    initialize: function (applicationOrRegistry) {
+      var registry, container;
+      if (applicationOrRegistry.registry && applicationOrRegistry.container) {
+        // initializeStoreService was registered with an
+        // instanceInitializer. The first argument is the application
+        // instance.
+        registry = applicationOrRegistry.registry;
+        container = applicationOrRegistry.container;
+      } else {
+        // initializeStoreService was called by an initializer instead of
+        // an instanceInitializer. The first argument is a registy. This
+        // case allows ED to support Ember pre 1.12
+        registry = applicationOrRegistry;
+        if (registry.container) {
+          // Support Ember 1.10 - 1.11
+          container = registry.container();
+        } else {
+          // Support Ember 1.9
+          container = registry;
+        }
+      }
+
+      registry.register('adapter:-active-model', _activeModelAdapter["default"]);
+      registry.register('serializer:-active-model', _activeModelAdapterActiveModelSerializer["default"]);
+    }
+  };
+});
+define('globals', ['exports', './index', 'instance-initializers/active-model-adapter', 'initializers/active-model-adapter', 'ember', 'ember-data'], function (exports, _index, _instanceInitializersActiveModelAdapter, _initializersActiveModelAdapter, _ember, _emberData) {
+
+  _emberData["default"].ActiveModelAdapter = _index.ActiveModelAdapter;
+  _emberData["default"].ActiveModelSerializer = _index.ActiveModelSerializer;
+
+  if (_ember["default"].Application.instanceInitializer) {
+    _ember["default"].Application.instanceInitializer(_instanceInitializersActiveModelAdapter["default"]);
+  } else {
+    _ember["default"].Application.initializer(_initializersActiveModelAdapter["default"]);
+  }
+});
+// this file is used to generate the globals build.
+// DO NOT try to use this in your app.
+
+require("globals");
+})();

data/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "active-model-adapter",
+  "version": "0.1.3",
+  "repository": "https://github.com/ember-data/active-model-adapter.git",
+  "description": "The default blueprint for ember-cli addons.",
+  "directories": {
+    "doc": "doc",
+    "test": "tests"
+  },
+  "scripts": {
+    "start": "ember server",
+    "build": "ember build",
+    "test": "ember try:testall"
+  },
+  "repository": "",
+  "engines": {
+    "node": ">= 0.10.0"
+  },
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "broccoli-asset-rev": "^2.0.2",
+    "broccoli-babel-transpiler": "^5.1.1",
+    "broccoli-concat": "0.0.13",
+    "broccoli-es3-safe-recast": "^2.0.0",
+    "broccoli-funnel": "^0.2.3",
+    "broccoli-merge-trees": "^0.2.1",
+    "broccoli-stew": "^0.3.2",
+    "ember-cli": "0.2.7",
+    "ember-cli-app-version": "0.3.3",
+    "ember-cli-content-security-policy": "0.4.0",
+    "ember-cli-dependency-checker": "^1.0.0",
+    "ember-cli-htmlbars": "0.7.6",
+    "ember-cli-ic-ajax": "0.1.1",
+    "ember-cli-inject-live-reload": "^1.3.0",
+    "ember-cli-qunit": "0.3.13",
+    "ember-cli-uglify": "^1.0.1",
+    "ember-data": "1.0.0-beta.18",
+    "ember-disable-prototype-extensions": "^1.0.0",
+    "ember-disable-proxy-controllers": "^1.0.0",
+    "ember-export-application-global": "^1.0.2",
+    "ember-try": "0.0.6",
+    "broccoli-replace": "^0.3.1"
+  },
+  "keywords": [
+    "ember-addon"
+  ],
+  "dependencies": {
+    "ember-cli-babel": "^5.0.0"
+  },
+  "ember-addon": {
+    "configPath": "tests/dummy/config"
+  }
+}

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: active-model-adapter-source
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Igor Terzic
+- Yehuda Katz
+- Tom Dale
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ember-source
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: ember-data active-model-adapter code wrapper for use with Ruby libs.
+email:
+- wycats@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- dist/active-model-adapter.js
+- package.json
+homepage: https://github.com/ember-data/active-model-adapter
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: active-model-adapter source code wrapper.
+test_files: []