Greetings all, 

I am interested in doing a GSOC project for the VIM organization and I would
like to get feedback on the idea.


** Pythonic Firefox Automation/LivePreview **

* Abstract *

An HTML, update as you type, live preview implementation for VIM using
MozillaBrowser and PyXPCOM. This would be built on a cross platform
MozillaBrowser/DOM automation class with convenience methods for recurring
usage patterns such as form testing automation. This would be extremely
useful for web developers using VIM.

* Detailed description *

Web development can be a painful process. Edit, save, refresh and then
repeat in tedious cycles. Testing forms can be especially painful as any one
who has experienced the process can attest. Unfortunately, for many jobs it
doesn't pay to jump through the hoops required for automation.   

Python, a most amiable languague is the perfect candidate for making the
process less tedious. The IPython shell in particular, a favorite of many
Django developers, with it's macros and command completion is well suited to
"quick throway tests"  (that you usually end up keeping anyway).

I would like to implement using PyXPCOM a wrapper around FireFox,
particularly the DOM with automated docstrings built from the Mozilla
documentation. This would enable autocompletion and help() , facilitating
easy experimentation from IPython or your choice of shell/editor. This makes
it much more likely for people to use it "in the heat of the moment". 

The API would contain convenience functions for recurring useage patterns so
people could very quickly experiment in IPython and create test macros.
Python wielding web developers everywhere would benefit as would "designers"
for whom Python is an approachable language. 

Some editors these days have inbuilt support for Live Preview of HTML as you
type. This speeds up the creative process considerably. I have created a
Live preview plugin for an windows editor using the win32py extensions,
using COM to manipulate the DOM. I would very much like to create a cross
platform solution that is easily callable from any editor with Python
embedded. 

As part of the project I would create an example of Live Preview for the VIM
editor (built with Python extensions).There are a number of feature
enhancements I would like to implement above "stock" Live Preview, useful as
it is. An url scheme that editors could register to be handled by their
editor of choice.
 
This would include line and column numbers eg.
edit://file=/home/joe/bloe.html&line=40column=20. This coupled with a
javascript hack that created links to the source of any element on mouseOver
would turn a MozillaBrowser into a source browser.

Also, with a fully documented foundation class to build from it would be
trivial to build editor hooks that could get FireFox to scroll to the
element your cursor currently resided on in your editor.

A lot of this functionality could be done in an editor agnostic manner.
Functionality that mapped buffer regions in byte positions to DOM elements
and updated on modifications for example is something that need only be
written once.

* Summary *

A Mozilla Browser automation and DOM manipulation class with built in
documentation via docstrings
Live preview API with the functionality commonly needed already programmed.
A live preview example using VIM with python extensions.

This would be of great benefit to all web developers using VIM.


--~--~---------~--~----~------------~-------~--~----~
You received this message from the "vim_dev" maillist.
For more information, visit http://www.vim.org/maillist.php
-~----------~----~----~----~------~----~------~--~---

Raspunde prin e-mail lui