fullware.net

Link Media, which broadcasts documentaries, global news, world music, international cinema and more on its Link TV satellite channel in the U.S., is expanding its news video offerings with the launch of Link News.  Link has long been a provider of international news reporting. During the recent uprisings in Egypt, it provided extensive coverage thanks to feeds from Al Jazeera English and Mosaic, its Knight-sponsored, Peabody Award-winning daily news program on the Middle East and North Africa. But with the launch of Link News, the site’s powerful new search tools will bring an even greater variety of stories from all over the web, which will be available to users worldwide for free.

With support from Knight Foundation, Link Media developed semantic search technology for its news video platform. This technology, based on Link’s ViewChange.org, analyzes the transcripts and descriptions of the videos and produces multiple topic keywords. These topics are then used to find related videos and articles from all over the web. The search also pulls up different suggestions on how viewers can engage with the news story they just watched— for example, the names of related volunteer organizations or petitions that they can sign. Results are constantly updated in real time to include new, relevant content.

After developing ViewChange.org and the LinkTV Platform in Ruby on Rails and jQuery with Definition LLC, I was asked to participate in the final stages of Link News, the second site to use the platform. Working with Link and Definition to advance the semantic web and now to add even more functionality around it was a great opportunity.

Read the rest of the blog post at the Knight Foundation.

Today, the ViewChange.org team announced the release of Link TV Platform, the open source project that powers ViewChange.org and LinkTV News. A semantic video platform, the project combines the rich media experience of video with the data-centric concepts of the Semantic Web.

Link TV Platform has been released as a Rails Engine for the popular Ruby on Rails web application framework. Essentially an application within an application, this modular approach provides a robust foundation, while allowing for your own customizations and enhancements.

Contact fullware for the most efficient implementation of your site using the platform, by its main developer. Email linktv_platform at this site’s domain for more information.

Platform Features

• Flexible video support
  Import videos from MRSS feeds to Amazon S3, streaming support via Amazon CloudFront, YouTube content and HTML5 video playback
• Content analysis & curation
  Create distinct video segments (chapters), assign suggested topics from video transcript text analysis (via Zemanta API) and weight topic associations by relevance.
• Semantic Web features
  Linked Data URIs, contextual RDFa markup with owl:sameAs links to Freebase and DBpedia entities, RDF/XML endpoints.
• Related content discovery
  Aggregate related articles, videos and actions from around the web, leveraging APIs from Daylife, Zemanta, Truveo and Social Actions.
• Advanced search & API
  Fulltext search powered by Apache Solr and an available JSON/XML API.

I’m happy to have worked with Definition, LinkTV, Method, and SocialActions on this very successful project.

Read more here.

When in development, you may find yourself making changes to your migrations rather than adding new ones. This makes sense when you haven’t deployed versions of the database, and you’d prefer to limit the number of migrations.

Create a file “config/initializers/require_migrations.rb”

# Load in all the migrations for easy manual exection
def require_migrations
  Dir.glob(Rails.root + "db/migrate/*.rb").each{|s| require s}
end

Then, in the console, you can easily redo a single migration:

ruby> require_migrations
ruby> CreateUsers.down
ruby> CreateUsers.up
 

Question: I’m developing a gem alongside my Rails app. I’d like to be able to modify the code in the gem without having to restart my server, or the console. How can I extend Rails’ “unloadable” functionality to my gem?

When developing a library to be used in your Rails app, it’s helpful that the modules and classes are reloaded on each request (and/or with the “reload!” command in the console), just as with what you have defined in your app. I’ve done quote a bit of hunting around for this, but in the end with trial and error did a simple solution reveal itself.

Just use ActiveSupport::Dependencies to handle your (auto)loading:

lib/my_gem/my_gem.rb:

require 'active_support/dependencies'
ActiveSupport::Dependencies.autoload_paths += [File.expand_path("..", __FILE__)]

module MyGem
  include ActiveSupport::Dependencies
  unloadable
end

Be sure to add “unloadable” to all of your classes as well.

In the default development.rb, cache_classes is set to false. This is what allows code changes to be reflected in each new request without requiring a server-restart. By default, this will only apply to the classes with your app, not those from external libraries or gems.

Let’s say you are extending a controller from a Rails Engine from a gem to add an action:

app/controllers/application_controller.rb

require "#{Gem.loaded_specs['my_engine'].full_gem_path}/app/controllers/application_controller'

class ApplicationController
  def new_action
  end
end

my_engine/app/controllers/application_controller.rb

class ApplicationController < ActionController::Base
  def old_action
  end
end

On the first request, everything works fine, but at the end of the request the problem begins. Rails will unload ApplicationController because the constant :ApplicationController was marked as unloadable when your app's version was autoloaded. But, Rails also remembers that the engine's file was already required in. On the second request, your app's controller will be reloaded, but the require statement will be ignored. As a result, "old_action", won't exist, and in fact, now your ApplicationController will inherit from Object and not ActionController::Base.

The simple fix is to use require_or_load, defined in activesupport/lib/active_support/dependencies.rb.

require_or_load "#{Gem.loaded_specs['my_engine'].full_gem_path}/app/controllers/application_controller'

class ApplicationController
  def new_action
  end
end

More information on how Rails in development mode and autoloading is included in Required or Not? by Frederick Cheung.

If your design counts on transaction support, it might be a good idea to specify the fact early and succinctly.

First, you’ll need to turn off use_transactional_fixtures. This means that rspec won’t wrap each example in a DB transaction, which it would roll back at the end of the example to return to DB to pristine state. Instead, use Database Cleaner, as shown in the spec_helper.rb below. Database Cleaner’s docs will also who you how to change modes on a per-example basis, if necessary.

In spec_helper.rb:

  require 'database_cleaner'
  DatabaseCleaner.strategy = :truncation

  RSpec.configure do |config|
    ...
    config.use_transactional_fixtures = false
  end

  # Might want to move these into a separate file, i.e. spec/models/shared_examples.rb
  shared_examples_for "transaction table" do
    it "supports transactions" do
      begin
        described_class.transaction do
          object = described_class.new
          object.save validate: false
          object.id.should_not == nil
          described_class.count.should == 1
          raise
        end
      rescue
      end
      described_class.count.should == 0
    end
  end

In your ActiveRecord model specs, indicate that the table should allow transactions:

  describe MyModel do
    it_behaves_like "transaction table"
  end

Note that if you’re using MySQL, you won’t automatically get InnoDB tables in your generated migrations. Add an option to each create_table block like this:

  create_table :rec, :options => 'ENGINE=InnoDB' do |t|
     ...
  end

The Interactive Media Awards recognize the highest standards of excellence in website design and development and honor individuals and organizations for their outstanding achievement. The awards competition is open to individuals and organizations involved in designing, developing, managing, supporting and promoting websites.

Congratulations to LinkTV, Method, and Definition for the Outstanding Achievement Award for ViewChange.org in the nonprofit category.

Eloquent Ruby by Russ Olsen is a great new book, available in print and on the kindle. If you’re familiar with ruby but have always been curious about many things you’ve seen, or they why’s of the “ruby way”, I highly recommend it.

Ruby 1.9 provides a nice new way to initialize hashes. Those of us that love JSON and like to use symbols as keys can breath a sigh of relief:

  my_hash = {key_one: 'value1', key_two: 'value2'} # => {:key_one=>"value1", :key_two=>"value2"}