├── .bowerrc
├── .coveralls.yml
├── .editorconfig
├── .gitignore
├── .jshintrc
├── .travis.yml
├── Gruntfile.js
├── LICENSE
├── README.md
├── bower.json
├── dist
    └── ngsails.io.js
├── docs
    ├── css
    │   ├── animations.css
    │   ├── bootstrap.min.css
    │   ├── doc_widgets.css
    │   ├── docs.css
    │   ├── font-awesome.css
    │   └── prettify.css
    ├── font
    │   ├── FontAwesome.otf
    │   ├── fontawesome-webfont.eot
    │   ├── fontawesome-webfont.svg
    │   ├── fontawesome-webfont.ttf
    │   └── fontawesome-webfont.woff
    ├── index.html
    ├── js
    │   ├── angular-bootstrap-prettify.js
    │   ├── angular-bootstrap.js
    │   ├── angular.min.js
    │   ├── docs-setup.js
    │   ├── docs.js
    │   ├── google-code-prettify.js
    │   └── marked.js
    └── partials
    │   └── api
    │       ├── ngsails.$sailsSocket.html
    │       ├── ngsails.$sailsSocketBackend.html
    │       └── ngsails.html
├── karma.conf.js
├── karma.postcompile.conf.js
├── lib
    ├── sails.io.js
    └── socket.io.min.js
├── module.prefix
├── module.suffix
├── package.json
├── src
    ├── angular-sails-io.js
    ├── request.js
    ├── response.js
    ├── socket.js
    ├── socketBackend.js
    ├── socketProvider.js
    └── utils.js
└── tests
    ├── .gitkeep
    ├── angular-sails-base.spec.js
    ├── angular-sails-io.spec.js
    └── angular-sails-stream.spec.js


/.bowerrc:
--------------------------------------------------------------------------------
1 | {
2 |   "directory": "vendor"
3 | }
4 | 


--------------------------------------------------------------------------------
/.coveralls.yml:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/balderdashy/angularSails/1deb8a05d737e5cb9224096378ebe949586cf570/.coveralls.yml


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | # EditorConfig helps developers define and maintain consistent
 2 | # coding styles between different editors and IDEs
 3 | # editorconfig.org
 4 | 
 5 | root = true
 6 | 
 7 | # Project editor configurations.
 8 | # NOTE: Do not change these.
 9 | [*]
10 | end_of_line = lf
11 | charset = utf-8
12 | trim_trailing_whitespace = true
13 | insert_final_newline = true
14 | indent_style = space
15 | indent_size = 2
16 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | .idea
3 | npm-debug.log
4 | 
5 | .grunt/grunt-gh-pages/gh-pages/src/
6 | 


--------------------------------------------------------------------------------
/.jshintrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "node": true,
 3 |   "browser": true,
 4 |   "esnext": true,
 5 |   "bitwise": true,
 6 |   "camelcase": true,
 7 |   "curly": false,
 8 |   "eqeqeq": true,
 9 |   "eqnull": true,
10 |   "immed": true,
11 |   "latedef": true,
12 |   "newcap": true,
13 |   "noarg": true,
14 |   "quotmark": "single",
15 |   "regexp": true,
16 |   "undef": true,
17 |   "unused": true,
18 |   "strict": true,
19 |   "trailing": true,
20 |   "smarttabs": true,
21 |   "globals": {
22 |     "jasmine": true,
23 |     "after": true,
24 |     "afterEach": true,
25 |     "angular": true,
26 |     "before": true,
27 |     "beforeEach": true,
28 |     "browser": true,
29 |     "describe": true,
30 |     "expect": true,
31 |     "inject": true,
32 |     "it": true,
33 |     "spyOn": true,
34 |     "StateMock": true
35 |   }
36 | }
37 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: node_js
 2 | 
 3 | node_js:
 4 |   - "0.10"
 5 |   
 6 | before_script:
 7 |   - npm install -g bower grunt-cli
 8 |   - bower install
 9 |   - export DISPLAY=:99.0
10 |   - sh -e /etc/init.d/xvfb start
11 | 
12 | # whitelisted branches
13 | branches:
14 |   only:
15 |     - master
16 | 


--------------------------------------------------------------------------------
/Gruntfile.js:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Grunt automation.
  3 |  */
  4 | module.exports = function(grunt) {
  5 | 
  6 |     var getTime = function(){
  7 | 
  8 |         return new Date().getTime();
  9 | 
 10 |     };
 11 | 
 12 | 
 13 |     require('load-grunt-tasks')(grunt);
 14 | 
 15 |     grunt.initConfig({
 16 | 
 17 |         app: {
 18 |             src: 'src',
 19 |             dist: 'dist',
 20 |             vendor: 'vendor',
 21 |             tests: 'tests',
 22 |             example: 'example/assets/',
 23 |             pkg: grunt.file.readJSON('bower.json')
 24 |         },
 25 | 
 26 |         ngdocs: {
 27 |             all: ['dist/ngsails.js']
 28 |         },
 29 | 
 30 |         concat: {
 31 |             sails: {
 32 |                 src: ['module.prefix','<%= app.src %>/*.js','module.suffix'],
 33 |                 dest: '<%= app.dist %>/ngsails.io.js'
 34 |             }
 35 | 
 36 |         },
 37 | 
 38 |         copy: {
 39 |             example: {
 40 |                 src: '<%= app.dist %>/*.js',
 41 |                 dest: '<%= app.example %>/js/angular-sails/',
 42 |                 flatten : true,
 43 |                 expand : true
 44 |             },
 45 |             vendor: {
 46 |                 src: ['<%= app.vendor %>/**/*.js','<%= app.vendor %>/**/*.js'],
 47 |                 dest: '<%= app.example %>/js/',
 48 |                 flatten : true,
 49 |                 expand : false
 50 |             }
 51 |         },
 52 | 
 53 |         uglify: {
 54 |             options: {
 55 |                 sourceMap: true,
 56 |                 banner: '/*\n'
 57 |                     + '  <%= app.pkg.name %> <%= app.pkg.version %>-build' + getTime() + '\n'
 58 |                     + '  Built with <3 by Balderdashy'
 59 |                     + '*/'
 60 |             },
 61 |             dist: {
 62 |                 files: {
 63 |                     '<%= app.dist %>/<%= app.pkg.name %>.min.js': ['<%= app.dist %>/<%= app.pkg.name %>.js']
 64 |                 }
 65 |             }
 66 |         },
 67 | 
 68 |         jshint: {
 69 | 
 70 |             options: {
 71 |                 reporter: require('jshint-stylish'),
 72 |                 jshintrc: true
 73 |             },
 74 | 
 75 |             all: [
 76 |                 '<%= app.src %>/**/*.js',
 77 |                 '<%= app.tests %>/**/*.spec.js'
 78 |             ]
 79 |         },
 80 | 
 81 |         watch: {
 82 |             source: {
 83 |                 files: ['<%= app.src %>/**/*.js'],
 84 |                 tasks: ['concat:sails','ngdocs:all','copy:example'],
 85 |                 options: {
 86 |                     debounceDelay: 500,
 87 |                     atBegin: true
 88 |                 }
 89 |             },
 90 |             tests: {
 91 |                 files: ['<%= app.tests %>/**/*.spec.js'],
 92 |                 tasks: ['newer:jshint', 'karma:precompile'],
 93 |                 options: {
 94 |                     debounceDelay: 500,
 95 |                     atBegin: true
 96 |                 }
 97 |             }
 98 |         },
 99 | 
100 |         karma: {
101 |             precompile: {
102 |                 configFile: 'karma.conf.js'
103 |             },
104 |             postcompile: {
105 |                 configFile: 'karma.postcompile.conf.js',
106 |             }
107 |         }
108 | 
109 |     });
110 | 
111 |     grunt.loadNpmTasks('grunt-ngdocs');
112 |     grunt.loadNpmTasks('grunt-contrib-copy');
113 | 
114 |     // Registered tasks.
115 |     grunt.registerTask('default', ['concat:sails']);
116 | 
117 |     grunt.registerTask('docs', ['ngdocs']);
118 | 
119 | //
120 | //  grunt.registerTask('dev', ['watch']);
121 | //
122 | //  grunt.registerTask('test', ['karma:precompile']);
123 | //
124 | //  grunt.registerTask('build', [
125 | ////    'jshint',
126 | ////    'karma:precompile',
127 | ////    'concat',
128 | //    'uglify',
129 | //    'copy',
130 | //    'karma:postcompile'
131 | //  ]);
132 | };
133 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Rob Wormwald
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | angularSails
2 | ============
3 | 
4 | AngularJS bindings for Sails. http://angularjs.org
5 | 
6 | Docs : http://balderdashy.github.io/angularSails/#/api/ngsails.$sailsSocket
7 | 


--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "angularSails",
 3 |   "version": "0.12.1",
 4 |   "homepage": "https://github.com/balderdashy/angularSails",
 5 |   "authors": [
 6 |     "Rob Wormald <rob.wormald@innitapps.com>",
 7 |     "Gabe Hernandez <ghernandez345@gmail.com>"
 8 |   ],
 9 |   "description": "SailsJS SDK for AngularJs",
10 |   "main": "dist/ngsails.io.js",
11 |   "keywords": [
12 |     "Angular",
13 |     "AngularJS",
14 |     "Sails",
15 |     "SailsJS",
16 |     "realtime"
17 |   ],
18 |   "license": "MIT",
19 |   "ignore": [
20 |     "**/.*",
21 |     "node_modules",
22 |     "bower_components",
23 |     "test",
24 |     "tests"
25 |   ],
26 |   "devDependencies": {
27 |     "angular-mocks": "~1.3.0"
28 |   },
29 |   "dependencies": {
30 |     "angular": "~1.3.0",
31 |     "sails.io.js" : "latest"
32 |   }
33 | }
34 | 


--------------------------------------------------------------------------------
/docs/css/animations.css:
--------------------------------------------------------------------------------
 1 | .slide-reveal.ng-enter {
 2 |   -webkit-transition:0.5s linear all;
 3 |   -moz-transition:0.5s linear all;
 4 |   -o-transition:0.5s linear all;
 5 |   transition:0.5s linear all;
 6 | 
 7 |   opacity:0.5;
 8 |   position:relative;
 9 |   opacity:0;
10 |   top:10px;
11 | }
12 | .slide-reveal.ng-enter-active {
13 |   top:0;
14 |   opacity:1;
15 | }
16 | 
17 | .expand.ng-enter {
18 |   -webkit-transition:0.3s cubic-bezier(0.250, 0.460, 0.450, 0.940) all;
19 |   -moz-transition:0.3s cubic-bezier(0.250, 0.460, 0.450, 0.940) all;
20 |   -o-transition:0.3s cubic-bezier(0.250, 0.460, 0.450, 0.940) all;
21 |   transition:0.3s cubic-bezier(0.250, 0.460, 0.450, 0.940) all;
22 | 
23 |   opacity:0;
24 |   max-height:0;
25 |   overflow:hidden;
26 | }
27 | .expand.ng-enter-active {
28 |   opacity:1;
29 |   max-height:40px;
30 | }
31 | 
32 | .expand.ng-leave {
33 |   -webkit-transition:0.3s cubic-bezier(0.250, 0.460, 0.450, 0.940) all;
34 |   -moz-transition:0.3s cubic-bezier(0.250, 0.460, 0.450, 0.940) all;
35 |   -o-transition:0.3s cubic-bezier(0.250, 0.460, 0.450, 0.940) all;
36 |   transition:0.3s cubic-bezier(0.250, 0.460, 0.450, 0.940) all;
37 | 
38 |   opacity:1;
39 |   max-height:40px;
40 |   overflow:hidden;
41 | }
42 | .expand.ng-leave-active {
43 |   opacity:0;
44 |   max-height:0;
45 | }
46 | 


--------------------------------------------------------------------------------
/docs/css/doc_widgets.css:
--------------------------------------------------------------------------------
  1 | ul.doc-example {
  2 |   list-style-type: none;
  3 |   position: relative;
  4 |   font-size: 14px;
  5 | }
  6 | 
  7 | ul.doc-example > li {
  8 |   border: 2px solid gray;
  9 |   border-radius: 5px;
 10 |   -moz-border-radius: 5px;
 11 |   -webkit-border-radius: 5px;
 12 |   background-color: white;
 13 |   margin-bottom: 20px;
 14 | }
 15 | 
 16 | ul.doc-example > li.doc-example-heading {
 17 |   border: none;
 18 |   border-radius: 0;
 19 |   margin-bottom: -10px;
 20 | }
 21 | 
 22 | span.nojsfiddle {
 23 |   float: right;
 24 |   font-size: 14px;
 25 |   margin-right:10px;
 26 |   margin-top: 10px;
 27 | }
 28 | 
 29 | form.jsfiddle {
 30 |   position: absolute;
 31 |   right: 0;
 32 |   z-index: 1;
 33 |   height: 14px;
 34 | }
 35 | 
 36 | form.jsfiddle button {
 37 |   cursor: pointer;
 38 |   padding: 4px 10px;
 39 |   margin: 10px;
 40 |   background-color: #FFF;
 41 |   font-weight: bold;
 42 |   color: #7989D6;
 43 |   border-color: #7989D6;
 44 |   -moz-border-radius: 8px;
 45 |   -webkit-border-radius:8px;
 46 |   border-radius: 8px;
 47 | }
 48 | 
 49 | form.jsfiddle textarea, form.jsfiddle input {
 50 |   display: none;
 51 | }
 52 | 
 53 | li.doc-example-live {
 54 |   padding: 10px;
 55 |   font-size: 1.2em;
 56 | }
 57 | 
 58 | div.syntaxhighlighter {
 59 |   padding-bottom: 1px !important; /* fix to remove unnecessary scrollbars http://is.gd/gSMgC */
 60 | }
 61 | 
 62 | /* TABS - tutorial environment navigation */
 63 | 
 64 | div.tabs-nav {
 65 |   height: 25px;
 66 |   position: relative;
 67 | }
 68 | 
 69 | div.tabs-nav ul li {
 70 |   list-style: none;
 71 |   display: inline-block;
 72 |   padding: 5px 10px;
 73 | }
 74 | 
 75 | div.tabs-nav ul li.current a {
 76 |   color: white;
 77 |   text-decoration: none;
 78 | }
 79 | 
 80 | div.tabs-nav ul li.current {
 81 |   background: #7989D6;
 82 |   -moz-box-shadow: 4px 4px 6px #48577D;
 83 |   -moz-border-radius-topright: 8px;
 84 |   -moz-border-radius-topleft: 8px;
 85 |   box-shadow: 4px 4px 6px #48577D;
 86 |   border-radius-topright: 8px;
 87 |   border-radius-topleft: 8px;
 88 |   -webkit-box-shadow: 4px 4px 6px #48577D;
 89 |   -webkit-border-top-right-radius: 8px;
 90 |   -webkit-border-top-left-radius: 8px;
 91 |   border-top-right-radius: 8px;
 92 |   border-top-left-radius: 8px;
 93 | }
 94 | 
 95 | div.tabs-content {
 96 |   padding: 4px;
 97 |   position: relative;
 98 |   background: #7989D6;
 99 |   -moz-border-radius: 8px;
100 |   border-radius: 8px;
101 |   -webkit-border-radius: 8px;
102 | }
103 | 
104 | div.tabs-content-inner {
105 |   margin: 1px;
106 |   padding: 10px;
107 |   background: white;
108 |   border-radius: 6px;
109 |   -moz-border-radius: 6px;
110 |   -webkit-border-radius: 6px;
111 | }
112 | 
113 | 
114 | /* Tutorial Nav Bar */
115 | 
116 | #tutorial-nav {
117 |   margin: 0.5em 0 1em 0;
118 |   padding: 0;
119 |   list-style-type: none;
120 |   background: #7989D6;
121 | 
122 |   -moz-border-radius: 15px;
123 |   -webkit-border-radius: 15px;
124 |   border-radius: 15px;
125 | 
126 |   -moz-box-shadow: 4px 4px 6px #48577D;
127 |   -webkit-box-shadow: 4px 4px 6px #48577D;
128 |   box-shadow: 4px 4px 6px #48577D;
129 | }
130 | 
131 | 
132 | #tutorial-nav li {
133 |   display: inline;
134 | }
135 | 
136 | 
137 | #tutorial-nav a:link, #tutorial-nav a:visited {
138 |   font-size: 1.2em;
139 |   color: #FFF;
140 |   text-decoration: none;
141 |   text-align: center;
142 |   display: inline-block;
143 |   width: 11em;
144 |   padding: 0.2em 0;
145 | }
146 | 
147 | 
148 | #tutorial-nav a:hover {
149 |   color: #000;
150 | }
151 | 


--------------------------------------------------------------------------------
/docs/css/docs.css:
--------------------------------------------------------------------------------
  1 | img.AngularJS-small {
  2 |   width: 95px;
  3 |   height: 25px;
  4 | }
  5 | 
  6 | /* this is here to avoid the display=block shuffling of ngShow */
  7 | .breadcrumb li > * {
  8 |   float:left;
  9 |   margin:0 2px 0 0;
 10 | }
 11 | 
 12 | .breadcrumb {
 13 |   padding-top: 6px;
 14 |   padding-bottom: 0;
 15 |   line-height: 18px
 16 | }
 17 | 
 18 | .header img {
 19 |   max-height: 40px;
 20 |   padding-right: 20px;
 21 | }
 22 | 
 23 | .header img+.brand {
 24 |   padding: 10px 20px 10px 10px;
 25 | }
 26 | 
 27 | .clear-navbar {
 28 |   margin-top: 60px;
 29 | }
 30 | 
 31 | .footer {
 32 |   padding-top: 2em;
 33 |   background-color: #333;
 34 |   color: white;
 35 |   padding-bottom: 2em;
 36 | }
 37 | 
 38 | .spacer {
 39 |   height: 1em;
 40 | }
 41 | 
 42 | 
 43 | .icon-cog {
 44 |   line-height: 13px;
 45 | }
 46 | 
 47 | /* =============================== */
 48 | 
 49 | .form-search {
 50 |   margin-right: 10px;
 51 | }
 52 | 
 53 | .form-search .search-query {
 54 |   width: 180px;
 55 |   width: 200px \9;
 56 | }
 57 | 
 58 | .form-search .dropdown-menu {
 59 |   margin-left: 10px;
 60 | }
 61 | 
 62 | .form-search .code {
 63 |   font-family: monospace;
 64 |   font-weight: bold;
 65 |   font-size: 13px;
 66 |   color: black;
 67 | }
 68 | 
 69 | .form-search > ul.nav > li > a {
 70 |   margin: 0;
 71 | }
 72 | 
 73 | .form-search > ul.nav > li.module {
 74 |   background-color: #d3d3d3;
 75 | }
 76 | 
 77 | .form-search > ul.nav > li.section {
 78 |   background-color: #ebebeb;
 79 |   min-height: 14px;
 80 | }
 81 | 
 82 | .form-search > ul.nav > li.first {
 83 |   padding-top: 6px;
 84 | }
 85 | 
 86 | .form-search > ul.nav > li.last {
 87 |   padding-bottom: 6px;
 88 | }
 89 | 
 90 | .form-search > ul.nav > li.last + li.api-list-item {
 91 |   margin-top: -6px;
 92 |   padding-bottom: 6px;
 93 | }
 94 | 
 95 | .form-search .well {
 96 |   border-color: #d3d3d3;
 97 |   padding: 0;
 98 |   margin-bottom: 15px;
 99 | }
100 | 
101 | .form-search .well .nav-header {
102 |   text-transform: none;
103 |   padding: 3px 1px;
104 |   margin: 0;
105 | }
106 | 
107 | .form-search .well .nav-header a {
108 |   text-transform: none;
109 |   color: black;
110 | }
111 | .form-search .well .nav-header a:hover {
112 |   background-color: inherit;
113 | }
114 | 
115 | .form-search .well li {
116 |   line-height: 14px;
117 | }
118 | 
119 | .form-search .well li a:focus {
120 | 	outline: none;
121 | }
122 | 
123 | .form-search .well .guide {
124 |   float: right;
125 |   padding-top: 0;
126 |   color: gray;
127 | }
128 | 
129 | .form-search .module .guide {
130 |   line-height: 20px;
131 | }
132 | 
133 | .match > a, .nav > .match > a:hover {
134 | 	background-color: #dbeaf4;
135 | }
136 | 
137 | /* =============================== */
138 | /*            Content              */
139 | /* =============================== */
140 | 
141 | .improve-docs {
142 |   float: right;
143 | }
144 | 
145 | .hint {
146 |   font-size: .6em;
147 |   color: #c0c0c0;
148 |   display: block;
149 | }
150 | 
151 | .content code {
152 |   background-color: inherit;
153 |   color: inherit;
154 |   border: none;
155 |   padding: 0;
156 |   font-size: inherit;
157 |   font-family: monospace;
158 | }
159 | 
160 | .content h2,
161 | .content h3,
162 | .content h4,
163 | .content h5 {
164 |   margin: 1em 0 5px;
165 | }
166 | 
167 | .content h1 {
168 |   font-size: 30px;
169 |   line-height: 36px;
170 | }
171 | 
172 | .content h2 {
173 |   font-size: 24px;
174 |   line-height: 36px;
175 | }
176 | 
177 | .content h3 {
178 |   line-height: 27px;
179 |   font-size: 18px;
180 | }
181 | 
182 | .content h4 {
183 |   font-size: 15px;
184 | }
185 | 
186 | ul.parameters > li > p,
187 | .returns > p {
188 |   display: inline;
189 | }
190 | 
191 | ul.methods > li,
192 | ul.properties > li,
193 | ul.events > li {
194 |   list-style: none;
195 |   min-height: 20px;
196 |   padding: 19px;
197 |   margin-bottom: 20px;
198 |   background-color: #f5f5f5;
199 |   border: 1px solid #eee;
200 |   border: 1px solid rgba(0, 0, 0, 0.05);
201 |   -webkit-border-radius: 4px;
202 |   -moz-border-radius: 4px;
203 |   border-radius: 4px;
204 |   -webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
205 |   -moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
206 |   box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.05);
207 | }
208 | 
209 | .member.method > h2,
210 | .member.property > h2,
211 | .member.event > h2 {
212 |   margin-bottom: .5em;
213 | }
214 | 
215 | ul.methods > li > h3,
216 | ul.properties > li > h3,
217 | ul.events > li > h3 {
218 |   margin: -19px -19px 1em -19px;
219 |   padding: .25em 19px;
220 |   background-color: #d3d3d3;
221 |   font-family: monospace;
222 | }
223 | 
224 | .center {
225 |   display: block;
226 |   margin: 2em auto;
227 | }
228 | 
229 | .diagram {
230 |   display: block;
231 |   margin: 2em auto;
232 |   padding: 1em;
233 |   border: 1px solid black;
234 | 
235 |   -moz-box-shadow: 4px 4px 6px #48577D;
236 |   -webkit-box-shadow: 4px 4px 6px #48577D;
237 |   box-shadow: 4px 4px 6px #48577D;
238 | 
239 |   -moz-border-radius: 15px;
240 |   -webkit-border-radius: 15px;
241 |   border-radius: 15px;
242 | }
243 | 
244 | .tutorial-nav {
245 |   margin-left: 175px;
246 |   color: black;
247 |   margin-top: 2em;
248 |   margin-bottom: 2em;
249 | }
250 | 
251 | .tutorial-nav a {
252 |   color: white;
253 | }
254 | 
255 | .tutorial-nav a:hover {
256 |   color: white;
257 |   text-decoration: none;
258 | }
259 | 
260 | .clear {
261 |   clear: both;
262 | }
263 | 
264 | .variables-matrix td {
265 |   vertical-align:top;
266 |   padding:5px;
267 | }
268 | 
269 | .type-hint {
270 |   display:inline-block;
271 | }
272 | 
273 | .variables-matrix .type-hint {
274 |   text-align:center;
275 |   display:block;
276 |   min-width:60px;
277 | }
278 | 
279 | .type-hint + .type-hint {
280 |   margin-top:5px;
281 | }
282 | 
283 | .type-hint-string {
284 |   background:#3a87ad;
285 | }
286 | 
287 | .type-hint-object {
288 |   background:#999;
289 | }
290 | 
291 | .type-hint-array {
292 |   background:#F90;;
293 | }
294 | 
295 | .type-hint-boolean {
296 |   background:rgb(18, 131, 39);
297 | }
298 | 
299 | .type-hint-number {
300 |   background:rgb(189, 63, 66);
301 | }
302 | 


--------------------------------------------------------------------------------
/docs/css/font-awesome.css:
--------------------------------------------------------------------------------
   1 | /*!
   2 |  *  Font Awesome 3.1.0
   3 |  *  the iconic font designed for Bootstrap
   4 |  *  -------------------------------------------------------
   5 |  *  The full suite of pictographic icons, examples, and documentation
   6 |  *  can be found at: http://fontawesome.io
   7 |  *
   8 |  *  License
   9 |  *  -------------------------------------------------------
  10 |  *  - The Font Awesome font is licensed under the SIL Open Font License v1.1 -
  11 |  *    http://scripts.sil.org/OFL
  12 |  *  - Font Awesome CSS, LESS, and SASS files are licensed under the MIT License -
  13 |  *    http://opensource.org/licenses/mit-license.html
  14 |  *  - Font Awesome documentation licensed under CC BY 3.0 License -
  15 |  *    http://creativecommons.org/licenses/by/3.0/
  16 |  *  - Attribution is no longer required in Font Awesome 3.0, but much appreciated:
  17 |  *    "Font Awesome by Dave Gandy - http://fontawesome.io"
  18 | 
  19 |  *  Contact
  20 |  *  -------------------------------------------------------
  21 |  *  Email: dave@fontawesome.io
  22 |  *  Twitter: http://twitter.com/fortaweso_me
  23 |  *  Work: Lead Product Designer @ http://kyruus.com
  24 |  */
  25 | /* FONT PATH
  26 |  * -------------------------- */
  27 | @font-face {
  28 |   font-family: 'FontAwesome';
  29 |   src: url('../font/fontawesome-webfont.eot?v=3.1.0');
  30 |   src: url('../font/fontawesome-webfont.eot?#iefix&v=3.1.0') format('embedded-opentype'), url('../font/fontawesome-webfont.woff?v=3.1.0') format('woff'), url('../font/fontawesome-webfont.ttf?v=3.1.0') format('truetype'), url('../font/fontawesome-webfont.svg#fontawesomeregular?v=3.1.0') format('svg');
  31 |   font-weight: normal;
  32 |   font-style: normal;
  33 | }
  34 | /* FONT AWESOME CORE
  35 |  * -------------------------- */
  36 | [class^="icon-"],
  37 | [class*=" icon-"] {
  38 |   font-family: FontAwesome;
  39 |   font-weight: normal;
  40 |   font-style: normal;
  41 |   text-decoration: inherit;
  42 |   -webkit-font-smoothing: antialiased;
  43 |   *margin-right: .3em;
  44 | }
  45 | [class^="icon-"]:before,
  46 | [class*=" icon-"]:before {
  47 |   text-decoration: inherit;
  48 |   display: inline-block;
  49 |   speak: none;
  50 | }
  51 | /* makes the font 33% larger relative to the icon container */
  52 | .icon-large:before {
  53 |   vertical-align: -10%;
  54 |   font-size: 1.3333333333333333em;
  55 | }
  56 | /* makes sure icons active on rollover in links */
  57 | a [class^="icon-"],
  58 | a [class*=" icon-"],
  59 | a [class^="icon-"]:before,
  60 | a [class*=" icon-"]:before {
  61 |   display: inline;
  62 | }
  63 | /* increased font size for icon-large */
  64 | [class^="icon-"].icon-fixed-width,
  65 | [class*=" icon-"].icon-fixed-width {
  66 |   display: inline-block;
  67 |   width: 1.2857142857142858em;
  68 |   text-align: center;
  69 | }
  70 | [class^="icon-"].icon-fixed-width.icon-large,
  71 | [class*=" icon-"].icon-fixed-width.icon-large {
  72 |   width: 1.5714285714285714em;
  73 | }
  74 | ul.icons-ul {
  75 |   list-style-type: none;
  76 |   text-indent: -0.7142857142857143em;
  77 |   margin-left: 2.142857142857143em;
  78 | }
  79 | ul.icons-ul > li .icon-li {
  80 |   width: 0.7142857142857143em;
  81 |   display: inline-block;
  82 |   text-align: center;
  83 | }
  84 | [class^="icon-"].hide,
  85 | [class*=" icon-"].hide {
  86 |   display: none;
  87 | }
  88 | .icon-muted {
  89 |   color: #eeeeee;
  90 | }
  91 | .icon-light {
  92 |   color: #ffffff;
  93 | }
  94 | .icon-dark {
  95 |   color: #333333;
  96 | }
  97 | .icon-border {
  98 |   border: solid 1px #eeeeee;
  99 |   padding: .2em .25em .15em;
 100 |   -webkit-border-radius: 3px;
 101 |   -moz-border-radius: 3px;
 102 |   border-radius: 3px;
 103 | }
 104 | .icon-2x {
 105 |   font-size: 2em;
 106 | }
 107 | .icon-2x.icon-border {
 108 |   border-width: 2px;
 109 |   -webkit-border-radius: 4px;
 110 |   -moz-border-radius: 4px;
 111 |   border-radius: 4px;
 112 | }
 113 | .icon-3x {
 114 |   font-size: 3em;
 115 | }
 116 | .icon-3x.icon-border {
 117 |   border-width: 3px;
 118 |   -webkit-border-radius: 5px;
 119 |   -moz-border-radius: 5px;
 120 |   border-radius: 5px;
 121 | }
 122 | .icon-4x {
 123 |   font-size: 4em;
 124 | }
 125 | .icon-4x.icon-border {
 126 |   border-width: 4px;
 127 |   -webkit-border-radius: 6px;
 128 |   -moz-border-radius: 6px;
 129 |   border-radius: 6px;
 130 | }
 131 | .icon-5x {
 132 |   font-size: 5em;
 133 | }
 134 | .icon-5x.icon-border {
 135 |   border-width: 5px;
 136 |   -webkit-border-radius: 7px;
 137 |   -moz-border-radius: 7px;
 138 |   border-radius: 7px;
 139 | }
 140 | .pull-right {
 141 |   float: right;
 142 | }
 143 | .pull-left {
 144 |   float: left;
 145 | }
 146 | [class^="icon-"].pull-left,
 147 | [class*=" icon-"].pull-left {
 148 |   margin-right: .3em;
 149 | }
 150 | [class^="icon-"].pull-right,
 151 | [class*=" icon-"].pull-right {
 152 |   margin-left: .3em;
 153 | }
 154 | /* BOOTSTRAP SPECIFIC CLASSES
 155 |  * -------------------------- */
 156 | /* Bootstrap 2.0 sprites.less reset */
 157 | [class^="icon-"],
 158 | [class*=" icon-"] {
 159 |   display: inline;
 160 |   width: auto;
 161 |   height: auto;
 162 |   line-height: normal;
 163 |   vertical-align: baseline;
 164 |   background-image: none;
 165 |   background-position: 0% 0%;
 166 |   background-repeat: repeat;
 167 |   margin-top: 0;
 168 | }
 169 | /* more sprites.less reset */
 170 | .icon-white,
 171 | .nav-pills > .active > a > [class^="icon-"],
 172 | .nav-pills > .active > a > [class*=" icon-"],
 173 | .nav-list > .active > a > [class^="icon-"],
 174 | .nav-list > .active > a > [class*=" icon-"],
 175 | .navbar-inverse .nav > .active > a > [class^="icon-"],
 176 | .navbar-inverse .nav > .active > a > [class*=" icon-"],
 177 | .dropdown-menu > li > a:hover > [class^="icon-"],
 178 | .dropdown-menu > li > a:hover > [class*=" icon-"],
 179 | .dropdown-menu > .active > a > [class^="icon-"],
 180 | .dropdown-menu > .active > a > [class*=" icon-"],
 181 | .dropdown-submenu:hover > a > [class^="icon-"],
 182 | .dropdown-submenu:hover > a > [class*=" icon-"] {
 183 |   background-image: none;
 184 | }
 185 | /* keeps Bootstrap styles with and without icons the same */
 186 | .btn [class^="icon-"].icon-large,
 187 | .nav [class^="icon-"].icon-large,
 188 | .btn [class*=" icon-"].icon-large,
 189 | .nav [class*=" icon-"].icon-large {
 190 |   line-height: .9em;
 191 | }
 192 | .btn [class^="icon-"].icon-spin,
 193 | .nav [class^="icon-"].icon-spin,
 194 | .btn [class*=" icon-"].icon-spin,
 195 | .nav [class*=" icon-"].icon-spin {
 196 |   display: inline-block;
 197 | }
 198 | .nav-tabs [class^="icon-"],
 199 | .nav-pills [class^="icon-"],
 200 | .nav-tabs [class*=" icon-"],
 201 | .nav-pills [class*=" icon-"],
 202 | .nav-tabs [class^="icon-"].icon-large,
 203 | .nav-pills [class^="icon-"].icon-large,
 204 | .nav-tabs [class*=" icon-"].icon-large,
 205 | .nav-pills [class*=" icon-"].icon-large {
 206 |   line-height: .9em;
 207 | }
 208 | .btn [class^="icon-"].pull-left.icon-2x,
 209 | .btn [class*=" icon-"].pull-left.icon-2x,
 210 | .btn [class^="icon-"].pull-right.icon-2x,
 211 | .btn [class*=" icon-"].pull-right.icon-2x {
 212 |   margin-top: .18em;
 213 | }
 214 | .btn [class^="icon-"].icon-spin.icon-large,
 215 | .btn [class*=" icon-"].icon-spin.icon-large {
 216 |   line-height: .8em;
 217 | }
 218 | .btn.btn-small [class^="icon-"].pull-left.icon-2x,
 219 | .btn.btn-small [class*=" icon-"].pull-left.icon-2x,
 220 | .btn.btn-small [class^="icon-"].pull-right.icon-2x,
 221 | .btn.btn-small [class*=" icon-"].pull-right.icon-2x {
 222 |   margin-top: .25em;
 223 | }
 224 | .btn.btn-large [class^="icon-"],
 225 | .btn.btn-large [class*=" icon-"] {
 226 |   margin-top: 0;
 227 | }
 228 | .btn.btn-large [class^="icon-"].pull-left.icon-2x,
 229 | .btn.btn-large [class*=" icon-"].pull-left.icon-2x,
 230 | .btn.btn-large [class^="icon-"].pull-right.icon-2x,
 231 | .btn.btn-large [class*=" icon-"].pull-right.icon-2x {
 232 |   margin-top: .05em;
 233 | }
 234 | .btn.btn-large [class^="icon-"].pull-left.icon-2x,
 235 | .btn.btn-large [class*=" icon-"].pull-left.icon-2x {
 236 |   margin-right: .2em;
 237 | }
 238 | .btn.btn-large [class^="icon-"].pull-right.icon-2x,
 239 | .btn.btn-large [class*=" icon-"].pull-right.icon-2x {
 240 |   margin-left: .2em;
 241 | }
 242 | /* EXTRAS
 243 |  * -------------------------- */
 244 | /* Stacked and layered icon */
 245 | .icon-stack {
 246 |   position: relative;
 247 |   display: inline-block;
 248 |   width: 2em;
 249 |   height: 2em;
 250 |   line-height: 2em;
 251 |   vertical-align: -35%;
 252 | }
 253 | .icon-stack [class^="icon-"],
 254 | .icon-stack [class*=" icon-"] {
 255 |   display: block;
 256 |   text-align: center;
 257 |   position: absolute;
 258 |   width: 100%;
 259 |   height: 100%;
 260 |   font-size: 1em;
 261 |   line-height: inherit;
 262 |   *line-height: 2em;
 263 | }
 264 | .icon-stack .icon-stack-base {
 265 |   font-size: 2em;
 266 |   *line-height: 1em;
 267 | }
 268 | /* Animated rotating icon */
 269 | .icon-spin {
 270 |   display: inline-block;
 271 |   -moz-animation: spin 2s infinite linear;
 272 |   -o-animation: spin 2s infinite linear;
 273 |   -webkit-animation: spin 2s infinite linear;
 274 |   animation: spin 2s infinite linear;
 275 | }
 276 | @-moz-keyframes spin {
 277 |   0% {
 278 |     -moz-transform: rotate(0deg);
 279 |   }
 280 |   100% {
 281 |     -moz-transform: rotate(359deg);
 282 |   }
 283 | }
 284 | @-webkit-keyframes spin {
 285 |   0% {
 286 |     -webkit-transform: rotate(0deg);
 287 |   }
 288 |   100% {
 289 |     -webkit-transform: rotate(359deg);
 290 |   }
 291 | }
 292 | @-o-keyframes spin {
 293 |   0% {
 294 |     -o-transform: rotate(0deg);
 295 |   }
 296 |   100% {
 297 |     -o-transform: rotate(359deg);
 298 |   }
 299 | }
 300 | @-ms-keyframes spin {
 301 |   0% {
 302 |     -ms-transform: rotate(0deg);
 303 |   }
 304 |   100% {
 305 |     -ms-transform: rotate(359deg);
 306 |   }
 307 | }
 308 | @keyframes spin {
 309 |   0% {
 310 |     transform: rotate(0deg);
 311 |   }
 312 |   100% {
 313 |     transform: rotate(359deg);
 314 |   }
 315 | }
 316 | /* Icon rotations and mirroring */
 317 | .icon-rotate-90:before {
 318 |   -webkit-transform: rotate(90deg);
 319 |   -moz-transform: rotate(90deg);
 320 |   -ms-transform: rotate(90deg);
 321 |   -o-transform: rotate(90deg);
 322 |   transform: rotate(90deg);
 323 |   filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=1);
 324 | }
 325 | .icon-rotate-180:before {
 326 |   -webkit-transform: rotate(180deg);
 327 |   -moz-transform: rotate(180deg);
 328 |   -ms-transform: rotate(180deg);
 329 |   -o-transform: rotate(180deg);
 330 |   transform: rotate(180deg);
 331 |   filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=2);
 332 | }
 333 | .icon-rotate-270:before {
 334 |   -webkit-transform: rotate(270deg);
 335 |   -moz-transform: rotate(270deg);
 336 |   -ms-transform: rotate(270deg);
 337 |   -o-transform: rotate(270deg);
 338 |   transform: rotate(270deg);
 339 |   filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=3);
 340 | }
 341 | .icon-flip-horizontal:before {
 342 |   -webkit-transform: scale(-1, 1);
 343 |   -moz-transform: scale(-1, 1);
 344 |   -ms-transform: scale(-1, 1);
 345 |   -o-transform: scale(-1, 1);
 346 |   transform: scale(-1, 1);
 347 | }
 348 | .icon-flip-vertical:before {
 349 |   -webkit-transform: scale(1, -1);
 350 |   -moz-transform: scale(1, -1);
 351 |   -ms-transform: scale(1, -1);
 352 |   -o-transform: scale(1, -1);
 353 |   transform: scale(1, -1);
 354 | }
 355 | /* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen
 356 |    readers do not read off random characters that represent icons */
 357 | .icon-glass:before {
 358 |   content: "\f000";
 359 | }
 360 | .icon-music:before {
 361 |   content: "\f001";
 362 | }
 363 | .icon-search:before {
 364 |   content: "\f002";
 365 | }
 366 | .icon-envelope:before {
 367 |   content: "\f003";
 368 | }
 369 | .icon-heart:before {
 370 |   content: "\f004";
 371 | }
 372 | .icon-star:before {
 373 |   content: "\f005";
 374 | }
 375 | .icon-star-empty:before {
 376 |   content: "\f006";
 377 | }
 378 | .icon-user:before {
 379 |   content: "\f007";
 380 | }
 381 | .icon-film:before {
 382 |   content: "\f008";
 383 | }
 384 | .icon-th-large:before {
 385 |   content: "\f009";
 386 | }
 387 | .icon-th:before {
 388 |   content: "\f00a";
 389 | }
 390 | .icon-th-list:before {
 391 |   content: "\f00b";
 392 | }
 393 | .icon-ok:before {
 394 |   content: "\f00c";
 395 | }
 396 | .icon-remove:before {
 397 |   content: "\f00d";
 398 | }
 399 | .icon-zoom-in:before {
 400 |   content: "\f00e";
 401 | }
 402 | .icon-zoom-out:before {
 403 |   content: "\f010";
 404 | }
 405 | .icon-off:before {
 406 |   content: "\f011";
 407 | }
 408 | .icon-signal:before {
 409 |   content: "\f012";
 410 | }
 411 | .icon-cog:before {
 412 |   content: "\f013";
 413 | }
 414 | .icon-trash:before {
 415 |   content: "\f014";
 416 | }
 417 | .icon-home:before {
 418 |   content: "\f015";
 419 | }
 420 | .icon-file:before {
 421 |   content: "\f016";
 422 | }
 423 | .icon-time:before {
 424 |   content: "\f017";
 425 | }
 426 | .icon-road:before {
 427 |   content: "\f018";
 428 | }
 429 | .icon-download-alt:before {
 430 |   content: "\f019";
 431 | }
 432 | .icon-download:before {
 433 |   content: "\f01a";
 434 | }
 435 | .icon-upload:before {
 436 |   content: "\f01b";
 437 | }
 438 | .icon-inbox:before {
 439 |   content: "\f01c";
 440 | }
 441 | .icon-play-circle:before {
 442 |   content: "\f01d";
 443 | }
 444 | .icon-repeat:before,
 445 | .icon-rotate-right:before {
 446 |   content: "\f01e";
 447 | }
 448 | /* F020 doesn't work in Safari. all shifted one down */
 449 | .icon-refresh:before {
 450 |   content: "\f021";
 451 | }
 452 | .icon-list-alt:before {
 453 |   content: "\f022";
 454 | }
 455 | .icon-lock:before {
 456 |   content: "\f023";
 457 | }
 458 | .icon-flag:before {
 459 |   content: "\f024";
 460 | }
 461 | .icon-headphones:before {
 462 |   content: "\f025";
 463 | }
 464 | .icon-volume-off:before {
 465 |   content: "\f026";
 466 | }
 467 | .icon-volume-down:before {
 468 |   content: "\f027";
 469 | }
 470 | .icon-volume-up:before {
 471 |   content: "\f028";
 472 | }
 473 | .icon-qrcode:before {
 474 |   content: "\f029";
 475 | }
 476 | .icon-barcode:before {
 477 |   content: "\f02a";
 478 | }
 479 | .icon-tag:before {
 480 |   content: "\f02b";
 481 | }
 482 | .icon-tags:before {
 483 |   content: "\f02c";
 484 | }
 485 | .icon-book:before {
 486 |   content: "\f02d";
 487 | }
 488 | .icon-bookmark:before {
 489 |   content: "\f02e";
 490 | }
 491 | .icon-print:before {
 492 |   content: "\f02f";
 493 | }
 494 | .icon-camera:before {
 495 |   content: "\f030";
 496 | }
 497 | .icon-font:before {
 498 |   content: "\f031";
 499 | }
 500 | .icon-bold:before {
 501 |   content: "\f032";
 502 | }
 503 | .icon-italic:before {
 504 |   content: "\f033";
 505 | }
 506 | .icon-text-height:before {
 507 |   content: "\f034";
 508 | }
 509 | .icon-text-width:before {
 510 |   content: "\f035";
 511 | }
 512 | .icon-align-left:before {
 513 |   content: "\f036";
 514 | }
 515 | .icon-align-center:before {
 516 |   content: "\f037";
 517 | }
 518 | .icon-align-right:before {
 519 |   content: "\f038";
 520 | }
 521 | .icon-align-justify:before {
 522 |   content: "\f039";
 523 | }
 524 | .icon-list:before {
 525 |   content: "\f03a";
 526 | }
 527 | .icon-indent-left:before {
 528 |   content: "\f03b";
 529 | }
 530 | .icon-indent-right:before {
 531 |   content: "\f03c";
 532 | }
 533 | .icon-facetime-video:before {
 534 |   content: "\f03d";
 535 | }
 536 | .icon-picture:before {
 537 |   content: "\f03e";
 538 | }
 539 | .icon-pencil:before {
 540 |   content: "\f040";
 541 | }
 542 | .icon-map-marker:before {
 543 |   content: "\f041";
 544 | }
 545 | .icon-adjust:before {
 546 |   content: "\f042";
 547 | }
 548 | .icon-tint:before {
 549 |   content: "\f043";
 550 | }
 551 | .icon-edit:before {
 552 |   content: "\f044";
 553 | }
 554 | .icon-share:before {
 555 |   content: "\f045";
 556 | }
 557 | .icon-check:before {
 558 |   content: "\f046";
 559 | }
 560 | .icon-move:before {
 561 |   content: "\f047";
 562 | }
 563 | .icon-step-backward:before {
 564 |   content: "\f048";
 565 | }
 566 | .icon-fast-backward:before {
 567 |   content: "\f049";
 568 | }
 569 | .icon-backward:before {
 570 |   content: "\f04a";
 571 | }
 572 | .icon-play:before {
 573 |   content: "\f04b";
 574 | }
 575 | .icon-pause:before {
 576 |   content: "\f04c";
 577 | }
 578 | .icon-stop:before {
 579 |   content: "\f04d";
 580 | }
 581 | .icon-forward:before {
 582 |   content: "\f04e";
 583 | }
 584 | .icon-fast-forward:before {
 585 |   content: "\f050";
 586 | }
 587 | .icon-step-forward:before {
 588 |   content: "\f051";
 589 | }
 590 | .icon-eject:before {
 591 |   content: "\f052";
 592 | }
 593 | .icon-chevron-left:before {
 594 |   content: "\f053";
 595 | }
 596 | .icon-chevron-right:before {
 597 |   content: "\f054";
 598 | }
 599 | .icon-plus-sign:before {
 600 |   content: "\f055";
 601 | }
 602 | .icon-minus-sign:before {
 603 |   content: "\f056";
 604 | }
 605 | .icon-remove-sign:before {
 606 |   content: "\f057";
 607 | }
 608 | .icon-ok-sign:before {
 609 |   content: "\f058";
 610 | }
 611 | .icon-question-sign:before {
 612 |   content: "\f059";
 613 | }
 614 | .icon-info-sign:before {
 615 |   content: "\f05a";
 616 | }
 617 | .icon-screenshot:before {
 618 |   content: "\f05b";
 619 | }
 620 | .icon-remove-circle:before {
 621 |   content: "\f05c";
 622 | }
 623 | .icon-ok-circle:before {
 624 |   content: "\f05d";
 625 | }
 626 | .icon-ban-circle:before {
 627 |   content: "\f05e";
 628 | }
 629 | .icon-arrow-left:before {
 630 |   content: "\f060";
 631 | }
 632 | .icon-arrow-right:before {
 633 |   content: "\f061";
 634 | }
 635 | .icon-arrow-up:before {
 636 |   content: "\f062";
 637 | }
 638 | .icon-arrow-down:before {
 639 |   content: "\f063";
 640 | }
 641 | .icon-share-alt:before,
 642 | .icon-mail-forward:before {
 643 |   content: "\f064";
 644 | }
 645 | .icon-resize-full:before {
 646 |   content: "\f065";
 647 | }
 648 | .icon-resize-small:before {
 649 |   content: "\f066";
 650 | }
 651 | .icon-plus:before {
 652 |   content: "\f067";
 653 | }
 654 | .icon-minus:before {
 655 |   content: "\f068";
 656 | }
 657 | .icon-asterisk:before {
 658 |   content: "\f069";
 659 | }
 660 | .icon-exclamation-sign:before {
 661 |   content: "\f06a";
 662 | }
 663 | .icon-gift:before {
 664 |   content: "\f06b";
 665 | }
 666 | .icon-leaf:before {
 667 |   content: "\f06c";
 668 | }
 669 | .icon-fire:before {
 670 |   content: "\f06d";
 671 | }
 672 | .icon-eye-open:before {
 673 |   content: "\f06e";
 674 | }
 675 | .icon-eye-close:before {
 676 |   content: "\f070";
 677 | }
 678 | .icon-warning-sign:before {
 679 |   content: "\f071";
 680 | }
 681 | .icon-plane:before {
 682 |   content: "\f072";
 683 | }
 684 | .icon-calendar:before {
 685 |   content: "\f073";
 686 | }
 687 | .icon-random:before {
 688 |   content: "\f074";
 689 | }
 690 | .icon-comment:before {
 691 |   content: "\f075";
 692 | }
 693 | .icon-magnet:before {
 694 |   content: "\f076";
 695 | }
 696 | .icon-chevron-up:before {
 697 |   content: "\f077";
 698 | }
 699 | .icon-chevron-down:before {
 700 |   content: "\f078";
 701 | }
 702 | .icon-retweet:before {
 703 |   content: "\f079";
 704 | }
 705 | .icon-shopping-cart:before {
 706 |   content: "\f07a";
 707 | }
 708 | .icon-folder-close:before {
 709 |   content: "\f07b";
 710 | }
 711 | .icon-folder-open:before {
 712 |   content: "\f07c";
 713 | }
 714 | .icon-resize-vertical:before {
 715 |   content: "\f07d";
 716 | }
 717 | .icon-resize-horizontal:before {
 718 |   content: "\f07e";
 719 | }
 720 | .icon-bar-chart:before {
 721 |   content: "\f080";
 722 | }
 723 | .icon-twitter-sign:before {
 724 |   content: "\f081";
 725 | }
 726 | .icon-facebook-sign:before {
 727 |   content: "\f082";
 728 | }
 729 | .icon-camera-retro:before {
 730 |   content: "\f083";
 731 | }
 732 | .icon-key:before {
 733 |   content: "\f084";
 734 | }
 735 | .icon-cogs:before {
 736 |   content: "\f085";
 737 | }
 738 | .icon-comments:before {
 739 |   content: "\f086";
 740 | }
 741 | .icon-thumbs-up:before {
 742 |   content: "\f087";
 743 | }
 744 | .icon-thumbs-down:before {
 745 |   content: "\f088";
 746 | }
 747 | .icon-star-half:before {
 748 |   content: "\f089";
 749 | }
 750 | .icon-heart-empty:before {
 751 |   content: "\f08a";
 752 | }
 753 | .icon-signout:before {
 754 |   content: "\f08b";
 755 | }
 756 | .icon-linkedin-sign:before {
 757 |   content: "\f08c";
 758 | }
 759 | .icon-pushpin:before {
 760 |   content: "\f08d";
 761 | }
 762 | .icon-external-link:before {
 763 |   content: "\f08e";
 764 | }
 765 | .icon-signin:before {
 766 |   content: "\f090";
 767 | }
 768 | .icon-trophy:before {
 769 |   content: "\f091";
 770 | }
 771 | .icon-github-sign:before {
 772 |   content: "\f092";
 773 | }
 774 | .icon-upload-alt:before {
 775 |   content: "\f093";
 776 | }
 777 | .icon-lemon:before {
 778 |   content: "\f094";
 779 | }
 780 | .icon-phone:before {
 781 |   content: "\f095";
 782 | }
 783 | .icon-check-empty:before {
 784 |   content: "\f096";
 785 | }
 786 | .icon-bookmark-empty:before {
 787 |   content: "\f097";
 788 | }
 789 | .icon-phone-sign:before {
 790 |   content: "\f098";
 791 | }
 792 | .icon-twitter:before {
 793 |   content: "\f099";
 794 | }
 795 | .icon-facebook:before {
 796 |   content: "\f09a";
 797 | }
 798 | .icon-github:before {
 799 |   content: "\f09b";
 800 | }
 801 | .icon-unlock:before {
 802 |   content: "\f09c";
 803 | }
 804 | .icon-credit-card:before {
 805 |   content: "\f09d";
 806 | }
 807 | .icon-rss:before {
 808 |   content: "\f09e";
 809 | }
 810 | .icon-hdd:before {
 811 |   content: "\f0a0";
 812 | }
 813 | .icon-bullhorn:before {
 814 |   content: "\f0a1";
 815 | }
 816 | .icon-bell:before {
 817 |   content: "\f0a2";
 818 | }
 819 | .icon-certificate:before {
 820 |   content: "\f0a3";
 821 | }
 822 | .icon-hand-right:before {
 823 |   content: "\f0a4";
 824 | }
 825 | .icon-hand-left:before {
 826 |   content: "\f0a5";
 827 | }
 828 | .icon-hand-up:before {
 829 |   content: "\f0a6";
 830 | }
 831 | .icon-hand-down:before {
 832 |   content: "\f0a7";
 833 | }
 834 | .icon-circle-arrow-left:before {
 835 |   content: "\f0a8";
 836 | }
 837 | .icon-circle-arrow-right:before {
 838 |   content: "\f0a9";
 839 | }
 840 | .icon-circle-arrow-up:before {
 841 |   content: "\f0aa";
 842 | }
 843 | .icon-circle-arrow-down:before {
 844 |   content: "\f0ab";
 845 | }
 846 | .icon-globe:before {
 847 |   content: "\f0ac";
 848 | }
 849 | .icon-wrench:before {
 850 |   content: "\f0ad";
 851 | }
 852 | .icon-tasks:before {
 853 |   content: "\f0ae";
 854 | }
 855 | .icon-filter:before {
 856 |   content: "\f0b0";
 857 | }
 858 | .icon-briefcase:before {
 859 |   content: "\f0b1";
 860 | }
 861 | .icon-fullscreen:before {
 862 |   content: "\f0b2";
 863 | }
 864 | .icon-group:before {
 865 |   content: "\f0c0";
 866 | }
 867 | .icon-link:before {
 868 |   content: "\f0c1";
 869 | }
 870 | .icon-cloud:before {
 871 |   content: "\f0c2";
 872 | }
 873 | .icon-beaker:before {
 874 |   content: "\f0c3";
 875 | }
 876 | .icon-cut:before {
 877 |   content: "\f0c4";
 878 | }
 879 | .icon-copy:before {
 880 |   content: "\f0c5";
 881 | }
 882 | .icon-paper-clip:before {
 883 |   content: "\f0c6";
 884 | }
 885 | .icon-save:before {
 886 |   content: "\f0c7";
 887 | }
 888 | .icon-sign-blank:before {
 889 |   content: "\f0c8";
 890 | }
 891 | .icon-reorder:before {
 892 |   content: "\f0c9";
 893 | }
 894 | .icon-list-ul:before {
 895 |   content: "\f0ca";
 896 | }
 897 | .icon-list-ol:before {
 898 |   content: "\f0cb";
 899 | }
 900 | .icon-strikethrough:before {
 901 |   content: "\f0cc";
 902 | }
 903 | .icon-underline:before {
 904 |   content: "\f0cd";
 905 | }
 906 | .icon-table:before {
 907 |   content: "\f0ce";
 908 | }
 909 | .icon-magic:before {
 910 |   content: "\f0d0";
 911 | }
 912 | .icon-truck:before {
 913 |   content: "\f0d1";
 914 | }
 915 | .icon-pinterest:before {
 916 |   content: "\f0d2";
 917 | }
 918 | .icon-pinterest-sign:before {
 919 |   content: "\f0d3";
 920 | }
 921 | .icon-google-plus-sign:before {
 922 |   content: "\f0d4";
 923 | }
 924 | .icon-google-plus:before {
 925 |   content: "\f0d5";
 926 | }
 927 | .icon-money:before {
 928 |   content: "\f0d6";
 929 | }
 930 | .icon-caret-down:before {
 931 |   content: "\f0d7";
 932 | }
 933 | .icon-caret-up:before {
 934 |   content: "\f0d8";
 935 | }
 936 | .icon-caret-left:before {
 937 |   content: "\f0d9";
 938 | }
 939 | .icon-caret-right:before {
 940 |   content: "\f0da";
 941 | }
 942 | .icon-columns:before {
 943 |   content: "\f0db";
 944 | }
 945 | .icon-sort:before {
 946 |   content: "\f0dc";
 947 | }
 948 | .icon-sort-down:before {
 949 |   content: "\f0dd";
 950 | }
 951 | .icon-sort-up:before {
 952 |   content: "\f0de";
 953 | }
 954 | .icon-envelope-alt:before {
 955 |   content: "\f0e0";
 956 | }
 957 | .icon-linkedin:before {
 958 |   content: "\f0e1";
 959 | }
 960 | .icon-undo:before,
 961 | .icon-rotate-left:before {
 962 |   content: "\f0e2";
 963 | }
 964 | .icon-legal:before {
 965 |   content: "\f0e3";
 966 | }
 967 | .icon-dashboard:before {
 968 |   content: "\f0e4";
 969 | }
 970 | .icon-comment-alt:before {
 971 |   content: "\f0e5";
 972 | }
 973 | .icon-comments-alt:before {
 974 |   content: "\f0e6";
 975 | }
 976 | .icon-bolt:before {
 977 |   content: "\f0e7";
 978 | }
 979 | .icon-sitemap:before {
 980 |   content: "\f0e8";
 981 | }
 982 | .icon-umbrella:before {
 983 |   content: "\f0e9";
 984 | }
 985 | .icon-paste:before {
 986 |   content: "\f0ea";
 987 | }
 988 | .icon-lightbulb:before {
 989 |   content: "\f0eb";
 990 | }
 991 | .icon-exchange:before {
 992 |   content: "\f0ec";
 993 | }
 994 | .icon-cloud-download:before {
 995 |   content: "\f0ed";
 996 | }
 997 | .icon-cloud-upload:before {
 998 |   content: "\f0ee";
 999 | }
1000 | .icon-user-md:before {
1001 |   content: "\f0f0";
1002 | }
1003 | .icon-stethoscope:before {
1004 |   content: "\f0f1";
1005 | }
1006 | .icon-suitcase:before {
1007 |   content: "\f0f2";
1008 | }
1009 | .icon-bell-alt:before {
1010 |   content: "\f0f3";
1011 | }
1012 | .icon-coffee:before {
1013 |   content: "\f0f4";
1014 | }
1015 | .icon-food:before {
1016 |   content: "\f0f5";
1017 | }
1018 | .icon-file-alt:before {
1019 |   content: "\f0f6";
1020 | }
1021 | .icon-building:before {
1022 |   content: "\f0f7";
1023 | }
1024 | .icon-hospital:before {
1025 |   content: "\f0f8";
1026 | }
1027 | .icon-ambulance:before {
1028 |   content: "\f0f9";
1029 | }
1030 | .icon-medkit:before {
1031 |   content: "\f0fa";
1032 | }
1033 | .icon-fighter-jet:before {
1034 |   content: "\f0fb";
1035 | }
1036 | .icon-beer:before {
1037 |   content: "\f0fc";
1038 | }
1039 | .icon-h-sign:before {
1040 |   content: "\f0fd";
1041 | }
1042 | .icon-plus-sign-alt:before {
1043 |   content: "\f0fe";
1044 | }
1045 | .icon-double-angle-left:before {
1046 |   content: "\f100";
1047 | }
1048 | .icon-double-angle-right:before {
1049 |   content: "\f101";
1050 | }
1051 | .icon-double-angle-up:before {
1052 |   content: "\f102";
1053 | }
1054 | .icon-double-angle-down:before {
1055 |   content: "\f103";
1056 | }
1057 | .icon-angle-left:before {
1058 |   content: "\f104";
1059 | }
1060 | .icon-angle-right:before {
1061 |   content: "\f105";
1062 | }
1063 | .icon-angle-up:before {
1064 |   content: "\f106";
1065 | }
1066 | .icon-angle-down:before {
1067 |   content: "\f107";
1068 | }
1069 | .icon-desktop:before {
1070 |   content: "\f108";
1071 | }
1072 | .icon-laptop:before {
1073 |   content: "\f109";
1074 | }
1075 | .icon-tablet:before {
1076 |   content: "\f10a";
1077 | }
1078 | .icon-mobile-phone:before {
1079 |   content: "\f10b";
1080 | }
1081 | .icon-circle-blank:before {
1082 |   content: "\f10c";
1083 | }
1084 | .icon-quote-left:before {
1085 |   content: "\f10d";
1086 | }
1087 | .icon-quote-right:before {
1088 |   content: "\f10e";
1089 | }
1090 | .icon-spinner:before {
1091 |   content: "\f110";
1092 | }
1093 | .icon-circle:before {
1094 |   content: "\f111";
1095 | }
1096 | .icon-reply:before,
1097 | .icon-mail-reply:before {
1098 |   content: "\f112";
1099 | }
1100 | .icon-folder-close-alt:before {
1101 |   content: "\f114";
1102 | }
1103 | .icon-folder-open-alt:before {
1104 |   content: "\f115";
1105 | }
1106 | .icon-expand-alt:before {
1107 |   content: "\f116";
1108 | }
1109 | .icon-collapse-alt:before {
1110 |   content: "\f117";
1111 | }
1112 | .icon-smile:before {
1113 |   content: "\f118";
1114 | }
1115 | .icon-frown:before {
1116 |   content: "\f119";
1117 | }
1118 | .icon-meh:before {
1119 |   content: "\f11a";
1120 | }
1121 | .icon-gamepad:before {
1122 |   content: "\f11b";
1123 | }
1124 | .icon-keyboard:before {
1125 |   content: "\f11c";
1126 | }
1127 | .icon-flag-alt:before {
1128 |   content: "\f11d";
1129 | }
1130 | .icon-flag-checkered:before {
1131 |   content: "\f11e";
1132 | }
1133 | .icon-terminal:before {
1134 |   content: "\f120";
1135 | }
1136 | .icon-code:before {
1137 |   content: "\f121";
1138 | }
1139 | .icon-reply-all:before {
1140 |   content: "\f122";
1141 | }
1142 | .icon-mail-reply-all:before {
1143 |   content: "\f122";
1144 | }
1145 | .icon-star-half-full:before,
1146 | .icon-star-half-empty:before {
1147 |   content: "\f123";
1148 | }
1149 | .icon-location-arrow:before {
1150 |   content: "\f124";
1151 | }
1152 | .icon-crop:before {
1153 |   content: "\f125";
1154 | }
1155 | .icon-code-fork:before {
1156 |   content: "\f126";
1157 | }
1158 | .icon-unlink:before {
1159 |   content: "\f127";
1160 | }
1161 | .icon-question:before {
1162 |   content: "\f128";
1163 | }
1164 | .icon-info:before {
1165 |   content: "\f129";
1166 | }
1167 | .icon-exclamation:before {
1168 |   content: "\f12a";
1169 | }
1170 | .icon-superscript:before {
1171 |   content: "\f12b";
1172 | }
1173 | .icon-subscript:before {
1174 |   content: "\f12c";
1175 | }
1176 | .icon-eraser:before {
1177 |   content: "\f12d";
1178 | }
1179 | .icon-puzzle-piece:before {
1180 |   content: "\f12e";
1181 | }
1182 | .icon-microphone:before {
1183 |   content: "\f130";
1184 | }
1185 | .icon-microphone-off:before {
1186 |   content: "\f131";
1187 | }
1188 | .icon-shield:before {
1189 |   content: "\f132";
1190 | }
1191 | .icon-calendar-empty:before {
1192 |   content: "\f133";
1193 | }
1194 | .icon-fire-extinguisher:before {
1195 |   content: "\f134";
1196 | }
1197 | .icon-rocket:before {
1198 |   content: "\f135";
1199 | }
1200 | .icon-maxcdn:before {
1201 |   content: "\f136";
1202 | }
1203 | .icon-chevron-sign-left:before {
1204 |   content: "\f137";
1205 | }
1206 | .icon-chevron-sign-right:before {
1207 |   content: "\f138";
1208 | }
1209 | .icon-chevron-sign-up:before {
1210 |   content: "\f139";
1211 | }
1212 | .icon-chevron-sign-down:before {
1213 |   content: "\f13a";
1214 | }
1215 | .icon-html5:before {
1216 |   content: "\f13b";
1217 | }
1218 | .icon-css3:before {
1219 |   content: "\f13c";
1220 | }
1221 | .icon-anchor:before {
1222 |   content: "\f13d";
1223 | }
1224 | .icon-unlock-alt:before {
1225 |   content: "\f13e";
1226 | }
1227 | .icon-bullseye:before {
1228 |   content: "\f140";
1229 | }
1230 | .icon-ellipsis-horizontal:before {
1231 |   content: "\f141";
1232 | }
1233 | .icon-ellipsis-vertical:before {
1234 |   content: "\f142";
1235 | }
1236 | .icon-rss-sign:before {
1237 |   content: "\f143";
1238 | }
1239 | .icon-play-sign:before {
1240 |   content: "\f144";
1241 | }
1242 | .icon-ticket:before {
1243 |   content: "\f145";
1244 | }
1245 | .icon-minus-sign-alt:before {
1246 |   content: "\f146";
1247 | }
1248 | .icon-check-minus:before {
1249 |   content: "\f147";
1250 | }
1251 | .icon-level-up:before {
1252 |   content: "\f148";
1253 | }
1254 | .icon-level-down:before {
1255 |   content: "\f149";
1256 | }
1257 | .icon-check-sign:before {
1258 |   content: "\f14a";
1259 | }
1260 | .icon-edit-sign:before {
1261 |   content: "\f14b";
1262 | }
1263 | .icon-external-link-sign:before {
1264 |   content: "\f14c";
1265 | }
1266 | .icon-share-sign:before {
1267 |   content: "\f14d";
1268 | }
1269 | 


--------------------------------------------------------------------------------
/docs/css/prettify.css:
--------------------------------------------------------------------------------
 1 | .pln { color: #000 }  /* plain text */
 2 | 
 3 | @media screen {
 4 |   .str { color: #080 }  /* string content */
 5 |   .kwd { color: #008 }  /* a keyword */
 6 |   .com { color: #800 }  /* a comment */
 7 |   .typ { color: #606 }  /* a type name */
 8 |   .lit { color: #066 }  /* a literal value */
 9 |   /* punctuation, lisp open bracket, lisp close bracket */
10 |   .pun, .opn, .clo { color: #660 }
11 |   .tag { color: #008 }  /* a markup tag name */
12 |   .atn { color: #606 }  /* a markup attribute name */
13 |   .atv { color: #080 }  /* a markup attribute value */
14 |   .dec, .var { color: #606 }  /* a declaration; a variable name */
15 |   .fun { color: red }  /* a function name */
16 | }
17 | 
18 | /* Use higher contrast and text-weight for printable form. */
19 | @media print, projection {
20 |   .str { color: #060 }
21 |   .kwd { color: #006; font-weight: bold }
22 |   .com { color: #600; font-style: italic }
23 |   .typ { color: #404; font-weight: bold }
24 |   .lit { color: #044 }
25 |   .pun, .opn, .clo { color: #440 }
26 |   .tag { color: #006; font-weight: bold }
27 |   .atn { color: #404 }
28 |   .atv { color: #060 }
29 | }
30 | 
31 | pre.prettyprint {
32 |   padding: 8px;
33 |   background-color: #f7f7f9;
34 |   border: 1px solid #e1e1e8;
35 | }
36 | pre.prettyprint.linenums {
37 |   -webkit-box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
38 |      -moz-box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
39 |           box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
40 | }
41 | ol.linenums {
42 |   margin: 0 0 0 33px; /* IE indents via margin-left */
43 | } 
44 | ol.linenums li {
45 |   padding-left: 12px;
46 |   font-size:12px;
47 |   color: #bebec5;
48 |   line-height: 18px;
49 |   text-shadow: 0 1px 0 #fff;
50 |   list-style-type:decimal!important;
51 | }
52 | 


--------------------------------------------------------------------------------
/docs/font/FontAwesome.otf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/balderdashy/angularSails/1deb8a05d737e5cb9224096378ebe949586cf570/docs/font/FontAwesome.otf


--------------------------------------------------------------------------------
/docs/font/fontawesome-webfont.eot:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/balderdashy/angularSails/1deb8a05d737e5cb9224096378ebe949586cf570/docs/font/fontawesome-webfont.eot


--------------------------------------------------------------------------------
/docs/font/fontawesome-webfont.ttf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/balderdashy/angularSails/1deb8a05d737e5cb9224096378ebe949586cf570/docs/font/fontawesome-webfont.ttf


--------------------------------------------------------------------------------
/docs/font/fontawesome-webfont.woff:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/balderdashy/angularSails/1deb8a05d737e5cb9224096378ebe949586cf570/docs/font/fontawesome-webfont.woff


--------------------------------------------------------------------------------
/docs/index.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <!--[if lt IE 7]> <html class="no-js lt-ie9 lt-ie8 lt-ie7 ng-app: docsApp; " lang="en" ng-controller="DocsController"> <![endif]-->
  3 | <!--[if IE 7]>    <html class="no-js lt-ie9 lt-ie8 ng-app: docsApp; " lang="en" ng-controller="DocsController"> <![endif]-->
  4 | <!--[if IE 8]>    <html class="no-js lt-ie9 ng-app: docsApp; " lang="en" ng-controller="DocsController"> <![endif]-->
  5 | <!--[if gt IE 8]><!--> <html class="no-js ng-app: docsApp; " lang="en" ng-controller="DocsController"> <!--<![endif]-->
  6 | <head>
  7 |   <meta charset="utf-8">
  8 |   <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
  9 |   <meta name="Description"
 10 |         content="AngularJS is what HTML would have been, had it been designed for building web-apps.
 11 |                  Declarative templates with data-binding, MVC, dependency injection and great
 12 |                  testability story all implemented with pure client-side JavaScript!">
 13 |   <meta name="fragment" content="!">
 14 |   <title ng-bind-template="Doc: {{partialTitle}}">Docs</title>
 15 |   <script type="text/javascript">
 16 |     // dynamically add base tag as well as css and javascript files.
 17 |     // we can't add css/js the usual way, because some browsers (FF) eagerly prefetch resources
 18 |     // before the base attribute is added, causing 404 and terribly slow loading of the docs app.
 19 |     (function() {
 20 |       var indexFile = (location.pathname.match(/\/(index[^\.]*\.html)/) || ['', ''])[1],
 21 |           rUrl = /(#!\/|api|index[^\.]*\.html).*$/,
 22 |           baseUrl = location.href.replace(rUrl, indexFile),
 23 |           headEl = document.getElementsByTagName('head')[0],
 24 |           sync = true;
 25 | 
 26 |       addTag('base', {href: baseUrl});
 27 |       addTag('link', {rel: 'stylesheet', href: 'css/bootstrap.min.css', type: 'text/css'});
 28 |       addTag('link', {rel: 'stylesheet', href: 'css/font-awesome.css', type: 'text/css'});
 29 |       addTag('link', {rel: 'stylesheet', href: 'css/prettify.css', type: 'text/css'});
 30 |       addTag('link', {rel: 'stylesheet', href: 'css/docs.css', type: 'text/css'});
 31 |       addTag('link', {rel: 'stylesheet', href: 'css/animations.css', type: 'text/css'});
 32 | 
 33 |       
 34 | 
 35 |       addTag('script', {src: 'js/google-code-prettify.js'}, sync);
 36 |       addTag('script', {src: 'js/marked.js'}, sync);
 37 | 
 38 |       
 39 |         addTag('script', {src: 'js/angular.min.js'}, sync);
 40 |       
 41 |       
 42 |       addTag('script', {src: 'js/angular-bootstrap.js'}, sync);
 43 |       addTag('script', {src: 'js/angular-bootstrap-prettify.js'}, sync);
 44 |       addTag('script', {src: 'js/docs-setup.js'}, sync);
 45 |       addTag('script', {src: 'js/docs.js'}, sync);
 46 |       
 47 |       function addTag(name, attributes, sync) {
 48 |         var el = document.createElement(name),
 49 |             attrName;
 50 | 
 51 |         for (attrName in attributes) {
 52 |           el.setAttribute(attrName, attributes[attrName]);
 53 |         }
 54 | 
 55 |         sync ? document.write(outerHTML(el)) : headEl.appendChild(el);
 56 |       }
 57 | 
 58 |       function outerHTML(node){
 59 |         // if IE, Chrome take the internal method otherwise build one
 60 |         return node.outerHTML || (
 61 |             function(n){
 62 |                 var div = document.createElement('div'), h;
 63 |                 div.appendChild(n);
 64 |                 h = div.innerHTML;
 65 |                 div = null;
 66 |                 return h;
 67 |             })(node);
 68 |       }
 69 |     })();
 70 | 
 71 |   </script>
 72 | </head>
 73 | 
 74 | <body>
 75 |   <header class="header">
 76 |     <div class="navbar navbar-fixed-top">
 77 |       <div class="navbar-inner">
 78 |         <div class="container">
 79 |           
 80 |           
 81 |           <ul class="nav">
 82 |             <li ng-repeat="(url, name) in sections" ng-class="{active: isActivePath(url)}">
 83 |               <a ng-href="{{url}}"><i class="icon-book icon-white"></i> {{name}}</a>
 84 |             </li>
 85 |           </ul>
 86 |           
 87 |         </div>
 88 |       </div>
 89 |     </div>
 90 |   </header>
 91 | 
 92 |   <div role="main" class="container">
 93 |     <div class="row clear-navbar"></div>
 94 | 
 95 |     <div class="row">
 96 |       <div class="span12">
 97 |         <!--[if lt IE 7]>
 98 |         <p class="alert alert-error">Your browser is <em>ancient!</em>
 99 |           <a href="http://browsehappy.com/">Upgrade to a different browser</a> or
100 |           <a href="http://www.google.com/chromeframe/?redirect=true">install Google Chrome Frame</a> to
101 |           experience this site.
102 |         </p>
103 |         <![endif]-->
104 | 
105 |         <!--[if lt IE 9]>
106 |         <div class="alert">
107 |           You are using an old version of Internet Explorer.
108 |           For better and safer browsing experience please <a href="http://www.microsoft.com/IE9">upgrade IE</a>
109 |           or install <a href="http://google.com/chrome">Google Chrome browser</a>.
110 |         </div>
111 |         <![endif]-->
112 |       </div>
113 | 
114 |     </div>
115 | 
116 |     <div class="row">
117 |       <div class="span3">
118 |         <form class="form-search" ng-submit="submitForm()">
119 |           
120 |           <input type="text" ng-model="search" placeholder="search the docs"
121 |                  tabindex="1" accesskey="s" class="search-query">
122 |           
123 |           <div class="spacer"></div>
124 | 
125 |           <ul class="nav nav-list well" ng-show="pages">
126 |             <li ng-repeat="page in pages track by page.url" ng-class="navClass(page)" class="api-list-item expand">
127 |               <a href="{{page.url}}" tabindex="2">{{page.shortName}}</a>
128 |             </li>
129 |           </ul>
130 | 
131 |           <ul class="nav nav-list well" ng-repeat="module in modules track by module.url" class="api-list-item">
132 |             <li class="nav-header module">
133 |               <a class="guide">module</a>
134 |               <a class="code" href="{{module.url}}">{{module.name}}</a>
135 |             </li>
136 | 
137 |             <li ng-repeat="page in module.others track by page.url" ng-class="navClass(page)" class="api-list-item expand">
138 |               <a href="{{page.url}}" tabindex="2">{{page.shortName}}</a>
139 |             </li>
140 | 
141 |             <li class="nav-header section" ng-show="module.directives">
142 |               <a class="guide">directive</a>
143 |             </li>
144 |             <li ng-repeat="page in module.directives track by page.url" ng-class="navClass(page)" class="api-list-item expand">
145 |               <a href="{{page.url}}" tabindex="2">{{page.shortName}}</a>
146 |             </li>
147 | 
148 |             <li class="nav-header section" ng-show="module.controllers">
149 |               <a class="guide">controller</a>
150 |             </li>
151 |             <li ng-repeat="page in module.controllers track by page.url" ng-class="navClass(page)" class="api-list-item expand">
152 |               <a href="{{page.url}}" tabindex="2">{{page.shortName}}</a>
153 |             </li>
154 | 
155 |             <li class="nav-header section" ng-show="module.filters">
156 |               <a class="guide">filter</a>
157 |             </li>
158 |             <li ng-repeat="page in module.filters track by page.url" ng-class="navClass(page)" class="api-list-item expand">
159 |               <a href="{{page.url}}" tabindex="2">{{page.shortName}}</a>
160 |             </li>
161 | 
162 |             <li class="nav-header section" ng-show="module.services">
163 |               <a class="guide">service</a>
164 |             </li>
165 |             <li ng-repeat="service in module.services track by service.instance.url" ng-class="navClass(service.instance, service.provider)" class="api-list-item expand">
166 |               <a ng-show="service.provider" class="pull-right" href="{{service.provider.url}}" tabindex="2"><i class="icon-cog"></i></a>
167 |               <a href="{{service.instance.url}}" tabindex="2">{{service.name}}</a>
168 |             </li>
169 | 
170 |             <li class="nav-header section" ng-show="module.types">
171 |               <a class="guide">Types</a>
172 |             </li>
173 |             <li ng-repeat="page in module.types track by page.url" ng-class="navClass(page)" class="api-list-item expand">
174 |               <a href="{{page.url}}" tabindex="2">{{page.shortName}}</a>
175 |             </li>
176 | 
177 |             <li class="nav-header section" ng-show="module.globals">
178 |               <a class="global guide">global APIs</a>
179 |               &nbsp;
180 |             </li>
181 |             <li ng-repeat="page in module.globals track by page.url" ng-class="navClass(page)" class="api-list-item expand">
182 |               <a href="{{page.url}}" tabindex="2">{{page.id}}</a>
183 |             </li>
184 | 
185 |           </ul>
186 | 
187 |         </form>
188 |       </div>
189 |       <div class="span9">
190 | 
191 |         <ul class="breadcrumb">
192 |           <li ng-repeat="crumb in breadcrumb">
193 |             <span ng-hide="crumb.url">{{crumb.name}}</span>
194 |             <a ng-show="crumb.url" href="{{crumb.url}}">{{crumb.name}}</a>
195 |             <span ng-show="crumb.url" class="divider">/</span>
196 |           </li>
197 |         </ul>
198 | 
199 |         <div id="loading" ng-show="loading">Loading...</div>
200 | 
201 |         <div ng-hide="loading" ng-include src="currentPage.partialUrl" onload="afterPartialLoaded()" autoscroll class="content slide-reveal"></div>
202 | 
203 |       </div>
204 |     </div>
205 |   </div>
206 | 
207 | </body>
208 | </html>
209 | 


--------------------------------------------------------------------------------
/docs/js/angular-bootstrap-prettify.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | var directive = {};
  4 | var service = { value: {} };
  5 | 
  6 | var DEPENDENCIES = {
  7 |   'angular.js': 'http://code.angularjs.org/' + angular.version.full + '/angular.min.js',
  8 |   'angular-resource.js': 'http://code.angularjs.org/' + angular.version.full + '/angular-resource.min.js',
  9 |   'angular-route.js': 'http://code.angularjs.org/' + angular.version.full + '/angular-route.min.js',
 10 |   'angular-animate.js': 'http://code.angularjs.org/' + angular.version.full + '/angular-animate.min.js',
 11 |   'angular-sanitize.js': 'http://code.angularjs.org/' + angular.version.full + '/angular-sanitize.min.js',
 12 |   'angular-cookies.js': 'http://code.angularjs.org/' + angular.version.full + '/angular-cookies.min.js'
 13 | };
 14 | 
 15 | 
 16 | function escape(text) {
 17 |   return text.
 18 |     replace(/\&/g, '&amp;').
 19 |     replace(/\</g, '&lt;').
 20 |     replace(/\>/g, '&gt;').
 21 |     replace(/"/g, '&quot;');
 22 | }
 23 | 
 24 | /**
 25 |  * http://stackoverflow.com/questions/451486/pre-tag-loses-line-breaks-when-setting-innerhtml-in-ie
 26 |  * http://stackoverflow.com/questions/195363/inserting-a-newline-into-a-pre-tag-ie-javascript
 27 |  */
 28 | function setHtmlIe8SafeWay(element, html) {
 29 |   var newElement = angular.element('<pre>' + html + '</pre>');
 30 | 
 31 |   element.empty();
 32 |   element.append(newElement.contents());
 33 |   return element;
 34 | }
 35 | 
 36 | 
 37 | directive.jsFiddle = function(getEmbeddedTemplate, escape, script) {
 38 |   return {
 39 |     terminal: true,
 40 |     link: function(scope, element, attr) {
 41 |       var name = '',
 42 |         stylesheet = '<link rel="stylesheet" href="http://twitter.github.com/bootstrap/assets/css/bootstrap.css">\n',
 43 |         fields = {
 44 |           html: '',
 45 |           css: '',
 46 |           js: ''
 47 |         };
 48 | 
 49 |       angular.forEach(attr.jsFiddle.split(' '), function(file, index) {
 50 |         var fileType = file.split('.')[1];
 51 | 
 52 |         if (fileType == 'html') {
 53 |           if (index == 0) {
 54 |             fields[fileType] +=
 55 |               '<div ng-app' + (attr.module ? '="' + attr.module + '"' : '') + '>\n' +
 56 |                 getEmbeddedTemplate(file, 2);
 57 |           } else {
 58 |             fields[fileType] += '\n\n\n  <!-- CACHE FILE: ' + file + ' -->\n' +
 59 |               '  <script type="text/ng-template" id="' + file + '">\n' +
 60 |               getEmbeddedTemplate(file, 4) +
 61 |               '  </script>\n';
 62 |           }
 63 |         } else {
 64 |           fields[fileType] += getEmbeddedTemplate(file) + '\n';
 65 |         }
 66 |       });
 67 | 
 68 |       fields.html += '</div>\n';
 69 | 
 70 |       setHtmlIe8SafeWay(element,
 71 |         '<form class="jsfiddle" method="post" action="http://jsfiddle.net/api/post/library/pure/" target="_blank">' +
 72 |           hiddenField('title', 'AngularJS Example: ' + name) +
 73 |           hiddenField('css', '</style> <!-- Ugly Hack due to jsFiddle issue: http://goo.gl/BUfGZ --> \n' +
 74 |             stylesheet +
 75 |             script.angular +
 76 |             (attr.resource ? script.resource : '') +
 77 |             '<style>\n' +
 78 |             fields.css) +
 79 |           hiddenField('html', fields.html) +
 80 |           hiddenField('js', fields.js) +
 81 |           '<button class="btn btn-primary"><i class="icon-white icon-pencil"></i> Edit Me</button>' +
 82 |           '</form>');
 83 | 
 84 |       function hiddenField(name, value) {
 85 |         return '<input type="hidden" name="' +  name + '" value="' + escape(value) + '">';
 86 |       }
 87 |     }
 88 |   }
 89 | };
 90 | 
 91 | 
 92 | directive.code = function() {
 93 |   return {restrict: 'E', terminal: true};
 94 | };
 95 | 
 96 | 
 97 | directive.prettyprint = ['reindentCode', function(reindentCode) {
 98 |   return {
 99 |     restrict: 'C',
100 |     compile: function(element) {
101 |       var html = element.html();
102 |       //ensure that angular won't compile {{ curly }} values
103 |       html = html.replace(/\{\{/g, '<span>{{</span>')
104 |                  .replace(/\}\}/g, '<span>}}</span>');
105 |       if (window.RUNNING_IN_NG_TEST_RUNNER) {
106 |         element.html(html);
107 |       }
108 |       else {
109 |         element.html(window.prettyPrintOne(reindentCode(html), undefined, true));
110 |       }
111 |     }
112 |   };
113 | }];
114 | 
115 | 
116 | directive.ngSetText = ['getEmbeddedTemplate', function(getEmbeddedTemplate) {
117 |   return {
118 |     restrict: 'CA',
119 |     priority: 10,
120 |     compile: function(element, attr) {
121 |       setHtmlIe8SafeWay(element, escape(getEmbeddedTemplate(attr.ngSetText)));
122 |     }
123 |   }
124 | }]
125 | 
126 | 
127 | directive.ngHtmlWrap = ['reindentCode', 'templateMerge', function(reindentCode, templateMerge) {
128 |   return {
129 |     compile: function(element, attr) {
130 |       var properties = {
131 |             head: '',
132 |             module: '',
133 |             body: element.text()
134 |           },
135 |         html = "<!doctype html>\n<html ng-app{{module}}>\n  <head>\n{{head:4}}  </head>\n  <body>\n{{body:4}}  </body>\n</html>";
136 | 
137 |       angular.forEach((attr.ngHtmlWrap || '').split(' '), function(dep) {
138 |         if (!dep) return;
139 |         dep = DEPENDENCIES[dep] || dep;
140 | 
141 |         var ext = dep.split(/\./).pop();
142 | 
143 |         if (ext == 'css') {
144 |           properties.head += '<link rel="stylesheet" href="' + dep + '" type="text/css">\n';
145 |         } else if(ext == 'js') {
146 |           properties.head += '<script src="' + dep + '"></script>\n';
147 |         } else {
148 |           properties.module = '="' + dep + '"';
149 |         }
150 |       });
151 | 
152 |       setHtmlIe8SafeWay(element, escape(templateMerge(html, properties)));
153 |     }
154 |   }
155 | }];
156 | 
157 | 
158 | directive.ngSetHtml = ['getEmbeddedTemplate', function(getEmbeddedTemplate) {
159 |   return {
160 |     restrict: 'CA',
161 |     priority: 10,
162 |     compile: function(element, attr) {
163 |       setHtmlIe8SafeWay(element, getEmbeddedTemplate(attr.ngSetHtml));
164 |     }
165 |   }
166 | }];
167 | 
168 | 
169 | directive.ngEvalJavascript = ['getEmbeddedTemplate', function(getEmbeddedTemplate) {
170 |   return {
171 |     compile: function (element, attr) {
172 |       var fileNames = attr.ngEvalJavascript.split(' ');
173 |       angular.forEach(fileNames, function(fileName) {
174 |         var script = getEmbeddedTemplate(fileName);
175 |         try {
176 |           if (window.execScript) { // IE
177 |             window.execScript(script || '""'); // IE complains when evaling empty string
178 |           } else {
179 |             window.eval(script + '//@ sourceURL=' + fileName);
180 |           }
181 |         } catch (e) {
182 |           if (window.console) {
183 |             window.console.log(script, '\n', e);
184 |           } else {
185 |             window.alert(e);
186 |           }
187 |         }
188 |       });
189 |     }
190 |   };
191 | }];
192 | 
193 | 
194 | directive.ngEmbedApp = ['$templateCache', '$browser', '$rootScope', '$location', '$sniffer', '$animate',
195 |                 function($templateCache,   $browser,  docsRootScope, $location,   $sniffer,   $animate) {
196 |   return {
197 |     terminal: true,
198 |     link: function(scope, element, attrs) {
199 |       var modules = ['ngAnimate'],
200 |           embedRootScope,
201 |           deregisterEmbedRootScope;
202 | 
203 |       modules.push(['$provide', function($provide) {
204 |         $provide.value('$templateCache', $templateCache);
205 |         $provide.value('$anchorScroll', angular.noop);
206 |         $provide.value('$browser', $browser);
207 |         $provide.value('$sniffer', $sniffer);
208 |         $provide.value('$animate', $animate);
209 |         $provide.provider('$location', function() {
210 |           this.$get = ['$rootScope', function($rootScope) {
211 |             docsRootScope.$on('$locationChangeSuccess', function(event, oldUrl, newUrl) {
212 |               $rootScope.$broadcast('$locationChangeSuccess', oldUrl, newUrl);
213 |             });
214 |             return $location;
215 |           }];
216 |           this.html5Mode = angular.noop;
217 |         });
218 | 
219 |         $provide.decorator('$rootScope', ['$delegate', function($delegate) {
220 |           embedRootScope = $delegate;
221 | 
222 |           // Since we are teleporting the $animate service, which relies on the $$postDigestQueue
223 |           // we need the embedded scope to use the same $$postDigestQueue as the outer scope
224 |           embedRootScope.$$postDigestQueue = docsRootScope.$$postDigestQueue;
225 | 
226 |           deregisterEmbedRootScope = docsRootScope.$watch(function embedRootScopeDigestWatch() {
227 |             embedRootScope.$digest();
228 |           });
229 | 
230 |           return embedRootScope;
231 |         }]);
232 |       }]);
233 |       if (attrs.ngEmbedApp)  modules.push(attrs.ngEmbedApp);
234 | 
235 |       element.on('click', function(event) {
236 |         if (event.target.attributes.getNamedItem('ng-click')) {
237 |           event.preventDefault();
238 |         }
239 |       });
240 | 
241 |       element.bind('$destroy', function() {
242 |         deregisterEmbedRootScope();
243 |         embedRootScope.$destroy();
244 |       });
245 | 
246 |       element.data('$injector', null);
247 |       angular.bootstrap(element, modules);
248 |     }
249 |   };
250 | }];
251 | 
252 | service.reindentCode = function() {
253 |   return function (text, spaces) {
254 |     if (!text) return text;
255 |     var lines = text.split(/\r?\n/);
256 |     var prefix = '      '.substr(0, spaces || 0);
257 |     var i;
258 | 
259 |     // remove any leading blank lines
260 |     while (lines.length && lines[0].match(/^\s*$/)) lines.shift();
261 |     // remove any trailing blank lines
262 |     while (lines.length && lines[lines.length - 1].match(/^\s*$/)) lines.pop();
263 |     var minIndent = 999;
264 |     for (i = 0; i < lines.length; i++) {
265 |       var line = lines[0];
266 |       var reindentCode = line.match(/^\s*/)[0];
267 |       if (reindentCode !== line && reindentCode.length < minIndent) {
268 |         minIndent = reindentCode.length;
269 |       }
270 |     }
271 | 
272 |     for (i = 0; i < lines.length; i++) {
273 |       lines[i] = prefix + lines[i].substring(minIndent);
274 |     }
275 |     lines.push('');
276 |     return lines.join('\n');
277 |   }
278 | };
279 | 
280 | service.templateMerge = ['reindentCode', function(indentCode) {
281 |   return function(template, properties) {
282 |     return template.replace(/\{\{(\w+)(?:\:(\d+))?\}\}/g, function(_, key, indent) {
283 |       var value = properties[key];
284 | 
285 |       if (indent) {
286 |         value = indentCode(value, indent);
287 |       }
288 | 
289 |       return value == undefined ? '' : value;
290 |     });
291 |   };
292 | }];
293 | 
294 | service.getEmbeddedTemplate = ['reindentCode', function(reindentCode) {
295 |   return function (id) {
296 |     var element = document.getElementById(id);
297 | 
298 |     if (!element) {
299 |       return null;
300 |     }
301 | 
302 |     return reindentCode(angular.element(element).html(), 0);
303 |   }
304 | }];
305 | 
306 | 
307 | angular.module('bootstrapPrettify', []).directive(directive).factory(service);
308 | 


--------------------------------------------------------------------------------
/docs/js/angular-bootstrap.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | var directive = {};
  4 | 
  5 | directive.dropdownToggle =
  6 |           ['$document', '$location', '$window',
  7 |   function ($document,   $location,   $window) {
  8 |     var openElement = null, close;
  9 |     return {
 10 |       restrict: 'C',
 11 |       link: function(scope, element, attrs) {
 12 |         scope.$watch(function dropdownTogglePathWatch(){return $location.path();}, function dropdownTogglePathWatchAction() {
 13 |           close && close();
 14 |         });
 15 | 
 16 |         element.parent().on('click', function(event) {
 17 |           close && close();
 18 |         });
 19 | 
 20 |         element.on('click', function(event) {
 21 |           event.preventDefault();
 22 |           event.stopPropagation();
 23 | 
 24 |           var iWasOpen = false;
 25 | 
 26 |           if (openElement) {
 27 |             iWasOpen = openElement === element;
 28 |             close();
 29 |           }
 30 | 
 31 |           if (!iWasOpen){
 32 |             element.parent().addClass('open');
 33 |             openElement = element;
 34 | 
 35 |             close = function (event) {
 36 |               event && event.preventDefault();
 37 |               event && event.stopPropagation();
 38 |               $document.off('click', close);
 39 |               element.parent().removeClass('open');
 40 |               close = null;
 41 |               openElement = null;
 42 |             }
 43 | 
 44 |             $document.on('click', close);
 45 |           }
 46 |         });
 47 |       }
 48 |     };
 49 |   }];
 50 | 
 51 | directive.syntax = function() {
 52 |   return {
 53 |     restrict: 'A',
 54 |     link: function(scope, element, attrs) {
 55 |       function makeLink(type, text, link, icon) {
 56 |         return '<a href="' + link + '" class="btn syntax-' + type + '" target="_blank" rel="nofollow">' + 
 57 |                 '<span class="' + icon + '"></span> ' + text +
 58 |                '</a>';
 59 |       };
 60 | 
 61 |       var html = '';
 62 |       var types = {
 63 |         'github' : {
 64 |           text : 'View on Github',
 65 |           key : 'syntaxGithub',
 66 |           icon : 'icon-github'
 67 |         },
 68 |         'plunkr' : {
 69 |           text : 'View on Plunkr',
 70 |           key : 'syntaxPlunkr',
 71 |           icon : 'icon-arrow-down'
 72 |         },
 73 |         'jsfiddle' : {
 74 |           text : 'View on JSFiddle',
 75 |           key : 'syntaxFiddle',
 76 |           icon : 'icon-cloud'
 77 |         }
 78 |       };
 79 |       for(var type in types) {
 80 |         var data = types[type];
 81 |         var link = attrs[data.key];
 82 |         if(link) {
 83 |           html += makeLink(type, data.text, link, data.icon);
 84 |         }
 85 |       };
 86 | 
 87 |       var nav = document.createElement('nav');
 88 |       nav.className = 'syntax-links';
 89 |       nav.innerHTML = html;
 90 | 
 91 |       var node = element[0];
 92 |       var par = node.parentNode;
 93 |       par.insertBefore(nav, node);
 94 |     }
 95 |   }
 96 | }
 97 | 
 98 | directive.tabbable = function() {
 99 |   return {
100 |     restrict: 'C',
101 |     compile: function(element) {
102 |       var navTabs = angular.element('<ul class="nav nav-tabs"></ul>'),
103 |           tabContent = angular.element('<div class="tab-content"></div>');
104 | 
105 |       tabContent.append(element.contents());
106 |       element.append(navTabs).append(tabContent);
107 |     },
108 |     controller: ['$scope', '$element', function($scope, $element) {
109 |       var navTabs = $element.contents().eq(0),
110 |           ngModel = $element.controller('ngModel') || {},
111 |           tabs = [],
112 |           selectedTab;
113 | 
114 |       ngModel.$render = function() {
115 |         var $viewValue = this.$viewValue;
116 | 
117 |         if (selectedTab ? (selectedTab.value != $viewValue) : $viewValue) {
118 |           if(selectedTab) {
119 |             selectedTab.paneElement.removeClass('active');
120 |             selectedTab.tabElement.removeClass('active');
121 |             selectedTab = null;
122 |           }
123 |           if($viewValue) {
124 |             for(var i = 0, ii = tabs.length; i < ii; i++) {
125 |               if ($viewValue == tabs[i].value) {
126 |                 selectedTab = tabs[i];
127 |                 break;
128 |               }
129 |             }
130 |             if (selectedTab) {
131 |               selectedTab.paneElement.addClass('active');
132 |               selectedTab.tabElement.addClass('active');
133 |             }
134 |           }
135 | 
136 |         }
137 |       };
138 | 
139 |       this.addPane = function(element, attr) {
140 |         var li = angular.element('<li><a href></a></li>'),
141 |             a = li.find('a'),
142 |             tab = {
143 |               paneElement: element,
144 |               paneAttrs: attr,
145 |               tabElement: li
146 |             };
147 | 
148 |         tabs.push(tab);
149 | 
150 |         attr.$observe('value', update)();
151 |         attr.$observe('title', function(){ update(); a.text(tab.title); })();
152 | 
153 |         function update() {
154 |           tab.title = attr.title;
155 |           tab.value = attr.value || attr.title;
156 |           if (!ngModel.$setViewValue && (!ngModel.$viewValue || tab == selectedTab)) {
157 |             // we are not part of angular
158 |             ngModel.$viewValue = tab.value;
159 |           }
160 |           ngModel.$render();
161 |         }
162 | 
163 |         navTabs.append(li);
164 |         li.on('click', function(event) {
165 |           event.preventDefault();
166 |           event.stopPropagation();
167 |           if (ngModel.$setViewValue) {
168 |             $scope.$apply(function() {
169 |               ngModel.$setViewValue(tab.value);
170 |               ngModel.$render();
171 |             });
172 |           } else {
173 |             // we are not part of angular
174 |             ngModel.$viewValue = tab.value;
175 |             ngModel.$render();
176 |           }
177 |         });
178 | 
179 |         return function() {
180 |           tab.tabElement.remove();
181 |           for(var i = 0, ii = tabs.length; i < ii; i++ ) {
182 |             if (tab == tabs[i]) {
183 |               tabs.splice(i, 1);
184 |             }
185 |           }
186 |         };
187 |       }
188 |     }]
189 |   };
190 | };
191 | 
192 | directive.table = function() {
193 |   return {
194 |     restrict: 'E',
195 |     link: function(scope, element, attrs) {
196 |       if (!attrs['class']) {
197 |         element.addClass('table table-bordered table-striped code-table');
198 |       }
199 |     }
200 |   };
201 | };
202 | 
203 | var popoverElement = function() {
204 |   var object = {
205 |     init : function() {
206 |       this.element = angular.element(
207 |         '<div class="popover popover-incode top">' +
208 |           '<div class="arrow"></div>' +
209 |           '<div class="popover-inner">' +
210 |             '<div class="popover-title"><code></code></div>' +
211 |             '<div class="popover-content"></div>' +
212 |           '</div>' +
213 |         '</div>'
214 |       );
215 |       this.node = this.element[0];
216 |       this.element.css({
217 |         'display':'block',
218 |         'position':'absolute'
219 |       });
220 |       angular.element(document.body).append(this.element);
221 | 
222 |       var inner = this.element.children()[1];
223 |       this.titleElement   = angular.element(inner.childNodes[0].firstChild);
224 |       this.contentElement = angular.element(inner.childNodes[1]);
225 | 
226 |       //stop the click on the tooltip
227 |       this.element.bind('click', function(event) {
228 |         event.preventDefault();
229 |         event.stopPropagation();
230 |       });
231 | 
232 |       var self = this;
233 |       angular.element(document.body).bind('click',function(event) {
234 |         if(self.visible()) self.hide();
235 |       });
236 |     },
237 | 
238 |     show : function(x,y) {
239 |       this.element.addClass('visible');
240 |       this.position(x || 0, y || 0);
241 |     },
242 | 
243 |     hide : function() {
244 |       this.element.removeClass('visible');
245 |       this.position(-9999,-9999);
246 |     },
247 | 
248 |     visible : function() {
249 |       return this.position().y >= 0;
250 |     },
251 | 
252 |     isSituatedAt : function(element) {
253 |       return this.besideElement ? element[0] == this.besideElement[0] : false;
254 |     },
255 | 
256 |     title : function(value) {
257 |       return this.titleElement.html(value);
258 |     },
259 | 
260 |     content : function(value) { 
261 |       if(value && value.length > 0) {
262 |         value = marked(value);
263 |       }
264 |       return this.contentElement.html(value);
265 |     },
266 | 
267 |     positionArrow : function(position) {
268 |       this.node.className = 'popover ' + position;
269 |     },
270 | 
271 |     positionAway : function() {
272 |       this.besideElement = null;
273 |       this.hide();
274 |     },
275 | 
276 |     positionBeside : function(element) {
277 |       this.besideElement = element;
278 | 
279 |       var elm = element[0];
280 |       var x = elm.offsetLeft;
281 |       var y = elm.offsetTop;
282 |       x -= 30;
283 |       y -= this.node.offsetHeight + 10;
284 |       this.show(x,y);
285 |     },
286 | 
287 |     position : function(x,y) {
288 |       if(x != null && y != null) {
289 |         this.element.css('left',x + 'px');
290 |         this.element.css('top', y + 'px');
291 |       }
292 |       else {
293 |         return {
294 |           x : this.node.offsetLeft,
295 |           y : this.node.offsetTop
296 |         };
297 |       }
298 |     }
299 |   };
300 | 
301 |   object.init();
302 |   object.hide();
303 | 
304 |   return object;
305 | };
306 | 
307 | directive.popover = ['popoverElement', function(popover) {
308 |   return {
309 |     restrict: 'A',
310 |     priority : 500,
311 |     link: function(scope, element, attrs) {
312 |       element.bind('click',function(event) {
313 |         event.preventDefault();
314 |         event.stopPropagation();
315 |         if(popover.isSituatedAt(element) && popover.visible()) {
316 |           popover.title('');
317 |           popover.content('');
318 |           popover.positionAway();
319 |         }
320 |         else {
321 |           popover.title(attrs.title);
322 |           popover.content(attrs.content);
323 |           popover.positionBeside(element);
324 |         }
325 |       });
326 |     }
327 |   }
328 | }];
329 | 
330 | directive.tabPane = function() {
331 |   return {
332 |     require: '^tabbable',
333 |     restrict: 'C',
334 |     link: function(scope, element, attrs, tabsCtrl) {
335 |       element.on('$remove', tabsCtrl.addPane(element, attrs));
336 |     }
337 |   };
338 | };
339 | 
340 | directive.foldout = ['$http', '$animate','$window', function($http, $animate, $window) {
341 |   return {
342 |     restrict: 'A',
343 |     priority : 500,
344 |     link: function(scope, element, attrs) {
345 |       var container, loading, url = attrs.url;
346 |       if(/\/build\//.test($window.location.href)) {
347 |         url = '/build/docs' + url;
348 |       }
349 |       element.bind('click',function() {
350 |         scope.$apply(function() {
351 |           if(!container) {
352 |             if(loading) return;
353 | 
354 |             loading = true;
355 |             var par = element.parent();
356 |             container = angular.element('<div class="foldout">loading...</div>');
357 |             $animate.enter(container, null, par);
358 | 
359 |             $http.get(url, { cache : true }).success(function(html) {
360 |               loading = false;
361 | 
362 |               html = '<div class="foldout-inner">' +
363 |                       '<div calss="foldout-arrow"></div>' +
364 |                       html +
365 |                      '</div>';
366 |               container.html(html);
367 | 
368 |               //avoid showing the element if the user has already closed it
369 |               if(container.css('display') == 'block') {
370 |                 container.css('display','none');
371 |                 $animate.addClass(container, 'ng-hide');
372 |               }
373 |             });
374 |           }
375 |           else {
376 |             container.hasClass('ng-hide') ? $animate.removeClass(container, 'ng-hide') : $animate.addClass(container, 'ng-hide');
377 |           }
378 |         });
379 |       });
380 |     }
381 |   }
382 | }];
383 | 
384 | angular.module('bootstrap', [])
385 |   .directive(directive)
386 |   .factory('popoverElement', popoverElement)
387 |   .run(function() {
388 |     marked.setOptions({
389 |       gfm: true,
390 |       tables: true
391 |     });
392 |   });
393 | 


--------------------------------------------------------------------------------
/docs/js/docs-setup.js:
--------------------------------------------------------------------------------
 1 | NG_DOCS={
 2 |   "sections": {
 3 |     "api": "API Documentation"
 4 |   },
 5 |   "pages": [],
 6 |   "apis": {
 7 |     "api": true
 8 |   },
 9 |   "html5Mode": false,
10 |   "startPage": "/api",
11 |   "scripts": [
12 |     "angular.min.js"
13 |   ]
14 | };


--------------------------------------------------------------------------------
/docs/js/docs.js:
--------------------------------------------------------------------------------
  1 | var docsApp = {
  2 |   controller: {},
  3 |   directive: {},
  4 |   serviceFactory: {}
  5 | };
  6 | 
  7 | 
  8 | docsApp.directive.ngHtmlWrapLoaded = function(reindentCode, templateMerge, loadedUrls) {
  9 |   function escape(text) {
 10 |     return text.
 11 |       replace(/\&/g, '&amp;').
 12 |       replace(/\</g, '&lt;').
 13 |       replace(/\>/g, '&gt;').
 14 |       replace(/"/g, '&quot;');
 15 |   }
 16 | 
 17 |   function setHtmlIe8SafeWay(element, html) {
 18 |     var newElement = angular.element('<pre>' + html + '</pre>');
 19 | 
 20 |     element.html('');
 21 |     element.append(newElement.contents());
 22 |     return element;
 23 |   }
 24 | 
 25 |   return {
 26 |     compile: function(element, attr) {
 27 |       var properties = {
 28 |             head: '',
 29 |             module: '',
 30 |             body: element.text()
 31 |           },
 32 |         html = "<!doctype html>\n<html ng-app{{module}}>\n  <head>\n{{head:4}}  </head>\n  <body>\n{{body:4}}  </body>\n</html>";
 33 | 
 34 |       angular.forEach(loadedUrls.base, function(dep) {
 35 |         properties.head += '<script src="' + dep + '"></script>\n';
 36 |       });
 37 | 
 38 |       angular.forEach((attr.ngHtmlWrapLoaded || '').split(' '), function(dep) {
 39 |         if (!dep) return;
 40 |         var ext = dep.split(/\./).pop();
 41 | 
 42 |         if (ext == 'css') {
 43 |           properties.head += '<link rel="stylesheet" href="' + dep + '" type="text/css">\n';
 44 |         } else if(ext == 'js' && dep !== 'angular.js') {
 45 |           properties.head += '<script src="' + (loadedUrls[dep] || dep) + '"></script>\n';
 46 |         } else if (dep !== 'angular.js') {
 47 |           properties.module = '="' + dep + '"';
 48 |         }
 49 |       });
 50 | 
 51 |       setHtmlIe8SafeWay(element, escape(templateMerge(html, properties)));
 52 |     }
 53 |   };
 54 | };
 55 | 
 56 | 
 57 | docsApp.directive.focused = function($timeout) {
 58 |   return function(scope, element, attrs) {
 59 |     element[0].focus();
 60 |     element.on('focus', function() {
 61 |       scope.$apply(attrs.focused + '=true');
 62 |     });
 63 |     element.on('blur', function() {
 64 |       // have to use $timeout, so that we close the drop-down after the user clicks,
 65 |       // otherwise when the user clicks we process the closing before we process the click.
 66 |       $timeout(function() {
 67 |         scope.$eval(attrs.focused + '=false');
 68 |       });
 69 |     });
 70 |     scope.$eval(attrs.focused + '=true');
 71 |   };
 72 | };
 73 | 
 74 | 
 75 | docsApp.directive.code = function() {
 76 |   return { restrict:'E', terminal: true };
 77 | };
 78 | 
 79 | 
 80 | docsApp.directive.sourceEdit = function(getEmbeddedTemplate) {
 81 |   return {
 82 |     template: '<div class="btn-group pull-right">' +
 83 |         '<a class="btn dropdown-toggle btn-primary" data-toggle="dropdown" href>' +
 84 |         '  <i class="icon-pencil icon-white"></i> Edit <span class="caret"></span>' +
 85 |         '</a>' +
 86 |         '<ul class="dropdown-menu">' +
 87 |         '  <li><a ng-click="plunkr($event)" href="">In Plunkr</a></li>' +
 88 |         '  <li><a ng-click="fiddle($event)" href="">In JsFiddle</a></li>' +
 89 |         '</ul>' +
 90 |         '</div>',
 91 |     scope: true,
 92 |     controller: function($scope, $attrs, openJsFiddle, openPlunkr) {
 93 |       var sources = {
 94 |         module: $attrs.sourceEdit,
 95 |         deps: read($attrs.sourceEditDeps),
 96 |         html: read($attrs.sourceEditHtml),
 97 |         css: read($attrs.sourceEditCss),
 98 |         js: read($attrs.sourceEditJs),
 99 |         unit: read($attrs.sourceEditUnit),
100 |         scenario: read($attrs.sourceEditScenario)
101 |       };
102 |       $scope.fiddle = function(e) {
103 |         e.stopPropagation();
104 |         openJsFiddle(sources);
105 |       };
106 |       $scope.plunkr = function(e) {
107 |         e.stopPropagation();
108 |         openPlunkr(sources);
109 |       };
110 |     }
111 |   };
112 | 
113 |   function read(text) {
114 |     var files = [];
115 |     angular.forEach(text ? text.split(' ') : [], function(refId) {
116 |       // refId is index.html-343, so we need to strip the unique ID when exporting the name
117 |       files.push({name: refId.replace(/-\d+$/, ''), content: getEmbeddedTemplate(refId)});
118 |     });
119 |     return files;
120 |   }
121 | };
122 | 
123 | 
124 | docsApp.serviceFactory.loadedUrls = function($document) {
125 |   var urls = {};
126 | 
127 |   angular.forEach($document.find('script'), function(script) {
128 |     var match = script.src.match(/^.*\/([^\/]*\.js)$/);
129 |     if (match) {
130 |       urls[match[1].replace(/(\-\d.*)?(\.min)?\.js$/, '.js')] = match[0];
131 |     }
132 |   });
133 | 
134 |   urls.base = [];
135 |   angular.forEach(NG_DOCS.scripts, function(script) {
136 |     var match = urls[script.replace(/(\-\d.*)?(\.min)?\.js$/, '.js')];
137 |     if (match) {
138 |       urls.base.push(match);
139 |     }
140 |   });
141 | 
142 |   return urls;
143 | };
144 | 
145 | 
146 | docsApp.serviceFactory.formPostData = function($document) {
147 |   return function(url, fields) {
148 |     var form = angular.element('<form style="display: none;" method="post" action="' + url + '" target="_blank"></form>');
149 |     angular.forEach(fields, function(value, name) {
150 |       var input = angular.element('<input type="hidden" name="' +  name + '">');
151 |       input.attr('value', value);
152 |       form.append(input);
153 |     });
154 |     $document.find('body').append(form);
155 |     form[0].submit();
156 |     form.remove();
157 |   };
158 | };
159 | 
160 | docsApp.serviceFactory.openPlunkr = function(templateMerge, formPostData, loadedUrls) {
161 |   return function(content) {
162 |     var allFiles = [].concat(content.js, content.css, content.html);
163 |     var indexHtmlContent = '<!doctype html>\n' +
164 |         '<html ng-app="{{module}}">\n' +
165 |         '  <head>\n' +
166 |         '{{scriptDeps}}' +
167 |         '  </head>\n' +
168 |         '  <body>\n\n' +
169 |         '{{indexContents}}\n\n' +
170 |         '  </body>\n' +
171 |         '</html>\n';
172 |     var scriptDeps = '';
173 |     angular.forEach(loadedUrls.base, function(url) {
174 |         scriptDeps += '    <script src="' + url + '"></script>\n';
175 |     });
176 |     angular.forEach(allFiles, function(file) {
177 |       var ext = file.name.split(/\./).pop();
178 |         if (ext == 'css') {
179 |           scriptDeps += '    <link rel="stylesheet" href="' + file.name + '" type="text/css">\n';
180 |         } else if (ext == 'js' && file.name !== 'angular.js') {
181 |         scriptDeps += '    <script src="' + file.name + '"></script>\n';
182 |       }
183 |     });
184 |     indexProp = {
185 |       module: content.module,
186 |       scriptDeps: scriptDeps,
187 |       indexContents: content.html[0].content
188 |     };
189 | 
190 |     var postData = {};
191 |     angular.forEach(allFiles, function(file, index) {
192 |       if (file.content && file.name != 'index.html') {
193 |         postData['files[' + file.name + ']'] = file.content;
194 |       }
195 |     });
196 | 
197 |     postData['files[index.html]'] = templateMerge(indexHtmlContent, indexProp);
198 |     postData['tags[]'] = "angularjs";
199 | 
200 |     postData.private = true;
201 |     postData.description = 'AngularJS Example Plunkr';
202 | 
203 |     formPostData('http://plnkr.co/edit/?p=preview', postData);
204 |   };
205 | };
206 | 
207 | docsApp.serviceFactory.openJsFiddle = function(templateMerge, formPostData, loadedUrls) {
208 | 
209 |   var HTML = '<div ng-app=\"{{module}}\">\n{{html:2}}</div>',
210 |       SCRIPT_CACHE = '\n\n<!-- {{name}} -->\n<script type="text/ng-template" id="{{name}}">\n{{content:2}}</script>';
211 | 
212 |   return function(content) {
213 |     var prop = {
214 |           module: content.module,
215 |           html: '',
216 |           css: '',
217 |           script: ''
218 |         };
219 | 
220 |     angular.forEach(content.html, function(file, index) {
221 |       if (index) {
222 |         prop.html += templateMerge(SCRIPT_CACHE, file);
223 |       } else {
224 |         prop.html += file.content;
225 |       }
226 |     });
227 | 
228 |     angular.forEach(content.js, function(file, index) {
229 |       prop.script += file.content;
230 |     });
231 | 
232 |     angular.forEach(content.css, function(file, index) {
233 |       prop.css += file.content;
234 |     });
235 | 
236 |     formPostData("http://jsfiddle.net/api/post/library/pure/dependencies/more/", {
237 |       title: 'AngularJS Example',
238 |       html: templateMerge(HTML, prop),
239 |       js: prop.script,
240 |       css: prop.css,
241 |       resources: loadedUrls.base.join(','),
242 |       wrap: 'b'
243 |     });
244 |   };
245 | };
246 | 
247 | 
248 | docsApp.serviceFactory.sections = function serviceFactory() {
249 |   var sections = {
250 |     getPage: function(sectionId, partialId) {
251 |       var pages = sections[sectionId];
252 | 
253 |       partialId = partialId || 'index';
254 | 
255 |       for (var i = 0, ii = pages.length; i < ii; i++) {
256 |         if (pages[i].id == partialId) {
257 |           return pages[i];
258 |         }
259 |       }
260 |       return null;
261 |     }
262 |   };
263 | 
264 |   angular.forEach(NG_DOCS.pages, function(page) {
265 |     var url = page.section + '/' +  page.id;
266 |     if (page.id == 'angular.Module') {
267 |       page.partialUrl = 'partials/api/angular.IModule.html';
268 |     } else {
269 |       page.partialUrl = 'partials/' + url.replace(':', '.') + '.html';
270 |     }
271 |     page.url = (NG_DOCS.html5Mode ? '' : '#/') + url;
272 |     if (!sections[page.section]) { sections[page.section] = []; }
273 |     sections[page.section].push(page);
274 |   });
275 | 
276 |   return sections;
277 | };
278 | 
279 | 
280 | docsApp.controller.DocsController = function($scope, $location, $window, sections) {
281 |   var INDEX_PATH = /^(\/|\/index[^\.]*.html)$/,
282 |       GLOBALS = /^angular\.([^\.]+)$/,
283 |       MODULE = /^([^\.]+)$/,
284 |       MODULE_MOCK = /^angular\.mock\.([^\.]+)$/,
285 |       MODULE_DIRECTIVE = /^(.+)\.directive:([^\.]+)$/,
286 |       MODULE_DIRECTIVE_INPUT = /^(.+)\.directive:input\.([^\.]+)$/,
287 |       MODULE_FILTER = /^(.+)\.filter:([^\.]+)$/,
288 |       MODULE_CUSTOM = /^(.+)\.([^\.]+):([^\.]+)$/,
289 |       MODULE_SERVICE = /^(.+)\.([^\.]+?)(Provider)?$/,
290 |       MODULE_TYPE = /^([^\.]+)\..+\.([A-Z][^\.]+)$/;
291 | 
292 | 
293 |   /**********************************
294 |    Publish methods
295 |    ***********************************/
296 | 
297 |   $scope.navClass = function(page1, page2) {
298 |     return {
299 |       first: this.$first,
300 |       last: this.$last,
301 |       active: page1 && this.currentPage == page1 || page2 && this.currentPage == page2,
302 |       match: this.focused && this.currentPage != page1 &&
303 |              this.bestMatch.rank > 0 && this.bestMatch.page == page1
304 | 
305 |     };
306 |   };
307 | 
308 |   $scope.isActivePath = function(url) {
309 |     if (url.charAt(0) == '#') {
310 |       url = url.substring(1, url.length);
311 |     }
312 |     return $location.path().indexOf(url) > -1;
313 |   };
314 | 
315 |   $scope.submitForm = function() {
316 |     if ($scope.bestMatch) {
317 |       var url =  $scope.bestMatch.page.url;
318 |       $location.path(NG_DOCS.html5Mode ? url : url.substring(1));
319 |     }
320 |   };
321 | 
322 |   $scope.afterPartialLoaded = function() {
323 |     var currentPageId = $location.path();
324 |     $scope.partialTitle = $scope.currentPage.shortName;
325 |     $window._gaq && $window._gaq.push(['_trackPageview', currentPageId]);
326 |     loadDisqus(currentPageId);
327 |   };
328 | 
329 | 
330 |   /**********************************
331 |    Watches
332 |    ***********************************/
333 | 
334 |   $scope.sections = {};
335 |   angular.forEach(NG_DOCS.sections, function(section, url) {
336 |     $scope.sections[(NG_DOCS.html5Mode ? '' : '#/') + url] = section;
337 |   });
338 |   $scope.$watch(function docsPathWatch() {return $location.path(); }, function docsPathWatchAction(path) {
339 |     var parts = path.split('/'),
340 |       sectionId = parts[1],
341 |       partialId = parts[2],
342 |       page, sectionName = $scope.sections[(NG_DOCS.html5Mode ? '' : '#/') + sectionId];
343 | 
344 |     if (!sectionName) { return; }
345 | 
346 |     $scope.currentPage = page = sections.getPage(sectionId, partialId);
347 | 
348 |     if (!$scope.currentPage) {
349 |       $scope.partialTitle = 'Error: Page Not Found!';
350 |       page = {};
351 |     }
352 | 
353 |     updateSearch();
354 | 
355 | 
356 |     // Update breadcrumbs
357 |     var breadcrumb = $scope.breadcrumb = [],
358 |       match, sectionPath = (NG_DOCS.html5Mode ? '' : '#/') +  sectionId;
359 | 
360 |     if (partialId) {
361 |       breadcrumb.push({ name: sectionName, url: sectionPath });
362 |       if (partialId == 'angular.Module') {
363 |         breadcrumb.push({ name: 'angular.Module' });
364 |       } else if (match = partialId.match(GLOBALS)) {
365 |         breadcrumb.push({ name: partialId });
366 |       } else if (match = partialId.match(MODULE)) {
367 |         match[1] = page.moduleName || match[1];
368 |         breadcrumb.push({ name: match[1] });
369 |       } else if (match = partialId.match(MODULE_FILTER)) {
370 |         match[1] = page.moduleName || match[1];
371 |         breadcrumb.push({ name: match[1], url: sectionPath + '/' + match[1] });
372 |         breadcrumb.push({ name: match[2] });
373 |       } else if (match = partialId.match(MODULE_DIRECTIVE)) {
374 |         breadcrumb.push({ name: match[1], url: sectionPath + '/' + match[1] });
375 |         breadcrumb.push({ name: match[2] });
376 |       } else if (match = partialId.match(MODULE_DIRECTIVE_INPUT)) {
377 |         breadcrumb.push({ name: match[1], url: sectionPath + '/' + match[1] });
378 |         breadcrumb.push({ name: 'input' });
379 |         breadcrumb.push({ name: match[2] });
380 |       } else if (match = partialId.match(MODULE_CUSTOM)) {
381 |         match[1] = page.moduleName || match[1];
382 |         breadcrumb.push({ name: match[1], url: sectionPath + '/' + match[1] });
383 |         breadcrumb.push({ name: match[3] });
384 |       } else if (match = partialId.match(MODULE_TYPE)) {
385 |         match[1] = page.moduleName || match[1];
386 |         breadcrumb.push({ name: match[1], url: sectionPath + '/' + match[1] });
387 |         breadcrumb.push({ name: match[2] });
388 |       }  else if (match = partialId.match(MODULE_SERVICE)) {
389 |         if ( page.type === 'overview') {
390 |           // module name with dots looks like a service
391 |           breadcrumb.push({ name: partialId });
392 |         } else {
393 |           match[1] = page.moduleName || match[1];
394 |           breadcrumb.push({ name: match[1], url: sectionPath + '/' + match[1] });
395 |           breadcrumb.push({ name: match[2] + (match[3] || '') });
396 |         }
397 |       } else if (match = partialId.match(MODULE_MOCK)) {
398 |         breadcrumb.push({ name: 'angular.mock.' + match[1] });
399 |       } else {
400 |         breadcrumb.push({ name: page.shortName });
401 |       }
402 |     } else {
403 |       breadcrumb.push({ name: sectionName });
404 |     }
405 |   });
406 | 
407 |   $scope.$watch('search', updateSearch);
408 | 
409 | 
410 | 
411 |   /**********************************
412 |    Initialize
413 |    ***********************************/
414 | 
415 |   $scope.versionNumber = angular.version.full;
416 |   $scope.version = angular.version.full + "  " + angular.version.codeName;
417 |   $scope.futurePartialTitle = null;
418 |   $scope.loading = 0;
419 | 
420 |   if (!$location.path() || INDEX_PATH.test($location.path())) {
421 |     $location.path(NG_DOCS.startPage).replace();
422 |   }
423 | 
424 |   /**********************************
425 |    Private methods
426 |    ***********************************/
427 | 
428 |   function updateSearch() {
429 |     var cache = {},
430 |         pages = sections[$location.path().split('/')[1]],
431 |         modules = $scope.modules = [],
432 |         otherPages = $scope.pages = [],
433 |         search = $scope.search,
434 |         bestMatch = {page: null, rank:0};
435 | 
436 |     angular.forEach(pages, function(page) {
437 |       var match,
438 |         id = page.id,
439 |         section = page.section;
440 | 
441 |       if (!(match = rank(page, search))) return;
442 | 
443 |       if (match.rank > bestMatch.rank) {
444 |         bestMatch = match;
445 |       }
446 | 
447 |       if (page.id == 'index') {
448 |         //skip
449 |       } else if (!NG_DOCS.apis[section]) {
450 |         otherPages.push(page);
451 |       } else if (id == 'angular.Module') {
452 |         module('ng', section).types.push(page);
453 |       } else if (match = id.match(GLOBALS)) {
454 |         module('ng', section).globals.push(page);
455 |       } else if (match = id.match(MODULE)) {
456 |         module(page.moduleName || match[1], section);
457 |       } else if (match = id.match(MODULE_FILTER)) {
458 |         module(page.moduleName || match[1], section).filters.push(page);
459 |       } else if (match = id.match(MODULE_DIRECTIVE)) {
460 |         module(page.moduleName || match[1], section).directives.push(page);
461 |       } else if (match = id.match(MODULE_DIRECTIVE_INPUT)) {
462 |         module(page.moduleName || match[1], section).directives.push(page);
463 |       } else if (match = id.match(MODULE_CUSTOM)) {
464 |         module(page.moduleName || match[1], section).others.push(page);
465 |       } else if (match = id.match(MODULE_TYPE)) {
466 |         module(page.moduleName || match[1], section).types.push(page);
467 |       } else if (match = id.match(MODULE_SERVICE)) {
468 |         if (page.type === 'overview') {
469 |           module(id, section);
470 |         } else {
471 |           module(page.moduleName || match[1], section).service(match[2])[match[3] ? 'provider' : 'instance'] = page;
472 |         }
473 |       } else if (match = id.match(MODULE_MOCK)) {
474 |         module('ngMock', section).globals.push(page);
475 |       }
476 | 
477 |     });
478 | 
479 |     $scope.bestMatch = bestMatch;
480 | 
481 |     /*************/
482 | 
483 |     function module(name, section) {
484 |       var module = cache[name];
485 |       if (!module) {
486 |         module = cache[name] = {
487 |           name: name,
488 |           url: (NG_DOCS.html5Mode ? '' : '#/') + section + '/' + name,
489 |           globals: [],
490 |           directives: [],
491 |           services: [],
492 |           others: [],
493 |           service: function(name) {
494 |             var service =  cache[this.name + ':' + name];
495 |             if (!service) {
496 |               service = {name: name};
497 |               cache[this.name + ':' + name] = service;
498 |               this.services.push(service);
499 |             }
500 |             return service;
501 |           },
502 |           types: [],
503 |           filters: []
504 |         };
505 |         modules.push(module);
506 |       }
507 |       return module;
508 |     }
509 | 
510 |     function rank(page, terms) {
511 |       var ranking = {page: page, rank:0},
512 |         keywords = page.keywords,
513 |         title = page.shortName.toLowerCase();
514 | 
515 |       terms && angular.forEach(terms.toLowerCase().split(' '), function(term) {
516 |         var index;
517 | 
518 |         if (ranking) {
519 |           if (keywords.indexOf(term) == -1) {
520 |             ranking = null;
521 |           } else {
522 |             ranking.rank ++; // one point for each term found
523 |             if ((index = title.indexOf(term)) != -1) {
524 |               ranking.rank += 20 - index; // ten points if you match title
525 |             }
526 |           }
527 |         }
528 |       });
529 |       return ranking;
530 |     }
531 |   }
532 | 
533 | 
534 |   function loadDisqus(currentPageId) {
535 |     if (!NG_DOCS.discussions) { return; }
536 |     // http://docs.disqus.com/help/2/
537 |     window.disqus_shortname = NG_DOCS.discussions.shortName;
538 |     window.disqus_identifier = currentPageId;
539 |     window.disqus_url = NG_DOCS.discussions.url + currentPageId;
540 |     window.disqus_developer = NG_DOCS.discussions.dev;
541 | 
542 |     // http://docs.disqus.com/developers/universal/
543 |     (function() {
544 |       var dsq = document.createElement('script'); dsq.type = 'text/javascript'; dsq.async = true;
545 |       dsq.src = '//angularjs.disqus.com/embed.js';
546 |       (document.getElementsByTagName('head')[0] ||
547 |         document.getElementsByTagName('body')[0]).appendChild(dsq);
548 |     })();
549 | 
550 |     angular.element(document.getElementById('disqus_thread')).html('');
551 |   }
552 | };
553 | 
554 | angular.module('docsApp', ['ngAnimate', 'bootstrap', 'bootstrapPrettify']).
555 |   config(function($locationProvider) {
556 |     if (NG_DOCS.html5Mode) {
557 |       $locationProvider.html5Mode(true).hashPrefix('!');
558 |     }
559 |   }).
560 |   factory(docsApp.serviceFactory).
561 |   directive(docsApp.directive).
562 |   controller(docsApp.controller);
563 | 


--------------------------------------------------------------------------------
/docs/js/marked.js:
--------------------------------------------------------------------------------
   1 | /**
   2 |  * marked - a markdown parser
   3 |  * Copyright (c) 2011-2013, Christopher Jeffrey. (MIT Licensed)
   4 |  * https://github.com/chjj/marked
   5 |  */
   6 | 
   7 | ;(function() {
   8 | 
   9 | /**
  10 |  * Block-Level Grammar
  11 |  */
  12 | 
  13 | var block = {
  14 |   newline: /^\n+/,
  15 |   code: /^( {4}[^\n]+\n*)+/,
  16 |   fences: noop,
  17 |   hr: /^( *[-*_]){3,} *(?:\n+|$)/,
  18 |   heading: /^ *(#{1,6}) *([^\n]+?) *#* *(?:\n+|$)/,
  19 |   nptable: noop,
  20 |   lheading: /^([^\n]+)\n *(=|-){3,} *\n*/,
  21 |   blockquote: /^( *>[^\n]+(\n[^\n]+)*\n*)+/,
  22 |   list: /^( *)(bull) [\s\S]+?(?:hr|\n{2,}(?! )(?!\1bull )\n*|\s*$)/,
  23 |   html: /^ *(?:comment|closed|closing) *(?:\n{2,}|\s*$)/,
  24 |   def: /^ *\[([^\]]+)\]: *<?([^\s>]+)>?(?: +["(]([^\n]+)[")])? *(?:\n+|$)/,
  25 |   table: noop,
  26 |   paragraph: /^((?:[^\n]+\n?(?!hr|heading|lheading|blockquote|tag|def))+)\n*/,
  27 |   text: /^[^\n]+/
  28 | };
  29 | 
  30 | block.bullet = /(?:[*+-]|\d+\.)/;
  31 | block.item = /^( *)(bull) [^\n]*(?:\n(?!\1bull )[^\n]*)*/;
  32 | block.item = replace(block.item, 'gm')
  33 |   (/bull/g, block.bullet)
  34 |   ();
  35 | 
  36 | block.list = replace(block.list)
  37 |   (/bull/g, block.bullet)
  38 |   ('hr', /\n+(?=(?: *[-*_]){3,} *(?:\n+|$))/)
  39 |   ();
  40 | 
  41 | block._tag = '(?!(?:'
  42 |   + 'a|em|strong|small|s|cite|q|dfn|abbr|data|time|code'
  43 |   + '|var|samp|kbd|sub|sup|i|b|u|mark|ruby|rt|rp|bdi|bdo'
  44 |   + '|span|br|wbr|ins|del|img)\\b)\\w+(?!:/|@)\\b';
  45 | 
  46 | block.html = replace(block.html)
  47 |   ('comment', /<!--[\s\S]*?-->/)
  48 |   ('closed', /<(tag)[\s\S]+?<\/\1>/)
  49 |   ('closing', /<tag(?:"[^"]*"|'[^']*'|[^'">])*?>/)
  50 |   (/tag/g, block._tag)
  51 |   ();
  52 | 
  53 | block.paragraph = replace(block.paragraph)
  54 |   ('hr', block.hr)
  55 |   ('heading', block.heading)
  56 |   ('lheading', block.lheading)
  57 |   ('blockquote', block.blockquote)
  58 |   ('tag', '<' + block._tag)
  59 |   ('def', block.def)
  60 |   ();
  61 | 
  62 | /**
  63 |  * Normal Block Grammar
  64 |  */
  65 | 
  66 | block.normal = merge({}, block);
  67 | 
  68 | /**
  69 |  * GFM Block Grammar
  70 |  */
  71 | 
  72 | block.gfm = merge({}, block.normal, {
  73 |   fences: /^ *(`{3,}|~{3,}) *(\S+)? *\n([\s\S]+?)\s*\1 *(?:\n+|$)/,
  74 |   paragraph: /^/
  75 | });
  76 | 
  77 | block.gfm.paragraph = replace(block.paragraph)
  78 |   ('(?!', '(?!' + block.gfm.fences.source.replace('\\1', '\\2') + '|')
  79 |   ();
  80 | 
  81 | /**
  82 |  * GFM + Tables Block Grammar
  83 |  */
  84 | 
  85 | block.tables = merge({}, block.gfm, {
  86 |   nptable: /^ *(\S.*\|.*)\n *([-:]+ *\|[-| :]*)\n((?:.*\|.*(?:\n|$))*)\n*/,
  87 |   table: /^ *\|(.+)\n *\|( *[-:]+[-| :]*)\n((?: *\|.*(?:\n|$))*)\n*/
  88 | });
  89 | 
  90 | /**
  91 |  * Block Lexer
  92 |  */
  93 | 
  94 | function Lexer(options) {
  95 |   this.tokens = [];
  96 |   this.tokens.links = {};
  97 |   this.options = options || marked.defaults;
  98 |   this.rules = block.normal;
  99 | 
 100 |   if (this.options.gfm) {
 101 |     if (this.options.tables) {
 102 |       this.rules = block.tables;
 103 |     } else {
 104 |       this.rules = block.gfm;
 105 |     }
 106 |   }
 107 | }
 108 | 
 109 | /**
 110 |  * Expose Block Rules
 111 |  */
 112 | 
 113 | Lexer.rules = block;
 114 | 
 115 | /**
 116 |  * Static Lex Method
 117 |  */
 118 | 
 119 | Lexer.lex = function(src, options) {
 120 |   var lexer = new Lexer(options);
 121 |   return lexer.lex(src);
 122 | };
 123 | 
 124 | /**
 125 |  * Preprocessing
 126 |  */
 127 | 
 128 | Lexer.prototype.lex = function(src) {
 129 |   src = src
 130 |     .replace(/\r\n|\r/g, '\n')
 131 |     .replace(/\t/g, '    ')
 132 |     .replace(/\u00a0/g, ' ')
 133 |     .replace(/\u2424/g, '\n');
 134 | 
 135 |   return this.token(src, true);
 136 | };
 137 | 
 138 | /**
 139 |  * Lexing
 140 |  */
 141 | 
 142 | Lexer.prototype.token = function(src, top) {
 143 |   var src = src.replace(/^ +$/gm, '')
 144 |     , next
 145 |     , loose
 146 |     , cap
 147 |     , bull
 148 |     , b
 149 |     , item
 150 |     , space
 151 |     , i
 152 |     , l;
 153 | 
 154 |   while (src) {
 155 |     // newline
 156 |     if (cap = this.rules.newline.exec(src)) {
 157 |       src = src.substring(cap[0].length);
 158 |       if (cap[0].length > 1) {
 159 |         this.tokens.push({
 160 |           type: 'space'
 161 |         });
 162 |       }
 163 |     }
 164 | 
 165 |     // code
 166 |     if (cap = this.rules.code.exec(src)) {
 167 |       src = src.substring(cap[0].length);
 168 |       cap = cap[0].replace(/^ {4}/gm, '');
 169 |       this.tokens.push({
 170 |         type: 'code',
 171 |         text: !this.options.pedantic
 172 |           ? cap.replace(/\n+$/, '')
 173 |           : cap
 174 |       });
 175 |       continue;
 176 |     }
 177 | 
 178 |     // fences (gfm)
 179 |     if (cap = this.rules.fences.exec(src)) {
 180 |       src = src.substring(cap[0].length);
 181 |       this.tokens.push({
 182 |         type: 'code',
 183 |         lang: cap[2],
 184 |         text: cap[3]
 185 |       });
 186 |       continue;
 187 |     }
 188 | 
 189 |     // heading
 190 |     if (cap = this.rules.heading.exec(src)) {
 191 |       src = src.substring(cap[0].length);
 192 |       this.tokens.push({
 193 |         type: 'heading',
 194 |         depth: cap[1].length,
 195 |         text: cap[2]
 196 |       });
 197 |       continue;
 198 |     }
 199 | 
 200 |     // table no leading pipe (gfm)
 201 |     if (top && (cap = this.rules.nptable.exec(src))) {
 202 |       src = src.substring(cap[0].length);
 203 | 
 204 |       item = {
 205 |         type: 'table',
 206 |         header: cap[1].replace(/^ *| *\| *$/g, '').split(/ *\| */),
 207 |         align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
 208 |         cells: cap[3].replace(/\n$/, '').split('\n')
 209 |       };
 210 | 
 211 |       for (i = 0; i < item.align.length; i++) {
 212 |         if (/^ *-+: *$/.test(item.align[i])) {
 213 |           item.align[i] = 'right';
 214 |         } else if (/^ *:-+: *$/.test(item.align[i])) {
 215 |           item.align[i] = 'center';
 216 |         } else if (/^ *:-+ *$/.test(item.align[i])) {
 217 |           item.align[i] = 'left';
 218 |         } else {
 219 |           item.align[i] = null;
 220 |         }
 221 |       }
 222 | 
 223 |       for (i = 0; i < item.cells.length; i++) {
 224 |         item.cells[i] = item.cells[i].split(/ *\| */);
 225 |       }
 226 | 
 227 |       this.tokens.push(item);
 228 | 
 229 |       continue;
 230 |     }
 231 | 
 232 |     // lheading
 233 |     if (cap = this.rules.lheading.exec(src)) {
 234 |       src = src.substring(cap[0].length);
 235 |       this.tokens.push({
 236 |         type: 'heading',
 237 |         depth: cap[2] === '=' ? 1 : 2,
 238 |         text: cap[1]
 239 |       });
 240 |       continue;
 241 |     }
 242 | 
 243 |     // hr
 244 |     if (cap = this.rules.hr.exec(src)) {
 245 |       src = src.substring(cap[0].length);
 246 |       this.tokens.push({
 247 |         type: 'hr'
 248 |       });
 249 |       continue;
 250 |     }
 251 | 
 252 |     // blockquote
 253 |     if (cap = this.rules.blockquote.exec(src)) {
 254 |       src = src.substring(cap[0].length);
 255 | 
 256 |       this.tokens.push({
 257 |         type: 'blockquote_start'
 258 |       });
 259 | 
 260 |       cap = cap[0].replace(/^ *> ?/gm, '');
 261 | 
 262 |       // Pass `top` to keep the current
 263 |       // "toplevel" state. This is exactly
 264 |       // how markdown.pl works.
 265 |       this.token(cap, top);
 266 | 
 267 |       this.tokens.push({
 268 |         type: 'blockquote_end'
 269 |       });
 270 | 
 271 |       continue;
 272 |     }
 273 | 
 274 |     // list
 275 |     if (cap = this.rules.list.exec(src)) {
 276 |       src = src.substring(cap[0].length);
 277 |       bull = cap[2];
 278 | 
 279 |       this.tokens.push({
 280 |         type: 'list_start',
 281 |         ordered: bull.length > 1
 282 |       });
 283 | 
 284 |       // Get each top-level item.
 285 |       cap = cap[0].match(this.rules.item);
 286 | 
 287 |       next = false;
 288 |       l = cap.length;
 289 |       i = 0;
 290 | 
 291 |       for (; i < l; i++) {
 292 |         item = cap[i];
 293 | 
 294 |         // Remove the list item's bullet
 295 |         // so it is seen as the next token.
 296 |         space = item.length;
 297 |         item = item.replace(/^ *([*+-]|\d+\.) +/, '');
 298 | 
 299 |         // Outdent whatever the
 300 |         // list item contains. Hacky.
 301 |         if (~item.indexOf('\n ')) {
 302 |           space -= item.length;
 303 |           item = !this.options.pedantic
 304 |             ? item.replace(new RegExp('^ {1,' + space + '}', 'gm'), '')
 305 |             : item.replace(/^ {1,4}/gm, '');
 306 |         }
 307 | 
 308 |         // Determine whether the next list item belongs here.
 309 |         // Backpedal if it does not belong in this list.
 310 |         if (this.options.smartLists && i !== l - 1) {
 311 |           b = block.bullet.exec(cap[i+1])[0];
 312 |           if (bull !== b && !(bull.length > 1 && b.length > 1)) {
 313 |             src = cap.slice(i + 1).join('\n') + src;
 314 |             i = l - 1;
 315 |           }
 316 |         }
 317 | 
 318 |         // Determine whether item is loose or not.
 319 |         // Use: /(^|\n)(?! )[^\n]+\n\n(?!\s*$)/
 320 |         // for discount behavior.
 321 |         loose = next || /\n\n(?!\s*$)/.test(item);
 322 |         if (i !== l - 1) {
 323 |           next = item[item.length-1] === '\n';
 324 |           if (!loose) loose = next;
 325 |         }
 326 | 
 327 |         this.tokens.push({
 328 |           type: loose
 329 |             ? 'loose_item_start'
 330 |             : 'list_item_start'
 331 |         });
 332 | 
 333 |         // Recurse.
 334 |         this.token(item, false);
 335 | 
 336 |         this.tokens.push({
 337 |           type: 'list_item_end'
 338 |         });
 339 |       }
 340 | 
 341 |       this.tokens.push({
 342 |         type: 'list_end'
 343 |       });
 344 | 
 345 |       continue;
 346 |     }
 347 | 
 348 |     // html
 349 |     if (cap = this.rules.html.exec(src)) {
 350 |       src = src.substring(cap[0].length);
 351 |       this.tokens.push({
 352 |         type: this.options.sanitize
 353 |           ? 'paragraph'
 354 |           : 'html',
 355 |         pre: cap[1] === 'pre' || cap[1] === 'script',
 356 |         text: cap[0]
 357 |       });
 358 |       continue;
 359 |     }
 360 | 
 361 |     // def
 362 |     if (top && (cap = this.rules.def.exec(src))) {
 363 |       src = src.substring(cap[0].length);
 364 |       this.tokens.links[cap[1].toLowerCase()] = {
 365 |         href: cap[2],
 366 |         title: cap[3]
 367 |       };
 368 |       continue;
 369 |     }
 370 | 
 371 |     // table (gfm)
 372 |     if (top && (cap = this.rules.table.exec(src))) {
 373 |       src = src.substring(cap[0].length);
 374 | 
 375 |       item = {
 376 |         type: 'table',
 377 |         header: cap[1].replace(/^ *| *\| *$/g, '').split(/ *\| */),
 378 |         align: cap[2].replace(/^ *|\| *$/g, '').split(/ *\| */),
 379 |         cells: cap[3].replace(/(?: *\| *)?\n$/, '').split('\n')
 380 |       };
 381 | 
 382 |       for (i = 0; i < item.align.length; i++) {
 383 |         if (/^ *-+: *$/.test(item.align[i])) {
 384 |           item.align[i] = 'right';
 385 |         } else if (/^ *:-+: *$/.test(item.align[i])) {
 386 |           item.align[i] = 'center';
 387 |         } else if (/^ *:-+ *$/.test(item.align[i])) {
 388 |           item.align[i] = 'left';
 389 |         } else {
 390 |           item.align[i] = null;
 391 |         }
 392 |       }
 393 | 
 394 |       for (i = 0; i < item.cells.length; i++) {
 395 |         item.cells[i] = item.cells[i]
 396 |           .replace(/^ *\| *| *\| *$/g, '')
 397 |           .split(/ *\| */);
 398 |       }
 399 | 
 400 |       this.tokens.push(item);
 401 | 
 402 |       continue;
 403 |     }
 404 | 
 405 |     // top-level paragraph
 406 |     if (top && (cap = this.rules.paragraph.exec(src))) {
 407 |       src = src.substring(cap[0].length);
 408 |       this.tokens.push({
 409 |         type: 'paragraph',
 410 |         text: cap[1][cap[1].length-1] === '\n'
 411 |           ? cap[1].slice(0, -1)
 412 |           : cap[1]
 413 |       });
 414 |       continue;
 415 |     }
 416 | 
 417 |     // text
 418 |     if (cap = this.rules.text.exec(src)) {
 419 |       // Top-level should never reach here.
 420 |       src = src.substring(cap[0].length);
 421 |       this.tokens.push({
 422 |         type: 'text',
 423 |         text: cap[0]
 424 |       });
 425 |       continue;
 426 |     }
 427 | 
 428 |     if (src) {
 429 |       throw new
 430 |         Error('Infinite loop on byte: ' + src.charCodeAt(0));
 431 |     }
 432 |   }
 433 | 
 434 |   return this.tokens;
 435 | };
 436 | 
 437 | /**
 438 |  * Inline-Level Grammar
 439 |  */
 440 | 
 441 | var inline = {
 442 |   escape: /^\\([\\`*{}\[\]()#+\-.!_>])/,
 443 |   autolink: /^<([^ >]+(@|:\/)[^ >]+)>/,
 444 |   url: noop,
 445 |   tag: /^<!--[\s\S]*?-->|^<\/?\w+(?:"[^"]*"|'[^']*'|[^'">])*?>/,
 446 |   link: /^!?\[(inside)\]\(href\)/,
 447 |   reflink: /^!?\[(inside)\]\s*\[([^\]]*)\]/,
 448 |   nolink: /^!?\[((?:\[[^\]]*\]|[^\[\]])*)\]/,
 449 |   strong: /^__([\s\S]+?)__(?!_)|^\*\*([\s\S]+?)\*\*(?!\*)/,
 450 |   em: /^\b_((?:__|[\s\S])+?)_\b|^\*((?:\*\*|[\s\S])+?)\*(?!\*)/,
 451 |   code: /^(`+)\s*([\s\S]*?[^`])\s*\1(?!`)/,
 452 |   br: /^ {2,}\n(?!\s*$)/,
 453 |   del: noop,
 454 |   text: /^[\s\S]+?(?=[\\<!\[_*`]| {2,}\n|$)/
 455 | };
 456 | 
 457 | inline._inside = /(?:\[[^\]]*\]|[^\]]|\](?=[^\[]*\]))*/;
 458 | inline._href = /\s*<?([^\s]*?)>?(?:\s+['"]([\s\S]*?)['"])?\s*/;
 459 | 
 460 | inline.link = replace(inline.link)
 461 |   ('inside', inline._inside)
 462 |   ('href', inline._href)
 463 |   ();
 464 | 
 465 | inline.reflink = replace(inline.reflink)
 466 |   ('inside', inline._inside)
 467 |   ();
 468 | 
 469 | /**
 470 |  * Normal Inline Grammar
 471 |  */
 472 | 
 473 | inline.normal = merge({}, inline);
 474 | 
 475 | /**
 476 |  * Pedantic Inline Grammar
 477 |  */
 478 | 
 479 | inline.pedantic = merge({}, inline.normal, {
 480 |   strong: /^__(?=\S)([\s\S]*?\S)__(?!_)|^\*\*(?=\S)([\s\S]*?\S)\*\*(?!\*)/,
 481 |   em: /^_(?=\S)([\s\S]*?\S)_(?!_)|^\*(?=\S)([\s\S]*?\S)\*(?!\*)/
 482 | });
 483 | 
 484 | /**
 485 |  * GFM Inline Grammar
 486 |  */
 487 | 
 488 | inline.gfm = merge({}, inline.normal, {
 489 |   escape: replace(inline.escape)('])', '~|])')(),
 490 |   url: /^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/,
 491 |   del: /^~~(?=\S)([\s\S]*?\S)~~/,
 492 |   text: replace(inline.text)
 493 |     (']|', '~]|')
 494 |     ('|', '|https?://|')
 495 |     ()
 496 | });
 497 | 
 498 | /**
 499 |  * GFM + Line Breaks Inline Grammar
 500 |  */
 501 | 
 502 | inline.breaks = merge({}, inline.gfm, {
 503 |   br: replace(inline.br)('{2,}', '*')(),
 504 |   text: replace(inline.gfm.text)('{2,}', '*')()
 505 | });
 506 | 
 507 | /**
 508 |  * Inline Lexer & Compiler
 509 |  */
 510 | 
 511 | function InlineLexer(links, options) {
 512 |   this.options = options || marked.defaults;
 513 |   this.links = links;
 514 |   this.rules = inline.normal;
 515 | 
 516 |   if (!this.links) {
 517 |     throw new
 518 |       Error('Tokens array requires a `links` property.');
 519 |   }
 520 | 
 521 |   if (this.options.gfm) {
 522 |     if (this.options.breaks) {
 523 |       this.rules = inline.breaks;
 524 |     } else {
 525 |       this.rules = inline.gfm;
 526 |     }
 527 |   } else if (this.options.pedantic) {
 528 |     this.rules = inline.pedantic;
 529 |   }
 530 | }
 531 | 
 532 | /**
 533 |  * Expose Inline Rules
 534 |  */
 535 | 
 536 | InlineLexer.rules = inline;
 537 | 
 538 | /**
 539 |  * Static Lexing/Compiling Method
 540 |  */
 541 | 
 542 | InlineLexer.output = function(src, links, options) {
 543 |   var inline = new InlineLexer(links, options);
 544 |   return inline.output(src);
 545 | };
 546 | 
 547 | /**
 548 |  * Lexing/Compiling
 549 |  */
 550 | 
 551 | InlineLexer.prototype.output = function(src) {
 552 |   var out = ''
 553 |     , link
 554 |     , text
 555 |     , href
 556 |     , cap;
 557 | 
 558 |   while (src) {
 559 |     // escape
 560 |     if (cap = this.rules.escape.exec(src)) {
 561 |       src = src.substring(cap[0].length);
 562 |       out += cap[1];
 563 |       continue;
 564 |     }
 565 | 
 566 |     // autolink
 567 |     if (cap = this.rules.autolink.exec(src)) {
 568 |       src = src.substring(cap[0].length);
 569 |       if (cap[2] === '@') {
 570 |         text = cap[1][6] === ':'
 571 |           ? this.mangle(cap[1].substring(7))
 572 |           : this.mangle(cap[1]);
 573 |         href = this.mangle('mailto:') + text;
 574 |       } else {
 575 |         text = escape(cap[1]);
 576 |         href = text;
 577 |       }
 578 |       out += '<a href="'
 579 |         + href
 580 |         + '">'
 581 |         + text
 582 |         + '</a>';
 583 |       continue;
 584 |     }
 585 | 
 586 |     // url (gfm)
 587 |     if (cap = this.rules.url.exec(src)) {
 588 |       src = src.substring(cap[0].length);
 589 |       text = escape(cap[1]);
 590 |       href = text;
 591 |       out += '<a href="'
 592 |         + href
 593 |         + '">'
 594 |         + text
 595 |         + '</a>';
 596 |       continue;
 597 |     }
 598 | 
 599 |     // tag
 600 |     if (cap = this.rules.tag.exec(src)) {
 601 |       src = src.substring(cap[0].length);
 602 |       out += this.options.sanitize
 603 |         ? escape(cap[0])
 604 |         : cap[0];
 605 |       continue;
 606 |     }
 607 | 
 608 |     // link
 609 |     if (cap = this.rules.link.exec(src)) {
 610 |       src = src.substring(cap[0].length);
 611 |       out += this.outputLink(cap, {
 612 |         href: cap[2],
 613 |         title: cap[3]
 614 |       });
 615 |       continue;
 616 |     }
 617 | 
 618 |     // reflink, nolink
 619 |     if ((cap = this.rules.reflink.exec(src))
 620 |         || (cap = this.rules.nolink.exec(src))) {
 621 |       src = src.substring(cap[0].length);
 622 |       link = (cap[2] || cap[1]).replace(/\s+/g, ' ');
 623 |       link = this.links[link.toLowerCase()];
 624 |       if (!link || !link.href) {
 625 |         out += cap[0][0];
 626 |         src = cap[0].substring(1) + src;
 627 |         continue;
 628 |       }
 629 |       out += this.outputLink(cap, link);
 630 |       continue;
 631 |     }
 632 | 
 633 |     // strong
 634 |     if (cap = this.rules.strong.exec(src)) {
 635 |       src = src.substring(cap[0].length);
 636 |       out += '<strong>'
 637 |         + this.output(cap[2] || cap[1])
 638 |         + '</strong>';
 639 |       continue;
 640 |     }
 641 | 
 642 |     // em
 643 |     if (cap = this.rules.em.exec(src)) {
 644 |       src = src.substring(cap[0].length);
 645 |       out += '<em>'
 646 |         + this.output(cap[2] || cap[1])
 647 |         + '</em>';
 648 |       continue;
 649 |     }
 650 | 
 651 |     // code
 652 |     if (cap = this.rules.code.exec(src)) {
 653 |       src = src.substring(cap[0].length);
 654 |       out += '<code>'
 655 |         + escape(cap[2], true)
 656 |         + '</code>';
 657 |       continue;
 658 |     }
 659 | 
 660 |     // br
 661 |     if (cap = this.rules.br.exec(src)) {
 662 |       src = src.substring(cap[0].length);
 663 |       out += '<br>';
 664 |       continue;
 665 |     }
 666 | 
 667 |     // del (gfm)
 668 |     if (cap = this.rules.del.exec(src)) {
 669 |       src = src.substring(cap[0].length);
 670 |       out += '<del>'
 671 |         + this.output(cap[1])
 672 |         + '</del>';
 673 |       continue;
 674 |     }
 675 | 
 676 |     // text
 677 |     if (cap = this.rules.text.exec(src)) {
 678 |       src = src.substring(cap[0].length);
 679 |       out += escape(this.smartypants(cap[0]));
 680 |       continue;
 681 |     }
 682 | 
 683 |     if (src) {
 684 |       throw new
 685 |         Error('Infinite loop on byte: ' + src.charCodeAt(0));
 686 |     }
 687 |   }
 688 | 
 689 |   return out;
 690 | };
 691 | 
 692 | /**
 693 |  * Compile Link
 694 |  */
 695 | 
 696 | InlineLexer.prototype.outputLink = function(cap, link) {
 697 |   if (cap[0][0] !== '!') {
 698 |     return '<a href="'
 699 |       + escape(link.href)
 700 |       + '"'
 701 |       + (link.title
 702 |       ? ' title="'
 703 |       + escape(link.title)
 704 |       + '"'
 705 |       : '')
 706 |       + '>'
 707 |       + this.output(cap[1])
 708 |       + '</a>';
 709 |   } else {
 710 |     return '<img src="'
 711 |       + escape(link.href)
 712 |       + '" alt="'
 713 |       + escape(cap[1])
 714 |       + '"'
 715 |       + (link.title
 716 |       ? ' title="'
 717 |       + escape(link.title)
 718 |       + '"'
 719 |       : '')
 720 |       + '>';
 721 |   }
 722 | };
 723 | 
 724 | /**
 725 |  * Smartypants Transformations
 726 |  */
 727 | 
 728 | InlineLexer.prototype.smartypants = function(text) {
 729 |   if (!this.options.smartypants) return text;
 730 |   return text
 731 |     .replace(/--/g, '\u2014')
 732 |     .replace(/'([^']*)'/g, '\u2018$1\u2019')
 733 |     .replace(/"([^"]*)"/g, '\u201C$1\u201D')
 734 |     .replace(/\.{3}/g, '\u2026');
 735 | };
 736 | 
 737 | /**
 738 |  * Mangle Links
 739 |  */
 740 | 
 741 | InlineLexer.prototype.mangle = function(text) {
 742 |   var out = ''
 743 |     , l = text.length
 744 |     , i = 0
 745 |     , ch;
 746 | 
 747 |   for (; i < l; i++) {
 748 |     ch = text.charCodeAt(i);
 749 |     if (Math.random() > 0.5) {
 750 |       ch = 'x' + ch.toString(16);
 751 |     }
 752 |     out += '&#' + ch + ';';
 753 |   }
 754 | 
 755 |   return out;
 756 | };
 757 | 
 758 | /**
 759 |  * Parsing & Compiling
 760 |  */
 761 | 
 762 | function Parser(options) {
 763 |   this.tokens = [];
 764 |   this.token = null;
 765 |   this.options = options || marked.defaults;
 766 | }
 767 | 
 768 | /**
 769 |  * Static Parse Method
 770 |  */
 771 | 
 772 | Parser.parse = function(src, options) {
 773 |   var parser = new Parser(options);
 774 |   return parser.parse(src);
 775 | };
 776 | 
 777 | /**
 778 |  * Parse Loop
 779 |  */
 780 | 
 781 | Parser.prototype.parse = function(src) {
 782 |   this.inline = new InlineLexer(src.links, this.options);
 783 |   this.tokens = src.reverse();
 784 | 
 785 |   var out = '';
 786 |   while (this.next()) {
 787 |     out += this.tok();
 788 |   }
 789 | 
 790 |   return out;
 791 | };
 792 | 
 793 | /**
 794 |  * Next Token
 795 |  */
 796 | 
 797 | Parser.prototype.next = function() {
 798 |   return this.token = this.tokens.pop();
 799 | };
 800 | 
 801 | /**
 802 |  * Preview Next Token
 803 |  */
 804 | 
 805 | Parser.prototype.peek = function() {
 806 |   return this.tokens[this.tokens.length-1] || 0;
 807 | };
 808 | 
 809 | /**
 810 |  * Parse Text Tokens
 811 |  */
 812 | 
 813 | Parser.prototype.parseText = function() {
 814 |   var body = this.token.text;
 815 | 
 816 |   while (this.peek().type === 'text') {
 817 |     body += '\n' + this.next().text;
 818 |   }
 819 | 
 820 |   return this.inline.output(body);
 821 | };
 822 | 
 823 | /**
 824 |  * Parse Current Token
 825 |  */
 826 | 
 827 | Parser.prototype.tok = function() {
 828 |   switch (this.token.type) {
 829 |     case 'space': {
 830 |       return '';
 831 |     }
 832 |     case 'hr': {
 833 |       return '<hr>\n';
 834 |     }
 835 |     case 'heading': {
 836 |       return '<h'
 837 |         + this.token.depth
 838 |         + '>'
 839 |         + this.inline.output(this.token.text)
 840 |         + '</h'
 841 |         + this.token.depth
 842 |         + '>\n';
 843 |     }
 844 |     case 'code': {
 845 |       if (this.options.highlight) {
 846 |         var code = this.options.highlight(this.token.text, this.token.lang);
 847 |         if (code != null && code !== this.token.text) {
 848 |           this.token.escaped = true;
 849 |           this.token.text = code;
 850 |         }
 851 |       }
 852 | 
 853 |       if (!this.token.escaped) {
 854 |         this.token.text = escape(this.token.text, true);
 855 |       }
 856 | 
 857 |       return '<pre><code'
 858 |         + (this.token.lang
 859 |         ? ' class="'
 860 |         + this.options.langPrefix
 861 |         + this.token.lang
 862 |         + '"'
 863 |         : '')
 864 |         + '>'
 865 |         + this.token.text
 866 |         + '</code></pre>\n';
 867 |     }
 868 |     case 'table': {
 869 |       var body = ''
 870 |         , heading
 871 |         , i
 872 |         , row
 873 |         , cell
 874 |         , j;
 875 | 
 876 |       // header
 877 |       body += '<thead>\n<tr>\n';
 878 |       for (i = 0; i < this.token.header.length; i++) {
 879 |         heading = this.inline.output(this.token.header[i]);
 880 |         body += this.token.align[i]
 881 |           ? '<th align="' + this.token.align[i] + '">' + heading + '</th>\n'
 882 |           : '<th>' + heading + '</th>\n';
 883 |       }
 884 |       body += '</tr>\n</thead>\n';
 885 | 
 886 |       // body
 887 |       body += '<tbody>\n'
 888 |       for (i = 0; i < this.token.cells.length; i++) {
 889 |         row = this.token.cells[i];
 890 |         body += '<tr>\n';
 891 |         for (j = 0; j < row.length; j++) {
 892 |           cell = this.inline.output(row[j]);
 893 |           body += this.token.align[j]
 894 |             ? '<td align="' + this.token.align[j] + '">' + cell + '</td>\n'
 895 |             : '<td>' + cell + '</td>\n';
 896 |         }
 897 |         body += '</tr>\n';
 898 |       }
 899 |       body += '</tbody>\n';
 900 | 
 901 |       return '<table>\n'
 902 |         + body
 903 |         + '</table>\n';
 904 |     }
 905 |     case 'blockquote_start': {
 906 |       var body = '';
 907 | 
 908 |       while (this.next().type !== 'blockquote_end') {
 909 |         body += this.tok();
 910 |       }
 911 | 
 912 |       return '<blockquote>\n'
 913 |         + body
 914 |         + '</blockquote>\n';
 915 |     }
 916 |     case 'list_start': {
 917 |       var type = this.token.ordered ? 'ol' : 'ul'
 918 |         , body = '';
 919 | 
 920 |       while (this.next().type !== 'list_end') {
 921 |         body += this.tok();
 922 |       }
 923 | 
 924 |       return '<'
 925 |         + type
 926 |         + '>\n'
 927 |         + body
 928 |         + '</'
 929 |         + type
 930 |         + '>\n';
 931 |     }
 932 |     case 'list_item_start': {
 933 |       var body = '';
 934 | 
 935 |       while (this.next().type !== 'list_item_end') {
 936 |         body += this.token.type === 'text'
 937 |           ? this.parseText()
 938 |           : this.tok();
 939 |       }
 940 | 
 941 |       return '<li>'
 942 |         + body
 943 |         + '</li>\n';
 944 |     }
 945 |     case 'loose_item_start': {
 946 |       var body = '';
 947 | 
 948 |       while (this.next().type !== 'list_item_end') {
 949 |         body += this.tok();
 950 |       }
 951 | 
 952 |       return '<li>'
 953 |         + body
 954 |         + '</li>\n';
 955 |     }
 956 |     case 'html': {
 957 |       return !this.token.pre && !this.options.pedantic
 958 |         ? this.inline.output(this.token.text)
 959 |         : this.token.text;
 960 |     }
 961 |     case 'paragraph': {
 962 |       return '<p>'
 963 |         + this.inline.output(this.token.text)
 964 |         + '</p>\n';
 965 |     }
 966 |     case 'text': {
 967 |       return '<p>'
 968 |         + this.parseText()
 969 |         + '</p>\n';
 970 |     }
 971 |   }
 972 | };
 973 | 
 974 | /**
 975 |  * Helpers
 976 |  */
 977 | 
 978 | function escape(html, encode) {
 979 |   return html
 980 |     .replace(!encode ? /&(?!#?\w+;)/g : /&/g, '&amp;')
 981 |     .replace(/</g, '&lt;')
 982 |     .replace(/>/g, '&gt;')
 983 |     .replace(/"/g, '&quot;')
 984 |     .replace(/'/g, '&#39;');
 985 | }
 986 | 
 987 | function replace(regex, opt) {
 988 |   regex = regex.source;
 989 |   opt = opt || '';
 990 |   return function self(name, val) {
 991 |     if (!name) return new RegExp(regex, opt);
 992 |     val = val.source || val;
 993 |     val = val.replace(/(^|[^\[])\^/g, '$1');
 994 |     regex = regex.replace(name, val);
 995 |     return self;
 996 |   };
 997 | }
 998 | 
 999 | function noop() {}
1000 | noop.exec = noop;
1001 | 
1002 | function merge(obj) {
1003 |   var i = 1
1004 |     , target
1005 |     , key;
1006 | 
1007 |   for (; i < arguments.length; i++) {
1008 |     target = arguments[i];
1009 |     for (key in target) {
1010 |       if (Object.prototype.hasOwnProperty.call(target, key)) {
1011 |         obj[key] = target[key];
1012 |       }
1013 |     }
1014 |   }
1015 | 
1016 |   return obj;
1017 | }
1018 | 
1019 | /**
1020 |  * Marked
1021 |  */
1022 | 
1023 | function marked(src, opt, callback) {
1024 |   if (callback || typeof opt === 'function') {
1025 |     if (!callback) {
1026 |       callback = opt;
1027 |       opt = null;
1028 |     }
1029 | 
1030 |     if (opt) opt = merge({}, marked.defaults, opt);
1031 | 
1032 |     var highlight = opt.highlight
1033 |       , tokens
1034 |       , pending
1035 |       , i = 0;
1036 | 
1037 |     try {
1038 |       tokens = Lexer.lex(src, opt)
1039 |     } catch (e) {
1040 |       return callback(e);
1041 |     }
1042 | 
1043 |     pending = tokens.length;
1044 | 
1045 |     var done = function(hi) {
1046 |       var out, err;
1047 | 
1048 |       if (hi !== true) {
1049 |         delete opt.highlight;
1050 |       }
1051 | 
1052 |       try {
1053 |         out = Parser.parse(tokens, opt);
1054 |       } catch (e) {
1055 |         err = e;
1056 |       }
1057 | 
1058 |       opt.highlight = highlight;
1059 | 
1060 |       return err
1061 |         ? callback(err)
1062 |         : callback(null, out);
1063 |     };
1064 | 
1065 |     if (!highlight || highlight.length < 3) {
1066 |       return done(true);
1067 |     }
1068 | 
1069 |     if (!pending) return done();
1070 | 
1071 |     for (; i < tokens.length; i++) {
1072 |       (function(token) {
1073 |         if (token.type !== 'code') {
1074 |           return --pending || done();
1075 |         }
1076 |         return highlight(token.text, token.lang, function(err, code) {
1077 |           if (code == null || code === token.text) {
1078 |             return --pending || done();
1079 |           }
1080 |           token.text = code;
1081 |           token.escaped = true;
1082 |           --pending || done();
1083 |         });
1084 |       })(tokens[i]);
1085 |     }
1086 | 
1087 |     return;
1088 |   }
1089 |   try {
1090 |     if (opt) opt = merge({}, marked.defaults, opt);
1091 |     return Parser.parse(Lexer.lex(src, opt), opt);
1092 |   } catch (e) {
1093 |     e.message += '\nPlease report this to https://github.com/chjj/marked.';
1094 |     if ((opt || marked.defaults).silent) {
1095 |       return '<p>An error occured:</p><pre>'
1096 |         + escape(e.message + '', true)
1097 |         + '</pre>';
1098 |     }
1099 |     throw e;
1100 |   }
1101 | }
1102 | 
1103 | /**
1104 |  * Options
1105 |  */
1106 | 
1107 | marked.options =
1108 | marked.setOptions = function(opt) {
1109 |   merge(marked.defaults, opt);
1110 |   return marked;
1111 | };
1112 | 
1113 | marked.defaults = {
1114 |   gfm: true,
1115 |   tables: true,
1116 |   breaks: false,
1117 |   pedantic: false,
1118 |   sanitize: false,
1119 |   smartLists: false,
1120 |   silent: false,
1121 |   highlight: null,
1122 |   langPrefix: 'lang-',
1123 |   smartypants: false
1124 | };
1125 | 
1126 | /**
1127 |  * Expose
1128 |  */
1129 | 
1130 | marked.Parser = Parser;
1131 | marked.parser = Parser.parse;
1132 | 
1133 | marked.Lexer = Lexer;
1134 | marked.lexer = Lexer.lex;
1135 | 
1136 | marked.InlineLexer = InlineLexer;
1137 | marked.inlineLexer = InlineLexer.output;
1138 | 
1139 | marked.parse = marked;
1140 | 
1141 | if (typeof exports === 'object') {
1142 |   module.exports = marked;
1143 | } else if (typeof define === 'function' && define.amd) {
1144 |   define(function() { return marked; });
1145 | } else {
1146 |   this.marked = marked;
1147 | }
1148 | 
1149 | }).call(function() {
1150 |   return this || (typeof window !== 'undefined' ? window : global);
1151 | }());
1152 | 


--------------------------------------------------------------------------------
/docs/partials/api/ngsails.$sailsSocket.html:
--------------------------------------------------------------------------------
  1 | <h1><code ng:non-bindable="">$sailsSocket</code>
  2 | <div><span class="hint">service in module <code ng:non-bindable="">ngsails</code>
  3 | </span>
  4 | </div>
  5 | </h1>
  6 | <div><h2 id="description">Description</h2>
  7 | <div class="description"><div class="ngsails-sailssocket-page"><p>The <code>$sailsSocket</code> service is the core service that facilitates communication with sails via socket.io</p>
  8 | <p>The $sailsSocket API is based on the deferred/promise APIs exposed by
  9 | the $q service. While for simple usage patterns this doesn&#39;t matter much, for advanced usage
 10 | it is important to familiarize yourself with these APIs and the guarantees they provide.</p>
 11 | <h3 id="description_general-usage">General usage</h3>
 12 | <p>The <code>$sailsSocket</code> service is a function which takes a single argument — a configuration object —
 13 | that is used to generate a request and returns  a promise
 14 | with two $sailsSocket specific methods: <code>success</code> and <code>error</code>.</p>
 15 | <pre><code class="lang-js">  $sailsSocket({method: &#39;GET&#39;, url: &#39;/someUrl&#39;}).
 16 |     success(function(data, status, headers, config) {
 17 |       // this callback will be called asynchronously
 18 |       // when the response is available
 19 |     }).
 20 |     error(function(data, status, headers, config) {
 21 |       // called asynchronously if an error occurs
 22 |       // or server returns response with an error status.
 23 |     });</code></pre>
 24 | <p>Since the returned value of calling the $sailsSocket function is a <code>promise</code>, you can also use
 25 | the <code>then</code> method to register callbacks, and these callbacks will receive a single argument –
 26 | an object representing the response. See the API signature and type info below for more
 27 | details.</p>
 28 | <h3 id="description_shortcut-methods">Shortcut methods</h3>
 29 | <p>Shortcut methods are also available. All shortcut methods require passing in the URL, and
 30 | request data must be passed in for POST/PUT requests.</p>
 31 | <pre><code class="lang-js">  $sailsSocket.get(&#39;/someUrl&#39;).success(successCallback);
 32 |   $sailsSocket.post(&#39;/someUrl&#39;, data).success(successCallback);</code></pre>
 33 | <p>Complete list of shortcut methods:</p>
 34 | <ul>
 35 | <li>$sailsSocket.get</li>
 36 | <li>$sailsSocket.head</li>
 37 | <li>$sailsSocket.post</li>
 38 | <li>$sailsSocket.put</li>
 39 | <li>$sailsSocket.delete</li>
 40 | <li>$sailsSocket.subscribe</li>
 41 | </ul>
 42 | <h3 id="description_setting-headers">Setting Headers</h3>
 43 | <p>The $sailsSocket service will automatically add certain headers to all requests. These defaults
 44 | can be fully configured by accessing the <code>$sailsSocketProvider.defaults.headers</code> configuration
 45 | object, which currently contains this default configuration:</p>
 46 | <ul>
 47 | <li><code>$sailsSocketProvider.defaults.headers.common</code> (headers that are common for all requests):<ul>
 48 | <li><code>Accept: application/json, text/plain, * / *</code></li>
 49 | </ul>
 50 | </li>
 51 | <li><code>$sailsSocketProvider.defaults.headers.post</code>: (header defaults for POST requests)<ul>
 52 | <li><code>Content-Type: application/json</code></li>
 53 | </ul>
 54 | </li>
 55 | <li><code>$sailsSocketProvider.defaults.headers.put</code> (header defaults for PUT requests)<ul>
 56 | <li><code>Content-Type: application/json</code></li>
 57 | </ul>
 58 | </li>
 59 | </ul>
 60 | <p>To add or overwrite these defaults, simply add or remove a property from these configuration
 61 | objects. To add headers for an HTTP method other than POST or PUT, simply add a new object
 62 | with the lowercased HTTP method name as the key, e.g.
 63 | `$sailsSocketProvider.defaults.headers.get = { &#39;My-Header&#39; : &#39;value&#39; }.</p>
 64 | <p>The defaults can also be set at runtime via the <code>$sailsSocket.defaults</code> object in the same
 65 | fashion. For example:</p>
 66 | <pre><code>module.run(function($sailsSocket) {
 67 |   $sailsSocket.defaults.headers.common.Authorization = &#39;Basic YmVlcDpib29w&#39;
 68 | });</code></pre>
 69 | <p>In addition, you can supply a <code>headers</code> property in the config object passed when
 70 | calling <code>$sailsSocket(config)</code>, which overrides the defaults without changing them globally.</p>
 71 | <h3 id="description_transforming-requests-and-responses">Transforming Requests and Responses</h3>
 72 | <p>Both requests and responses can be transformed using transform functions. By default, Angular
 73 | applies these transformations:</p>
 74 | <p>Request transformations:</p>
 75 | <ul>
 76 | <li>If the <code>data</code> property of the request configuration object contains an object, serialize it
 77 | into JSON format.</li>
 78 | </ul>
 79 | <p>Response transformations:</p>
 80 | <ul>
 81 | <li>If XSRF prefix is detected, strip it (see Security Considerations section below).</li>
 82 | <li>If JSON response is detected, deserialize it using a JSON parser.</li>
 83 | </ul>
 84 | <p>To globally augment or override the default transforms, modify the
 85 | <code>$sailsSocketProvider.defaults.transformRequest</code> and <code>$sailsSocketProvider.defaults.transformResponse</code>
 86 | properties. These properties are by default an array of transform functions, which allows you
 87 | to <code>push</code> or <code>unshift</code> a new transformation function into the transformation chain. You can
 88 | also decide to completely override any default transformations by assigning your
 89 | transformation functions to these properties directly without the array wrapper.  These defaults
 90 | are again available on the $sailsSocket factory at run-time, which may be useful if you have run-time
 91 | services you wish to be involved in your transformations.</p>
 92 | <p>Similarly, to locally override the request/response transforms, augment the
 93 | <code>transformRequest</code> and/or <code>transformResponse</code> properties of the configuration object passed
 94 | into <code>$sailsSocket</code>.</p>
 95 | <h3 id="description_interceptors">Interceptors</h3>
 96 | <p>Before you start creating interceptors, be sure to understand the
 97 | $q and deferred/promise APIs.</p>
 98 | <p>For purposes of global error handling, authentication, or any kind of synchronous or
 99 | asynchronous pre-processing of request or postprocessing of responses, it is desirable to be
100 | able to intercept requests before they are handed to the server and
101 | responses before they are handed over to the application code that
102 | initiated these requests. The interceptors leverage the promise APIs to fulfill this need for both synchronous and asynchronous pre-processing.</p>
103 | <p>The interceptors are service factories that are registered with the <code>$sailsSocketProvider</code> by
104 | adding them to the <code>$sailsSocketProvider.interceptors</code> array. The factory is called and
105 | injected with dependencies (if specified) and returns the interceptor.</p>
106 | <p>There are two kinds of interceptors (and two kinds of rejection interceptors):</p>
107 | <ul>
108 | <li><code>request</code>: interceptors get called with http <code>config</code> object. The function is free to
109 | modify the <code>config</code> or create a new one. The function needs to return the <code>config</code>
110 | directly or as a promise.</li>
111 | <li><code>requestError</code>: interceptor gets called when a previous interceptor threw an error or
112 | resolved with a rejection.</li>
113 | <li><code>response</code>: interceptors get called with http <code>response</code> object. The function is free to
114 | modify the <code>response</code> or create a new one. The function needs to return the <code>response</code>
115 | directly or as a promise.</li>
116 | <li><code>responseError</code>: interceptor gets called when a previous interceptor threw an error or
117 | resolved with a rejection.</li>
118 | </ul>
119 | <p>```js
120 |   // register the interceptor as a service
121 |   $provide.factory(&#39;myHttpInterceptor&#39;, function($q, dependency1, dependency2) {
122 |     return {
123 |       // optional method
124 |       &#39;request&#39;: function(config) {
125 |         // do something on success
126 |         return config || $q.when(config);
127 |       },</p>
128 | <pre><code>  // optional method
129 |  &#39;requestError&#39;: function(rejection) {
130 |     // do something on error
131 |     if (canRecover(rejection)) {
132 |       return responseOrNewPromise
133 |     }
134 |     return $q.reject(rejection);
135 |   },
136 | 
137 | 
138 | 
139 |   // optional method
140 |   &#39;response&#39;: function(response) {
141 |     // do something on success
142 |     return response || $q.when(response);
143 |   },
144 | 
145 |   // optional method
146 |  &#39;responseError&#39;: function(rejection) {
147 |     // do something on error
148 |     if (canRecover(rejection)) {
149 |       return responseOrNewPromise
150 |     }
151 |     return $q.reject(rejection);
152 |   }
153 | };</code></pre>
154 | <p>  });</p>
155 | <p>  $sailsSocketProvider.interceptors.push(&#39;mySocketInterceptor&#39;);</p>
156 | <p>  // alternatively, register the interceptor via an anonymous factory
157 |   $sailsSocketProvider.interceptors.push(function($q, dependency1, dependency2) {
158 |     return {
159 |      &#39;request&#39;: function(config) {
160 |          // same as above
161 |       },</p>
162 | <pre><code>  &#39;response&#39;: function(response) {
163 |      // same as above
164 |   }
165 | };</code></pre>
166 | <p>  });</p>
167 | </div></div>
168 | <h2 id="dependencies">Dependencies</h2>
169 | <ul class="dependencies"><li><code ng:non-bindable=""><a href="#/api/ng.$cacheFactory">$cacheFactory</a></code>
170 | </li>
171 | <li><code ng:non-bindable=""><a href="#/api/ng.$rootScope">$rootScope</a></code>
172 | </li>
173 | <li><code ng:non-bindable=""><a href="#/api/ng.$q">$q</a></code>
174 | </li>
175 | <li><code ng:non-bindable=""><a href="#/api/ng.$injector">$injector</a></code>
176 | </li>
177 | </ul>
178 | <h2 id="usage">Usage</h2>
179 | <div class="usage"><pre class="prettyprint linenums">$sailsSocket(config);</pre>
180 | <h4 id="usage_parameters">Parameters</h4><table class="variables-matrix table table-bordered table-striped"><thead><tr><th>Param</th><th>Type</th><th>Details</th></tr></thead><tbody><tr><td>config</td><td><a href="" class="label type-hint type-hint-object">object</a></td><td><div class="ngsails-sailssocket-page"><p>Object describing the request to be made and how it should be
181 | processed. The object has following properties:</p>
182 | <ul>
183 | <li><strong>method</strong> – <code>{string}</code> – HTTP method (e.g. &#39;GET&#39;, &#39;POST&#39;, etc)</li>
184 | <li><strong>url</strong> – <code>{string}</code> – Absolute or relative URL of the resource that is being requested.</li>
185 | <li><strong>params</strong> – <code>{Object.&lt;string|Object&gt;}</code> – Map of strings or objects which will be turned
186 | to <code>?key1=value1&amp;key2=value2</code> after the url. If the value is not a string, it will be
187 | JSONified.</li>
188 | <li><strong>data</strong> – <code>{string|Object}</code> – Data to be sent as the request message data.</li>
189 | <li><strong>headers</strong> – <code>{Object}</code> – Map of strings or functions which return strings representing
190 | HTTP headers to send to the server. If the return value of a function is null, the
191 | header will not be sent.</li>
192 | <li><strong>xsrfHeaderName</strong> – <code>{string}</code> – Name of HTTP header to populate with the XSRF token.</li>
193 | <li><strong>xsrfCookieName</strong> – <code>{string}</code> – Name of cookie containing the XSRF token.</li>
194 | <li><strong>transformRequest</strong> –
195 | <code>{function(data, headersGetter)|Array.&lt;function(data, headersGetter)&gt;}</code> –
196 | transform function or an array of such functions. The transform function takes the http
197 | request body and headers and returns its transformed (typically serialized) version.</li>
198 | <li><strong>transformResponse</strong> –
199 | <code>{function(data, headersGetter)|Array.&lt;function(data, headersGetter)&gt;}</code> –
200 | transform function or an array of such functions. The transform function takes the http
201 | response body and headers and returns its transformed (typically deserialized) version.</li>
202 | <li><strong>cache</strong> – <code>{boolean|Cache}</code> – If true, a default $sailsSocket cache will be used to cache the
203 | GET request, otherwise if a cache instance built with
204 | $cacheFactory, this cache will be used for
205 | caching.</li>
206 | <li><strong>timeout</strong> – <code>{number|Promise}</code> – timeout in milliseconds, or a promise
207 | that should abort the request when resolved.</li>
208 | <li><strong>withCredentials</strong> - <code>{boolean}</code> - whether to to set the <code>withCredentials</code> flag on the
209 | XHR object. See [requests with credentials]<a href="https://developer.mozilla.org/en/http_access_control#section_5">https://developer.mozilla.org/en/http_access_control#section_5</a>
210 | for more information.</li>
211 | <li><strong>responseType</strong> - <code>{string}</code> - see
212 | <a href="https://developer.mozilla.org/en-US/docs/DOM/XMLHttpRequest#responseType">requestType</a>.</li>
213 | </ul>
214 | </div></td></tr></tbody></table><h4 id="usage_returns">Returns</h4><table class="variables-matrix"><tr><td><a href="" class="label type-hint type-hint-promise">Promise</a></td><td><div class="ngsails-sailssocket-page"><p>Returns a promise object with the
215 | standard <code>then</code> method and two http specific methods: <code>success</code> and <code>error</code>. The <code>then</code>
216 | method takes two arguments a success and an error callback which will be called with a
217 | response object. The <code>success</code> and <code>error</code> methods take a single argument - a function that
218 | will be called when the request succeeds or fails respectively. The arguments passed into
219 | these functions are destructured representation of the response object passed into the
220 | <code>then</code> method. The response object has these properties:</p>
221 | <ul>
222 | <li><strong>data</strong> – <code>{string|Object}</code> – The response body transformed with the transform
223 | functions.</li>
224 | <li><strong>status</strong> – <code>{number}</code> – HTTP status code of the response.</li>
225 | <li><strong>headers</strong> – <code>{function([headerName])}</code> – Header getter function.</li>
226 | <li><strong>config</strong> – <code>{Object}</code> – The configuration object that was used to generate the request.</li>
227 | <li><strong>statusText</strong> – <code>{string}</code> – HTTP status text of the response.</li>
228 | </ul>
229 | </div></td></tr></table></div>
230 | <div class="member method"><h2 id="methods">Methods</h2>
231 | <ul class="methods"><li><h3 id="methods_delete">delete(url, config)</h3>
232 | <div class="delete"><div class="-sailssocket-delete-page"><p>Shortcut method to perform <code>DELETE</code> request.</p>
233 | </div><h5 id="methods_delete_parameters">Parameters</h5><table class="variables-matrix table table-bordered table-striped"><thead><tr><th>Param</th><th>Type</th><th>Details</th></tr></thead><tbody><tr><td>url</td><td><a href="" class="label type-hint type-hint-string">string</a></td><td><div class="-sailssocket-delete-page"><p>Relative or absolute URL specifying the destination of the request</p>
234 | </div></td></tr><tr><td>config <div><em>(optional)</em></div></td><td><a href="" class="label type-hint type-hint-object">Object</a></td><td><div class="-sailssocket-delete-page"><p>Optional configuration object</p>
235 | </div></td></tr></tbody></table><h5 id="methods_delete_returns">Returns</h5><table class="variables-matrix"><tr><td><a href="" class="label type-hint type-hint-httppromise">HttpPromise</a></td><td><div class="-sailssocket-delete-page"><p>Future object</p>
236 | </div></td></tr></table></div>
237 | </li>
238 | <li><h3 id="methods_get">get(url, config)</h3>
239 | <div class="get"><div class="-sailssocket-get-page"><p>Shortcut method to perform <code>GET</code> request.</p>
240 | </div><h5 id="methods_get_parameters">Parameters</h5><table class="variables-matrix table table-bordered table-striped"><thead><tr><th>Param</th><th>Type</th><th>Details</th></tr></thead><tbody><tr><td>url</td><td><a href="" class="label type-hint type-hint-string">string</a></td><td><div class="-sailssocket-get-page"><p>Relative or absolute URL specifying the destination of the request</p>
241 | </div></td></tr><tr><td>config <div><em>(optional)</em></div></td><td><a href="" class="label type-hint type-hint-object">Object</a></td><td><div class="-sailssocket-get-page"><p>Optional configuration object</p>
242 | </div></td></tr></tbody></table><h5 id="methods_get_returns">Returns</h5><table class="variables-matrix"><tr><td><a href="" class="label type-hint type-hint-httppromise">HttpPromise</a></td><td><div class="-sailssocket-get-page"><p>Future object</p>
243 | </div></td></tr></table></div>
244 | </li>
245 | <li><h3 id="methods_head">head(url, config)</h3>
246 | <div class="head"><div class="-sailssocket-head-page"><p>Shortcut method to perform <code>HEAD</code> request.</p>
247 | </div><h5 id="methods_head_parameters">Parameters</h5><table class="variables-matrix table table-bordered table-striped"><thead><tr><th>Param</th><th>Type</th><th>Details</th></tr></thead><tbody><tr><td>url</td><td><a href="" class="label type-hint type-hint-string">string</a></td><td><div class="-sailssocket-head-page"><p>Relative or absolute URL specifying the destination of the request</p>
248 | </div></td></tr><tr><td>config <div><em>(optional)</em></div></td><td><a href="" class="label type-hint type-hint-object">Object</a></td><td><div class="-sailssocket-head-page"><p>Optional configuration object</p>
249 | </div></td></tr></tbody></table><h5 id="methods_head_returns">Returns</h5><table class="variables-matrix"><tr><td><a href="" class="label type-hint type-hint-httppromise">HttpPromise</a></td><td><div class="-sailssocket-head-page"><p>Future object</p>
250 | </div></td></tr></table></div>
251 | </li>
252 | <li><h3 id="methods_on">on(event, callback)</h3>
253 | <div class="on"><div class="-sailssocket-on-page"><p>Subscribes to an incoming socket event</p>
254 | </div><h5 id="methods_on_parameters">Parameters</h5><table class="variables-matrix table table-bordered table-striped"><thead><tr><th>Param</th><th>Type</th><th>Details</th></tr></thead><tbody><tr><td>event</td><td><a href="" class="label type-hint type-hint-string">string</a></td><td><div class="-sailssocket-on-page"><p>socket event name to listen for.</p>
255 | </div></td></tr><tr><td>callback</td><td><a href="" class="label type-hint type-hint-function">function</a></td><td><div class="-sailssocket-on-page"><p>listener function</p>
256 | </div></td></tr></tbody></table><h5 id="methods_on_returns">Returns</h5><table class="variables-matrix"><tr><td><a href="" class="label type-hint type-hint-httppromise">HttpPromise</a></td><td><div class="-sailssocket-on-page"><p>Future object</p>
257 | </div></td></tr></table></div>
258 | </li>
259 | <li><h3 id="methods_post">post(url, data, config)</h3>
260 | <div class="post"><div class="-sailssocket-post-page"><p>Shortcut method to perform <code>POST</code> request.</p>
261 | </div><h5 id="methods_post_parameters">Parameters</h5><table class="variables-matrix table table-bordered table-striped"><thead><tr><th>Param</th><th>Type</th><th>Details</th></tr></thead><tbody><tr><td>url</td><td><a href="" class="label type-hint type-hint-string">string</a></td><td><div class="-sailssocket-post-page"><p>Relative or absolute URL specifying the destination of the request</p>
262 | </div></td></tr><tr><td>data</td><td><a href="" class="label type-hint type-hint-object">*</a></td><td><div class="-sailssocket-post-page"><p>Request content</p>
263 | </div></td></tr><tr><td>config <div><em>(optional)</em></div></td><td><a href="" class="label type-hint type-hint-object">Object</a></td><td><div class="-sailssocket-post-page"><p>Optional configuration object</p>
264 | </div></td></tr></tbody></table><h5 id="methods_post_returns">Returns</h5><table class="variables-matrix"><tr><td><a href="" class="label type-hint type-hint-httppromise">HttpPromise</a></td><td><div class="-sailssocket-post-page"><p>Future object</p>
265 | </div></td></tr></table></div>
266 | </li>
267 | <li><h3 id="methods_put">put(url, data, config)</h3>
268 | <div class="put"><div class="-sailssocket-put-page"><p>Shortcut method to perform <code>PUT</code> request.</p>
269 | </div><h5 id="methods_put_parameters">Parameters</h5><table class="variables-matrix table table-bordered table-striped"><thead><tr><th>Param</th><th>Type</th><th>Details</th></tr></thead><tbody><tr><td>url</td><td><a href="" class="label type-hint type-hint-string">string</a></td><td><div class="-sailssocket-put-page"><p>Relative or absolute URL specifying the destination of the request</p>
270 | </div></td></tr><tr><td>data</td><td><a href="" class="label type-hint type-hint-object">*</a></td><td><div class="-sailssocket-put-page"><p>Request content</p>
271 | </div></td></tr><tr><td>config <div><em>(optional)</em></div></td><td><a href="" class="label type-hint type-hint-object">Object</a></td><td><div class="-sailssocket-put-page"><p>Optional configuration object</p>
272 | </div></td></tr></tbody></table><h5 id="methods_put_returns">Returns</h5><table class="variables-matrix"><tr><td><a href="" class="label type-hint type-hint-httppromise">HttpPromise</a></td><td><div class="-sailssocket-put-page"><p>Future object</p>
273 | </div></td></tr></table></div>
274 | </li>
275 | <li><h3 id="methods_subscribe">subscribe(eventName, eventHandler)</h3>
276 | <div class="subscribe"><div class="-sailssocket-subscribe-page"><p>Low-level method to register handlers for socket.io events.</p>
277 | </div><h5 id="methods_subscribe_parameters">Parameters</h5><table class="variables-matrix table table-bordered table-striped"><thead><tr><th>Param</th><th>Type</th><th>Details</th></tr></thead><tbody><tr><td>eventName</td><td><a href="" class="label type-hint type-hint-string">string</a></td><td><div class="-sailssocket-subscribe-page"><p>Name of server-emitted event to listen for.</p>
278 | </div></td></tr><tr><td>eventHandler</td><td><a href="" class="label type-hint type-hint-function">Function</a></td><td><div class="-sailssocket-subscribe-page"><p>Method to fire when event is recieved.</p>
279 | </div></td></tr></tbody></table><h5 id="methods_subscribe_returns">Returns</h5><table class="variables-matrix"><tr><td><a href="" class="label type-hint type-hint-function">Function</a></td><td><div class="-sailssocket-subscribe-page"><p>A function which, if called, will remove the event handler</p>
280 | </div></td></tr></table></div>
281 | </li>
282 | </ul>
283 | </div>
284 | <div class="member property"><h2 id="properties">Properties</h2>
285 | <ul class="properties"><li><h3 id="properties_defaults">defaults</h3>
286 | <div class="defaults"><div class="-sailssocket-defaults-page"><p>Runtime equivalent of the <code>$sailsSocketProvider.defaults</code> property. Allows configuration of
287 | default headers, withCredentials as well as request and response transformations.</p>
288 | <p>See &quot;Setting HTTP Headers&quot; and &quot;Transforming Requests and Responses&quot; sections above.</p>
289 | </div></div>
290 | </li>
291 | <li><h3 id="properties_pendingrequests">pendingRequests</h3>
292 | <div class="pendingrequests"><div class="ngsails-sailssocket-page"><p>Array of config objects for currently pending
293 | requests. This is primarily meant to be used for debugging purposes.</p>
294 | </div></div>
295 | </li>
296 | </ul>
297 | </div>
298 | </div>
299 | 


--------------------------------------------------------------------------------
/docs/partials/api/ngsails.$sailsSocketBackend.html:
--------------------------------------------------------------------------------
 1 | <h1><code ng:non-bindable="">$sailsSocketBackend</code>
 2 | <div><span class="hint">service in module <code ng:non-bindable="">ngsails</code>
 3 | </span>
 4 | </div>
 5 | </h1>
 6 | <div><h2 id="description">Description</h2>
 7 | <div class="description"><div class="ngsails-sailssocketbackend-page"><p>Service used by the $sailsSocket that delegates to a
 8 | Socket.io connection (or in theory, any connection type eventually)</p>
 9 | <p>You should never need to use this service directly, instead use the higher-level abstraction:
10 | $sailsSocket.</p>
11 | <p>During testing this implementation is swapped with $sailsMockBackend
12 |  which can be trained with responses.</p>
13 | </div></div>
14 | <h2 id="dependencies">Dependencies</h2>
15 | <ul class="dependencies"><li><code ng:non-bindable=""><a href="#/api/ng.$window">$window</a></code>
16 | </li>
17 | <li><code ng:non-bindable=""><a href="#/api/ng.$document">$document</a></code>
18 | </li>
19 | </ul>
20 | </div>
21 | 


--------------------------------------------------------------------------------
/docs/partials/api/ngsails.html:
--------------------------------------------------------------------------------
1 | <h1><code ng:non-bindable=""></code>
2 | <div><span class="hint"></span>
3 | </div>
4 | </h1>
5 | <div><div class="ngsails-page"><p>foobar</p>
6 | </div></div>
7 | 


--------------------------------------------------------------------------------
/karma.conf.js:
--------------------------------------------------------------------------------
 1 | // Karma configuration
 2 | // http://karma-runner.github.io/0.10/config/configuration-file.html
 3 | 
 4 | module.exports = function(config) {
 5 |   config.set({
 6 |     // base path, that will be used to resolve files and exclude
 7 |     basePath: '',
 8 | 
 9 |     // testing framework to use (jasmine/mocha/qunit/...)
10 |     frameworks: ['jasmine'],
11 | 
12 |     // list of files / patterns to load in the browser
13 |     files: [
14 |       'vendor/angular/angular.js',
15 |       'vendor/angular-mocks/angular-mocks.js',
16 |       'src/**/*.js',
17 |       'tests/**/*.spec.js'
18 |     ],
19 | 
20 |     // list of files / patterns to exclude
21 |     exclude: [],
22 | 
23 |     // web server port
24 |     port: 8080,
25 | 
26 |     // level of logging
27 |     // possible values: LOG_DISABLE || LOG_ERROR || LOG_WARN || LOG_INFO || LOG_DEBUG
28 |     logLevel: config.LOG_INFO,
29 | 
30 | 
31 |     // enable / disable watching file and executing tests whenever any file changes
32 |     autoWatch: false,
33 | 
34 | 
35 |     // Start these browsers, currently available:
36 |     // - Chrome
37 |     // - ChromeCanary
38 |     // - Firefox
39 |     // - Opera
40 |     // - Safari (only Mac)
41 |     // - PhantomJS
42 |     // - IE (only Windows)
43 |     browsers: ['PhantomJS'],
44 | 
45 | 
46 |     // Continuous Integration mode
47 |     // if true, it capture browsers, run tests and exit
48 |     singleRun: true
49 |   });
50 | };
51 | 


--------------------------------------------------------------------------------
/karma.postcompile.conf.js:
--------------------------------------------------------------------------------
 1 | // Karma configuration
 2 | // http://karma-runner.github.io/0.10/config/configuration-file.html
 3 | 
 4 | module.exports = function(config) {
 5 |   config.set({
 6 |     // base path, that will be used to resolve files and exclude
 7 |     basePath: '',
 8 | 
 9 |     // testing framework to use (jasmine/mocha/qunit/...)
10 |     frameworks: ['jasmine'],
11 | 
12 |     // list of files / patterns to load in the browser
13 |     files: [
14 |       'vendor/angular/angular.js',
15 |       'vendor/angular-mocks/angular-mocks.js',
16 |       'dist/angularSails.min.js', //first, load non-root modules so that root has it's dependencies
17 |       'tests/**/*.spec.js'
18 |     ],
19 | 
20 |     // list of files / patterns to exclude
21 |     exclude: [],
22 | 
23 |     // web server port
24 |     port: 8080,
25 | 
26 |     // level of logging
27 |     // possible values: LOG_DISABLE || LOG_ERROR || LOG_WARN || LOG_INFO || LOG_DEBUG
28 |     logLevel: config.LOG_INFO,
29 | 
30 | 
31 |     // enable / disable watching file and executing tests whenever any file changes
32 |     autoWatch: false,
33 | 
34 | 
35 |     // Start these browsers, currently available:
36 |     // - Chrome
37 |     // - ChromeCanary
38 |     // - Firefox
39 |     // - Opera
40 |     // - Safari (only Mac)
41 |     // - PhantomJS
42 |     // - IE (only Windows)
43 |     browsers: ['PhantomJS', 'Chrome', 'Firefox'],
44 | 
45 | 
46 |     // Continuous Integration mode
47 |     // if true, it capture browsers, run tests and exit
48 |     singleRun: true
49 |   });
50 | };
51 | 


--------------------------------------------------------------------------------
/module.prefix:
--------------------------------------------------------------------------------
1 | (function ( window, angular ) {


--------------------------------------------------------------------------------
/module.suffix:
--------------------------------------------------------------------------------
1 | })( window, angular );


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "angularsails",
 3 |   "version": "0.12.1",
 4 |   "description": "SailsJS SDK for AngularJS",
 5 |   "main": "dist/ngsails.io.js",
 6 |   "directories": {
 7 |     "doc": "docs",
 8 |     "example": "example",
 9 |     "test": "tests"
10 |   },
11 |   "scripts": {
12 |     "test": "grunt"
13 |   },
14 |   "repository": {
15 |     "type": "git",
16 |     "url": "https://github.com/balderdashy/angularSails.git"
17 |   },
18 |   "keywords": [
19 |     "Angular",
20 |     "AngularJS",
21 |     "Sails",
22 |     "SailJS",
23 |     "realtime"
24 |   ],
25 |   "authors": [
26 |     "Rob Wormald <rob.wormald@innitapps.com>",
27 |     "Gabe Hernandez <ghernandez345@gmail.com>",
28 |     "Andrew Rhyne <rhyneandrew@gmail.com>"
29 |   ],
30 |   "license": "MIT",
31 |   "bugs": {
32 |     "url": "https://github.com/balderdashy/angularSails.git/issues"
33 |   },
34 |   "homepage": "https://github.com/balderdashy/angularSails.git",
35 |   "devDependencies": {
36 |     "grunt": "~0.4.2",
37 |     "grunt-contrib-watch": "~0.5.3",
38 |     "grunt-contrib-concat": "~0.3.0",
39 |     "grunt-contrib-uglify": "~0.4.0",
40 |     "grunt-contrib-jshint": "~0.9.2",
41 |     "grunt-karma": "~0.8.0",
42 |     "grunt-ng-constant": "~0.4.8",
43 |     "grunt-newer": "~0.6.1",
44 |     "jshint-stylish": "~0.1.5",
45 |     "karma-phantomjs-launcher": "~0.1.2",
46 |     "karma-chrome-launcher": "~0.1.2",
47 |     "karma-firefox-launcher": "~0.1.3",
48 |     "karma-jasmine": "~0.2.2",
49 |     "load-grunt-tasks": "~0.4.0",
50 |     "grunt-ngmin": "0.0.3",
51 |     "grunt-contrib-clean": "~0.5.0",
52 |     "gulp": "~3.6.0",
53 |     "grunt-traceur": "0.0.3",
54 |     "grunt-ngdocs": "~0.2.1",
55 |     "grunt-contrib-copy": "^0.5.0"
56 |   },
57 |   "dependencies": {},
58 |   "author": ""
59 | }
60 | 


--------------------------------------------------------------------------------
/src/angular-sails-io.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | /**
  4 |  * @ngdoc module
  5 |  * @name sails.io
  6 |  * @file angularSails.io.js
  7 |  *
  8 |  * @description
  9 |  *
 10 |  * This file allows you to send and receive socket.io messages to & from Sails
 11 |  * by simulating a REST client interface on top of socket.io.
 12 |  *
 13 |  * It models its API after the $http pattern from Angular and returns $q promises.
 14 |  *
 15 |  * So if you're switching from using AJAX to sockets, instead of:
 16 |  *  `$http.post( url, [data]).then( successHandler, errorHandler )`
 17 |  *
 18 |  * You would use:
 19 |  *    `socket.post( url, [data]).then( successHandler, errorHandler )`
 20 |  *
 21 |  * It also supports $http-style success / error callbacks:
 22 |  *  ` socket.get( url, [params] )
 23 |  *      .success(function(results){})
 24 |  *      .error(function(results){}) `
 25 |  *
 26 |  *
 27 |  * For more information, visit:
 28 |  * http://github.com/balderdashy/angularSails
 29 |  */
 30 | angular.module('angularSails.io', [])
 31 | 
 32 | 
 33 | /**
 34 |  * @ngdoc constant
 35 |  * @name sails.io.$$sailsConnectionMetaData
 36 |  *
 37 |  * @description
 38 |  *
 39 |  * //TODO
 40 |  *
 41 |  */
 42 |     .constant('$$sailsConnectionMetaData', {
 43 | 
 44 |         version: '__sails_io_sdk_version',
 45 |         platform: '__sails_io_sdk_platform',
 46 |         language: '__sails_io_sdk_language'
 47 | 
 48 |     })
 49 | 
 50 | /**
 51 |  * @ngdoc constant
 52 |  * @name sails.io.$SAILS_SDK_PARAMS
 53 |  *
 54 |  * @description
 55 |  *
 56 |  * //TODO
 57 |  *
 58 |  */
 59 |     .constant('$$sailsSDKParams', {
 60 | 
 61 |         version: '0.11.0',  // TODO: pull this automatically from package.json during build.
 62 |         platform: typeof module === 'undefined' ? 'browser' : 'node',
 63 |         language: 'javascript',
 64 |         flavor: 'angular'
 65 | 
 66 |     })
 67 | 
 68 | /**
 69 |  * @ngdoc factory
 70 |  * @name sails.io.$SAILS_SDK_INFO
 71 |  *
 72 |  * @description
 73 |  *
 74 |  * //TODO
 75 |  *
 76 |  */
 77 |     .factory('$$sailsSDKInfo', ['$$sailsConnectionMetaData', '$$sailsSDKParams', function ($$sailsConnectionMetaData, $$sailsSDKParams) {
 78 | 
 79 |         function _getVersionString() {
 80 | 
 81 |             var versionString = $$sailsConnectionMetaData.version + '=' +
 82 |                 $$sailsSDKParams.version + '&' + $$sailsConnectionMetaData.platform + '=' +
 83 |                 $$sailsSDKParams.platform + '&' + $$sailsConnectionMetaData.language + '=' +
 84 |                 $$sailsSDKParams.language;
 85 | 
 86 |             return versionString;
 87 |         }
 88 | 
 89 |         return {
 90 |             getVersionString: _getVersionString
 91 |         };
 92 | 
 93 |     }])
 94 | 
 95 |     .factory('SocketIo', ['$window', function ($window) {
 96 |         if (!$window.io) {
 97 |             throw new Error('Socket IO Not Found!');
 98 |         }
 99 |         return $window.io;
100 | 
101 |     }])
102 | 
103 | 
104 | /**
105 |  * @ngdoc provider
106 |  * @name sails.io.$sailsSocket
107 |  *
108 |  * @description
109 |  *
110 |  * This provider returns a service that allows you to create a connection to a Sails server via socket.io.
111 |  *
112 |  *
113 |  *
114 |  * Code from :
115 |  *
116 |  * - angular-socket-io by Brian Ford : https://github.com/btford/angular-socket-io
117 |  *
118 |  * (c) 2014 Brian Ford http://briantford.com
119 |  * License: MIT
120 |  *
121 |  * sails.io.js by Balderdashy : https://github.com/balderdashy/sails
122 |  */
123 | 
124 |     .provider('$sailsSocket', function () {
125 |         var _debug = false;
126 | 
127 |         var _socketDefaults = {
128 |             autoConnect: true,
129 |             environment: 'development',
130 |             baseUrl: 'http://localhost:1337'
131 |         };
132 | 
133 |         var SailsSocketFactory = function ($q, $timeout, SocketIo, $$sailsSDKInfo) {
134 | 
135 | 
136 |             var versionString = $$sailsSDKInfo.getVersionString();
137 | 
138 |             var tick = function (socket, callback) {
139 |                 return callback ? function () {
140 |                     var args = arguments;
141 |                     $timeout(function () {
142 |                        callback.apply(socket, args);
143 |                     }, 0);
144 |                 } : angular.noop;
145 |             };
146 | 
147 |             /**
148 |              * TmpSocket
149 |              *
150 |              * A mock Socket used for binding events before the real thing
151 |              * has been instantiated (since we need to use io.connect() to
152 |              * instantiate the real thing, which would kick off the connection
153 |              * process w/ the server, and we don't necessarily have the valid
154 |              * configuration to know WHICH SERVER to talk to yet.)
155 |              *
156 |              * @api private
157 |              * @constructor
158 |              */
159 | 
160 |             function TmpSocket() {
161 |                 var boundEvents = {};
162 | 
163 |                 this.socket = {connected: false};
164 | 
165 |                 this.on = function (evName, fn) {
166 |                     boundEvents[evName] = fn;
167 |                     return this;
168 |                 };
169 |                 this.become = function (actualSocket) {
170 |                     for (var eventName in boundEvents) {
171 |                         actualSocket.on(eventName, boundEvents[eventName]);
172 | 
173 |                         // boundEvents[eventName] = angular.noop;
174 |                     }
175 |                     return actualSocket;
176 |                 };
177 |             }
178 | 
179 | 
180 |             /**
181 |              * @ngDoc function
182 |              * @name angularSails.io.SailsResponse
183 |              *
184 |              * @description
185 |              *
186 |              * Transforms a raw sails response into a $http-like responseObject
187 |              *
188 |              * @param requestContext
189 |              * @param responseContext
190 |              * @constructor
191 |              */
192 | 
193 |             function SailsResponse(requestContext, responseContext) {
194 | 
195 |                 if(angular.isString(responseContext)){
196 |                     responseContext = angular.fromJson(responseContext);
197 | 
198 |                 }
199 | 
200 |                 this.data = responseContext.body || {};
201 |                 this.headers = responseContext.headers || {};
202 |                 this.status = responseContext.statusCode || 200;
203 |                 this.config = requestContext;
204 | 
205 |             }
206 | 
207 | 
208 |             function _sendRequest(socket, requestCtx) {
209 | 
210 |                 // Since callback is embedded in requestCtx,
211 |                 // retrieve it and delete the key before continuing.
212 |                 var response = requestCtx.response;
213 |                 delete requestCtx.response;
214 | 
215 |                 // Name of socket request listener on the server
216 |                 // ( === the request method, e.g. 'get', 'post', 'put', etc. )
217 |                 var sailsEndpoint = requestCtx.method.toLowerCase();
218 | 
219 | 
220 |                 socket.emit(sailsEndpoint, requestCtx, tick(socket, function serverResponded(responseCtx) {
221 |                     if (_debug) console.log(responseCtx)
222 | 
223 |                     var serverResponse = new SailsResponse(requestCtx, responseCtx);
224 | 
225 |                     if (serverResponse.status >= 400) {
226 |                         response.reject(serverResponse);
227 |                     }
228 |                     else {
229 |                         response.resolve(serverResponse);
230 |                     }
231 |                 }));
232 |             }
233 | 
234 |             /**
235 |              * @ngDoc function
236 |              * @name angularSails.io.SailsSocket
237 |              *
238 |              * @param options
239 |              * @constructor
240 |              */
241 |             var SailsSocket = function (options) {
242 |                 var self = this;
243 | 
244 |                 self._requestQueue = []
245 | 
246 |                 self._socketOptions = angular.extend({}, _socketDefaults, options);
247 | 
248 |                 self._socket = new TmpSocket();
249 | 
250 |                 if (self._socketOptions.autoConnect) self.connect();
251 |             };
252 | 
253 |             SailsSocket.prototype.connect = function (url, opts) {
254 | 
255 |                 var connection = $q.defer();
256 | 
257 |                 var self = this;
258 | 
259 |                 opts = opts || {};
260 | 
261 |                 // If explicit connection url is specified, use it
262 |                 url = url || self._socketOptions.baseUrl || undefined;
263 | 
264 |                 // Mix the current SDK version into the query string in
265 |                 // the connection request to the server:
266 |                 if (typeof opts.query !== 'string') opts.query = versionString;
267 |                 else opts.query += '&' + versionString;
268 | 
269 |                 var socket = SocketIo.connect(url, opts);
270 | 
271 |                 self._socket = self._socket.become(socket);
272 | 
273 |                 self._socket.on('connect', function () {
274 | 
275 |                     angular.forEach(self._requestQueue, function (queuedRequest,idx) {
276 | 
277 |                         _sendRequest(self._socket, queuedRequest);
278 | 
279 |                     })
280 |                 })
281 | 
282 |                 self._socket.once('connect', connection.resolve);
283 |                 self._socket.on('connecting', connection.notify);
284 |                 self._socket.once('connect_failed', connection.reject);
285 |                 self.connection = connection;
286 | 
287 |                 return connection.promise;
288 | 
289 |             }
290 | 
291 |             SailsSocket.prototype.isConnected = function () {
292 | 
293 |                 return this.connection && this.connection.promise.$$state.status === 1;
294 | 
295 |             }
296 | 
297 |             SailsSocket.prototype.get = function (url, data) {
298 | 
299 | 
300 |                 return this._request({
301 |                     method: 'get',
302 |                     url: url,
303 |                     data: data
304 |                 });
305 |             };
306 | 
307 |             SailsSocket.prototype.post = function (url, data) {
308 | 
309 |                 return this._request({
310 |                     method: 'post',
311 |                     url: url,
312 |                     data: data
313 |                 });
314 |             };
315 |             SailsSocket.prototype.post = function (url, data) {
316 | 
317 |                 return this._request({
318 |                     method: 'post',
319 |                     url: url,
320 |                     data: data
321 |                 });
322 |             };
323 |             SailsSocket.prototype['delete'] = function (url, data) {
324 | 
325 |                 return this._request({
326 |                     method: 'delete',
327 |                     url: url,
328 |                     data: data
329 |                 });
330 |             };
331 | 
332 |             SailsSocket.prototype._request = function (options) {
333 | 
334 |                 var response = $q.defer()
335 | 
336 | 
337 |                 var usage = 'Usage:\n socket.' +
338 |                     (options.method || 'request') +
339 |                     '( destinationURL, [dataToSend] )';
340 | 
341 |                 options = options || {};
342 |                 options.data = options.data || {};
343 |                 options.headers = options.headers || {};
344 | 
345 |                 // Remove trailing slashes and spaces to make packets smaller.
346 |                 options.url = options.url.replace(/^(.+)\/*\s*$/, '$1');
347 |                 if (typeof options.url !== 'string') {
348 |                     throw new Error('Invalid or missing URL!\n' + usage);
349 |                 }
350 | 
351 |                 var self = this;
352 | 
353 |                 // Build a simulated request object.
354 |                 var request = {
355 |                     method: options.method,
356 |                     data: options.data,
357 |                     url: options.url,
358 |                     headers: options.headers,
359 |                     response: response
360 |                 };
361 | 
362 |                 response.promise.success = function (fn) {
363 |                     response.promise.then(function (response) {
364 |                       if (_debug) console.log(response)
365 |                       fn(response.data, response.statusCode, response.headers, request);
366 |                     });
367 |                     return response.promise;
368 |                 };
369 | 
370 |                 response.promise.error = function (fn) {
371 |                     response.promise.then(null, function (response) {
372 |                         fn(response.data, response.statusCode, response.headers, request);
373 |                     });
374 |                     return response.promise;
375 |                 };
376 | 
377 |                 if (self._socket && self.isConnected()) {
378 | 
379 |                     _sendRequest(self._socket, request);
380 | 
381 |                 }
382 |                 else {
383 | 
384 |                     self._requestQueue.push(request);
385 | 
386 |                 }
387 | 
388 | 
389 |                 return response.promise;
390 |             };
391 | 
392 |             SailsSocket.prototype.on = function (eventName, callback) {
393 | 
394 |                 var self = this;
395 | 
396 |                 self._socket.on(eventName, tick(self._socket, callback));
397 | 
398 |             }
399 | 
400 | 
401 |             return function (options) {
402 | 
403 |                 var sailSocket = new SailsSocket(options);
404 | 
405 |                 return sailSocket;
406 | 
407 |             }
408 | 
409 |         };
410 | 
411 |         return {
412 |             '$get': ['$q', '$timeout', 'SocketIo', '$$sailsSDKInfo', SailsSocketFactory ]
413 |         }
414 |     });
415 | 


--------------------------------------------------------------------------------
/src/request.js:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/balderdashy/angularSails/1deb8a05d737e5cb9224096378ebe949586cf570/src/request.js


--------------------------------------------------------------------------------
/src/response.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * @ngDoc function
 3 |  * @name angularSails.io.SailsResponse
 4 |  *
 5 |  * @description
 6 |  *
 7 |  * Transforms a raw sails response into a $http-like responseObject
 8 |  *
 9 |  * @param requestContext
10 |  * @param responseContext
11 |  * @constructor
12 |  */
13 | 
14 | function SailsResponse(requestContext, responseContext) {
15 | 
16 |     if(angular.isString(responseContext)){
17 |         responseContext = angular.fromJson(responseContext);
18 | 
19 |     }
20 | 
21 |     this.data = responseContext.body || {};
22 |     this.headers = responseContext.headers || {};
23 |     this.status = responseContext.statusCode || 200;
24 |     this.config = requestContext;
25 | 
26 | }


--------------------------------------------------------------------------------
/src/socketBackend.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | function createSailsBackend($browser, $window, $injector, $q, $timeout){
 4 | 
 5 | 
 6 | 
 7 | 
 8 |     if(!$window.io){
 9 |         throw new Error('socket.io client not found')
10 |     }
11 | 
12 |     if(!$window.io.sails){
13 |         throw new Error('sails.io client not found')
14 |     }
15 | 
16 |     if(!$window.io.socket){
17 |         console.warn('no connected socket...')
18 |     }
19 | 
20 | 
21 |     var tick = function (socket, callback) {
22 |         return callback ? function () {
23 |             var args = arguments;
24 |             $timeout(function () {
25 |                 callback.apply(socket, args);
26 |             }, 0);
27 |         } : angular.noop;
28 |     };
29 | 
30 | 
31 |     function connection(method, url, post, callback, headers, timeout, withCredentials, responseType){
32 | 
33 | 
34 | 
35 |         function socketResponse(body,jwr){
36 | 
37 |             callback(jwr.statusCode,body);
38 |             //status, response, headersString, statusText
39 |         }
40 | 
41 | 
42 |         url = url || $browser.url();
43 | 
44 | 
45 |         $window.io.socket.request({
46 |             method: method.toLowerCase(),
47 |             url: url,
48 |             data: fromJson(post),
49 |             headers: headers
50 |         }, socketResponse);
51 | 
52 |     }
53 | 
54 |     //TODO normalize http paths to event names
55 |     connection.subscribe = function(event,handler){
56 |         var callback = tick($window.io.socket,handler);
57 |         $window.io.socket.on(event,callback);
58 |         return angular.bind($window.io.socket, $window.io.socket.removeListener, event, callback);
59 |     }
60 | 
61 |     return connection;
62 | 
63 | }
64 | 
65 | /**
66 |  * @ngdoc service
67 |  * @name ngsails.$sailsSocketBackend
68 |  * @requires $window
69 |  * @requires $document
70 |  *
71 |  * @description
72 |  * Service used by the $sailsSocket that delegates to a
73 |  * Socket.io connection (or in theory, any connection type eventually)
74 |  *
75 |  * You should never need to use this service directly, instead use the higher-level abstraction:
76 |  * $sailsSocket.
77 |  *
78 |  * During testing this implementation is swapped with $sailsMockBackend
79 |  *  which can be trained with responses.
80 |  */
81 | function sailsBackendProvider() {
82 |     this.$get = ['$browser', '$window','$injector', '$q','$timeout', function($browser, $window, $injector, $q,$timeout) {
83 |         return createSailsBackend($browser,$window, $injector, $q,$timeout);
84 |     }];
85 | }
86 | 


--------------------------------------------------------------------------------
/src/socketProvider.js:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/balderdashy/angularSails/1deb8a05d737e5cb9224096378ebe949586cf570/src/socketProvider.js


--------------------------------------------------------------------------------
/src/utils.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | // NOTE:  The usage of window and document instead of $window and $document here is
  3 | // deliberate.  This service depends on the specific behavior of anchor nodes created by the
  4 | // browser (resolving and parsing URLs) that is unlikely to be provided by mock objects and
  5 | // cause us to break tests.  In addition, when the browser resolves a URL for XHR, it
  6 | // doesn't know about mocked locations and resolves URLs to the real document - which is
  7 | // exactly the behavior needed here.  There is little value is mocking these out for this
  8 | // service.
  9 | var urlParsingNode = document.createElement("a");
 10 | var originUrl = urlResolve(window.location.href, true);
 11 | 
 12 | /**
 13 |  * Chain all given functions
 14 |  *
 15 |  * This function is used for both request and response transforming
 16 |  *
 17 |  * @param {*} data Data to transform.
 18 |  * @param {function(string=)} headers Http headers getter fn.
 19 |  * @param {(Function|Array.<Function>)} fns Function or an array of functions.
 20 |  * @returns {*} Transformed data.
 21 |  */
 22 | function transformData(data, headers, fns) {
 23 |     if (isFunction(fns))
 24 |         return fns(data, headers);
 25 | 
 26 |     forEach(fns, function(fn) {
 27 |         data = fn(data, headers);
 28 |     });
 29 | 
 30 |     return data;
 31 | }
 32 | 
 33 | 
 34 | function isSuccess(status) {
 35 |     return 200 <= status && status < 300;
 36 | }
 37 | 
 38 | 
 39 | /**
 40 |  * Parse headers into key value object
 41 |  *
 42 |  * @param {string} headers Raw headers as a string
 43 |  * @returns {Object} Parsed headers as key value object
 44 |  */
 45 | function parseHeaders(headers) {
 46 |     var parsed = {}, key, val, i;
 47 | 
 48 |     if (!headers) return parsed;
 49 | 
 50 |     forEach(headers.split('\n'), function(line) {
 51 |         i = line.indexOf(':');
 52 |         key = lowercase(trim(line.substr(0, i)));
 53 |         val = trim(line.substr(i + 1));
 54 | 
 55 |         if (key) {
 56 |             if (parsed[key]) {
 57 |                 parsed[key] += ', ' + val;
 58 |             } else {
 59 |                 parsed[key] = val;
 60 |             }
 61 |         }
 62 |     });
 63 | 
 64 |     return parsed;
 65 | }
 66 | /**
 67 |  * Returns a function that provides access to parsed headers.
 68 |  *
 69 |  * Headers are lazy parsed when first requested.
 70 |  * @see parseHeaders
 71 |  *
 72 |  * @param {(string|Object)} headers Headers to provide access to.
 73 |  * @returns {function(string=)} Returns a getter function which if called with:
 74 |  *
 75 |  *   - if called with single an argument returns a single header value or null
 76 |  *   - if called with no arguments returns an object containing all headers.
 77 |  */
 78 | function headersGetter(headers) {
 79 |     var headersObj = isObject(headers) ? headers : undefined;
 80 | 
 81 |     return function(name) {
 82 |         if (!headersObj) headersObj =  parseHeaders(headers);
 83 | 
 84 |         if (name) {
 85 |             return headersObj[lowercase(name)] || null;
 86 |         }
 87 | 
 88 |         return headersObj;
 89 |     };
 90 | }
 91 | 
 92 | function urlResolve(url, base) {
 93 |     var href = url;
 94 | 
 95 |     if (typeof msie !== 'undefined') {
 96 |         // Normalize before parse.  Refer Implementation Notes on why this is
 97 |         // done in two steps on IE.
 98 |         urlParsingNode.setAttribute("href", href);
 99 |         href = urlParsingNode.href;
100 |     }
101 | 
102 |     urlParsingNode.setAttribute('href', href);
103 | 
104 |     // urlParsingNode provides the UrlUtils interface - http://url.spec.whatwg.org/#urlutils
105 |     return {
106 |         href: urlParsingNode.href,
107 |         protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, '') : '',
108 |         host: urlParsingNode.host,
109 |         search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, '') : '',
110 |         hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, '') : '',
111 |         hostname: urlParsingNode.hostname,
112 |         port: urlParsingNode.port,
113 |         pathname: (urlParsingNode.pathname.charAt(0) === '/')
114 |             ? urlParsingNode.pathname
115 |             : '/' + urlParsingNode.pathname
116 |     };
117 | }
118 | 
119 | /**
120 |  * Parse a request URL and determine whether this is a same-origin request as the application document.
121 |  *
122 |  * @param {string|object} requestUrl The url of the request as a string that will be resolved
123 |  * or a parsed URL object.
124 |  * @returns {boolean} Whether the request is for the same origin as the application document.
125 |  */
126 | function urlIsSameOrigin(requestUrl) {
127 |     var parsed = (isString(requestUrl)) ? urlResolve(requestUrl) : requestUrl;
128 |     return (parsed.protocol === originUrl.protocol &&
129 |         parsed.host === originUrl.host);
130 | }
131 | 
132 | function buildUrl(url, params) {
133 |     if (!params) return url;
134 |     var parts = [];
135 |     angular.forEach(params, function(value, key) {
136 |         if (value === null || angular.isUndefined(value)) return;
137 |         if (!isArray(value)) value = [value];
138 | 
139 |         angular.forEach(value, function(v) {
140 |             if (isObject(v)) {
141 |                 v = toJson(v);
142 |             }
143 |             parts.push(encodeUriQuery(key) + '=' +
144 |                 encodeUriQuery(v));
145 |         });
146 |     });
147 |     if(parts.length > 0) {
148 |         url += ((url.indexOf('?') == -1) ? '?' : '&') + parts.join('&');
149 |     }
150 |     return url;
151 | }
152 | /**
153 |  * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
154 |  * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
155 |  * segments:
156 |  *    segment       = *pchar
157 |  *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
158 |  *    pct-encoded   = "%" HEXDIG HEXDIG
159 |  *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
160 |  *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
161 |  *                     / "*" / "+" / "," / ";" / "="
162 |  */
163 | function encodeUriSegment(val) {
164 |     return encodeUriQuery(val, true).
165 |         replace(/%26/gi, '&').
166 |         replace(/%3D/gi, '=').
167 |         replace(/%2B/gi, '+');
168 | }
169 | 
170 | 
171 | function toJsonReplacer(key, value) {
172 |     var val = value;
173 | 
174 |     if (typeof key === 'string' && key.charAt(0) === '$') {
175 |         val = undefined;
176 |     } else if (isWindow(value)) {
177 |         val = '$WINDOW';
178 |     } else if (value &&  document === value) {
179 |         val = '$DOCUMENT';
180 |     } else if (isScope(value)) {
181 |         val = '$SCOPE';
182 |     }
183 | 
184 |     return val;
185 | }
186 | 
187 | function forEach(obj, iterator, context) {
188 |     var key;
189 |     if (obj) {
190 |         if (isFunction(obj)){
191 |             for (key in obj) {
192 |                 // Need to check if hasOwnProperty exists,
193 |                 // as on IE8 the result of querySelectorAll is an object without a hasOwnProperty function
194 |                 if (key != 'prototype' && key != 'length' && key != 'name' && (!obj.hasOwnProperty || obj.hasOwnProperty(key))) {
195 |                     iterator.call(context, obj[key], key);
196 |                 }
197 |             }
198 |         } else if (obj.forEach && obj.forEach !== forEach) {
199 |             obj.forEach(iterator, context);
200 |         } else if (isArrayLike(obj)) {
201 |             for (key = 0; key < obj.length; key++)
202 |                 iterator.call(context, obj[key], key);
203 |         } else {
204 |             for (key in obj) {
205 |                 if (obj.hasOwnProperty(key)) {
206 |                     iterator.call(context, obj[key], key);
207 |                 }
208 |             }
209 |         }
210 |     }
211 |     return obj;
212 | }
213 | 
214 | function sortedKeys(obj) {
215 |     var keys = [];
216 |     for (var key in obj) {
217 |         if (obj.hasOwnProperty(key)) {
218 |             keys.push(key);
219 |         }
220 |     }
221 |     return keys.sort();
222 | }
223 | 
224 | function forEachSorted(obj, iterator, context) {
225 |     var keys = sortedKeys(obj);
226 |     for ( var i = 0; i < keys.length; i++) {
227 |         iterator.call(context, obj[keys[i]], keys[i]);
228 |     }
229 |     return keys;
230 | }
231 | 
232 | 
233 | /**
234 |  * when using forEach the params are value, key, but it is often useful to have key, value.
235 |  * @param {function(string, *)} iteratorFn
236 |  * @returns {function(*, string)}
237 |  */
238 | function reverseParams(iteratorFn) {
239 |     return function(value, key) { iteratorFn(key, value); };
240 | }
241 | 
242 | 
243 | /**
244 |  * This method is intended for encoding *key* or *value* parts of query component. We need a custom
245 |  * method because encodeURIComponent is too aggressive and encodes stuff that doesn't have to be
246 |  * encoded per http://tools.ietf.org/html/rfc3986:
247 |  *    query       = *( pchar / "/" / "?" )
248 |  *    pchar         = unreserved / pct-encoded / sub-delims / ":" / "@"
249 |  *    unreserved    = ALPHA / DIGIT / "-" / "." / "_" / "~"
250 |  *    pct-encoded   = "%" HEXDIG HEXDIG
251 |  *    sub-delims    = "!" / "$" / "&" / "'" / "(" / ")"
252 |  *                     / "*" / "+" / "," / ";" / "="
253 |  */
254 | function encodeUriQuery(val, pctEncodeSpaces) {
255 |     return encodeURIComponent(val).
256 |         replace(/%40/gi, '@').
257 |         replace(/%3A/gi, ':').
258 |         replace(/%24/g, '$').
259 |         replace(/%2C/gi, ',').
260 |         replace(/%20/g, (pctEncodeSpaces ? '%20' : '+'));
261 | }
262 | 
263 | 
264 | function valueFn(value) {return function() {return value;};}
265 | 
266 | 
267 | function isUndefined(value){return typeof value === 'undefined';}
268 | 
269 | 
270 | function isDefined(value){return typeof value !== 'undefined';}
271 | function isObject(value){return value != null && typeof value === 'object';}
272 | function isString(value){return typeof value === 'string';}
273 | function isNumber(value){return typeof value === 'number';}
274 | function isDate(value){
275 |     return {}.toString.call(value) === '[object Date]';
276 | }
277 | function isFunction(value){return typeof value === 'function';}
278 | 
279 | function isScope(obj) {
280 |     return obj && obj.$evalAsync && obj.$watch;
281 | }
282 | function isFile(obj) {
283 |     return {}.toString.call(obj) === '[object File]';
284 | }
285 | 
286 | 
287 | function isBlob(obj) {
288 |     return {}.toString.call(obj) === '[object Blob]';
289 | }
290 | 
291 | 
292 | function isBoolean(value) {
293 |     return typeof value === 'boolean';
294 | }
295 | 
296 | function isArray(value) {
297 |     return {}.toString.call(value) === '[object Array]';
298 | }
299 | 
300 | 
301 | /**
302 |  * @private
303 |  * @param {*} obj
304 |  * @return {boolean} Returns true if `obj` is an array or array-like object (NodeList, Arguments,
305 |  *                   String ...)
306 |  */
307 | function isArrayLike(obj) {
308 |     if (obj == null || isWindow(obj)) {
309 |         return false;
310 |     }
311 | 
312 |     var length = obj.length;
313 | 
314 |     if (obj.nodeType === 1 && length) {
315 |         return true;
316 |     }
317 | 
318 |     return isString(obj) || isArray(obj) || length === 0 ||
319 |         typeof length === 'number' && length > 0 && (length - 1) in obj;
320 | }
321 | 
322 | function isWindow(obj) {
323 |     return obj && obj.document && obj.location && obj.alert && obj.setInterval;
324 | }
325 | 
326 | var lowercase = function(string){return isString(string) ? string.toLowerCase() : string;};
327 | var hasOwnProperty = Object.prototype.hasOwnProperty;
328 | 
329 | function mergeHeaders(config) {
330 |     var defHeaders = defaults.headers,
331 |         reqHeaders = extend({}, config.headers),
332 |         defHeaderName, lowercaseDefHeaderName, reqHeaderName;
333 | 
334 |     defHeaders = extend({}, defHeaders.common, defHeaders[lowercase(config.method)]);
335 | 
336 |     // execute if header value is function
337 |     execHeaders(defHeaders);
338 |     execHeaders(reqHeaders);
339 | 
340 |     // using for-in instead of forEach to avoid unecessary iteration after header has been found
341 |     defaultHeadersIteration:
342 |         for (defHeaderName in defHeaders) {
343 |             lowercaseDefHeaderName = lowercase(defHeaderName);
344 | 
345 |             for (reqHeaderName in reqHeaders) {
346 |                 if (lowercase(reqHeaderName) === lowercaseDefHeaderName) {
347 |                     continue defaultHeadersIteration;
348 |                 }
349 |             }
350 | 
351 |             reqHeaders[defHeaderName] = defHeaders[defHeaderName];
352 |         }
353 | 
354 |     return reqHeaders;
355 | 
356 |     function execHeaders(headers) {
357 |         var headerContent;
358 | 
359 |         forEach(headers, function(headerFn, header) {
360 |             if (isFunction(headerFn)) {
361 |                 headerContent = headerFn();
362 |                 if (headerContent != null) {
363 |                     headers[header] = headerContent;
364 |                 } else {
365 |                     delete headers[header];
366 |                 }
367 |             }
368 |         });
369 |     }
370 | }
371 | 
372 | var uppercase = function(string){return isString(string) ? string.toUpperCase() : string;};
373 | 
374 | 
375 | var manualLowercase = function(s) {
376 |     /* jshint bitwise: false */
377 |     return isString(s)
378 |         ? s.replace(/[A-Z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) | 32);})
379 |         : s;
380 | };
381 | var manualUppercase = function(s) {
382 |     /* jshint bitwise: false */
383 |     return isString(s)
384 |         ? s.replace(/[a-z]/g, function(ch) {return String.fromCharCode(ch.charCodeAt(0) & ~32);})
385 |         : s;
386 | };
387 | 
388 | 
389 | // String#toLowerCase and String#toUpperCase don't produce correct results in browsers with Turkish
390 | // locale, for this reason we need to detect this case and redefine lowercase/uppercase methods
391 | // with correct but slower alternatives.
392 | if ('i' !== 'I'.toLowerCase()) {
393 |     lowercase = manualLowercase;
394 |     uppercase = manualUppercase;
395 | }
396 | 
397 | function toJson(obj, pretty) {
398 |     if (typeof obj === 'undefined') return undefined;
399 |     return JSON.stringify(obj, toJsonReplacer, pretty ? '  ' : null);
400 | }
401 | 
402 | 
403 | 
404 | function fromJson(json) {
405 |     return isString(json)
406 |         ? JSON.parse(json)
407 |         : json;
408 | }
409 | 
410 | function size(obj, ownPropsOnly) {
411 |     var count = 0, key;
412 | 
413 |     if (isArray(obj) || isString(obj)) {
414 |         return obj.length;
415 |     } else if (isObject(obj)){
416 |         for (key in obj)
417 |             if (!ownPropsOnly || obj.hasOwnProperty(key))
418 |                 count++;
419 |     }
420 | 
421 |     return count;
422 | }
423 | 
424 | 
425 | function includes(array, obj) {
426 |     return indexOf(array, obj) != -1;
427 | }
428 | 
429 | function indexOf(array, obj) {
430 |     if (array.indexOf) return array.indexOf(obj);
431 | 
432 |     for (var i = 0; i < array.length; i++) {
433 |         if (obj === array[i]) return i;
434 |     }
435 |     return -1;
436 | }
437 | 
438 | function arrayRemove(array, value) {
439 |     var index = indexOf(array, value);
440 |     if (index >=0)
441 |         array.splice(index, 1);
442 |     return value;
443 | }
444 | 


--------------------------------------------------------------------------------
/tests/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/balderdashy/angularSails/1deb8a05d737e5cb9224096378ebe949586cf570/tests/.gitkeep


--------------------------------------------------------------------------------
/tests/angular-sails-base.spec.js:
--------------------------------------------------------------------------------
  1 | (function(){
  2 | 
  3 |   'use strict';
  4 | 
  5 |   describe('Module angularSails.base', function () {
  6 | 
  7 |     it('should be registered', function() {
  8 |       var module = angular.module('angularSails.base');
  9 |       expect(module).not.toBeNull();
 10 |     });
 11 | 
 12 | 
 13 |     beforeEach(module('angularSails.base'));
 14 | 
 15 |     describe('$sailsRef service api', function () {
 16 | 
 17 |       // Mock socket service.
 18 |       beforeEach(module(function ($provide) {
 19 |         $provide.factory('angularSailsSocket', ['$q', function ($q) {
 20 |           var collectionData = [{id:1}, {id: 2}, {id: 3}];
 21 |           var deferred = $q.defer();
 22 |           return {
 23 |             get: function() {
 24 |               deferred.resolve(collectionData);
 25 |               return deferred.promise;
 26 |             },
 27 |             post: function() {
 28 |               collectionData = [{id:1}, {id: 2}, {id: 3}, {id: 4}];
 29 |               deferred.resolve(collectionData);
 30 |               return deferred.promise;
 31 |             },
 32 |             put: function(path, data) {
 33 |               deferred.resolve(data);
 34 |               return deferred.promise;
 35 |             },
 36 |             delete: function() {
 37 |               return deferred.promise;
 38 |             },
 39 |             on: function () {}
 40 |           };
 41 |         }]);
 42 |       }));
 43 | 
 44 |       var $sailsRef, $rootScope, collection;
 45 |       beforeEach(inject(function (_$sailsRef_, _$rootScope_) {
 46 |         $sailsRef = _$sailsRef_;
 47 |         $rootScope = _$rootScope_;
 48 |         collection = $sailsRef('/comment');
 49 |         $rootScope.$apply();
 50 |       }));
 51 | 
 52 |       it('should create a collection object from a resource', function () {
 53 |         expect(angular.isObject(collection)).toBe(true);
 54 |         expect(collection.$add).toBeDefined();
 55 |         expect(collection.$update).toBeDefined();
 56 |         expect(collection.$remove).toBeDefined();
 57 |         expect(collection.$save).toBeDefined();
 58 |       });
 59 | 
 60 |       it('should contain models that are model objects', function () {
 61 |         var model = collection['1'];
 62 |         expect(angular.isObject(model)).toBe(true);
 63 |         expect(model.$update).toBeDefined();
 64 |         expect(model.$remove).toBeDefined();
 65 |       });
 66 | 
 67 |       it('should add a model to the collection when using $add', function () {
 68 |         collection.$add({id: 4});
 69 |         $rootScope.$apply();
 70 |         var newModel = collection['4'];
 71 |         expect(newModel).toBeDefined();
 72 |         expect(angular.isObject(newModel)).toBe(true);
 73 |         expect(newModel.$update).toBeDefined();
 74 |         expect(newModel.$remove).toBeDefined();
 75 |       });
 76 | 
 77 |       it('should update the model in the collection when using $update', function () {
 78 |         var collection = $sailsRef('/comment');
 79 |         $rootScope.$apply();
 80 |         var modelToUpdate = collection['1'];
 81 |         modelToUpdate.name = 'Greg';
 82 |         collection.$update(modelToUpdate);
 83 |         $rootScope.$apply();
 84 |         expect(collection['1'].name).toEqual('Greg');
 85 |       });
 86 | 
 87 |     });
 88 | 
 89 | 
 90 |     describe('angular sails filter', function () {
 91 | 
 92 |       var filter, data, result;
 93 |       beforeEach(inject(function ($filter) {
 94 |         filter = $filter('collectionToArray');
 95 | 
 96 |         data = {
 97 |           '1': {id: 1},
 98 |           '4': {id: 10},
 99 |           '3': {id: 5},
100 |           '2': {id: 8}
101 |         };
102 | 
103 |         result = filter(data);
104 |       }));
105 | 
106 |       it('should map an object to an array of objects', function () {
107 |         expect(angular.isArray(result)).toBe(true);
108 |         expect(angular.isObject(result[0])).toBe(true);
109 |       });
110 | 
111 |       it('should be mutable by other angular filters', inject( function ($filter) {
112 |         var orderByResult = $filter('orderBy')(result, 'id');
113 |         expect(orderByResult).toEqual([
114 |           {id: 1},
115 |           {id: 5},
116 |           {id: 8},
117 |           {id: 10}
118 |         ]);
119 |       }));
120 | 
121 |     });
122 | 
123 |   });
124 | 
125 | }());
126 | 


--------------------------------------------------------------------------------
/tests/angular-sails-io.spec.js:
--------------------------------------------------------------------------------
 1 | (function(){
 2 | 
 3 |   'use strict';
 4 | 
 5 |   describe('Module angularSails.io', function(){
 6 | 
 7 |     beforeEach(function(){
 8 | 
 9 |       module('angularSails.io');
10 | 
11 |     });
12 | 
13 |     it('should pass', function(){
14 | 
15 |       expect(true).toEqual(true);
16 | 
17 |     });
18 | 
19 |   });
20 | 
21 | }());
22 | 


--------------------------------------------------------------------------------
/tests/angular-sails-stream.spec.js:
--------------------------------------------------------------------------------
 1 | (function(){
 2 | 
 3 |   'use strict';
 4 | 
 5 |   describe('Module angularSails.stream', function(){
 6 | 
 7 |     beforeEach(function(){
 8 | 
 9 |       module('angularSails.stream');
10 | 
11 |     });
12 | 
13 |     it('should pass', function(){
14 | 
15 |       expect(true).toEqual(true);
16 | 
17 |     });
18 | 
19 |   });
20 | 
21 | }());
22 | 


--------------------------------------------------------------------------------