metry 1.0.0

data/radiant/example/features/step_definitions/experiments.rb

@@ -0,0 +1,12 @@
+Then /^I should see the same "([^\"]*)" alternative (\d+) times$/ do |experiment, count|
+  events = Metry.current.last_events(count.to_i)
+  assert_equal count.to_i, events.size
+  seen = events.collect{|e| e["experiment.#{experiment}"]}.uniq
+  assert_equal 1, seen.size, "More than one seen in #{events.collect{|e| [e[:pk], e["visitor"], e["time"], e["experiment.#{experiment}"]]}.inspect}"
+end
+
+Then /^at least (\d+) should see alternative "([^\"]*)" of experiment "([^\"]*)"$/ do |count, alternative, experiment|
+  events = Metry.current.all_events
+  matching_count = events.select{|e| e["experiment.#{experiment}"] == alternative}.size
+  assert matching_count > count.to_i
+end

data/radiant/example/features/step_definitions/radiant.rb

@@ -0,0 +1,14 @@
+Given /^I have a layout$/ do
+  Layout.create!(:name => "basic", :content => <<EOC)
+<r:content />
+EOC
+end
+
+Given /^a page at "([^\"]*)" containing:$/ do |path, content|
+  page = Page.create!(:title => "test", :breadcrumb => "test", :slug => path, :status_id => 100)
+  page.parts.create!(:name => "body", :content => content)
+end
+
+When /^there is an empty Radiant cache$/ do
+  Radiant::Cache.clear
+end

data/radiant/example/features/step_definitions/tracking.rb

@@ -0,0 +1,35 @@
+Given /^an empty tracking database$/ do
+  Metry.current.clear
+end
+
+Then /^there should be (\d+) tracking events?$/ do |event_count|
+  assert_equal(event_count.to_i, Metry.current.event_count)
+end
+
+When /^there should be a tracking event "(\d+)":$/ do |id, table|
+  event = Metry.current[id]
+  assert event, "Unable to lookup event #{id}."
+  table.hashes.each do |hash|
+    expected = hash["value"]
+    case expected
+    when "_exists_"
+      assert event[hash["key"]], "Key #{hash["key"]} does not exist."
+    else
+      assert_equal expected, event[hash["key"]], "Key #{hash["key"]} does not match."
+    end
+  end
+end
+
+Then /^there should be a visitor "([^\"]*)":$/ do |id, table|
+  visitor = Metry.current.visitor(id)
+  assert visitor, "Unable to lookup visitor #{id}."
+  table.hashes.each do |hash|
+    expected = hash["value"]
+    case expected
+    when "_exists_"
+      assert visitor[hash["key"]], "Key #{hash["key"]} does not exist."
+    else
+      assert_equal expected, visitor[hash["key"]], "Key #{hash["key"]} does not match."
+    end
+  end
+end

data/radiant/example/features/step_definitions/web.rb

@@ -0,0 +1,22 @@
+Given /^I am a new visitor$/ do
+  clear_cookies
+end
+
+When /^I view "([^\"]*)"$/ do |path|
+  visit(path)
+end
+
+When /^(\d+) visitors view "([^\"]*)"$/ do |count, path|
+  count.to_i.times do
+    visit(path)
+    clear_cookies
+  end
+end
+
+When /^I view "([^\"]*)" (\d+) times$/ do |path, count|
+  count.to_i.times{visit(path)}
+end
+
+Then /^I should see "([^\"]*)"$/ do |content|
+  assert_contain(content)
+end

data/radiant/example/features/support/env.rb

@@ -0,0 +1,52 @@
+# Sets up the Rails environment for Cucumber
+ENV["RAILS_ENV"] ||= "cucumber"
+require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
+#require 'cucumber/rails/world'
+
+# Comment out the next line if you don't want transactions to
+# open/roll back around each scenario
+# Cucumber::Rails.use_transactional_fixtures
+
+# Comment out the next line if you want Rails' own error handling
+# (e.g. rescue_action_in_public / rescue_responses / rescue_from)
+# Cucumber::Rails.bypass_rescue
+
+require 'test/unit/assertions'
+World(Test::Unit::Assertions)
+
+require 'rack/test'
+World(Rack::Test::Methods)
+
+$: << RAILS_ROOT + '/../../vendor/webrat/lib'
+require 'webrat'
+
+Webrat.configure do |config|
+  config.mode = :rack_test
+end
+
+def app
+  ActionController::Dispatcher.new
+end
+
+World(Webrat::Methods)
+World(Webrat::Matchers)
+
+Before do
+  @__cucumber_ar_connection = ActiveRecord::Base.connection
+  if @__cucumber_ar_connection.respond_to?(:increment_open_transactions)
+    @__cucumber_ar_connection.increment_open_transactions
+  else
+    ActiveRecord::Base.__send__(:increment_open_transactions)
+  end
+  @__cucumber_ar_connection.begin_db_transaction
+  ActionMailer::Base.deliveries = [] if defined?(ActionMailer::Base)
+end
+
+After do
+  @__cucumber_ar_connection.rollback_db_transaction
+  if @__cucumber_ar_connection.respond_to?(:decrement_open_transactions)
+    @__cucumber_ar_connection.decrement_open_transactions
+  else
+    ActiveRecord::Base.__send__(:decrement_open_transactions)
+  end
+end

data/radiant/example/public/.htaccess

@@ -0,0 +1,40 @@
+# General Apache options
+AddHandler fastcgi-script .fcgi
+#AddHandler cgi-script .cgi
+Options +FollowSymLinks +ExecCGI
+
+# If you don't want Rails to look in certain directories,
+# use the following rewrite rules so that Apache won't rewrite certain requests
+# 
+# Example:
+#   RewriteCond %{REQUEST_URI} ^/notrails.*
+#   RewriteRule .* - [L]
+
+# Redirect all requests not available on the filesystem to Rails
+# By default the cgi dispatcher is used which is very slow
+# 
+# For better performance replace the dispatcher with the fastcgi one
+#
+# Example:
+#   RewriteRule ^(.*)$ dispatch.fcgi [QSA,L]
+RewriteEngine On
+
+# If your Rails application is accessed via an Alias directive,
+# then you MUST also set the RewriteBase in this htaccess file.
+#
+# Example:
+#   Alias /myrailsapp /path/to/myrailsapp/public
+#   RewriteBase /myrailsapp
+
+RewriteRule ^$ index.html [QSA]
+RewriteRule ^([^.]+)$ $1.html [QSA]
+RewriteCond %{REQUEST_FILENAME} !-f
+RewriteRule ^(.*)$ dispatch.fcgi [QSA,L]
+
+# In case Rails experiences terminal errors
+# Instead of displaying this message you can supply a file here which will be rendered instead
+# 
+# Example:
+#   ErrorDocument 500 /500.html
+
+ErrorDocument 500 "<h2>Application error</h2>Rails application failed to start properly"

data/radiant/example/public/404.html

@@ -0,0 +1,8 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<body>
+  <h1>File not found</h1>
+  <p>Change this error message for pages not found in public/404.html</p>
+</body>
+</html>

data/radiant/example/public/500.html

@@ -0,0 +1,8 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+   "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<body>
+  <h1>Application error</h1>
+  <p>Change this error message for exceptions thrown outside of an action (like in Dispatcher setups or broken Ruby code) in public/500.html</p>
+</body>
+</html>

data/radiant/example/public/dispatch.cgi

@@ -0,0 +1,10 @@
+#!/opt/local/bin/ruby
+
+require File.dirname(__FILE__) + "/../config/environment" unless defined?(RAILS_ROOT)
+
+# If you're using RubyGems and mod_ruby, this require should be changed to an absolute path one, like:
+# "/usr/local/lib/ruby/gems/1.8/gems/rails-0.8.0/lib/dispatcher" -- otherwise performance is severely impaired
+require "dispatcher"
+
+ADDITIONAL_LOAD_PATHS.reverse.each { |dir| $:.unshift(dir) if File.directory?(dir) } if defined?(Apache::RubyRun)
+Dispatcher.dispatch

data/radiant/example/public/dispatch.fcgi

@@ -0,0 +1,24 @@
+#!/opt/local/bin/ruby
+#
+# You may specify the path to the FastCGI crash log (a log of unhandled
+# exceptions which forced the FastCGI instance to exit, great for debugging)
+# and the number of requests to process before running garbage collection.
+#
+# By default, the FastCGI crash log is RAILS_ROOT/log/fastcgi.crash.log
+# and the GC period is nil (turned off).  A reasonable number of requests
+# could range from 10-100 depending on the memory footprint of your app.
+#
+# Example:
+#   # Default log path, normal GC behavior.
+#   RailsFCGIHandler.process!
+#
+#   # Default log path, 50 requests between GC.
+#   RailsFCGIHandler.process! nil, 50
+#
+#   # Custom log path, normal GC behavior.
+#   RailsFCGIHandler.process! '/var/log/myapp_fcgi_crash.log'
+#
+require File.dirname(__FILE__) + "/../config/environment"
+require 'fcgi_handler'
+
+RailsFCGIHandler.process!

data/radiant/example/public/dispatch.rb

@@ -0,0 +1,10 @@
+#!/opt/local/bin/ruby
+
+require File.dirname(__FILE__) + "/../config/environment" unless defined?(RAILS_ROOT)
+
+# If you're using RubyGems and mod_ruby, this require should be changed to an absolute path one, like:
+# "/usr/local/lib/ruby/gems/1.8/gems/rails-0.8.0/lib/dispatcher" -- otherwise performance is severely impaired
+require "dispatcher"
+
+ADDITIONAL_LOAD_PATHS.reverse.each { |dir| $:.unshift(dir) if File.directory?(dir) } if defined?(Apache::RubyRun)
+Dispatcher.dispatch

data/radiant/example/public/javascripts/admin/admin.js

@@ -0,0 +1,149 @@
+document.observe('dom:loaded', function() {
+  
+  when('table.index', function(table){
+    if(table.identify() == 'site-map')
+      new SiteMap(table);
+    else
+      new RuledTable(table);
+  });
+  
+  when('page_title', function(title) {
+    var slug = $('page_slug'),
+        breadcrumb = $('page_breadcrumb'),
+        oldTitle = title.value;
+
+    if (!slug || !breadcrumb) return;
+
+    new Form.Element.Observer(title, 0.15, function() {
+      if (oldTitle.toSlug() == slug.value) slug.value = title.value.toSlug();
+      if (oldTitle == breadcrumb.value) breadcrumb.value = title.value;
+      oldTitle = title.value;
+    });
+  });
+
+  when('tab-control', function(element) {
+    tabControl = new TabControl(element);
+
+    $$('#pages div.part > input[type=hidden]:first-child').each(function(part, index) {
+      var page = part.up('.page');
+      tabControl.addTab('tab-' + (index + 1), part.value, page.id);
+    });
+
+    tabControl.autoSelect();
+  });
+
+  when('tag-reference-popup', function(popup) {
+    var tags, searchingOn = "";
+
+    new Form.Element.Observer('search-tag-reference', 0.5, function(element, value) {
+      if (!tags) tags = popup.select('.tag-description')
+
+      if (value.length < 3 && searchingOn != "") {
+        searchingOn = "";
+        tags.invoke('show');
+      } else if (value.length >= 3 && searchingOn != value) {
+        searchingOn = value
+        tags.each(function(div) {
+          div[div.hasWord(value) ? 'show' : 'hide']();
+        });
+      }
+    });
+  });
+
+  when($$('.popup p a.close'), function(links){
+    links.invoke('observe', 'click', function(e) {
+      e.findElement('.popup').hide();
+      e.stop();
+    });
+  });
+  
+  when('publication-date', function(pub_date){
+    if($('page_status_id')) {
+      if($F('page_status_id') == '100')
+        $('publication-date').show().select('select').invoke('enable');
+
+      $('page_status_id').observe('change', function(){
+        if($F(this) == '100')
+          $('publication-date').show().select('select').invoke('enable');
+        else
+          $('publication-date').hide().select('select').invoke('disable');
+      })
+    }
+  });
+
+  when('notice', function(notice) {
+    new Effect.Fade(notice, {delay: 3});
+  });
+
+});
+
+Element.addMethods({
+  hasWord: function(element, word) {
+    element = $(element);
+    if (element.nodeType == Node.TEXT_NODE) {
+      return element.nodeValue.include(word);
+    } else {
+      return $A(element.childNodes).any(function(child) {
+        return Element.hasWord(child, word);
+      });
+    }
+  }
+})
+
+// When object is available, do function fn.
+function when(obj, fn) {
+  if (Object.isString(obj)) obj = /^[\w-]+$/.test(obj) ? $(obj) : $(document.body).down(obj);
+  if (Object.isArray(obj) && !obj.length) return;
+  if (obj) fn(obj);
+}
+
+function part_added() {
+  var partName = $F('part-name-field');
+  var tab = 'tab-' + partName.toSlug();
+  var page = 'page-' + partName.toSlug();
+  tabControl.addTab(tab, partName, page);
+  $('add-part-popup').hide();
+  $('busy').hide();
+  $('part-name-field').value = '';
+  $('add-part-button').enable();
+  $('page-part-index-field').value = parseInt($('page-part-index-field').value) + 1;
+  $(page).down('textarea').focus();
+  tabControl.select(tab);
+}
+function part_loading() {
+  $('add-part-button').disable();
+  $('busy').appear();
+}
+function valid_part_name() {
+  var partNameField = $('part-name-field');
+  var name = partNameField.value.downcase().strip();
+  var result = true;
+  if (name == '') {
+    alert('Part name cannot be empty.');
+    return false;
+  }
+  tabControl.tabs.each(function(pair){
+    if (tabControl.tabs.get(pair.key).caption == name) {
+      result = false;
+      alert('Part name must be unique.');
+      throw $break;
+    }
+  })
+  return result;
+}
+function center(element) {
+  var header = $('header')
+  element = $(element);
+  element.style.position = 'absolute';
+  var dim = Element.getDimensions(element);
+  var top = document.documentElement.scrollTop ? document.documentElement.scrollTop : document.body.scrollTop;
+  element.style.top = (top + 200) + 'px';
+  element.style.left = ((header.offsetWidth - dim.width) / 2) + 'px';
+}
+function toggle_add_part_popup() {
+  var popup = $('add-part-popup');
+  var partNameField = $('part-name-field');
+  center(popup);
+  Element.toggle(popup);
+  Field.focus(partNameField);
+}