We included a JavaScript file and set its src attribute to a file’s RAW URL on github. After about 400 requests within an hour, github started returning 403.
Public Service Announcement: local_assigns is a hash of local variables in a view. Useful when passing those variables on when rendering a partial; instead of enumerating the variables: render :partial 'foo', locals: { bar: bar, baz: baz}, pass the hash of locals: render :partial 'foo', locals: local_assigns
“What’s the canonical version of Firefox to use with Selenium”
Firefox 3.6 is recommended.
“I’m having trouble compiling Ruby 1.8.7 on Lion.”
Turns out there specifying the version of GCC to use fixed the problem.
CC=4.2 rvm install ruby-1.8.7
“What are the recommended jQuery plugins to do file uploading?”
There is a jQuery plugin by blueimp that is supposed to be customizable and backward-compatible for most browsers (even IE6!).
Also, Ajax Upload is supposed to be a reasonable alternative.
Ilya Zhitomirskiy’s memorial service will be held today. Everyone is welcome to come from 5pm to 8pm
McAvoy O’Hara
4545 Geary Blvd
San Francisco, CA 94118
Oh Javascript, you prankster.
typeof(NaN) => “number”
At Pivotal Labs, one of the services we provide our clients is helping them interview and hire. Pivotal Labs and our clients place a strong emphasis on Agile development and its many aspects: Pair Programming, Test-Driven Development, rapid iterations, and frequent refactoring.
Below is the description for a Ruby developer position for Post+Beam, who connect with audiences by listening to their needs, and influencers by understanding their vision. The result is innovation: new products, experiences and processes. Our expertise in communication gets the word out.
Post+Beam is hiring senior Ruby on Rails developers – here’s why you want to work there:
You will be building web applications and designing websites for clients across multiple industries that integrate with various platforms and third party APIs. This requires rock solid RoR development skills and the ability to work fluidly with a design team.
You will be working for an incubator of funded startups, backed by years of agency experience in PR, marketing, design, and development. This is a fast-paced position that focuses on mobile and web development in multiple industries. As such, your will role will have a heavy stake in product development.
You will be expected to participate in all phases of our software development life cycle to convert concepts and specifications into released web applications and websites. You will be the lead developer at our SF office and work collaboratively with our other offices and realize this is not a managerial position.
Our offices are in beautiful South Park in San Francisco. We are very interested in people looking to relocate to join our team.
We pay special attention to those that are looking to create the new, not just re-purpose the old. Special consideration will be given to those that show entrepreneurial spirit, are looking to mold the organization, and help create a better agile development environment.
Candidates should have solid communication skills: on one hand they should be able to “speak truth to power” but at the same time be able to listen to and understand strategic business, design and user needs.
Based on experience, talent and ability to innovate and communicate. Strong bonus tied to delivery of successful startups in the incubator.
“Adding a JS alert box (with
remote:true, confirm: 'Are you sure?'on alink_to) causes the cucumber feature to fail. It looks like, after we accept the alert withpage.page.driver.browser.switch_to.alert.accept, the browser runs much slower than the cucumber feature, so while everything technically works, the feature fails. We worked around this by delaying cucumber withpage.should have_no_content('content inside removed li')but it feels like a hack. Does anyone know what could be wrong with our setup, or is this to be expected?”
“The pattern we use when testing ajax calls in Jasmine feels unsatisfactory because
expect($.ajax).toHaveBeenCalledWith({ /* all params here */});requires all the parameters passed to the ajax call to be specified in the expectation. This includes parameters we don’t care about, such asbeforeSend(which is passed by Rails’remote: true). There must be a better way?”
hash_including, or building it if it doesn’t exist. Turns out, there’s a pull request from earlier this year with just this improvement.To get the html of an element (ie: a ‘ul’) including itself, append the element to a new element (ie: an empty div), then get the html of the new element. For example: $('<div>').append($('ul')).html(). The element’s parent could also be used if the element is an only child.
When appending an element which already exists in the DOM to another element, it will be moved from its present location in the DOM. This can be problematic when using the trick above to generate an element’s html, and is fixed by cloning the element.
If you see ‘Timezone Displacement out of range’ when doing a heroku db:push, it’s probably because you’re using Ruby 1.9.3 in development while Heroku runs 1.9.2. Don’t do that.
Jasmine gem test suites are now being run on Travis CI which is an open, distributed build system for the open source community.
Check out Travis CI.
As Pivots move to different machines frequently when we pair switch, its often a problem that we forget to switch the author when we commit to Git. Here’s how you can fix the author of a commit (before you’ve pushed to remote).
This changes the author of commit to whomever is configured in the git config, and uses the same message you previously used (the -C HEAD part).
TDDium is an easy-to-use, secure, hosted testing environment that takes the tedium out of building high quality Ruby web applications using Test Driven Development and Continuous Integration.
“Can anyone recommend a good Rails shopping cart?”
Spree was mentioned as reasonable suitable, but it does not support multiple merchants.
A Pivot was experiencing Modernizer at versions less than 2.0 throwing insecure content exceptions because of version detection code that it was using. Upgrading to version higher than 2.0 or removing Modernizer solved the problem.
There is a bug when using RPM contrib in New Relic while also using Resque that causes Resque workers to die. Definitely something to watch out for.
tl;dr Latest version of Cedar can nicely integrate with Xcode just like OCUnit.
When creating new Xcode project you might have noticed that New Project dialog has ‘Include Unit Tests’ checkbox at the bottom. When that option is selected in addition to creating an app target Xcode will also create a separate target that is used for testing your application. This target most likely will be named [app]Tests. Convenient, huh! Since Xcode is such a nice IDE[1] it will also create an example test file that uses Xcode’s built-in unit testing framework — OCUnit (also known as SenTestingKit). If you never heard of it below is a screenshot of how that example OCUnit test file looks.
Because Apple ships OCUnit with Xcode it is tightly integrated into the IDE and that gives it somewhat of an advantage over other testing frameworks. Example of such unfair treatment is relatively nice looking red error markers (shown above) that show up next to failed test cases when application tests are run. If you have ever used Cedar before you would know that when Cedar specs fail we do not get those markers but rather we are presented with boring gray console output (we have dots though!). Unfortunately there is no documented way for custom testing frameworks to mimic OCUnit behavior without building on top of it. But even if do decide to use OCUnit as a base for your custom testing framework you will run into several problems. One of those problems, at least a year ago, was that you could not reliably use debugger with OCUnit tests. That was one of the main reasons why Cedar was not build on top of it. Recently, however, Xcode 4 was released with a lot of enhancements including better support for running OCUnit tests (with or without debugger) or so it seems. Red markers being a driving force, once again it was worth to investigate on how take advantage of OCUnit goodies from Cedar. Latest version of Cedar succeeds at that. What follows are the steps on how to setup Cedar for maximum Xcode integration.
Check ‘Include Unit Tests’ checkbox in New Project dialog. If you want to add application tests to an existing project here is a very nice tutorial: http://twobitlabs.com/2011/06/adding-ocunit-to-an-existing-ios-project-with-xcode-4/
After Xcode is done creating a new project file go to Build Settings for application tests target (in this case ExampleTests) and find Other Linker Flags settings. Add -ObjC, -all_load, and -lstdc++ to that setting and click Done.
Next step is to add Cedar static library to application tests target.
Now you are ready to create a Cedar spec file. Create a new empty file and end the filename with ‘Spec.mm’. ‘mm’ file extension is needed to be able to use built-in Cedar matcher library. Also since this file should only be run as part of application tests and not the actual application make sure that you only include it in application tests target.
Add a test or two (see above for example) to be able to test that Cedar is working correctly. Example above tries to assert that 2+2 equals 5 and that should hopefully fail. Notice that here I’m using recently added Cedar matchers should syntax. If you do not like that you can always rewrite that expectation as expect(2+2).to(equal(5));
Larger image.
And finally to run specs you just wrote select scheme for your app (in this case Example) from the drop down in the upper left corner and press ‘Cmd+U’. ‘Cmd+U’ in Xcode by default runs tests associated with selected scheme. That should first build your app (because application tests target lists the app as a target dependency), then build application tests target and then run the tests. Since 2+2 does not equal 5 you will see that Xcode will highlight that line in red and show that as an error in the errors panel on the left side. Fixing that expectation should make the test pass.
If you want to run your application tests from the command line you can use rake ocunit:application to do that. Before doing so make sure you have updated APP_NAME and OCUNIT_APPLICATION_SPECS_TARGET_NAME in the Rakefile. Also you’ll need to use Debug for CONFIGURATION so that your tests are able to include classes from your application. What’s nice about this rake task is that it is ready to be used on your CI machine since it returns exit code 1 when any tests fail and 0 if they all succeed. It also prints in color.
If you are wondering how Cedar pretends to be OCUnit here is a short summary:
SenTestProbe class (related file to look at is CDROTestIPhoneRunner.m)SenTestProbe +runTests gets called by otest — an executable that Xcode uses to run tests after it injected the application tests bundle into TEST_HOST appSenTestProbe +runTests was overridden with Cedar’s run method Cedar executes all of its specs following all the usual rules: focused, pended, etc.CDROTestReporter (source) gets notified which tests passed, failed, got skipped, etc. and prints out appropriate information which you see in console logCDROTestReporter prints out failed tests in a way that is recognized by Xcode (OCUnit spits out same output for failed examples) e.g.:Test Case '-[ExampleTests testExample]' started. /Users/work/workspace/Example/ExampleTests/ExampleTests.m:16: error: -[ExampleTests testExample] : '4' should be equal to '5': 2+2 != 5 Test Case '-[ExampleTests testExample]' failed (0.000 seconds).
-SenTest option to run specific test case it will be ignored; however, you can use Cedar’s fit, fdescribe, and fcontext to focus on specific tests[1] It’s not.
Cedar comes with its own built-in matcher library and here is Adam Milligan’s blog post that explains on how to use it. An example of expectation written using Cedar matcher library:
expect(controller.button).to_not(be_nil());
Even though this is much better than OCHamcrest it is still not satisfying (in my opinion) because there are so many parentheses involved. Since Cedar matcher library is written in C++ we can do some magic here. The result is you can write your expectations like this:
controller.button should_not be_nil;
So let’s dig into how Cedar’s should syntax is implemented.
controller.button should_not be_nil
|-------------------|------------|--------|
actual value C macro matcher
As you might have guessed should and should_not are C macros. Besides making possible for each expectation to know its filename and line number (with __FILE__ and __LINE__ preprocessor variables), they also hide the unnecessary complexity which makes this syntax possible. Here is how it looks expanded:
controller.button ,(ActualValueMarker){__FILE__, __LINE__},true, be_nil
|-------------------|------------------------------------------------|--------|
actual value mumbo jumbo matcher
So how does this mumbo jumbo work? Since Cedar matcher library was written in C++ we can overload the comma operator. Besides being a weird operator to overload, it has a useful property that we can exploit here. Comma operator has the lowest precedence among all other operators and that allows us to write 2+2 should equal(4) instead of (2+2) should equal(4). Now let’s break mumbo jumbo into pieces:
(1) <actual value>
(ActualValueMarker){__FILE__, __LINE__} -> (2) ActualValue
true/false -> (3) ActualValueProxy
<matcher>
(1) This step captures actual value (can be anything since it is templated), filename and line number. It is implemented like this:
template<typename T>
const ActualValue<T> operator,(const T & actualValue, const ActualValueMarker & marker) {
return ActualValue<T>(marker.fileName, marker.lineNumber, actualValue);
}
(2) Now we overload comma operator to match ActualValue (returned from step 1) and a bool that indicates whether matcher result should be negated.
template<typename T>
const ActualValueMatchProxy<T> operator,(const ActualValue<T> & actualValue, bool negate) {
return negate ? actualValue.to_not : actualValue.to;
}
(3) And finally we overload comma operator again so that it matches ActualValueMatchProxy (returned from step 2) and anything else. Second argument will be considered to be a matcher.
template<typename T, typename MatcherType>
void operator,(const ActualValueMatchProxy<T> & matchProxy, const MatcherType & matcher) {
matchProxy(matcher);
}
That’s pretty much all. Full implementation of should syntax (which is just several more lines more than what is shown above) can be found in ShouldSyntax.h (and corresponding spec file that makes sure syntax works). Everything above allows us to write expectations as follows:
controller.button should_not be_nil();
Since the goal is to get rid of as many parentheses as possible we still have some work to do. Nil matcher that comes with Cedar is implemented with BeNil class. The way it worked before was be_nil was a function defined in Cedar::Matchers namespace. Calling it each time would return a new instance of BeNil class. To make parentheses go away be_nil was turned into a static variable that is initialized only once to an instance of BeNil class. (be_nil matcher still supports being used with two parentheses for backwards compatibility by implementing call operator on BeNil class.) Bam.
controller.button should_not be_nil;
Usually it is not recommended to use operator overloading for non-operator related purposes (e.g. don’t use + operator for subtraction); however, in this case I think it’s fine to bend the rules just a bit to escape all those parentheses and provide clean expectation DSL. You can use should syntax with the latest Cedar master branch.
Someone on Hacker News mentioned the number of orderings of a deck of cards. I took up the challenge in some of my favorite and not so favorite languages, I’ll let you guess :).
ruby-1.9.2-p180> (1..52).inject{|a,b|a*b}
=>
80658175170943878571660636856403766975289505440883277824000000000000
scala> BigInt(1).to(BigInt(52)).toList.foldLeft(BigInt(1))((a,b) => a*b)
res23: scala.math.BigInt =>
80658175170943878571660636856403766975289505440883277824000000000000
Prelude> foldl1 (x -> y -> x*y) [1..52]
80658175170943878571660636856403766975289505440883277824000000000000
coffee> [1..52].reduce (a,b) -> a*b
8.065817517094388e+67
Non-existent REPL>
import java.math.*;
public class Factorial {
public static void main(String[] args) {
BigInteger result = BigInteger.ONE;
BigInteger fiftyTwo = new BigInteger(”52″);
for(BigInteger i = BigInteger.ONE; i.compareTo(fiftyTwo) <= 0; i = i.add(BigInteger.ONE)) {
result = result.multiply(i);
}
System.out.println(result);
}
}$ java Factorial
80658175170943878571660636856403766975289505440883277824000000000000
** I could have used the product function in most of those examples, but I wanted to play with foldL ;)