This introductory course was intimate and collaborative. The attendees learned about the different aspects of the Social Web and how to apply them to their nonprofit organization. The Social Web is not a fad. Our goal for this course was to help our partners navigate through this intricate and forever changing space.

We will continue to partner with CNPE to offer courses that will dive further into specific types of Social Media.

http://www.bizjournals.com/louisville/calendar/

In an interview by Business First, Stuart Gavurin, CEO of Mission Data, spoke to our talent and our offerings.

Read the full Business First article.

Our work with KAR led to a request for Mission Data to present at their annual convention and expo. Todd Budnikas, Creative Director for Mission Data and Marvin Chartoff, VP of Managed Services gave a talk about Website Trends and Design Strategies. We were honored to have the opportunity to speak to realtors about strategies they can use to attract more business and influence their existing clients. Realtors are in a competitive space, the use of the web, social media and mobile devices is critical to conducting and attracting business.

while true; do kill -USR1 `pidof dd`; sleep 2; done

(NOTE: if `pidof dd` doesn’t work for you, just use the process id directly)

Switch back to the terminal where dd is running and you should see:

9902751744 bytes (9.9 GB) copied, 732.883 s, 13.5 MB/s
9469+0 records in
9468+0 records out
9927917568 bytes (9.9 GB) copied, 734.914 s, 13.5 MB/s
9496+0 records in
9495+0 records out
9956229120 bytes (10 GB) copied, 736.941 s, 13.5 MB/s

updating every couple of seconds.

This prestigious award recognizes employers that are successfully using workplace flexibility to meet both employer and employee goals. As a winner, Mission Data ranks in the top 20% — the 80th percentile — of employers nationally in terms of flexible work programs, policies and culture.

The Alfred P. Sloan Awards for Business Excellence in Workplace Flexibility are part of the When Work Works project, an ongoing initiative of Families and Work Institute, the Institute for a Competitive Workforce (an affiliate of the U.S. Chamber of Commerce), and the Twiga Foundation. Through When Work Works, these partner organizations provide research, resources, and recognition to employers nationwide. The project shares the results of research on creating effective and flexible workplaces that meet the needs of the 21st century.

We are honored to receive this award. Workplace flexibility is an integral part of our business practices.

Treetop appeared to gather all the concepts together into an understandable domain specific language. All of the tokenization and node structure can go into a single file, and the interactive nature of Ruby makes for the perfect sand box. I felt like I could get somewhere if I invested just an hour into this. I was happy to find that my impressions were correct.

After a short time I had caught on enough to start writing my own code. Once over the hump the rest was easy. I was able to write and test a Treetop grammar for parsing CSV files within a few hours. I chose CSV parsing because I was already familiar with the format, and I could compare my implementation to not just one but two existing Ruby libraries.

commaseparatedfile.treetop

grammar CommaSeparatedFile
  rule lines
    line (newline line)*
    {
      def values
        vals = []
        vals << line.values
        more.elements.each { |additional| vals << additional.line.values }
        vals
      end
    }
  end

  rule line
    valueline / emptyline
  end

  rule emptyline
    '' {
      def values
        []
      end
    }
  end

  rule valueline
    leading:(value separator)* trailing:value
    {
      def values
        list = []
        list += leading.elements.collect { |lead| lead.value.text_value } if leading
        list << trailing.text_value if trailing
        list
      end
    }
  end

  rule value
    quotedvalue / nakedvalue
  end

  rule quotedvalue
    '"' wrapped:( !'"' . / '""' )* '"' {
      def text_value
        wrapped.text_value.gsub(/""/,'"')
      end
    }
  end

  rule nakedvalue
    (!(separator / newline ) .)*
  end

  rule separator
    ','
  end

  rule newline
    [\n]
  end
end

One concept that became clear to me is that the tokens that are defined in the grammar are objects in the resulting tree returned after input is parsed. Ruby code embedded in the Treetop’s node definitions are added as methods to the object declared by that node.

In the simple harness below, the lines object returned from the parse call below is the object representation of the rule lines node above, defined as the root of the parse tree. The values method I call below is defined above in the definition of the lines node.

require 'rubygems'
require 'treetop'
require 'commaseparatedfile' 

parser = CommaSeparatedFileParser.new
lines = parser.parse("this,that,these,those")
puts lines.values.inspect #-> [["this", "that", "these", "those"]]

I think it was much simpler for me to write this parsing as a grammar instead of trying to combine regular expressions with Ruby code. The grammar above handles multiple lines and quote-wrapped values, and escaped quotes.

It was actually fun to write as well, and I’m still learning a lot. Notice that my lines node and my valueline node both approach a similar problem (a list of 0 or more items) differently. For the lines the grammar grabs one line followed by 0 or more separators followed by lines. For the valueline I grab 0 ore more values followed by separators and terminate on the last value. Is one approach better than the other? Are they both junk? I can’t wait to figure that out.

My poor parser is left in the dust by both Ruby’s stdlib csv library, and the fastercsv gem. I ran these tests under the 1.8.5 version of Ruby. The dataset I used is 44k in total and has 961 records.

                       user     system      total        real
stdlib_csv:        0.210000   0.000000   0.210000 (  0.217275)
faster_csv:        0.040000   0.000000   0.040000 (  0.060788)
treetop_grammar:   2.910000   0.010000   2.920000 (  3.126020)

I don’t know what sort of speed I should reasonably expect, actually. I’d hoped that my compiler would be competitive with the standard library’s csv parsing. It’s possible that my grammar’s definition could be innefficient. If anyone has any ideas let me know.

After playing around with Treetop I’ll definitely tinker some more. There are many other features I haven’t explored yet, like extending a base grammar to create a new grammar. PEGs have implementations in other languages so this isn’t a Ruby-only facility, either.

On a side note, I used stdlib’s benchmark to generate the numbers above. Pretty swank stuff.

require 'rubygems'
require 'treetop'
require 'commaseparatedfile'
require 'fastercsv'
require 'csv'
require 'benchmark'

def with_stdlib_csv(csv)
  parsed = CSV.parse(csv)
  parsed.size
end

def with_fastercsv(csv)
  rows = FasterCSV.parse(csv)
  rows.size
end

def with_treetop_parser(csv)
  parser = CommaSeparatedFileParser.new
  parsed = parser.parse(csv)
  parsed.values.size
end

csv = File.read('../kentucky.csv')

Benchmark.bmbm("treetop_parser:".length) do |x|
  x.report("stdlib_csv:") { with_stdlib_csv(csv) }
  x.report("faster_csv:") { with_fastercsv(csv) }
  x.report("treetop_grammar:") { with_treetop_parser(csv) }
end

cap --set-before branch=testbranch  deploy

…where ‘testbranch’ is the name of my subversion branch, and ‘deploy’ is the action to take. The ‘–set-before option’ sets a variable before the recipes are loaded (sort of). All you need to do to make this work you just need to set the repository URL correctly based on if the branch variable exists or not. In my case, that is editing the top of deploy.rb in the config section of my rails app:

if variables.include?(:branch)
  set :repository,  "http://svn.example.com/project/branches/#{branch}"
else
  set :repository,  "http://svn.example.com/project/trunk"
end

Handling session timeouts on non-Ajax requests

The first step to handing session timeouts with AJAX is to handle them for non-Ajax requests first. One way of doing this is trapping the URL the user is attempting to access (but not authenticated to), redirecting them to a login page, and upon success, redirecting them back to their original request.

If they aren’t authenticated, send them to the login page:

if(!loggedIn())
{
  response.sendRedirect("/login.jsp?uri=" + URLEncoder.encode(fullURI, "UTF8"));
}

Hide the original request in the page:

<form action="/account/login" method='POST'>
  <input type="hidden" name="uri" value="<%=request.getParameter("uri")%>">
  <label for="user_login">ID:</label>
  <input type="text" id="user_login" name="user_login" value=""/>
  <label for="user_password">Password:</label>
  <input type="password" id="user_password" name="user_password"/>
  <input type="submit" name="login" value=""/>
</form>

…and after a successful signup, send them back to where they wanted to go:

if(authenticated())
{
  response.sendRedirect(request.getParameter("uri"));
}

Handling Session Timeouts for Ajax Requests

The first thing we need to know is if it is an ajax request or not. Since I am going to use prototype for all my ajax calls it is as straight forward as looking for the special header prototype sends on each request:

private boolean isXMLHttpRequest(HttpServletRequest request)
{
  return request.getHeader("x-requested-with") != null && request.getHeader("x-requested-with").equals("XMLHttpRequest");
}

Once we know the request type, we will send a non-200 HTTP status code if their is an authentication error. From the standards, the most appropriate status code is a 401 (Unauthorized). This code, however, comes with some baggage. On a non-ajax HTTP request all browsers will respond by displaying an authentication dialog. Most browsers don’t do this on ajax calls. Most. Safari decided that it should pop up the authentication dialog on ajax requests. Without going too deeply into how this is probably correct and we should be using HTTP to its full advantage and using HTTP authentication instead of a custom authentication scheme, I don’t want this behavior. I landed on using the much less appropriate 403 (Forbidden).

So, if the user isn’t authenticated (such as with an expired session), send the 403 response back to the browser:

if(isXMLHttpRequest(request))
{
  response.sendError(403);
}

Now we handle the 403 on the browser side of things:

new Ajax.Request('/search',
     {asynchronous:true,
       evalScripts:true,
       onException: function(req,exception) {
         alert('An exception "' + exception + '" was thrown accessing "' + request.url + '"' )
         return true
       },
       on403: function(t) {
         alert('Your session appears to have expired.  You will asked to log in again and returned here.')
         window.location.reload()
         return true
       },
       onFailure: function(request) {
         alert('An unhandled error occured ' + t.status + ': ' + t.statusText);
         return true
       },
       onLoading:function(request){Element.show('loading')},
       onComplete:function(request){Element.hide('loading')},
       onSuccess: function(t) {
         //do something with the results
       },
       parameters:Form.serialize(this)
     })

The interesting bit of this call is the on403 method. Prototype will call onXXX() where XXX is a non-200 HTTP response code. When a 403 is returned, I simply reload the current page. Since we handled the scenario of authenticating and returning to the requested page for the non-Ajax call, this ‘just works’. You may wish to do something else here, including some nifty ajax widget that authenticates in-line and makes the call again.

Now that we have an Ajax request that suits our needs, we will want to use it throughout our project. Instead of repeating the same code over and over again, let’s DRY it up.

Creating a Wrapper Class

Since I am going to use this scheme for Ajax.Request and Ajax.Updater I created two wrapper classes that use a common function for setting the options. This scheme allows you to override any of the default options I use in the wrapper:

Ajax.MyRequest = Class.create(Ajax.Request, {
  initialize: function($super, url, options) {
    $super(url,_options(options));
  }
})

Ajax.MyUpdater = Class.create(Ajax.Updater, {
  initialize: function($super, container, url, options) {
    $super({success:container},url,_options(options));
  }
})

function _options(options) {
  return Object.extend({
     asynchronous:true,
     evalScripts:true,
     onException: function(request,exception) {
       Element.hide('loading')
       alert('An exception "' + exception + '" was thrown accessing "' + request.url + '"' )
       return true
     },
     on403: function(t) {
       Element.hide('loading')
       alert('Your session appears to have expired.  You will asked to log in again and returned here.')
       window.location.reload()
       return true
     },
     onFailure: function(t) {
       Element.hide('loading')
       alert('An unhandled error occured ' + t.status + ': ' + t.statusText);
     },
     onLoading:function(request){Element.show('loading')},
     onComplete:function(request){window.setTimeout('Element.hide("loading");', 100);}
  }, options || {});
}

C lib/jt400_3_3.jar
cvs update: move away lib/jt400_3_3.jar; it is in the way

Very peculiar. That file hadn’t changed on the branch. I googled around and an explanation started to come together.

First, from the always excellent Roedy Green’s Java & Internet Glossary on Mindprod:

CVS is disturbed by the appearance of repository files it did not put there. Your best bet is simply to delete the entire directory containing the offending file by hand, and re checkout or reupdate the directory to build the necessary entries. Then you can add the files safely.

Then, I found this mailing list post:

This means the file that CVS wants to checkout exists on the local machine but CVS never created the file in the past. This it isn’t CVS’s file and it complains rather than blindly overwriting.

The solution everywhere was the same: just blow away the directory and check it out again. Worked for me. Now I need to puzzle out how it happened in the first place…

Here is a simple example:

We’ll start with a table named libris_book that contains book entries. The name libris_book won’t really fly with the Rails pluralized table name approach. It’s easy, however, to fix that disconnect in the model:

class Book < ActiveRecord::Base
  set_table_name 'libris_book'
end

Let’s take a look at our data:

~/src/libris$ script/console
Loading development environment.
>> Book.count
=> 1230

Good enough. Now, we’ll be good little coders and write some unit tests using fixtures. We’ll create a fixture file and our test class:

books.yml

test_book:
  title: Life in Lawrenceburg
  author: Darren Day

book_test.rb

require File.dirname(__FILE__) + '/../test_helper'

class BookTest < Test::Unit::TestCase
  fixtures :books

  def test_fixtures
    assert_equal(2,Book.count)
    test_book = books(:test_book)
  end
end

Looks good, but it won’t work!

~/src/libris$ rake test
(in /home/darrend/src/libris)
/usr/local/bin/ruby -Ilib:test "/usr/local/lib/ruby/gems/1.8/gems/rake-0.7.2/lib/rake/rake_test_loader.rb" "test/unit/book_test.rb"
Loaded suite /usr/local/lib/ruby/gems/1.8/gems/rake-0.7.2/lib/rake/rake_test_loader
Started
E
Finished in 0.01133 seconds.

  1) Error:
test_fixtures(BookTest):
ActiveRecord::StatementInvalid: Mysql::Error: Table 'libris_test.books' doesn't exist: DELETE FROM books
...

Ugh. That doesn’t look pretty. After some googling around the following comes together

• Rename books.yml to libris_book.yml. The fixture yaml file has to share the same name as the database table name.
• Change the fixtures declaration to fixtures :libris_book.
• Use set_fixture_class to connect the fixture to the model class.

Here is our new and improved book_test.rb file:

require File.dirname(__FILE__) + '/../test_helper'

class BookTest < Test::Unit::TestCase
  set_fixture_class :libris_book => Book
  fixtures :libris_book

  def test_fixtures
    assert_equal(2,Book.count)
    test_book = libris_book(:test_book)
  end
end