Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2016 E1684: Feature Test for Assignment Submission

2016-12-01T22:51:31Z

Ysun34:

== '''Introduction''' ==

=== Expertiza ===
[https://github.com/expertiza/expertiza Expertiza] is an open-source project on GitHub used by students to view/submit assignments and review others' work. Expertiza also provides tools to visualize the scores and gauge the improvements made during the course semester. It also facilitates and monitors team projects. It is targeted at educational and non-profit organizations.

=== Travis CI ===
[https://travis-ci.org Travis CI] is a hosted, distributed continuous integration service used to build and test software projects hosted at GitHub.

'''Configuration:'''
Travis CI is configured by adding a file named .travis.yml, which is a YAML format text file, to the root directory of the repository. This file specifies the programming language used, the desired building and testing environment (including dependencies which must be installed before the software can be built and tested), and various other parameters.

'''Operation:'''
When Travis CI has been activated for a given repository, GitHub will notify it whenever new commits are pushed to that repository or a pull request is submitted. It can also be configured to only run for specific branches, or branches whose names match a specific pattern. Travis CI will then check out the relevant branch and run the commands specified in .travis.yml, which usually build the software and run any automated tests. When that process has completed, Travis notifies the developer(s) in the way it has been configured to do so—for example, by sending an email containing the test results (showing success or failure), or by posting a message on an IRC channel. In the case of pull requests, the pull request will be annotated with the outcome and a link to the build log, using a GitHub integration.

=== Capybara ===
[https://github.com/jnicklas/capybara Capybara] supports selenium-webdriver, which is mostly used in web-based automation frameworks. It supports JavaScript, can access HTTP resources outside the application, and can also be setup for testing in headless mode which is especially useful for CI scenarios.

'''Using Capybara with [http://rspec.info/ RSpec]:'''
Load RSpec 2.x support by adding the following line(typically to the spec_helper.rb file):
''require 'capybara/rspec'
''

== '''Project Requirement''' ==

There should be a feature test for submission of the assignment by the student. Once the assignment is created by the instructor the only call to action for the student is assignment submission. The purpose of this project is to test whether the submission function could work properly under different scenarios. We will design multiple test cases to simulate different scenarios which the system could encounter. For example, how system respond when a user uploads an invalid URL. The following part will provide more and detailed information on test cases.

== '''Test Plan''' ==

When a user is attempting to submit an assignment, there are some possible cases need to be considered.

# Upload single valid link: upload a valid link, the system should properly render the page and add this link into the database. We will use the following statements to simulate the submit action.

''
fill_in 'submission', with: "https://www.google.com"
click_on 'Upload link'
''

# Upload invalid link: upload an invalid link (e.g. a non-existing link), the system should detect the invalid link, reject the submission and cast corresponding error message.
# Upload multiple links: upload multiple links, the system should properly render the page and add the new link into the database. We will use the following statement to check if the current page has the uploaded URL.

''
expect(page).to have_content "https://www.google.com"
''

# Upload duplicated links: upload an link which has already been uploaded before, the system should detect this duplicated link, reject the submission and cast error message.
# Upload empty link: upload an empty link, the system should reject the submission and cast corresponding error message.
# Upload a valid file: upload a valid file, the system should properly render the page and add this file into the directory. We will use the following statements to simulation the submit action.

''
attach_file('uploaded_file', file_path)
click_on 'Upload file'
''

# Upload multiple files: upload multiple files, the system should properly render the page and add the new file into the directory.
# Upload duplicated files: upload a file which has already been uploaded before, the system should update the existed file with new one. The test code will check whether the content of this specific file was successfully updated.

== '''Approach''' ==
1. First, using [https://github.com/expertiza/expertiza/blob/master/spec/factories/factories.rb factories] to create test data: create assignment, create topic, create participant.
''before(:each) do
create(:assignment, name: "Assignment1684", directory_path: "Assignment1684")
create_list(:participant, 3)
create(:topic, topic_name: "Topic")
create(:deadline_type, name: "submission")
create(:deadline_type, name: "review")
create(:deadline_type, name: "metareview")
create(:deadline_type, name: "drop_topic")
create(:deadline_type, name: "signup")
create(:deadline_type, name: "team_formation")
create(:deadline_right)
create(:deadline_right, name: 'Late')
create(:deadline_right, name: 'OK')
create(:assignment_due_date, deadline_type: DeadlineType.where(name: "submission").first, due_at: DateTime.now + 1)
end''
2. Mock the workflow of Assignment submission using Capybara.

[[File:Work flow.png]]

3. Check the result of the submission from both web page and database.

In database level, the submission results are stored in the table: TEAMS.

[[File:Teams.jpg]]

CSC/ECE 517 Fall 2016 E1684: Feature Test for Assignment Submission

2016-12-01T20:29:16Z

Ysun34:

== '''Introduction''' ==

=== Expertiza ===
[https://github.com/expertiza/expertiza Expertiza] is an open-source project on GitHub used by students to view/submit assignments and review others' work. Expertiza also provides tools to visualize the scores and gauge the improvements made during the course semester. It also facilitates and monitors team projects. It is targeted at educational and non-profit organizations.

=== Travis CI ===
[https://travis-ci.org Travis CI] is a hosted, distributed continuous integration service used to build and test software projects hosted at GitHub.

'''Configuration:'''
Travis CI is configured by adding a file named .travis.yml, which is a YAML format text file, to the root directory of the repository. This file specifies the programming language used, the desired building and testing environment (including dependencies which must be installed before the software can be built and tested), and various other parameters.

'''Operation:'''
When Travis CI has been activated for a given repository, GitHub will notify it whenever new commits are pushed to that repository or a pull request is submitted. It can also be configured to only run for specific branches, or branches whose names match a specific pattern. Travis CI will then check out the relevant branch and run the commands specified in .travis.yml, which usually build the software and run any automated tests. When that process has completed, Travis notifies the developer(s) in the way it has been configured to do so—for example, by sending an email containing the test results (showing success or failure), or by posting a message on an IRC channel. In the case of pull requests, the pull request will be annotated with the outcome and a link to the build log, using a GitHub integration.

=== Capybara ===
[https://github.com/jnicklas/capybara Capybara] supports selenium-webdriver, which is mostly used in web-based automation frameworks. It supports JavaScript, can access HTTP resources outside the application, and can also be setup for testing in headless mode which is especially useful for CI scenarios.

'''Using Capybara with [http://rspec.info/ RSpec]:'''
Load RSpec 2.x support by adding the following line(typically to the spec_helper.rb file):
''require 'capybara/rspec'
''

== '''Project Requirement''' ==

There should be a feature test for submission of the assignment by the student. Once the assignment is created by the instructor the only call to action for the student is assignment submission. The purpose of this project is to test whether the submission function could work properly under different scenarios. We will design multiple test cases to simulate different scenarios which the system could encounter. For example, how system respond when a user uploads an invalid URL. The following part will provide more and detailed information on test cases.

== '''Test Plan''' ==

When a user is attempting to submit an assignment, there are some possible cases need to be considered.

# Upload single valid link: upload a valid link, the system should properly render the page and add this link into the database.
# Upload invalid link: upload an invalid link (e.g. a non-existing link), the system should detect the invalid link, reject the submission and cast error message.
# Upload multiple links: upload multiple links, the system should properly render the page and add the new link into the database.
# Upload duplicated links: upload an link which has already been uploaded before, the system should detect this duplicated link, reject the submission and cast error message.
# Upload empty link: upload an empty link, the system should reject the submission and cast error message.
# Upload a valid file: upload a valid file, the system should properly render the page and add this file into the database.
# Upload multiple files: upload multiple files, the system should properly render the page and add the new file into the database.
# Upload duplicated files: upload a file which has already been uploaded before, the system should update the existed file with new one.

== '''Approach''' ==
1. First, using [https://github.com/expertiza/expertiza/blob/master/spec/factories/factories.rb factories] to create test data: create assignment, create topic, create participant.
''before(:each) do
create(:assignment, name: "Assignment1684", directory_path: "Assignment1684")
create_list(:participant, 3)
create(:topic, topic_name: "Topic")
create(:deadline_type, name: "submission")
create(:deadline_type, name: "review")
create(:deadline_type, name: "metareview")
create(:deadline_type, name: "drop_topic")
create(:deadline_type, name: "signup")
create(:deadline_type, name: "team_formation")
create(:deadline_right)
create(:deadline_right, name: 'Late')
create(:deadline_right, name: 'OK')
create(:assignment_due_date, deadline_type: DeadlineType.where(name: "submission").first, due_at: DateTime.now + 1)
end''
2. Mock the workflow of Assignment submission using Capybara.

[[File:Work flow.png]]

3. Check the result of the submission from both web page and database.

In database level, the submission results are stored in the table: TEAMS.

[[File:Teams.jpg]]

CSC/ECE 517 Fall 2016 E1684: Feature Test for Assignment Submission

2016-12-01T02:30:15Z

Ysun34:

== '''Introduction''' ==

=== Expertiza ===
[https://github.com/expertiza/expertiza Expertiza] is an open-source project on GitHub used by students to view/submit assignments and review others' work. Expertiza also provides tools to visualize the scores and gauge the improvements made during the course semester. It also facilitates and monitors team projects. It is targeted at educational and non-profit organizations.

=== Travis CI ===
[https://travis-ci.org Travis CI] is a hosted, distributed continuous integration service used to build and test software projects hosted at GitHub.

'''Configuration:'''
Travis CI is configured by adding a file named .travis.yml, which is a YAML format text file, to the root directory of the repository. This file specifies the programming language used, the desired building and testing environment (including dependencies which must be installed before the software can be built and tested), and various other parameters.

'''Operation:'''
When Travis CI has been activated for a given repository, GitHub will notify it whenever new commits are pushed to that repository or a pull request is submitted. It can also be configured to only run for specific branches, or branches whose names match a specific pattern. Travis CI will then check out the relevant branch and run the commands specified in .travis.yml, which usually build the software and run any automated tests. When that process has completed, Travis notifies the developer(s) in the way it has been configured to do so—for example, by sending an email containing the test results (showing success or failure), or by posting a message on an IRC channel. In the case of pull requests, the pull request will be annotated with the outcome and a link to the build log, using a GitHub integration.

=== Capybara ===
[https://github.com/jnicklas/capybara Capybara] supports selenium-webdriver, which is mostly used in web-based automation frameworks. It supports JavaScript, can access HTTP resources outside the application, and can also be setup for testing in headless mode which is especially useful for CI scenarios.

'''Using Capybara with [http://rspec.info/ RSpec]:'''
Load RSpec 2.x support by adding the following line(typically to the spec_helper.rb file):
''require 'capybara/rspec'
''

== '''Project Requirement''' ==

There should be a feature test for submission of the assignment by the student. Once the assignment is created by the instructor the only call to action for the student is assignment submission. The purpose of this project is to test whether the submission function could work properly under different scenarios. We will design multiple test cases to simulate different scenarios which the system could encounter. For example, how system respond when a user uploads an invalid URL. The following part will provide more and detailed information on test cases.

== '''Test Plan''' ==

When a user is attempting to submit an assignment, there are some possible cases need to be considered.

# Upload single valid link: upload a valid link, the system should properly render the page and add this link into the database.
# Upload invalid link: upload an invalid link (e.g. a non-existing link), the system should detect the invalid link, reject the submission and cast error message.
# Upload multiple links: upload multiple links, the system should properly render the page and add the new link into the database.
# Upload duplicated links: upload an link which has already been uploaded before, the system should detect this duplicated link, reject the submission and cast error message.
# Upload empty link: upload an empty link, the system should reject the submission and cast error message.
# Upload a valid file: upload a valid file, the system should properly render the page and add this file into the database.
# Upload multiple files: upload multiple files, the system should properly render the page and add the new file into the database.
# Upload duplicated files: upload a file which has already been uploaded before, the system should detect this duplicated file, reject the submission and cast error message.

== '''Approach''' ==
1. First, using [https://github.com/expertiza/expertiza/blob/master/spec/factories/factories.rb factories] to create test data: create assignment, create topic, create participant.
''before(:each) do
create(:assignment, name: "Assignment1684", directory_path: "Assignment1684")
create_list(:participant, 3)
create(:topic, topic_name: "Topic")
create(:deadline_type, name: "submission")
create(:deadline_type, name: "review")
create(:deadline_type, name: "metareview")
create(:deadline_type, name: "drop_topic")
create(:deadline_type, name: "signup")
create(:deadline_type, name: "team_formation")
create(:deadline_right)
create(:deadline_right, name: 'Late')
create(:deadline_right, name: 'OK')
create(:assignment_due_date, deadline_type: DeadlineType.where(name: "submission").first, due_at: DateTime.now + 1)
end''
2. Mock the workflow of Assignment submission using Capybara.

[[File:Work flow.png]]

3. Check the result of the submission from both web page and database.

In database level, the submission results are stored in the table: TEAMS.

[[File:Teams.jpg]]

CSC/ECE 517 Fall 2016 E1684: Feature Test for Assignment Submission

2016-11-16T18:30:46Z

Ysun34:

== '''Introduction''' ==

=== Expertiza ===
[https://github.com/expertiza/expertiza Expertiza] is an open-source project on GitHub used by students to view/submit assignments and review others' work. Expertiza also provides tools to visualize the scores and gauge the improvements made during the course semester. It also facilitates and monitors team projects. It is targeted at educational and non-profit organizations.

=== Travis CI ===
[https://travis-ci.org Travis CI] is a hosted, distributed continuous integration service used to build and test software projects hosted at GitHub.

'''Configuration:'''
Travis CI is configured by adding a file named .travis.yml, which is a YAML format text file, to the root directory of the repository. This file specifies the programming language used, the desired building and testing environment (including dependencies which must be installed before the software can be built and tested), and various other parameters.

'''Operation:'''
When Travis CI has been activated for a given repository, GitHub will notify it whenever new commits are pushed to that repository or a pull request is submitted. It can also be configured to only run for specific branches, or branches whose names match a specific pattern. Travis CI will then check out the relevant branch and run the commands specified in .travis.yml, which usually build the software and run any automated tests. When that process has completed, Travis notifies the developer(s) in the way it has been configured to do so—for example, by sending an email containing the test results (showing success or failure), or by posting a message on an IRC channel. In the case of pull requests, the pull request will be annotated with the outcome and a link to the build log, using a GitHub integration.

=== Capybara ===
[https://github.com/jnicklas/capybara Capybara] supports selenium-webdriver, which is mostly used in web-based automation frameworks. It supports JavaScript, can access HTTP resources outside the application, and can also be setup for testing in headless mode which is especially useful for CI scenarios.

'''Using Capybara with [http://rspec.info/ RSpec]:'''
Load RSpec 2.x support by adding the following line(typically to the spec_helper.rb file):
''require 'capybara/rspec'
''

== '''Project Requirement''' ==

There should be a feature test for submission of the assignment by the student. Once the assignment is created by the instructor the only call to action for the student is assignment submission. The purpose of this project is to test whether the submission function could work properly under different scenarios. We will design multiple test cases to simulate different scenarios which the system could encounter. For example, how system respond when a user uploads an invalid URL. The following part will provide more and detailed information on test cases.

== '''Test Plan''' ==

When a user is attempting to submit an assignment, there are some possible cases need to be considered.

# Upload a valid link: upload a valid link, the system should properly render the page and add this link into the database.
# Upload an invalid link: upload an invalid link (e.g. a non-existing link), the system should detect the invalid link, reject the submission and cast error message.
# Upload multiple links: upload multiple links, the system should properly render the page and add the new link into the database.
# Upload duplicated links: upload an link which has already been uploaded before, the system should detect this duplicated link, reject the submission and cast error message.
# Upload empty link: upload an empty link, the system should reject the submission and cast error message.
# Upload a valid file: upload a valid file, the system should properly render the page and add this file into the database.
# Upload multiple files: upload multiple files, the system should properly render the page and add the new file into the database.
# Upload duplicated files: upload a file which has already been uploaded before, the system should detect this duplicated file, reject the submission and cast error message.

== '''Approach''' ==
1. First, using [https://github.com/expertiza/expertiza/blob/master/spec/factories/factories.rb factories] to create test data: create assignment, create topic, create participant.
''before(:each) do
create(:assignment, name: "Assignment1684", directory_path: "Assignment1684")
create_list(:participant, 3)
create(:topic, topic_name: "Topic")
create(:deadline_type, name: "submission")
create(:deadline_type, name: "review")
create(:deadline_type, name: "metareview")
create(:deadline_type, name: "drop_topic")
create(:deadline_type, name: "signup")
create(:deadline_type, name: "team_formation")
create(:deadline_right)
create(:deadline_right, name: 'Late')
create(:deadline_right, name: 'OK')
create(:assignment_due_date, deadline_type: DeadlineType.where(name: "submission").first, due_at: DateTime.now + 1)
end''
2. Mock the workflow of Assignment submission using Capybara.

[[File:Work flow.png]]

3. Check the result of the submission from both web page and database.

In database level, the submission results are stored in the table: TEAMS.

[[File:Teams.jpg]]

CSC/ECE 517 Fall 2016 E1684: Feature Test for Assignment Submission

2016-11-10T02:14:10Z

Ysun34:

== '''Introduction to Expertiza''' ==
Expertiza is an online system that is used by students to view/submit assignments and review others' work. Expertiza also provides tools to visualize the scores and gauge the improvements made during the course semester. It also facilitates and monitors team projects. It is targeted at educational and non-profit organizations.

Expertiza is an open-source project with the source code available as a public repository on GitHub. It is developed using Ruby on Rails and is increasingly becoming robust thanks to the innumerable bugs being fixed by the community. The project has a micro-blog on SourceForge where the developer community report bugs and document updates.

== '''Project Requirement''' ==

There should be a feature test for submission of the assignment by the student. Once the Assignment is created by the instructor the only Call to action for the student is assignment submission.

== '''Approach''' ==

Mock the flow of Assignment submission using Capybara and check the result of the submission.

===Workflow===

Student login -> click on the assignment -> upload link or upload file

[[File:Work flow.png]]

=== Scenarios ===

# Submit hyperlink → click hyperlink → have content.
# Submit file → download file → have content.

File:Work flow.png

2016-11-10T02:11:29Z

Ysun34:

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-11-05T05:44:38Z

Ysun34: /* Project description */

[https://servo.org Servo] is a modern high-performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a newly developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements HTML form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines a set of specifications which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on the single-thread model. The motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source system programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe system. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original servo repository and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

*We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
*Change using enum to bitflags that represents each possible validity check in <code>ValidityState</code>.
[[File:Bitflags.JPG]]

*Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.
[[File:Validation.JPG]]

*The traits for different form elements like Input text, Input submit, Input Button, Input Image are defined in htmlInputElement.rs
[[File:Inputelement.JPG]]

*The code below will check the type of elements from the form and if they are input elements then it will call the <code>is_instance_validatable</code> function to check the validation.
[[File:Formelement.JPG]]

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

===Subsequent steps===
* We will be adding methods so that we can statically and dynamically validate the constraints of the form element.
* We will implement the checkValidity and ReportValidity API for HTML form element.
* We will implement the validity state defined in the spec and implement the form submission algorithm to include the constraint validation.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. However, after further discuss with servo project member, we found a disadvantage of the original design of using enum. Therefore we have made an agreement on changing this into using bitflags. Throughout the development process, we tried to follow good o-o practices by following DRY, giving the elements and functions the correct names and we tried and maintained the servo and rust coding standards.

=='''Test'''==
===Test with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.
===Compile test===
After adding code, we compiled the servo by the following command

cd servo
./mach build -d

No error showed up, servo worked as expected with the new code.
===Test from UI===
At this stage, the project can't be tested from UI. There are still some subsequent steps to be implemented after this.

===For reviewers===
In addition to the reasons mentioned above, the servo is a web browser and not a web application. Therefore it can't be deployed on the cloud server. All these would make it hard for reviewers to test the correctness of code at this time.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-11-05T05:41:55Z

Ysun34: /* Project description */

[https://servo.org Servo] is a modern high-performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a newly developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements HTML form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines a set of specifications which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on the single-thread model. The motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source system programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe system. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original servo repository and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

*We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
*Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.
[[File:Validation.JPG]]

*The traits for different form elements like Input text, Input submit, Input Button, Input Image are defined in htmlInputElement.rs
[[File:Inputelement.JPG]]

*The code below will check the type of elements from the form and if they are input elements then it will call the <code>is_instance_validatable</code> function to check the validation.
[[File:Formelement.JPG]]

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

===Subsequent steps===
* We will be adding methods so that we can statically and dynamically validate the constraints of the form element.
* We will implement the checkValidity and ReportValidity API for HTML form element.
* We will implement the validity state defined in the spec and implement the form submission algorithm to include the constraint validation.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. However, after further discuss with servo project member, we found a disadvantage of the original design of using enum. Therefore we have made an agreement on changing this into using bitflags. Throughout the development process, we tried to follow good o-o practices by following DRY, giving the elements and functions the correct names and we tried and maintained the servo and rust coding standards.

=='''Test'''==
===Test with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.
===Compile test===
After adding code, we compiled the servo by the following command

cd servo
./mach build -d

No error showed up, servo worked as expected with the new code.
===Test from UI===
At this stage, the project can't be tested from UI. There are still some subsequent steps to be implemented after this.

===For reviewers===
In addition to the reasons mentioned above, the servo is a web browser and not a web application. Therefore it can't be deployed on the cloud server. All these would make it hard for reviewers to test the correctness of code at this time.

=='''References'''==
<references />

File:Bitflags.JPG

2016-11-05T05:41:22Z

Ysun34:

File:Inputelement.JPG

2016-11-05T05:38:18Z

Ysun34:

File:Formelement.JPG

2016-11-05T05:38:00Z

Ysun34:

File:Validation.JPG

2016-11-05T05:37:35Z

Ysun34:

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-11-05T05:29:55Z

Ysun34: /* Design patterns & o-o practices */

[https://servo.org Servo] is a modern high-performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a newly developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements HTML form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines a set of specifications which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on the single-thread model. The motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source system programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe system. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original servo repository and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

*We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
*Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.
[[File:Validatable.PNG]]

*The traits for different form elements like Input text, Input submit, Input Button, Input Image are defined in htmlInputElement.rs
[[File:Inputelement.PNG]]

*The code below will check the type of elements from the form and if they are input elements then it will call the <code>is_instance_validatable</code> function to check the validation.
[[File:Formelement.PNG]]

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

===Subsequent steps===
* We will be adding methods so that we can statically and dynamically validate the constraints of the form element.
* We will implement the checkValidity and ReportValidity API for HTML form element.
* We will implement the validity state defined in the spec and implement the form submission algorithm to include the constraint validation.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. However, after further discuss with servo project member, we found a disadvantage of the original design of using enum. Therefore we have made an agreement on changing this into using bitflags. Throughout the development process, we tried to follow good o-o practices by following DRY, giving the elements and functions the correct names and we tried and maintained the servo and rust coding standards.

=='''Test'''==
===Test with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.
===Compile test===
After adding code, we compiled the servo by the following command

cd servo
./mach build -d

No error showed up, servo worked as expected with the new code.
===Test from UI===
At this stage, the project can't be tested from UI. There are still some subsequent steps to be implemented after this.

===For reviewers===
In addition to the reasons mentioned above, the servo is a web browser and not a web application. Therefore it can't be deployed on the cloud server. All these would make it hard for reviewers to test the correctness of code at this time.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-31T23:16:29Z

Ysun34: /* Test from ui */

[https://servo.org Servo] is a modern high-performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a newly developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements HTML form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines a set of specifications which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on the single-thread model. The motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source system programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe system. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original servo repository and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

*We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
*Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.
[[File:Validatable.PNG]]

*The traits for different form elements like Input text, Input submit, Input Button, Input Image are defined in htmlInputElement.rs
[[File:Inputelement.PNG]]

*The code below will check the type of elements from the form and if they are input elements then it will call the <code>is_instance_validatable</code> function to check the validation.
[[File:Formelement.PNG]]

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

===Subsequent steps===
* We will be adding methods so that we can statically and dynamically validate the constraints of the form element.
* We will implement the checkValidity and ReportValidity API for HTML form element.
* We will implement the validity state defined in the spec and implement the form submission algorithm to include the constraint validation.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. Throughout the development process, we tried to follow good o-o practices by following DRY, giving the elements and functions the correct names and we tried and maintained the servo and rust coding standards.

=='''Test'''==
===Test with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.
===Compile test===
After adding code, we compiled the servo by the following command

cd servo
./mach build -d

No error showed up, servo worked as expected with new code.
===Test from UI===
At this stage, the project can't be tested from UI. There are still some subsequent steps to be implemented after this.

===For reviewers===
In addition to the reason mentioned above, servo is a browser but not a web application. Therefore it can't be deployed on the cloud server. All these would make it hard for reviewers to test the correctness of code at this time.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-31T23:16:17Z

Ysun34: /* Test */

[https://servo.org Servo] is a modern high-performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a newly developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements HTML form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines a set of specifications which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on the single-thread model. The motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source system programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe system. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original servo repository and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

*We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
*Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.
[[File:Validatable.PNG]]

*The traits for different form elements like Input text, Input submit, Input Button, Input Image are defined in htmlInputElement.rs
[[File:Inputelement.PNG]]

*The code below will check the type of elements from the form and if they are input elements then it will call the <code>is_instance_validatable</code> function to check the validation.
[[File:Formelement.PNG]]

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

===Subsequent steps===
* We will be adding methods so that we can statically and dynamically validate the constraints of the form element.
* We will implement the checkValidity and ReportValidity API for HTML form element.
* We will implement the validity state defined in the spec and implement the form submission algorithm to include the constraint validation.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. Throughout the development process, we tried to follow good o-o practices by following DRY, giving the elements and functions the correct names and we tried and maintained the servo and rust coding standards.

=='''Test'''==
===Test with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.
===Compile test===
After adding code, we compiled the servo by the following command

cd servo
./mach build -d

No error showed up, servo worked as expected with new code.
===Test from ui===
At this stage, the project can't be tested from UI. There are still some subsequent steps to be implemented after this.
===For reviewers===
In addition to the reason mentioned above, servo is a browser but not a web application. Therefore it can't be deployed on the cloud server. All these would make it hard for reviewers to test the correctness of code at this time.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-31T22:57:32Z

Ysun34: fix some grammar mistakes

[https://servo.org Servo] is a modern high-performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a newly developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements HTML form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines a set of specifications which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on the single-thread model. The motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source system programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe system. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original servo repository and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

*We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
*Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.
[[File:Validatable.PNG]]

*The traits for different form elements like Input text, Input submit, Input Button, Input Image are defined in htmlInputElement.rs
[[File:Inputelement.PNG]]

*The code below will check the type of elements from the form and if they are input elements then it will call the <code>is_instance_validatable</code> function to check the validation.
[[File:Formelement.PNG]]

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

===Subsequent steps===
* We will be adding methods so that we can statically and dynamically validate the constraints of the form element.
* We will implement the checkValidity and ReportValidity API for HTML form element.
* We will implement the validity state defined in the spec and implement the form submission algorithm to include the constraint validation.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. Throughout the development process, we tried to follow good o-o practices by following DRY, giving the elements and functions the correct names and we tried and maintained the servo and rust coding standards.

=='''Test'''==
===Test with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.
===Compile test===
After adding code, we compiled the servo by the following command

cd servo
./mach build -d

No error showed up, servo worked as expected with new code.
===For reviewers===
So far this project only contains initial steps, the whole HTML form validation will be implemented after subsequent steps. So it would be hard for reviewers to test the correctness of code at this time.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T23:30:31Z

Ysun34: /* Testing */

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

*We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
*Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.
[[File:Validatable.PNG]]

*The traits for different form elements like Input text, Input submit, Input Button, Input Image are defined in htmlInputElement.rs
[[File:Inputelement.PNG]]

*The code below will check the type of elements from the form and if they are input elements then it will call the <code>is_instance_validatable</code> function to check the validation.
[[File:Formelement.PNG]]

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

===Subsequent steps===
* We will be adding methods so that we can statically and dynamically validate the constraints of the form element.
* We will implement the checkValidity and ReportValidity API for HTML form element.
* We will implement the validity state defined in the spec and implement the form submission algorithm to include the constraint validation.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. Throughout the development process we tried to follow good o-o practices by following DRY, giving the elements and functions the correct names and we tried and maintained the servo and rust coding standards.

=='''Test'''==
===Test with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.
===Compile test===
After adding code, we compiled the servo by following command

cd servo
./mach build -d

No error showed up, servo worked as expected with new code.
===For reviewers===
So far this project only contains initial steps, the whole HTML form validation will be implemented after subsequent steps. So it would be hard for reviewers to test the correctness of code at this time.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016

2016-10-29T18:29:01Z

Ysun34:

[http://www.example.com link title]==Calibration Assignment Submissions==
*[[Calibration Assignment Submission (Firebrick JS)]]
*[[Calibration Assignment Submission (Active Job)]]
==Writing Assignments 2==
*[[CSC/ECE 517 Fall 2016/E1666. Test team functionality]]
*[[CSC/ECE 517 Fall 2016/E1643. Refactor Suggestion controller]]
*[[CSC/ECE 517 Fall 2016/E1631. Refactoring Bidding Interface]]
*[[CSC/ECE 517 Fall 2016/E1674.Refactor leaderboard.rb and write unit tests]]
*[[CSC/ECE 517 Fall 2016/E1671. Unit Tests for participants.rb Hierarchy]]
*[[CSC/ECE 517 Fall 2016/E1668.Test e-mailing functionality]]
*[[CSC/ECE 517 Fall 2016/E1658. Refractor lottery_controller.rb and write integration tests]]
*[[CSC/ECE 517 Fall 2016/E1660. Review requirements and thresholds]]
*[[CSC/ECE 517 Fall 2016/E1650. Sort instructor views alphabetically by default]]
*[[CSC/ECE 517 Fall 2016/E1644. Refactor and test Teams Controller]]
*[[CSC/ECE 517 Fall 2016/E1645. Refactoring Tree Display Controller]]
*[[CSC/ECE 517 Fall 2016/E1659. Refactor on_the_fly_calc.rb]]
*[[CSC/ECE 517 Fall 2016/E1657. Introduce a Student View for instructors]]
*[[CSC/ECE 517 Fall 2016/E1653. Fix and improve rubric criteria]]
*[[CSC/ECE 517 Fall 2016/E1642. Refactor review_response_map.rb]]
*[[CSC/ECE_517_Fall_2016/E1664:_Feature_Test_Assignment_Creation]]
*[[CSC/ECE 517 Fall 2016/E1666. Test team functionality]]
*[[CSC/ECE_517_Fall_2016/E1654. Improve_date-picker_and_deadlines]]
*[[CSC/ECE_517_Fall_2016/E1652 Fix teammate advertisements and requests to join a team ]]
*[[CSC/ECE_517_Fall_2016/E1662. UI issues/fixes]]
*[[CSC/ECE_517_Fall_2016/E1673. Refactor question_type.rb]]
*[[CSC/ECE_517_Fall_2016/E1675. Timestamp for student file & hyperlink submissions]]
*[[CSC/ECE_517_Fall_2016/E1640. Refactor response.rb and response_helper.rb]]
*[[CSC/ECE 517 Fall 2016/E1634. Refactor and write unit test of due_date.rb and deadline_helper.rb]]
*[[CSC/ECE_517_Fall_2016/M1654._Improve_network_security_features]]
*[[CSC/ECE_517_Fall_2016/E1670._Unit_tests_for_answers.rb]]
*[[CSC/ECE_517_Fall_2016/E1641. Refactor review_mapping_controller.rb]]
*[[CSC/ECE_517_Fall_2016/M1652_Implement_ImageMap_Support_Servo]]
*[[CSC/ECE_517_Fall_2016/E1648/Add_past_due_assignment]]
*[[CSC/ECE 517 Fall 2016/E1656. Improve imports]]
*[[CSC/ECE_517_Fall_2016/M1653_Implement_HTML_form_validation]]

M1653 Implement HTML form validation

2016-10-29T18:20:44Z

Ysun34: moved M1653 Implement HTML form validation to CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

#REDIRECT [[CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation]]

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T18:20:44Z

Ysun34: moved M1653 Implement HTML form validation to CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

*We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
*Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.
[[File:Validatable.PNG]]

*The traits for different form elements like Input text, Input submit, Input Button, Input Image are defined in htmlInputElement.rs
[[File:Inputelement.PNG]]

*The code below will check the type of elements from the form and if they are input elements then it will call the <code>is_instance_validatable</code> function to check the validation.
[[File:Formelement.PNG]]

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

===Subsequent steps===
* We will be adding methods so that we can statically and dynamically validate the constraints of the form element.
* We will implement the checkValidity and ReportValidity API for HTML form element.
* We will implement the validity state defined in the spec and implement the form submission algorithm to include the constraint validation.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. Throughout the development process we tried to follow good o-o practices by following DRY, giving the elements and functions the correct names and we tried and maintained the servo and rust coding standards.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T04:00:11Z

Ysun34: /* Implemented steps */

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

*We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
*Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.
[[File:Validatable.PNG]]

*We implemented this trait for different form elements
[[File:Inputelement.PNG]]

*Add code to circularly check the type of elements, if it is input elements then calls <code>is_instance_validatable</code>
[[File:Formelement.PNG]]

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. We used enum and tried to follow good o-o practices in the process of development.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

===Testing with ui===

We created a test form to check our validation function.

=='''References'''==
<references />

File:Formelement.PNG

2016-10-29T03:59:40Z

Ysun34:

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T03:46:44Z

Ysun34: /* Project description */

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

*We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
*Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.

*We implemented this trait for different form elements
[[File:http://wiki.expertiza.ncsu.edu/images/6/6c/Validatable.PNG]]

*Add code to circularly check the type of elements, if it is input elements then calls <code>is_instance_validatable</code>

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. We used enum and tried to follow good o-o practices in the process of development.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

===Testing with ui===

We created a test form to check our validation function.

=='''References'''==
<references />

File:Inputelement.PNG

2016-10-29T03:43:40Z

Ysun34:

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T03:42:23Z

Ysun34:

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

*We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
*Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.

*We implemented this trait for different form elements

*Add code to circularly check the type of elements, if it is input elements then calls <code>is_instance_validatable</code>

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. We used enum and tried to follow good o-o practices in the process of development.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

===Testing with ui===

We created a test form to check our validation function.

=='''References'''==
<references />

File:Validatable.PNG

2016-10-29T03:27:20Z

Ysun34:

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T03:25:50Z

Ysun34: /* Project description */

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project begin with installing and compiling the servo browser<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>. For different operating systems the dependencies are different. We installed it on Ubuntu using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
* We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
* Defined a trait <code>Validatable</code> in <code>validation.rs</code> file that contains methods to be used for validating an html element.

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. We used enum and tried to follow good o-o practices in the process of development.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

===Testing with ui===

We created a test form to check our validation function.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T03:12:55Z

Ysun34:

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project description'''==
===Build process===
* The project <ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref> begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
* We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
* Defined a trait Validatable in validation.rs file that contains methods to be used for validating an html element.

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. We used enum and tried to follow good o-o practices in the process of development.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

===Testing with ui===

We created a test form to check our validation function.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T03:11:42Z

Ysun34: /* Implemented Steps */

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
===Build Process===
* The project <ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref> begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial Steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
* We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented steps===
* Defined a trait Validatable in validation.rs file that contains methods to be used for validating an html element.

===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. We used enum and tried to follow good o-o practices in the process of development.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

===Testing with ui===

We created a test form to check our validation function.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T03:11:31Z

Ysun34: /* Challenges Faced */

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
===Build Process===
* The project <ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref> begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial Steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
* We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented Steps===
* Defined a trait Validatable in validation.rs file that contains methods to be used for validating an html element.
===Challenges faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. We used enum and tried to follow good o-o practices in the process of development.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

===Testing with ui===

We created a test form to check our validation function.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T03:11:15Z

Ysun34: /* Design Patterns & OO Practices */

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
===Build Process===
* The project <ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref> begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial Steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
* We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented Steps===
* Defined a trait Validatable in validation.rs file that contains methods to be used for validating an html element.
===Challenges Faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design patterns & o-o practices'''==
This project is to add some features to servo, so we were not supposed to change the design of original servo project. We used enum and tried to follow good o-o practices in the process of development.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

===Testing with ui===

We created a test form to check our validation function.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T03:09:57Z

Ysun34: /* Testing with UI */

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
===Build Process===
* The project <ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref> begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial Steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
* We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented Steps===
* Defined a trait Validatable in validation.rs file that contains methods to be used for validating an html element.
===Challenges Faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

===Testing with ui===

We created a test form to check our validation function.

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T03:08:11Z

Ysun34: /* Testing with tidy */

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
===Build Process===
* The project <ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref> begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial Steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
* We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented Steps===
* Defined a trait Validatable in validation.rs file that contains methods to be used for validating an html element.
===Challenges Faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard by using the following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

===Testing with UI===

We created a test form to check whether the validation was working or not.
=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T03:07:30Z

Ysun34: /* Testing with Tidy */

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
===Build Process===
* The project <ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref> begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial Steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
* We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented Steps===
* Defined a trait Validatable in validation.rs file that contains methods to be used for validating an html element.
===Challenges Faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
===Testing with tidy===
Servo has its own code standard. We managed to meet its code standard. We use following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 code style errors and we fixed all the errors.

===Testing with UI===

We created a test form to check whether the validation was working or not.
=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-29T03:05:30Z

Ysun34: /* Initial Steps */

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
===Build Process===
* The project <ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref> begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

===Initial Steps===

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
* We pushed the code to the servo and the pull request is [https://github.com/servo/servo/pull/13969 #13969]. The servo team requires only one commit so that all modifications we made are in that single commit.

===Implemented Steps===
* Defined a trait Validatable in validation.rs file that contains methods to be used for validating an html element.
===Challenges Faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
===Testing with Tidy===
Servo has its own code standard. We managed to meet its code standard. We use following command to run code style check.

cd servo
./mach test-tidy

When we ran tidy we got 20 syntactic errors and we fixed all the errors.

===Testing with UI===

We created a test form to check whether the validation was working or not.
=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T18:43:27Z

Ysun34:

[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
===Challenges Faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
Servo has its own code standard. We managed to meet its code standard. We use following command to run code style check.

cd servo
./mach test-tidy

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T18:43:13Z

Ysun34:

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
===Challenges Faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
Servo has its own code standard. We managed to meet its code standard. We use following command to run code style check.

cd servo
./mach test-tidy

=='''References'''==
<references />

User:Bbansal

2016-10-28T18:42:16Z

Ysun34: moved User:Bbansal to M1653 Implement HTML form validation: Move user page to project title page

#REDIRECT [[M1653 Implement HTML form validation]]

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T18:42:16Z

Ysun34: moved User:Bbansal to M1653 Implement HTML form validation: Move user page to project title page

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.
===Challenges Faced===
* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
Servo has its own code standard. We managed to meet its code standard. We use following command to run code style check.

cd servo
./mach test-tidy

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T16:46:38Z

Ysun34:

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
Servo has its own code standard. We managed to meet its code standard. We use following command to run code style check.

cd servo
./mach test-tidy

=='''References'''==
<references />

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T16:45:59Z

Ysun34:

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors<ref>https://en.wikipedia.org/wiki/Servo_(layout_engine)</ref>. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
Servo has its own code standard. We managed to meet its code standard. We use following command to run code style check.

cd servo
./mach test-tidy

=='''References'''==
<references />
1. https://doc.rust-lang.org/stable/book/ 
2. https://en.wikipedia.org/wiki/Rust_(programming_language) 
3. https://en.wikipedia.org/wiki/Servo_(layout_engine) 
4. https://github.com/servo/servo/wiki/Form-validation-student-project 
5. https://doc.rust-lang.org/book/ 
6. http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2016/Mozilla_Implement_HTML5_form_validation

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T16:43:03Z

Ysun34: /* Introduction */

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
Servo has its own code standard. We managed to meet its code standard. We use following command to run code style check.

cd servo
./mach test-tidy

=='''References'''==
<references />
1. https://doc.rust-lang.org/stable/book/ 
2. https://en.wikipedia.org/wiki/Rust_(programming_language) 
3. https://en.wikipedia.org/wiki/Servo_(layout_engine) 
4. https://github.com/servo/servo/wiki/Form-validation-student-project 
5. https://doc.rust-lang.org/book/ 
6. http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2016/Mozilla_Implement_HTML5_form_validation

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T16:42:32Z

Ysun34: /* Project Description */

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==<ref>https://github.com/servo/servo/wiki/Form-validation-student-project</ref>
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
Servo has its own code standard. We managed to meet its code standard. We use following command to run code style check.

cd servo
./mach test-tidy

=='''References'''==
<references />
1. https://doc.rust-lang.org/stable/book/ 
2. https://en.wikipedia.org/wiki/Rust_(programming_language) 
3. https://en.wikipedia.org/wiki/Servo_(layout_engine) 
4. https://github.com/servo/servo/wiki/Form-validation-student-project 
5. https://doc.rust-lang.org/book/ 
6. http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2016/Mozilla_Implement_HTML5_form_validation

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T16:41:22Z

Ysun34: /* Design Patterns & OO Practices */

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development.

=='''Testing'''==
Servo has its own code standard. We managed to meet its code standard. We use following command to run code style check.

cd servo
./mach test-tidy

=='''References'''==
<references />
1. https://doc.rust-lang.org/stable/book/ 
2. https://en.wikipedia.org/wiki/Rust_(programming_language) 
3. https://en.wikipedia.org/wiki/Servo_(layout_engine) 
4. https://github.com/servo/servo/wiki/Form-validation-student-project 
5. https://doc.rust-lang.org/book/ 
6. http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2016/Mozilla_Implement_HTML5_form_validation

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T16:39:27Z

Ysun34: /* Design Patterns & OO Practices */

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development. We managed to avoid the redundant code and tried to meet code standard of servo. We use following command to run code style check.

cd servo
./mach test-tidy

=='''References'''==
<references />
1. https://doc.rust-lang.org/stable/book/ 
2. https://en.wikipedia.org/wiki/Rust_(programming_language) 
3. https://en.wikipedia.org/wiki/Servo_(layout_engine) 
4. https://github.com/servo/servo/wiki/Form-validation-student-project 
5. https://doc.rust-lang.org/book/ 
6. http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2016/Mozilla_Implement_HTML5_form_validation

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T16:39:06Z

Ysun34: /* Design Patterns & OO Practices */

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development. We managed to avoid the redundant code and tried to meet code standard of servo. We use following command to run code style check.

cd servo
./mach test-tidy

=='''References'''==
<references />
1. https://doc.rust-lang.org/stable/book/ 
2. https://en.wikipedia.org/wiki/Rust_(programming_language) 
3. https://en.wikipedia.org/wiki/Servo_(layout_engine) 
4. https://github.com/servo/servo/wiki/Form-validation-student-project 
5. https://doc.rust-lang.org/book/ 
6. http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2016/Mozilla_Implement_HTML5_form_validation

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T16:38:42Z

Ysun34: /* Design Patterns & OO Practices */

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development. We managed to avoid the redundant code and tried to meet code standard of servo. We use following command to run code style check.

cd servo
./mach test-tidy

=='''References'''==
<references />
1. https://doc.rust-lang.org/stable/book/ 
2. https://en.wikipedia.org/wiki/Rust_(programming_language) 
3. https://en.wikipedia.org/wiki/Servo_(layout_engine) 
4. https://github.com/servo/servo/wiki/Form-validation-student-project 
5. https://doc.rust-lang.org/book/ 
6. http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2016/Mozilla_Implement_HTML5_form_validation

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T16:37:11Z

Ysun34: /* Design Patterns & OO Practices */

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

=='''Design Patterns & OO Practices'''==
This project is to add some feature to servo, so we were not supposed to change the design of original servo project. We used Enum and tried to follow good OO practices in the process of development. We managed to avoid the redundant code and tried to meet code standard of servo. We use following command to run code style check.

<code>
./mach test-tidy
</code>

=='''References'''==
<references />
1. https://doc.rust-lang.org/stable/book/ 
2. https://en.wikipedia.org/wiki/Rust_(programming_language) 
3. https://en.wikipedia.org/wiki/Servo_(layout_engine) 
4. https://github.com/servo/servo/wiki/Form-validation-student-project 
5. https://doc.rust-lang.org/book/ 
6. http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2016/Mozilla_Implement_HTML5_form_validation

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T16:16:38Z

Ysun34: /* Project Description */

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

*Add new enum that represents each possible validity check in <code>ValidityState</code>.

*Define a <code>Validatable</code> [https://doc.rust-lang.org/1.12.0/book/traits.html trait] that contains a method which accepts this enum as an argument.

*Implement this trait for different form element types (<code>HTMLInputElement</code>, <code>HTMLButtonElement</code>, etc.), and define an as_maybe_validatable method on Element which returns an <code>&Validatable</code> value if the element implements the trait.

*Use <code>JS<Element></code> member to call these new methods in <code>ValidityState</code>.

=='''Design Patterns & OO Practices'''==
We were not supposed to change the design apart from adding a new behaviour/ability for HTML Element. We tried to follow good OO practices throughout the development process. We always tried to follow the DRY principle in order to avoid repetition of code. Servo has it's own coding standards which are checked by running following command.

<code>
./mach test-tidy
</code>

Using the above code there were a few issues generated and we have fixed all the issues.

=='''References'''==
<references />
1. https://doc.rust-lang.org/stable/book/ 
2. https://en.wikipedia.org/wiki/Rust_(programming_language) 
3. https://en.wikipedia.org/wiki/Servo_(layout_engine) 
4. https://github.com/servo/servo/wiki/Form-validation-student-project 
5. https://doc.rust-lang.org/book/ 
6. http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2016/Mozilla_Implement_HTML5_form_validation

CSC/ECE 517 Fall 2016/M1653 Implement HTML form validation

2016-10-28T16:00:02Z

Ysun34: /* Project Description */

''' Implementation of HTML5 form validation in servo'''

----
[https://servo.org Servo] is a modern high performance web browser developed by Mozilla with Samsung porting it on android and arm processors. The source code is written in the [https://www.rust-lang.org/en-US/ rust] programming language, which is a new developed system level programming language. The major advantage of rust language is that it is thread-safe<ref>https://www.rust-lang.org/en-US/</ref>. This project implements html form validation on servo browser.

=='''Introduction'''==
The [https://en.wikipedia.org/wiki/HTML5 HTML5]is a markup language used for content organizing and showing on the World Wide Web<ref>https://en.wikipedia.org/wiki/HTML5</ref>. It defines set of specification which users needs to follow to make web pages HTML5 compliant. In HTML 5 there is a major type of element which is form element. When user trying to submit their form, the system should be able to check the validation status of this form and decide whether accept this form or reject the request. HTML provides such mechanism. Using this mechanism will allow the system to check whether the contents of forms are validated before it is allowed to submit. [https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] currently implements validation check for some of the form element types. The objective of this project is to define and implement validation check function and implement validate step for these HTML5 form elements.

===Servo===
[https://en.wikipedia.org/wiki/Servo_(layout_engine) Servo] is an open source prototype web browser layout engine that is being developed by Mozilla Research. Its source code can be found [https://github.com/servo/servo here]. Current browser engines are mostly based on single-threaded model. Motivation behind building servo web browser is to build a highly parallel and reliable environment, where different components (such as rendering, layout, HTML parsing, image decoding, etc.) can be handled by fine-grained, isolated tasks.

===Rust===
[http://doc.rust-lang.org/book/README.html Rust] is an open source systems programming language developed by Mozilla. Rust is a language suited for creating a highly concurrent and safe systems. In performance and syntax, rust is similar to C++ but semantically it is very different. Rust emphasis is on speed, safety and control of memory layout<ref>https://en.wikipedia.org/wiki/Rust_(programming_language)</ref>.

=='''Project Description'''==
* The project begin with installing and compiling the servo browser. For different Operating systems the dependencies are different. We installed it on Ubuntu 14.04 using the following commands.

On Debian-based Linuxes:

sudo apt-get install curl freeglut3-dev \
libfreetype6-dev libgl1-mesa-dri libglib2.0-dev xorg-dev \
msttcorefonts gperf g++ cmake python-virtualenv \
libssl-dev libglfw-dev

* We then forked the original repository from servo and cloned the forked repository on our local machines and then compiled and ran the servo browser.

cd servo
./mach build --dev
./mach run tests/html/about-mozilla.html

* While building the servo as shown above we were getting GLSL 1.50 is not supported error. We investigated this issue and found that there was an open issue [https://github.com/servo/servo/issues/13515 #13515]. We found that the error was because the rendering was done with Nvidia graphics card and so we changed it to the intel graphics card by <code>./mach run tests/html/about-mozilla.html -c</code> and were able to run the browser. We even updated the open thread so that other people can take advantage of that.

=='''Design Patterns & OO Practices'''==
We were not supposed to change the design apart from adding a new behaviour/ability for HTML Element. We tried to follow good OO practices throughout the development process. We always tried to follow the DRY principle in order to avoid repetition of code. Servo has it's own coding standards which are checked by running following command.

<code>
./mach test-tidy
</code>

Using the above code there were a few issues generated and we have fixed all the issues.

=='''References'''==
<references />
1. https://doc.rust-lang.org/stable/book/ 
2. https://en.wikipedia.org/wiki/Rust_(programming_language) 
3. https://en.wikipedia.org/wiki/Servo_(layout_engine) 
4. https://github.com/servo/servo/wiki/Form-validation-student-project 
5. https://doc.rust-lang.org/book/ 
6. http://wiki.expertiza.ncsu.edu/index.php/CSC/ECE_517_Spring_2016/Mozilla_Implement_HTML5_form_validation