Merge branch 'master' of github.com:mzabriskie/axios

README.md

@@ -140,6 +140,7 @@ You can create a new instance of axios with a custom config.
 
 ```js
 var instance = axios.create({
+  baseURL: 'https://some-domain.com/api/',
   timeout: 1000,
   headers: {'X-Custom-Header': 'foobar'}
 });
@@ -165,6 +166,11 @@ These are the available config options for making requests. Only the `url` is re
 {
   // `url` is the server URL that will be used for the request
   url: '/user',
+  
+  // `baseURL` will be prepended to `url` unless `url` is absolute. 
+  // It can be convenient to set `baseURL` for an instance of axios to pass relative URLs 
+  // to methods of that instance.
+  baseURL: 'https://some-domain.com/api/',
 
   // `method` is the request method to be used when making the request
   method: 'get', // default

axios.d.ts

@@ -49,6 +49,7 @@ declare module axios {
     xsrfCookieName?: string;
     xsrfHeaderName?: string;
     paramsSerializer?: (params: any) => string;
+    baseURL?: string;
   }
 
   interface RequestOptions extends InstanceOptions {

lib/axios.js

@@ -4,6 +4,8 @@ var defaults = require('./defaults');
 var utils = require('./utils');
 var dispatchRequest = require('./core/dispatchRequest');
 var InterceptorManager = require('./core/InterceptorManager');
+var isAbsoluteURL = require('./helpers/isAbsoluteURL');
+var combineURLs = require('./helpers/combineURLs');
 
 function Axios (defaultConfig) {
   this.defaultConfig = utils.merge({
@@ -29,6 +31,10 @@ Axios.prototype.request = function (config) {
 
   config = utils.merge(this.defaultConfig, { method: 'get' }, config);
 
+  if (config.baseURL && !isAbsoluteURL(config.url)) {
+    config.url = combineURLs(config.baseURL, config.url);
+  }
+
   // Don't allow overriding defaults.withCredentials
   config.withCredentials = config.withCredentials || defaults.withCredentials;
 

lib/helpers/combineURLs.js

+'use strict';
+
+/**
+ * Creates a new URL by combining the specified URLs
+ *
+ * @param {string} baseURL The base URL
+ * @param {string} relativeURL The relative URL
+ * @returns {string} The combined URL
+ */
+module.exports = function combineURLs(baseURL, relativeURL) {
+  return baseURL.replace(/\/+$/, '') + '/' + relativeURL.replace(/^\/+/, '');
+};

lib/helpers/isAbsoluteURL.js

+'use strict';
+
+/**
+ * Determines whether the specified URL is absolute
+ *
+ * @param {string} url The URL to test
+ * @returns {boolean} True if the specified URL is absolute, otherwise false
+ */
+module.exports = function isAbsoluteURL(url) {
+  // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
+  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
+  // by any combination of letters, digits, plus, period, or hyphen.
+  return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+};

test/specs/helpers/combineURLs.spec.js

+var combineURLs = require('../../../lib/helpers/combineURLs');
+
+describe('helpers::combineURLs', function () {
+  it('should combine URLs', function () {
+    expect(combineURLs('https://api.github.com', '/users')).toBe('https://api.github.com/users');
+  });
+
+  it('should remove duplicate slashes', function () {
+    expect(combineURLs('https://api.github.com/', '/users')).toBe('https://api.github.com/users');
+  });
+
+  it('should insert missing slash', function () {
+    expect(combineURLs('https://api.github.com', 'users')).toBe('https://api.github.com/users');
+  });
+});

test/specs/helpers/isAbsoluteURL.spec.js

+var isAbsoluteURL = require('../../../lib/helpers/isAbsoluteURL');
+
+describe('helpers::isAbsoluteURL', function () {
+  it('should return true if URL begins with valid scheme name', function () {
+    expect(isAbsoluteURL('https://api.github.com/users')).toBe(true);
+    expect(isAbsoluteURL('custom-scheme-v1.0://example.com/')).toBe(true);
+    expect(isAbsoluteURL('HTTP://example.com/')).toBe(true);
+  });
+
+  it('should return false if URL begins with invalid scheme name', function () {
+    expect(isAbsoluteURL('123://example.com/')).toBe(false);
+    expect(isAbsoluteURL('!valid://example.com/')).toBe(false);
+  });
+
+  it('should return true if URL is protocol-relative', function () {
+    expect(isAbsoluteURL('//example.com/')).toBe(true);
+  });
+
+  it('should return false if URL is relative', function () {
+    expect(isAbsoluteURL('/foo')).toBe(false);
+    expect(isAbsoluteURL('foo')).toBe(false);
+  });
+});

test/specs/options.spec.js

@@ -78,4 +78,42 @@ describe('options', function () {
       done();
     }, 0);
   });
+
+  it('should accept base URL', function (done) {
+    var request;
+
+    const instance = axios.create({
+      baseURL: 'http://test.com/'
+    });
+
+    instance.request({
+      url: '/foo'
+    });
+
+    setTimeout(function () {
+      request = jasmine.Ajax.requests.mostRecent();
+
+      expect(request.url).toBe('http://test.com/foo');
+      done();
+    }, 0);
+  });
+
+  it('should ignore base URL if request URL is absolute', function (done) {
+    var request;
+
+    const instance = axios.create({
+      baseURL: 'http://someurl.com/'
+    });
+
+    instance.request({
+      url: 'http://someotherurl.com/'
+    });
+
+    setTimeout(function () {
+      request = jasmine.Ajax.requests.mostRecent();
+
+      expect(request.url).toBe('http://someotherurl.com/');
+      done();
+    }, 0);
+  });
 });