From b842642b574a2b95c53b791308ed1bf8ff9d304d Mon Sep 17 00:00:00 2001
From: Igor Minar
Date: Wed, 15 Jun 2011 22:31:40 -0700
Subject: docs - stripping extra new lines
---
docs/content/misc/contribute.ngdoc | 108 ------------------------------------
docs/content/misc/downloading.ngdoc | 16 ------
docs/content/misc/faq.ngdoc | 29 ----------
docs/content/misc/started.ngdoc | 46 ---------------
4 files changed, 199 deletions(-)
(limited to 'docs/content/misc')
diff --git a/docs/content/misc/contribute.ngdoc b/docs/content/misc/contribute.ngdoc
index 2a398400..d519a819 100644
--- a/docs/content/misc/contribute.ngdoc
+++ b/docs/content/misc/contribute.ngdoc
@@ -3,8 +3,6 @@
@description
-
-
* License
* Contributing to Source Code
* Applying Code Standards
@@ -12,349 +10,243 @@
* Submitting Your Changes
-
-
# License
-
`Angular` is an open source project licensed under the {@link
http://github.com/angular/angular.js/blob/master/LICENSE MIT license}. Your contributions are
always welcome. When working with `angular` source base, please follow the guidelines provided on
this page.
-
-
# Contributing to Source Code
-
We'd love for you to contribute to our source code and to make `angular` even better than it is
today! Here are the guidelines we'd like you to use:
-
* Major changes that you intend to contribute to the project must be discussed first on our {@link
https://groups.google.com/forum/?hl=en#!forum/angular mailing list} so that we can better
coordinate our efforts, prevent duplication of work, and help you to craft the change so that it
is successfully accepted upstream.
-
* Small changes and bug fixes can be crafted and submitted to Github as a pull
request.
-
-
-
# Applying Code Standards
-
To ensure consistency throughout the source code, keep these rules in mind as you are working:
-
* All features or bug fixes must be tested by one or more specs.
-
* All public API methods must be documented with ngdoc, an extended version of jsdoc (we added
support for markdown and templating via `@ngdoc` tag). To see how we document our APIs, please
check out the existing ngdocs.
-
* With the exceptions listed below, we follow the rules contained in {@link
http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml Google's JavaScript Style
Guide}:
-
* Do not use namespaces: Instead, we wrap the entire `angular` code base in an anonymous closure
and export our API explicitly rather than implicitly.
-
* Wrap all code at 100 characters.
-
* Instead of complex inheritance hierarchies, we prefer simple objects. We use prototypical
inheritance only when absolutely necessary.
-
* We love functions and closures and, whenever possible, prefer them over objects.
-
* To write concise code that can be better minified, internally we use aliases that map to the
external API. See our existing code to see what we mean.
-
* We don't go crazy with type annotations for private internal APIs unless it's an internal API
that is used throughout `angular`. The best guidance is to do what makes the most sense.
-
-
# Checking Out and Building Angular
-
The `angular` source code is hosted at {@link http://github.com Github}, which we also use to
accept code contributions. Several steps are needed to check out and build `angular`:
-
-
## Installation Dependencies
-
Before you can build `angular`, you must install or configure the following dependencies on your
machine:
-
* {@link http://rake.rubyforge.org Rake}: We use Rake as our build system, which is pre-installed
on most Macintosh and Linux machines. If that is not true in your case, you can grab it from the
Rake website.
-
* {@link http://nodejs.org Node.js}: We use Node to generate the documentation and to run a
development web server. Depending on your system, you can install Node either from source or as a
pre-packaged bundle.
-
* Java: The Java runtime is used to run {@link http://code.google.com/p/js-test-driver
JsTestDriver} (JSTD), which we use to run our unit test suite. JSTD binaries are part of the
`angular` source base, which means there is no need to install or configure it separately.
-
* Git: The {@link http://help.github.com/mac-git-installation Github Guide to Installing Git} is
quite a good source for information on Git.
-
-
## Creating a Github Account and Forking Angular
-
To create a Github account, follow the instructions {@link https://github.com/signup/free here}.
Afterwards, go ahead and {@link http://help.github.com/forking fork} the {@link
https://github.com/angular/angular.js main angular repository}.
-
-
## Building `Angular`
-
To build `angular`, you check out the source code and use Rake to generate the non-minified and
minified `angular` files:
-
1. To clone your Github repository, run:
-
git clone git@github.com:/angular.js.git
-
2. To go to the `angular` directory, run:
-
cd angular.js
-
3. To add the main `angular` repository as an upstream remote to your repository, run:
-
git remote add upstream https://github.com/angular/angular.js.git
-
4. To build `angular`, run:
-
rake package
-
The build output can be located under the `build` directory. It consists of the following files and
directories:
-
* `angular-.tgz` — This is the complete tarball, which contains all of the release build
artifacts.
-
* `angular.js` — The non-minified `angular` script.
-
* `angular.min.js` — The minified `angular` script.
-
* `angular-scenario.js` — The `angular` End2End test runner.
-
* `angular-ie-compat.js` — The Internet Explorer compatibility patch file.
-
* `docs/` — A directory that contains all of the files needed to run `docs.angularjs.org`.
-
* `docs/index.html` — The main page for the documentation.
-
* `docs/docs-scenario.html` — The End2End test runner for the documentation application.
-
-
## Running a Local Development Web Server
-
To debug or test code, it is often useful to have a local HTTP server. For this purpose, we have
made available a local web server based on Node.js.
-
1. To start the web server, run:
-
./nodeserver.sh
-
2. To access the local server, go to this website:
-
http://localhost:8000/
-
By default, it serves the contents of the `angular` project directory.
-
-
## Running the Unit Test Suite
-
Our unit and integration tests are written with Jasmine and executed with JsTestDriver. To run the
tests:
-
1. To start the JSTD server, run:
-
./server.sh
-
2. To capture one or more browsers, go to this website:
-
http://localhost:9876/
-
3. To trigger a test execution, run:
-
./test.sh
-
4. To automatically run the test suite each time one or more of the files in the project directory
is changed, you can install `watchr` and then run:
-
watchr watchr.rb
-
5. To view the output of each test run, you can tail this log file:
-
./logs/jstd.log
-
-
## Running the End2End Test Suite
-
To run the End2End test suite:
-
1. Start the local web server.
2. In a browser, go to:
-
http://localhost:8000/build/docs/docs-scenario.html
-
The tests are executed automatically.
-
-
-
# Submitting Your Changes
-
To create and submit a change:
-
1. Create a new branch off the master for your changes:
-
git branch my-fix-branch
-
2. Check out the branch:
-
git checkout my-fix-branch
-
3. Create your patch, make sure to have plenty of tests (that pass).
-
4. Commit your changes:
-
git commit -a
-
5. Run JavaScript Lint and be sure to address all new warnings and errors:
-
rake lint
-
6. Push your branch to Github:
-
git push origin my-fix-branch
-
7. In Github, send a pull request to `angular:master`.
-
8. When the patch is reviewed and merged, delete your branch and pull yours — and other — changes
from the main (upstream) repository:
1. To delete the branch in Github, run:
-
git push origin :my-fix-branch
-
2. To check out the master branch, run:
-
git checkout master
-
3. To delete a local branch, run:
-
git branch -D my-fix-branch
-
4. To update your master with the latest upstream version, run:
-
git pull --ff upstream master
-
That's it! Thank you for your contribution!
diff --git a/docs/content/misc/downloading.ngdoc b/docs/content/misc/downloading.ngdoc
index 9406d49c..f111991f 100644
--- a/docs/content/misc/downloading.ngdoc
+++ b/docs/content/misc/downloading.ngdoc
@@ -3,27 +3,22 @@
@name Downloading
@description
-
# Including angular scripts from the angular server
The quickest way to get started is to point your html `
-
(For details on what happens when `angular` processes an HTML page,
see {@link guide/dev_guide.bootstrap Bootstrap}.)
-
Finally, this line in the `` of the page is the template that describes
how to display our greeting in the UI:
-
Hello {{'World'}}!
-
Note the use of the double curly brace markup (`{{ }}`) to bind the expression to
the greeting text. Here the expression is the string literal 'World'.
-
Next let's look at a more interesting example, that uses `angular` to
bind a dynamic expression to our greeting text.
-
# Hello World!
-
This example demonstrates `angular`'s two-way data binding:
-
1. Edit the HTML file you created in the "Hello World!" example above.
2. Replace the contents of `` with the code from the __Source__ box below.
3. Refresh your browswer window.
-
Your name:
@@ -93,24 +73,18 @@ This example demonstrates `angular`'s two-way data binding:
-
After the refresh, the page should look something like this:
-
-
These are some of the important points to note from this example:
-
* The text input {@link api/angular.widget widget} called `yourname` is bound to a model variable
called `yourname`.
* The double curly braces notation binds the `yourname` model to the greeting text.
-
* You did not need to explicitly register an event listener or define an event handler for events!
-
Now try typing your name into the input box, and notice the immediate change to
the displayed greeting. This demonstrates the concept of `angular`'s
{@link guide/dev_guide.templates.databinding bi-directional data binding}. Any changes to the input
@@ -119,70 +93,50 @@ reflected in the model (one direction), and any changes to the model are
reflected in the greeting text (the other direction).
-
-
# Anatomy Of An Angular App
-
This section describes the 3 parts of an angular app, and explains how they map to the
Model-View-Controller design pattern:
-
## Templates
-
Templates, which you write in HTML and CSS, serve as the View. You add elements, attributes, and
markup to HTML, which serve as instructions to the angular compiler. The angular compiler is fully
extensible, meaning that with angular you can build your own declarative language on top of HTML!
-
-
## Application Logic and Behavior
-
Application Logic and Behavior, which you define in JavaScript, serve as the Controller. With
angular (unlike with standard AJAX applications) you don't need to write additional listeners or
DOM manipulators, because they are built-in. This feature makes your application logic very easy to
write, test, maintain, and understand.
-
-
## Data
-
The Model is referenced from properties on {@link guide/dev_guide.scopes angular scope objects}.
The data in your model could be Javascript objects, arrays, or primitives, it doesn't matter. What
matters is that these are all referenced by the scope object.
-
Angular employs scopes to keep your data model and your UI in sync. Whenever something occurs to
change the state of the model, angular immediately reflects that change in the UI, and vice versa.
-
The following illustration shows the parts of an angular application and how they work together:
-
-
In addition, angular comes with a set of Services, which have the following properties:
-
* The services provided are very useful for building web applications.
* You can extend and add application-specific behavior to services.
* Services include Dependency-Injection, XHR, caching, URL routing, and browser abstraction.
-
-
# Where To Go Next
-
* For explanations and examples of the angular concepts presented on this page, see the {@link
guide/index Developer Guide}.
-
* For additional hands-on examples of using `angular`, including more source code that you can
copy and paste into your own pages, take a look through the `angular` {@link cookbook/ Cookbook}.
--
cgit v1.2.3