This Rails plugin makes including an swf object easier, no more writing javascript for that, just plain ruby.
To install this plugin:script/plugin install git://github.com/japetheape/swfobject_helper.gitMake sure swfobject.js is in your javascripts dir (download here:http://code.google.com/p/swfobject/)
Here's how you use it:
./script/plugin install git://github.com/psionides/jslint_on_rails.gitrake jslintVoila :) That's all you need to check your JS code. You will get a result like this (if everything goes well):
Running JSLint:
checking public/javascripts/Event.js... OK
checking public/javascripts/Map.js... OK
checking public/javascripts/Marker.js... OK
checking public/javascripts/Reports.js... OK
No JS errors found.
If you've messed up something, you will get such results instead:
Running JSLint:
checking public/javascripts/Event.js... 2 errors:
Lint at line 24 character 15: Use '===' to compare with 'null'.
if (a == null && b == null) {
Lint at line 72 character 6: Extra comma.
},
checking public/javascripts/Marker.js... 1 error:
Lint at line 275 character 27: Missing radix parameter.
var x = parseInt(mapX);
Found 3 errors.
rake aborted!
JSLint test failed.
http://psionides.jogger.pl/2009/11/23/check-your-scripts-with-jslint-on-rails/
require "RMagick"
def show_textimg
bg = Magick::Image.new(120,20){self.background_color = "#9E9E9E"}
text = Magick::Draw.new
text.encoding = "Unicode"
text.text(23,14,"ドの半角⇔全角")
text.draw(bg)
bg.write "#{RAILS_ROOT}/public/images/text.jpg"
endAmp is a general-purpose version-control system. It currently implements Mercurial, and we hope to support git, bazaar, svn, cvs, and darcs in the future. Why? Well, that leads us to the question: "Why Amp?"
Amp does not define a repository format, and most likely never will.
Amp exists because there's plenty of excellent repository formats out there, but none of them are truly good software. We chose Mercurial as our first VCS to implement because it comes closest to what we feel is a solid user experience, and that's what we're building upon.
Amp exists to make VCS work for you. Want to add your own commands? Write a few lines of code. Want to use git's commands on a Mercurial repository, switches and all? Amp is working on it. Our goal is to produce a piece of software that lets you forget that you're working on git project one moment and a Mercurial project the next.
AJAX improves user experience by moving more code to the browser. Frameworks accelerate development, but lead to opaque application behavior and new performance issues.
dynaTrace AJAX Edition aims to solve these issues:
Redmine is a flexible project management web application. Written using Ruby on Rails framework, it is cross-platform and cross-database.
Redmine is open source and released under the terms of the GNU General Public License v2 (GPL).
Overview
class State < ActiveRecord::Base
has_many :cities
end
class City < ActiveRecord::Base
has_many :streets
belongs_to :state
end
class Street < ActiveRecord::Base
has_many :houses
belongs_to :city
end
class House < ActiveRecord::Base
belongs_to :street
end
Well, you could do this:
virginia.cities.collect{|c| c.streets}.flatten.uniq.collect{|s| s.houses}.flatten.uniq
... but that's epically lame. It looks like shit and produces an metric ton of queries and as a result is highly inefficient. How about this:
House.find(
:all,
:include => {:street => {:city => :state}},
:conditions => {'states.id' => virginia.id}
)
This is a single query with joins where appropriate, and it's a finder on House which is what you're getting anyways. Makes sense, no?
But in the distributed revision control world we live in, it's never really that simple. Here are some other notes:
JSGI is a web server interface specification for JavaScript, inspired by Ruby’s Rack (http://rack.rubyforge.org/) and Python’s WSGI (http://www.wsgi.org/). It provides a common API for connecting JavaScript frameworks and applications to webservers.
Jack is a collection of JSGI compatible handlers (connect web servers to JavaScript web application/frameworks), middleware (intercept and manipulate requests to add functionality), and other utilities (to help build middleware, frameworks, and applications).
Narwhal is a cross-platform, multi-interpreter, general purpose JavaScript platform. It aims to provide a solid foundation for building JavaScript applications, primarily outside the web browser. Narwhal includes a package manager, module system, and standard library for multiple JavaScript interpreters. Currently Narwhal’s Rhino support is the most complete, but other engines are available too.
Narwhal’s standard library conforms to the ServerJS standard. It is designed to work with multiple JavaScript interpreters, and to be easy to add support for new interpreters. Wherever possible, it is implemented in pure JavaScript to maximize reuse of code among engines.
Combined with Jack, a Rack-like JSGI compatible library, Narwhal provides a platform for creating server-side JavaScript web applications and frameworks such as Nitro.
DbCharmer is a simple yet powerful plugin for ActiveRecord that does a few things:
switch_connection_to method) on_* methods family) Firebug now uses a component called http-activity-distributor that allows to register a listener and get notifications about various phases of each network request (DNS Lookup, connecting, sending, etc.). The most important thing is that one of the parameters passed to the listener is a time-stamp. This is something what was missing till now.
Having the time-stamp is critical since Javascript code (and Firebug is entirely implemented in Javascript) is executed on Firefox UI thread. In case when the UI is blocked by time expensive operation (e.g. DOM rendering, script execution, etc.) any event sent to a Javascript handler (and so, handled on the UI thread) can be delayed. So, getting the time-stamp withing JS handler can produce impaired time results.
Firebug Net panel now fixes this problem and the timing info is correct. See couple of examples I have analyzed when testing with a nice online tool called Cuzillion developed by Steve Souders.
Inline scripts block downloads and any resources (e.g. images) below an inline script don't get downloaded until the script finishes execution.
Let's imagine a page with following structure.
<html>
<head></head>
<body>
<img src="resource.cgi" />
<script> {an inline script running for 5 sec } </script>
<img src="resource.cgi" />
</body>
</html>
The first image resource.cgi starts downloading immediately after the page itself is downloaded. The second image resource.cgi starts downloading after 5 sec delay caused by the inline script. Try the example online.
The green area represents connecting time an the purple area represents waiting for response time. The blue line shows when DOMContentLoaded event was fired and the red line is associated with page load event.
Firefox limits the number of connections per server to 6. If the limit is reached other requests wait in an internal queue. This value can be changed by editing network.http.max-persistent-connections-per-server preference in about:config
See how the timeline looks like for a page that loads 8 images.
See the last two images. These are waiting in a queue (light brown area) till there is a free connection. The 7th image starts downloading as soon as the first image finishes and share the same connection (see, there is no green connection time). Similarly, the 8th image starts when the 2nd is completed. Try the example online.
http://www.softwareishard.com/blog/firebug/firebug-http-time-monitor/
In order to create a XHR breakpoint, the Net panel offers the same breakpoint bar that is already well known from the Script panel.
So, creating a new breakpoint for XHR request is as easy as clicking on the appropriate row with the request the user wants to debug.
As soon as the breakpoint is there and a request to the same URL is executed by the current page again, Firebug halt's Javascript execution at the source line where the request has been initiated.
You can see two things on this screenshot. First, there is no breakpoint in the source code so, you don't have to know the source code line in advance to start debugging and second, the breakpoint is listed in the Breakpoints side panel in a new section called XHR Breakpoints.
If you want to halt the Javascript execution only in specific cases you can specify a condition. Again, this is done in the same way as specifying condition for regular Javascript breakpoint - just right click on the breakpoint circle 
.
The condition editor allows to specify a Javascript expression that if evaluated to true activates the breakpoint. The condition is evaluated in a scope with some built-in variables that can be used in your expression.
Couple of examples:
Halt JS execution only if URL parameter count is present and equal to 1.URL: http://www.example.com?count=1
Expression: count == 1
Halt JS execution only if posted data contains string key.URL: http://www.example.com?count=1
Expression: $postBody.indexOf("key") >= 0
See online demo here.
http://www.softwareishard.com/blog/firebug/firebug-15-xhr-breakpoints/
The entire feature is represented by a new Break On button that is available in Firebug's main toolbar.
The logic of the button depends on the panel that is currently selected in Firebug. For instance, if the Script panel is selected and the feature activated (by clicking on the button that starts throbbing 
), the debugger halts as soon as the next line of Javascript is executed. So, this is the moment when you have to e.g. press a button in your web app and see what code is actually called.
Here is how the button works in other Firebug panels (the button is disabled for panels, which doesn't support this feature):
Prototype:var tip = {} else {return false}
init : function(e){
$(e).bind("mouseenter", this.createTip);
$(e).mouseleave(function(){$("#tip").remove()});
$(e).click(function(){$("#tip").remove()});
$(e).mousemove(function(e){$("#tip").css({left:e.pageX+30,
top:e.pageY-16})});
},
createTip : function(e) {
var obj=$(e.currentTarget),
title=$.trim(obj.attr("helper"));
if(title.length>0){
return $("#tip").length === 0 ?
$("<div>").html("<span>"+$.trim(obj.attr("helper"))+"</span>").
attr("id","tip").
css({left:e.pageX+30,
top:e.pageY-16,
position:'absolute',
border:'1px solid #FFE222',
background:'#FFFBC2',
color:'#514721',
padding:'5px 10px',
textTransform:'lowercase',
fontVariant:'small-caps',
zIndex:9000}).
appendTo("body") : null;}
};
var tip = {
title : '',
opacity: .8,
marginX: 30,
marginY: -46,
position : function(i,e){
return i.setStyle({left:e.clientX+this.marginX+'px',
top:e.clientY+this.marginY+'px'})
},
enter : function(i){
var tip=this;
$(i).observe(antHill.events.menter,function(e){
var div,obj=$(e.currentTarget);
tip.title=obj.readAttribute("title");
obj.writeAttribute("title",'');
if($("tip")===null){
div=new Element('div',{id:'tip'});
div.addClassName('tooltip').
setOpacity(tip.opacity).
innerHTML="<span>"+tip.title+"</span>";
tip.position(div,e);
$($$('body')[0]).insert({bottom:div});
}
Event.stop(e)}.bindAsEventListener($(i)));
},
leave : function(i){
$(i).observe(antHill.events.mleave,function(e){
$("tip").remove();
$(i).writeAttribute("title",tip.title);
Event.stop(e)}.bindAsEventListener($(i)));
},
move : function(i){
$(i).observe(antHill.events.mmove,function(e){
antHill.tip.position($("tip"),e);
Event.stop(e)}.bindAsEventListener($(i)));
},
init : function(i){
this.enter(i);
this.leave(i);
this.move(i);
},
createTip : function(c,i){c.select(i).
each(function(i){tip.init(i)})}
};
Today, some websites embed third-party code using iframes. This approach does not prevent a wide variety of attacks: redirection to phishing pages which could pretend to be a login page for the embedding application; stopping the browser from working until the user downloads malware; stealing history information about which sites a user has visited so that more target phishing attacks can be done; and port scanning the user's local network. Finally, even though a website can choose not to give data to an iframe app, once it has done so it can place no further restrictions on what the iframe app can do with it — it cannot stop the iframe app from sending that data elsewhere.
Caja addresses these problems which are not addressed by iframe jails; and it does so in a very flexible way. If a container wishes to allow an embedded application to use a particular web service, but not to send arbitrary network requests, then it can give the application an object that interacts with that web service, but deny access to XMLHttpRequest. Under Caja, passing objects grants authority, and denying access to objects denies authority, as is typical in an object-capability environment. Information leakage can be prevented by allowing user data to be encapsulated in objects that can be rendered in user-readable form but not read by scripts ; we can prevent leakage without solving the problem of covert channels.