stratify-base 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+.bundle
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.2-p180@stratify

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in stratify-base.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,52 @@
+PATH
+  remote: .
+  specs:
+    stratify-base (0.1.0)
+      bson_ext (~> 1.3.1)
+      mongoid (~> 2.0.2)
+      tilt (~> 1.3.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.1.0.rc1)
+      activesupport (= 3.1.0.rc1)
+      bcrypt-ruby (~> 2.1.4)
+      builder (~> 3.0.0)
+      i18n (~> 0.6.0beta1)
+    activesupport (3.1.0.rc1)
+      multi_json (~> 1.0)
+    bcrypt-ruby (2.1.4)
+    bson (1.3.1)
+    bson_ext (1.3.1)
+    builder (3.0.0)
+    database_cleaner (0.6.7)
+    diff-lcs (1.1.2)
+    i18n (0.6.0)
+    mocha (0.9.12)
+    mongo (1.3.1)
+      bson (>= 1.3.1)
+    mongoid (2.0.2)
+      activemodel (~> 3.0)
+      mongo (~> 1.3)
+      tzinfo (~> 0.3.22)
+    multi_json (1.0.3)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.3)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    tilt (1.3.2)
+    tzinfo (0.3.27)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  database_cleaner (~> 0.6.7)
+  mocha (~> 0.9.12)
+  rspec (~> 2.6.0)
+  stratify-base!

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jason Rudolph (http://jasonrudolph.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,21 @@
+# stratify-base
+
+## Dependencies
+
+Stratify is developed and tested with the following dependencies.
+
+* Ruby 1.9.2 (See `.rvmrc` for the specific version.)
+* MongoDB 1.8
+
+## Development
+
+To get set up for development on stratify-base, clone the repo, and ...
+
+    cd stratify/stratify-base
+    gem install bundler
+    bundle
+    rake
+
+## License
+
+Copyright 2011 Jason Rudolph ([jasonrudolph.com](http://jasonrudolph.com)). Released under the MIT license. See the LICENSE file for further details.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/lib/stratify/activity.rb

@@ -0,0 +1,33 @@
+require 'mongoid'
+require 'stratify/mongoid_extension'
+require 'stratify/renderable'
+
+module Stratify
+  class Activity
+    include Mongoid::Document
+    include Mongoid::Paranoia
+    include MongoidExtension::NaturalKey
+    include Renderable
+
+    store_in :activities
+    
+    field :source, :type => String
+    field :created_at, :type => DateTime
+
+    validates_presence_of :created_at
+
+    def permalink
+      nil
+    end
+
+    def created_on
+      return nil unless created_at
+      created_at.to_date
+    end
+
+    def duplicate?
+      duplicate_activities = self.class.where(natural_key_hash)
+      duplicate_activities.exists? || duplicate_activities.deleted.exists?
+    end
+  end
+end

data/lib/stratify/archiver.rb

@@ -0,0 +1,45 @@
+require 'stratify/logger'
+
+module Stratify
+  class Archiver
+    attr_reader :collector
+  
+    def initialize(collector)
+      @collector = collector
+    end
+
+    def run
+      collect_activities
+    ensure
+      record_collection_statistics
+    end
+
+    protected
+
+    def collect_activities
+      collector.activities.each do |activity|
+        document_activity_source(activity)
+        persist_activity(activity)
+      end
+    end
+
+    def document_activity_source(activity)
+      activity.source = collector.source
+    end
+
+    def persist_activity(activity)
+      # Since we run the collectors frequently, it is very common to encounter 
+      # objects that we have already imported.  If this activity is a duplicate
+      # of an existing object, then we skip importing this activity.
+      return if activity.duplicate? 
+
+      unless activity.save
+        Stratify.logger.error("Failed to persist activity: #{activity}.\nValidation errors: #{activity.errors}")
+      end
+    end
+  
+    def record_collection_statistics
+      collector.update_attribute :last_ran_at, Time.now
+    end
+  end
+end

data/lib/stratify/collector.rb

@@ -0,0 +1,100 @@
+require 'mongoid'
+require 'stratify/archiver'
+require 'stratify/field_definition'
+
+module Stratify
+  class Collector
+    include Mongoid::Document
+
+    store_in :collectors
+  
+    field :last_ran_at, :type => DateTime
+
+    def self.configuration_fields(fields_hash = nil)
+      @configuration_fields = initialize_configuration_fields(fields_hash) unless fields_hash.nil?
+      @configuration_fields || []
+    end
+
+    def configuration_fields
+      self.class.configuration_fields
+    end
+
+    def self.configuration_instructions(instructions = nil)
+      @configuration_instructions = instructions unless instructions.nil?
+      @configuration_instructions
+    end
+
+    def configuration_instructions
+      self.class.configuration_instructions
+    end
+
+    def configuration_summary
+      return nil if configuration_fields.empty?
+      read_attribute(configuration_fields.first.name)
+    end
+  
+    def run
+      Archiver.new(self).run
+    end
+
+    # To be implemented by subclasses
+    #
+    # Returns a collection of activities to be saved.
+    def activities
+      raise NotImplementedError
+    end
+
+    # Define where this collector's activities originate from (e.g., "Twitter", "iTunes")
+    def self.source(src = nil)
+      @source = src unless src.nil?
+      @source
+    end
+
+    def source
+      self.class.source
+    end
+
+    def self.sources
+      unsorted_sources = Collector.collector_classes.map(&:source)
+      unsorted_sources.sort_by {|source| source.downcase}
+    end
+
+    class << self
+      attr_reader :collector_classes
+    end
+  
+    @collector_classes = []
+  
+    def self.inherited(subclass)
+      super
+      Collector.collector_classes << subclass
+    end
+  
+    def self.collector_class_for(source)
+      Collector.collector_classes.find {|clazz| clazz.source == source}
+    end
+
+    private
+
+    def self.initialize_configuration_fields(fields_hash)
+      field_definitions = objectify_fields(fields_hash)
+      apply_fields_to_class(field_definitions)
+      field_definitions
+    end
+
+    def self.objectify_fields(fields_hash)
+      fields_hash.map do |f|
+        name = f[0]
+        attributes = f[1]
+        Stratify::FieldDefinition.new(name, attributes) 
+      end
+    end
+  
+    def self.apply_fields_to_class(field_definitions)
+      field_definitions.each do |field|
+        field field.name
+        validates_presence_of field.name
+      end
+    end
+  end
+end

data/lib/stratify/collector_coordinator.rb

@@ -0,0 +1,13 @@
+module Stratify
+  class CollectorCoordinator
+    def self.run_all
+      Stratify::Collector.all.each do |collector|
+        begin
+          collector.run
+        rescue => e
+          Stratify.logger.error("Error running collector.  Collector => #{collector}.  Error => #{e}")
+        end
+      end
+    end
+  end
+end

data/lib/stratify/field_definition.rb

@@ -0,0 +1,15 @@
+module Stratify
+  class FieldDefinition
+    attr_reader :name, :type, :label
+
+    def initialize(name, attribute_hash)
+      @name = name
+      @type = attribute_hash[:type]
+      @label = attribute_hash[:label]
+    end
+
+    def label
+      @label || @name.to_s.titleize
+    end
+  end
+end

data/lib/stratify/logger.rb

@@ -0,0 +1,14 @@
+module Stratify
+  class << self
+    def logger
+      @logger ||= initialize_logger
+    end
+
+    private
+    
+    def initialize_logger
+      return Rails.logger if defined?(Rails)
+      Logger.new(STDOUT)
+    end    
+  end
+end

data/lib/stratify/mongoid_extension.rb

@@ -0,0 +1,38 @@
+module Stratify
+  module MongoidExtension
+    module NaturalKey
+      module ClassMethods
+        attr_reader :natural_key_fields
+
+        def natural_key(*fields)
+          @natural_key_fields = fields.dup
+          validates_uniqueness_of_natural_key
+        end
+        
+        def validates_uniqueness_of_natural_key
+          first, *rest = *natural_key_fields
+          if rest.empty?
+            validates_uniqueness_of first
+          else
+            validates_uniqueness_of first, :scope => rest
+          end
+        end
+      end
+
+      module InstanceMethods
+        def natural_key_hash
+          {}.tap do |hash|
+            self.class.natural_key_fields.each do |field|
+              hash[field] = self.send(field)
+            end
+          end
+        end
+      end
+
+      def self.included(receiver)
+        receiver.extend ClassMethods
+        receiver.send :include, InstanceMethods
+      end
+    end
+  end
+end

data/lib/stratify/renderable.rb

@@ -0,0 +1,41 @@
+require "tilt"
+
+module Stratify
+  module Renderable
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def template(data = nil)
+        @template = data unless data.nil?
+        @template
+      end
+
+      def template_format(format = nil)
+        @template_format = format unless format.nil?
+        @template_format || default_template_format
+      end
+
+      def default_template_format
+        :erb
+      end
+    end
+    
+    def to_html
+      template_handler = Tilt[self.class.template_format].new { self.class.template.strip }
+      template_handler.render(presenter)
+    end
+
+    # Returns the object that will be passed to the template for rendering.
+    # 
+    # The default implementation returns 'self' (i.e., the renderable object).
+    #
+    # Subclasses may optionally override this method to provide an object 
+    # better suited for use in rendering (e.g., an object implementing the
+    # presenter pattern).
+    def presenter
+      self
+    end
+  end
+end

data/lib/stratify/version.rb

@@ -0,0 +1,5 @@
+module Stratify
+  module Base
+    VERSION = "0.1.0"
+  end
+end

data/lib/stratify-base.rb

@@ -0,0 +1,4 @@
+require 'stratify/activity'
+require 'stratify/collector'
+require 'stratify/collector_coordinator'
+require 'stratify/version'

data/spec/mongoid.yml

@@ -0,0 +1,3 @@
+persist_in_safe_mode: true
+host: localhost
+database: stratify_base_test

data/spec/prototypes/bacon.rb

@@ -0,0 +1,46 @@
+# This file defines an example Stratify collector and activity for testing
+# purposes.  
+# 
+# Stratify::Bacon::Activity and Stratify::Bacon::Collector represent a 
+# (fictitious, unfortunately) service for tracking your bacon-related 
+# achievements. This also happens to be an *amazing* idea for a service. 
+# You know you want to track your bacon-related achievements. You just know it.
+
+# Stratify::Bacon::Activity implements all *mandatory* functionality required 
+# for it to be a valid activity.
+module Stratify
+  module Bacon
+    class Activity < Stratify::Activity
+      field :slices, :type => Integer
+
+      natural_key :created_at
+
+      template "Enjoyed <%= slices %> slices of delicious bacon"
+    end
+  end
+end
+
+# Stratify::Bacon::Collector implements all *mandatory* functionality required 
+# for it to be a valid collector.
+module Stratify
+  module Bacon
+    class Collector < Stratify::Collector
+      source "Baconation"
+
+      configuration_fields :username => {:type => :string},
+                           :password => {:type => :password}
+
+      # Return a fixed set of Stratify::Bacon::Activity objects.  (A real 
+      # collector would tend to return new data as time goes by.  For testing 
+      # purposes, it's convenient to have a fixed set of data returned by the 
+      # collector.)
+      def activities
+        [
+          Stratify::Bacon::Activity.new(:slices => 3, :created_at => Time.new(2011, 4, 3, 7, 2)),
+          Stratify::Bacon::Activity.new(:slices => 5, :created_at => Time.new(2011, 4, 7, 8, 17)),
+          Stratify::Bacon::Activity.new(:slices => 4, :created_at => Time.new(2011, 4, 9, 6, 24)),
+        ]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'stratify-base'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+require 'database_cleaner'
+
+require 'prototypes/bacon'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter = :progress
+  config.mock_with :mocha
+
+  # Configure RSpec to run focused specs, and also respect the alias 'fit' for focused specs
+  config.filter_run :focused => true
+  config.run_all_when_everything_filtered = true
+  config.alias_example_to :fit, :focused => true
+
+  # Configure RSpec to truncate the database before any spec tagged with ":database => true"
+  DatabaseCleaner.strategy = :truncation
+  DatabaseCleaner.orm = "mongoid"
+  config.before(:each, :database => true) do
+    DatabaseCleaner.clean
+  end    
+
+  config.before(:suite) do
+    silence_mongoid_logging
+    initialize_mongoid_configuration
+  end
+end
+
+def silence_mongoid_logging
+  Mongoid.logger = Logger.new("/dev/null")
+end
+
+def silence_stratify_logging
+  Stratify.stubs(:logger).returns(Logger.new("/dev/null")) # Silence the logger so as not to clutter the test output
+end
+
+def initialize_mongoid_configuration
+  mongoid_config = YAML::load_file(File.join(File.dirname(__FILE__), "mongoid.yml"))
+  Mongoid.from_hash(mongoid_config)
+end

data/spec/stratify/activity_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Stratify::Activity do
+
+  describe "#created_on" do
+    it "returns the date portion of the created_at value" do
+      activity = Stratify::Activity.new(:created_at => DateTime.parse("2010-11-27 6:35 PM"))
+      activity.created_on.should == Date.parse("2010-11-27")
+    end
+
+    it "returns nil if the created_at value is nil" do
+      activity = Stratify::Activity.new(:created_at => nil)
+      activity.created_on.should be_nil
+    end
+  end
+  
+  describe "#delete", :database => true do
+    it "soft-deletes the activity" do
+      creation_time = Time.now
+      activity = Stratify::Bacon::Activity.create!(:slices => 42, :created_at => creation_time)
+      activity.delete
+      
+      Stratify::Bacon::Activity.where(:slices => 42, :created_at => creation_time).should_not exist
+      Stratify::Bacon::Activity.deleted.where(:slices => 42, :created_at => creation_time).should exist
+    end
+  end
+  
+  describe "#duplicate?", :database => true do
+    class ActivityForTestingDuplicates < Stratify::Activity
+      field :foo
+      field :bar
+      
+      natural_key :foo, :bar
+    end
+
+    it "returns false if no record exists with the same natural key" do
+      ActivityForTestingDuplicates.create!(:foo => "a", :bar => "b", :created_at => Time.now)
+      ActivityForTestingDuplicates.new(:foo => "1", :bar => "2").should_not be_duplicate
+    end
+
+    it "returns true if a saved record already exists with the same natural key" do
+      ActivityForTestingDuplicates.create!(:foo => "a", :bar => "b", :created_at => Time.now)
+      ActivityForTestingDuplicates.new(:foo => "a", :bar => "b").should be_duplicate
+    end
+
+    it "returns true if a soft-deleted record already exists with the same natural key" do
+      original = ActivityForTestingDuplicates.new(:foo => "a", :bar => "b", :created_at => Time.now)
+      original.save!
+      original.delete
+      
+      ActivityForTestingDuplicates.new(:foo => "a", :bar => "b").should be_duplicate
+    end
+  end
+
+end

data/spec/stratify/archiver_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Stratify::Archiver do
+
+  describe ".run" do
+    context "when the collection succeeds" do
+      it "updates the last_ran_at timestamp for the collector" do
+        stub_current_timestamp = Time.parse "2011-04-30 14:11:02"
+        Time.stubs(:now).returns stub_current_timestamp
+
+        collector = Stratify::Collector.create
+        archiver = Stratify::Archiver.new(collector)
+        archiver.stubs(:collect_activities)
+        archiver.run
+        collector.last_ran_at.should == stub_current_timestamp
+      end
+    end
+
+    context "when an exception occurs during collection" do
+      it "propagates the exception to the caller" do
+        archiver = Stratify::Archiver.new(collector = stub)
+        archiver.stubs(:collect_activities).raises("some gnarly error") 
+        lambda { archiver.run }.should raise_error
+      end
+
+      it "updates the last_ran_at timestamp for the collector" do
+        stub_current_timestamp = Time.parse "2011-04-30 14:11:02"
+        Time.stubs(:now).returns stub_current_timestamp
+
+        collector = Stratify::Collector.create
+        archiver = Stratify::Archiver.new(collector)
+        archiver.stubs(:collect_activities).raises("some gnarly error") 
+        archiver.run rescue nil
+        collector.last_ran_at.should == stub_current_timestamp
+      end
+    end
+  end
+  
+  describe ".collect_activities" do
+    it "documents the source of each activity" do
+      example_collector_class = Class.new(Stratify::Collector)
+      example_collector_class.source("some-example-source")
+      collector = example_collector_class.new
+
+      activity = Stratify::Activity.new
+      collector.stubs(:activities).returns [activity]
+      
+      archiver = Stratify::Archiver.new(collector)
+      archiver.stubs(:persist_activity)
+      archiver.send(:collect_activities)
+      activity.source.should == "some-example-source"
+    end
+    
+    it "persists each activity" do
+      collector = Stratify::Collector.new
+      activity = Stratify::Activity.new
+      collector.stubs(:activities).returns [activity]
+      
+      archiver = Stratify::Archiver.new(collector)
+      archiver.expects(:persist_activity).with(activity)
+      archiver.send(:collect_activities)
+    end
+  end
+
+  describe "persisting activities" do
+    it "logs when an error is encountered attempting to persist an activity" do
+      activity = stub('activity', :duplicate? => false, :save => false, :errors => {})
+
+      archiver = Stratify::Archiver.new(collector = stub)
+
+      Stratify.logger.expects(:error).with() { |value| value.starts_with? "Failed to persist activity" }
+      archiver.send(:persist_activity, activity)
+    end
+
+    it "does not log an error when activity is persisted successfully" do
+      activity = stub('activity', :duplicate? => false, :save => true)
+
+      archiver = Stratify::Archiver.new(collector = stub)
+
+      Stratify.logger.expects(:error).never
+      archiver.send(:persist_activity, activity)
+    end
+  end
+
+end

data/spec/stratify/collector_coordinator_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Stratify::CollectorCoordinator do
+
+  describe ".run_all" do
+    it "runs all collectors" do
+      collector_1 = mock(:run)
+      collector_2 = mock(:run)
+      
+      Stratify::Collector.stubs(:all).returns([collector_1, collector_2])
+
+      Stratify::CollectorCoordinator.run_all
+    end
+    
+    context "when an exception occurs in a collector" do
+      it "logs the exception" do
+        collector = stub
+        collector.stubs(:run).raises("some gnarly error") 
+        Stratify::Collector.stubs(:all).returns([collector])
+        
+        Stratify.logger.expects(:error).with() { |value| value.include? "some gnarly error" }
+        Stratify::CollectorCoordinator.run_all
+      end
+      
+      it "runs the remaining collectors" do
+        silence_stratify_logging # Silence the logger so as not to clutter the test output
+
+        troublesome_collector = stub
+        troublesome_collector.stubs(:run).raises("some gnarly error") 
+        
+        other_collector = mock
+        other_collector.expects(:run).returns(nil)
+
+        Stratify::Collector.stubs(:all).returns([troublesome_collector, other_collector])
+
+        Stratify::CollectorCoordinator.run_all
+      end
+    end
+  end
+
+end

data/spec/stratify/collector_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+class TestCollector < Stratify::Collector
+  configuration_fields :username => {:type => :string},
+                       :password => {:type => :password}
+end
+
+def anonymous_collector_subclass
+  Class.new(Stratify::Collector)
+end
+
+describe Stratify::Collector do
+
+  describe ".collector_class_for" do
+    it "returns the collector subclass associated with the given source" do
+      example_collector_subclass = anonymous_collector_subclass
+      example_collector_subclass.source("Twitter")
+      Stratify::Collector.collector_class_for("Twitter").should == example_collector_subclass
+    end
+
+    it "returns nil when no collector subclass exists for the given source" do
+      Stratify::Collector.collector_class_for("lol").should be_nil
+    end
+  end
+
+  describe ".sources" do
+    before { Stratify::Collector.collector_classes.clear }
+    
+    it "returns the list of sources for all collectors" do
+      anonymous_collector_subclass.source("FourSquare")
+      anonymous_collector_subclass.source("Twitter")
+      Stratify::Collector.sources.should =~ ["FourSquare", "Twitter"]
+    end
+    
+    it "returns the sources in case-insensitive alphabetical order" do
+      anonymous_collector_subclass.source("Twitter")
+      anonymous_collector_subclass.source("iTunes")
+      anonymous_collector_subclass.source("Instapaper")
+      anonymous_collector_subclass.source("Pandora")
+      Stratify::Collector.sources.should == %w(Instapaper iTunes Pandora Twitter)
+    end
+  end
+
+  describe ".configuration_fields" do
+    it "tracks the fields used to configure the collector" do
+      fields = TestCollector.configuration_fields
+      fields.find {|f| f.name == :username && f.type == :string}.should be
+      fields.find {|f| f.name == :password && f.type == :password}.should be
+    end
+    
+    it "registers the given fields with Mongoid" do
+      TestCollector.fields.should include("username", "password")
+    end
+    
+    describe "influences validation" do
+      it "adds an error when a collector instance fails to provide a value for each field" do
+        collector = TestCollector.new
+        collector.should_not be_valid
+        collector.errors[:username].should include("can't be blank")
+      end
+    
+      it "adds NO errors when a collector instance provides a value for each field" do
+        collector = TestCollector.new(:username => "foo")
+        collector.valid?
+        collector.errors[:username].should_not include("can't be blank")
+      end
+    end
+  end
+
+  describe ".configuration_instructions (class method)" do
+    it "returns the configuration instructions for a specific Collector subclass" do
+      collector_subclass = anonymous_collector_subclass
+      collector_subclass.configuration_instructions("Provide your username and ...")
+      collector_subclass.configuration_instructions.should == "Provide your username and ..."
+    end
+
+    it "returns nil if a Collector subclass does not specify any configuration instructions" do
+      anonymous_collector_subclass.configuration_instructions.should == nil
+    end
+  end
+  
+  describe "#configuration_instructions (instance method)" do
+    it "returns the configuration instructions defined in the class" do
+      collector_subclass = anonymous_collector_subclass
+      collector_subclass.configuration_instructions("Provide your username and ...")
+      collector = collector_subclass.new
+      collector.configuration_instructions.should == "Provide your username and ..."
+    end
+  end
+  
+  describe "#configuration_summary" do
+    context "when the collector's class has one configuration field" do
+      it "returns the value of the field" do
+        collector_subclass = Class.new(Stratify::Collector) do
+          configuration_fields :username => {:type => :string}
+        end
+        collector = collector_subclass.new
+        collector.username = "johndoe"
+        collector.configuration_summary.should == "johndoe"
+      end
+    end
+
+    context "when the collector's class has multiple configuration fields" do
+      it "returns the value of the first field" do
+        collector_subclass = Class.new(Stratify::Collector) do
+          configuration_fields :username => {:type => :string},
+                               :tag => {:type => :string}
+        end
+        collector = collector_subclass.new
+        collector.username = "johndoe"
+        collector.tag = "programming"
+        collector.configuration_summary.should == "johndoe"
+      end
+    end
+
+    context "when the collector's class has no configuration fields" do
+      it "returns nil" do
+        collector_subclass = Class.new(Stratify::Collector)
+        collector = collector_subclass.new
+        collector.configuration_summary.should == nil
+      end
+    end
+  end
+  
+end

data/spec/stratify/field_definition_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Stratify::FieldDefinition do
+  describe "#name" do
+    it "returns the name of the field" do
+      field = Stratify::FieldDefinition.new(:username, :type => :string)
+      field.name.should == :username
+    end
+  end
+
+  describe "#type" do
+    it "returns the type of the field" do
+      field = Stratify::FieldDefinition.new(:username, :type => :string)
+      field.type.should == :string
+    end
+  end
+
+  describe "#label" do
+    it "returns the label for the field when an explicit label is specified" do
+      field = Stratify::FieldDefinition.new(:username, :type => :string, :label => "User ID")
+      field.label.should == "User ID"
+    end
+
+    it "returns the titleized name for the field when no explicit label is specified" do
+      field = Stratify::FieldDefinition.new(:username, :type => :string)
+      field.label.should == "Username"
+    end
+  end
+end

data/spec/stratify/integration_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "collecting activities", :database => true do
+  it "runs the collector and stores activities" do
+    collector = Stratify::Bacon::Collector.create!(:username => "johndoe", :password => "secret")
+
+    expect { collector.run }.to change(Stratify::Bacon::Activity, :count).by(3)
+
+    Stratify::Bacon::Activity.where(:slices => 3, :created_at => Time.new(2011, 4, 3, 7, 2)).should exist
+    Stratify::Bacon::Activity.where(:slices => 5, :created_at => Time.new(2011, 4, 7, 8, 17)).should exist
+    Stratify::Bacon::Activity.where(:slices => 4, :created_at => Time.new(2011, 4, 9, 6, 24)).should exist
+  end
+  
+  it "does not import duplicate activities" do
+    collector = Stratify::Bacon::Collector.new(:username => "johndoe", :password => "secret")
+    expect { collector.run }.to change(Stratify::Bacon::Activity, :count).by(3)
+    expect { collector.run }.to change(Stratify::Bacon::Activity, :count).by(0)
+  end
+  
+  it "does not re-import soft-deleted activities" do
+    collector = Stratify::Bacon::Collector.new(:username => "johndoe", :password => "secret")
+
+    collector.run
+    activity = Stratify::Bacon::Activity.where(:created_at => Time.new(2011, 4, 3, 7, 2)).first
+    activity.should be
+    activity.delete
+    
+    collector.run
+    Stratify::Bacon::Activity.where(:created_at => Time.new(2011, 4, 3, 7, 2)).should_not exist
+  end
+end

data/spec/stratify/mongoid_extension_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+def class_with_natural_key_mixin(&blk)
+  Class.new do
+    include Mongoid::Document
+    include Stratify::MongoidExtension::NaturalKey
+    yield(self) if block_given?
+  end
+end
+
+describe Stratify::MongoidExtension::NaturalKey do
+  describe ".natural_key" do
+    context "given a single field as the key" do
+      it "stores the field in an array of key fields" do
+        klass = class_with_natural_key_mixin do |k|
+          k.natural_key :status_id
+        end
+        klass.natural_key_fields.should == [:status_id]
+      end
+    end
+
+    context "given a multi-field key" do
+      it "stores the fields in an array of key fields" do
+        klass = class_with_natural_key_mixin do |k|
+          k.natural_key :url, :created_at
+        end
+        klass.natural_key_fields.should == [:url, :created_at]
+      end
+    end
+    
+    it "declares a uniqueness validator for the natural key" do
+      klass = class_with_natural_key_mixin
+      klass.expects(:validates_uniqueness_of_natural_key)
+      klass.natural_key :foo
+    end
+  end
+
+  describe ".validates_uniqueness_of_natural_key" do
+    context "given a single field as the key" do
+      it "declares that no two documents can have the same value for that field" do
+        klass = class_with_natural_key_mixin
+        klass.stubs(:natural_key_fields).returns [:status_id]
+        klass.expects(:validates_uniqueness_of).with(:status_id)
+        klass.validates_uniqueness_of_natural_key
+      end
+    end
+
+    context "given a two-field key" do
+      it "declares that no two documents can have the same combination of values for these two fields" do
+        klass = class_with_natural_key_mixin
+        klass.stubs(:natural_key_fields).returns [:url, :created_at]
+        klass.expects(:validates_uniqueness_of).with(:url, :scope => [:created_at])
+        klass.validates_uniqueness_of_natural_key
+      end
+    end
+
+    context "given a key with more than two fields" do
+      it "declares that no two documents can have the same combination of values for these fields" do
+        klass = class_with_natural_key_mixin
+        klass.stubs(:natural_key_fields).returns [:foo, :bar, :baz]
+        klass.expects(:validates_uniqueness_of).with(:foo, :scope => [:bar, :baz])
+        klass.validates_uniqueness_of_natural_key
+      end
+    end
+  end
+  
+  describe "#natural_key_hash" do
+    it "returns the field name and value for the object's natural key" do
+      klass = class_with_natural_key_mixin do |k|
+        k.field :foo
+        k.field :bar
+        k.field :baz
+        k.natural_key :foo, :bar
+      end
+
+      model = klass.new(:foo => 1, :bar => 2, :baz => 3)
+      model.natural_key_hash.should == {:foo => 1, :bar => 2}
+    end
+  end
+end

data/spec/stratify/renderable_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+def anonymous_class_with_renderable_mixin
+  Class.new do
+    include Stratify::Renderable
+  end
+end
+
+describe Stratify::Renderable do
+  describe ".template" do
+    it "returns the template specified for use in rendering the object" do
+      renderable_class = anonymous_class_with_renderable_mixin
+      renderable_class.template "some custom template"
+      renderable_class.template.should == "some custom template"
+    end
+  end
+
+  describe ".template_format" do
+    it "returns ':erb' when no explicit format has been set" do
+      renderable_class = anonymous_class_with_renderable_mixin
+      renderable_class.template_format.should == :erb
+    end
+
+    it "returns a custom template format when one has been set" do
+      renderable_class = anonymous_class_with_renderable_mixin
+      renderable_class.template_format :haml
+      renderable_class.template_format.should == :haml
+    end
+  end
+  
+  describe "#presenter" do
+    it "returns the object" do
+      renderable_object = anonymous_class_with_renderable_mixin.new
+      renderable_object.presenter.should == renderable_object
+    end
+  end
+
+  describe "#to_html" do
+    it "returns the result of rendering the template with the presenter" do
+      renderable_class = anonymous_class_with_renderable_mixin
+      renderable_class.template "Hello, <%= name %>"
+
+      renderable_object = renderable_class.new
+      class << renderable_object
+        def name
+          "Kilgore"
+        end
+      end
+      
+      renderable_object.to_html.should == "Hello, Kilgore"
+    end
+  end
+end

data/stratify-base.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "stratify/version"
+
+Gem::Specification.new do |s|
+  s.name        = "stratify-base"
+  s.version     = Stratify::Base::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jason Rudolph"]
+  s.email       = ["jason@jasonrudolph.com"]
+  s.homepage    = "http://github.com/jasonrudolph/stratify/"
+  s.summary     = "Core collector and activity componentry for Stratify"
+  s.description = "Provides the infrastructure to support the development and use of Stratify collectors and activities"
+
+  s.rubyforge_project = "stratify-base"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "bson_ext", "~> 1.3.1"
+  s.add_runtime_dependency "mongoid", "~> 2.0.2"
+  s.add_runtime_dependency "tilt", "~> 1.3.2"
+  
+  s.add_development_dependency "rspec", "~> 2.6.0"
+  s.add_development_dependency "mocha", "~> 0.9.12"
+  s.add_development_dependency "database_cleaner", "~> 0.6.7"
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification 
+name: stratify-base
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jason Rudolph
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-26 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.3.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.0.2
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: tilt
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.3.2
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.9.12
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.6.7
+  type: :development
+  version_requirements: *id006
+description: Provides the infrastructure to support the development and use of Stratify collectors and activities
+email: 
+- jason@jasonrudolph.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/stratify-base.rb
+- lib/stratify/activity.rb
+- lib/stratify/archiver.rb
+- lib/stratify/collector.rb
+- lib/stratify/collector_coordinator.rb
+- lib/stratify/field_definition.rb
+- lib/stratify/logger.rb
+- lib/stratify/mongoid_extension.rb
+- lib/stratify/renderable.rb
+- lib/stratify/version.rb
+- spec/mongoid.yml
+- spec/prototypes/bacon.rb
+- spec/spec_helper.rb
+- spec/stratify/activity_spec.rb
+- spec/stratify/archiver_spec.rb
+- spec/stratify/collector_coordinator_spec.rb
+- spec/stratify/collector_spec.rb
+- spec/stratify/field_definition_spec.rb
+- spec/stratify/integration_spec.rb
+- spec/stratify/mongoid_extension_spec.rb
+- spec/stratify/renderable_spec.rb
+- stratify-base.gemspec
+homepage: http://github.com/jasonrudolph/stratify/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: stratify-base
+rubygems_version: 1.8.5
+signing_key: 
+specification_version: 3
+summary: Core collector and activity componentry for Stratify
+test_files: 
+- spec/mongoid.yml
+- spec/prototypes/bacon.rb
+- spec/spec_helper.rb
+- spec/stratify/activity_spec.rb
+- spec/stratify/archiver_spec.rb
+- spec/stratify/collector_coordinator_spec.rb
+- spec/stratify/collector_spec.rb
+- spec/stratify/field_definition_spec.rb
+- spec/stratify/integration_spec.rb
+- spec/stratify/mongoid_extension_spec.rb
+- spec/stratify/renderable_spec.rb