Jiggy-based development

[mattmcc999]

Jiggy lets you use Javascript to write pod apps. This is way cool.
This means you don't need to work with objective-c to write apps, and
while it's probable you would need to do certain stuff, but this seems
to be a way to get productive fast. A full port of the JDK to a pod
dev version seems like it's awhile away. In the meantime though,
there's Jiggy. Google has a dev group for it, too:
http://groups.google.com/group/jiggyapp-devel

The only Jiggy app I have on my pod is MapsOffline by nambrot. It
seems very useful though and it has a good interface, written in
Javascript. The support for it out there seems very good, too.
Jiggy's home is http://jiggyapp.com/

I'm off to the races now. :) Anyone care to discuss Jiggy? Thsi is
why I have it in a discussion thread.

[mattmcc999]

I have started on my first actually useful jiggy app and I have to
say it's a lot of fun. I can see so many applications for this kind
of thing. It's great to be in on the ground floor of a new dev
platform. The dev tools the iDeities are coming up with are getting
better every day. In less than 2 days I have made huge progress with
a simple HTML-getting app. The idea here is that along with an XSL
processor, XML available via some web-based gateway could be read into
this app and placed into context there. Or, the data can be placed
into context via the XML, with key-value pairs that are descriptive.

I see a lot of ways that this kind of programming could find a use in
a lot of info- and knowledge-heavy industries, particularly for mgt.
and technical people who need to keep on top of machine status, for
example, but don't want to wade through web pages or deal with more
information than they can handle on a small hand-held device.

But truth is, this is not about the wheel, but the size of it. We are
reinventing all manner of stuff, ie, the typical business hack. It's
one database app after another, etc. And even new ways to transfer
data (eg: XML) are all right, but it's still an application of a few
bigger menthodologies (ie, client-server in that case). The next
phase will be mind-controlled apps. There are already simple ones in
operation, mostly to help the handicapped. But the time is coming
when they will be as common as Internet-enabled/Wi-fi devices are
today. Don't think so? Back in 1990, when someone told you that one
day soon, there'd be devices like iPhones and ubiquitous Internet
access in large metro areas, did you laugh?

That is neither here nor there, really. I am just pointing out the
possibilities, and how human beings have this tendency to discount the
rate of change in their societies, particularly as it comes to
technology.

On May 2, 1:33 pm, mattmcc999 <mattmcc...@gmail.com> wrote:
> Jiggy lets you use Javascript to write pod apps. This is way cool.
> This means you don't need to work with objective-c to write apps, and
> while it's probable you would need to do certain stuff, but this seems
> to be a way to get productive fast. A full port of the JDK to a pod
> dev version seems like it's awhile away. In the meantime though,
> there's Jiggy. Google has a dev group for it, too:http://groups.google.com/group/jiggyapp-devel
>
> The only Jiggy app I have on my pod is MapsOffline by nambrot. It
> seems very useful though and it has a good interface, written in
> Javascript. The support for it out there seems very good, too.

> Jiggy's home ishttp://jiggyapp.com/

[mattmcc999]

Nasty parsing task required custom coding. I hate actually having to
write code. I'd much rather rip it, er, I mean, examine others' work
and honor them via emulation. =)

Anyway, I hope this saves someone else the trouble:

/**
content - string to be searched within (eg: "My dog has fleas my dog
has three fleas.")
starttext - string being the starting delineation (eg: "dog")
endtext - string being the ending delineation (eg: "fleas")
instancenumber - integer - which instance of the text delineated by
the start- and end-text values to get, always counting
rightward through the value of 'content' (eg: 2, if I want the
second instance of the enclosed text)
startfromstarttext - boolean - If 'true' the search will look for the
val. of starttext, then seek endtext val.
But if 'false', search will look for the endtext val., then look
for the starttext val. closest to it
in the preceding text. (ie, if 'true', search would find 2nd
instance of "dog", then look for next instance of "fleas".
But if 'false', search would find the second instance of "fleas",
then moving leftward through
the 'content' string, would find the first instance of "dog" it
reaches, still reading the word "dog" left-to-right,
and return the intervening text).
Note this is not the same as doing a search from the end of the
'content' string to the start, or searching backward for the text
being sought for. In both cases, the search logic starts from the
beginning of the 'content' string and processes the
text rightward.

In the example:

returned = getEnclosedText("My dog has fleas my dog has three
fleas.","dog","fleas",2,false);

the 'returned' string would be " has three ".
*/
function
getEnclosedText(content,starttext,endtext,instancenumber,startfromstarttext)
{
if ( (starttext.length + endtext.length) > content.length) { return
""; }
if ( instancenumber==0 ) { return ""; }

var locn = 0;
var startlocn = 0;
var endlocn = 0;
var cnt=0;

if (startfromstarttext == true)
{
for (cnt=0;cnt < instancenumber; cnt++)
{
startlocn = content.indexOf(starttext);
endlocn = content.indexOf(endtext);
if ((startlocn == -1 || endlocn == -1)) { return ""; }
if (startlocn > endlocn) { return ""; }
startlocn = startlocn + starttext.length;
if (cnt == (instancenumber-1)) { return
content.slice(startlocn,endlocn); }
content = content.slice(endlocn + endtext.length, content.length);
}
}
else
{
for (cnt=0;cnt < instancenumber; cnt++)
{
endlocn = content.indexOf(endtext);
startlocn = ((content.slice(0,endlocn)).lastIndexOf(starttext));
if ((endlocn == -1) || (startlocn == -1)) { return ""; }
startlocn = startlocn + (starttext.length)

if ( cnt == (instancenumber-1) ) {
return content.slice( startlocn , endlocn );
}
content = content.slice( (endlocn+(endtext.length)),
content.length );
}
}

return "";

} // getEnclosedText()