lifestreamable 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2010-05-19
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+lib/lifestreamable.rb
+script/console
+script/destroy
+script/generate
+test/test_helper.rb
+test/test_lifestreamable.rb

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on lifestreamable, see http://lifestreamable.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,103 @@
+= lifestreamable
+
+* github.com/benoitgoyette/lifestreamable
+
+== DESCRIPTION:
+
+Lifestreamable is a rails gem that allows social network life lifestream operations. A lifestream is a series of events that occured and that are related to an owner.
+It has been designed to collect data upfront in model observers to minimize the number of request done at display time. the goal being that if the lifestream dislays several types of data over several different models, then only a single query will be run to get all the data to display instead of querying all data for each model. this radiaclly cuts down on display time.
+This is a port to a gem of the lifestream libraries that have been designed for the sports social network legrandclub.rds.ca
+
+== FEATURES/PROBLEMS:
+
+TODO:
+add support for pagination.
+add support for delayed jobs.
+port to rails 3.0
+write the tests
+complete the doc on which options are available for lifestreamable and lifestreamed
+
+== SYNOPSIS:
+
+Ths lifestream modules is made up of 2 mixins, the lifestreamable, and lifestreamed modules.
+The lifestreamed module is included for models that own events, while the lifestreamable module is included on each model that triggers the event.
+
+for example, a user can write posts and comments, we want to report in the user's lifestream that the user has written posts and comments.
+
+
+defining the owner class
+    class User < ActiveRecord::Base
+        lifestreamed 
+    end
+
+defining the event classes
+    class Post < ActiveRecord::Base
+        belongs_to :user
+        has_many :comments
+        lifestreamable :on=>[:create, :update, :destroy], data=>:get_data, :owner=>:user
+    
+        def get_data   # this method must return a data structure that is serializable by YAML
+            {
+                :user=>{:firstname=>self.user.firstname, :lastname=>self.user.lastname},
+                :post=>{:title=>self.title}
+            }
+        end
+    end
+
+    class Comment < ActiveRecord::Base
+        belongs_to :user
+        belongs_to :post
+        # another way to get the data is through a Proc
+        lifestreamable :on=>[:create, :update, :destroy], :owner=>:user, data=> lambda {|model| 
+                    {
+                        :user=>{:firstname=>model.user.firstname, :lastname=>model.user.lastname},
+                        :post=>{:title=>model.post.title},
+                        :comment=>{:body=>model.body}
+                    }
+                }
+    end
+
+get the lifestream from the owner
+    user=User.first
+
+    # get the lifestream for the user
+    lifestream = user.lifestream  #=> returns an array of Lifestreamable::Lifesteam instances
+    
+    #get the data that was stored 
+    data = lifestream.first.object_data
+    
+    
+
+== REQUIREMENTS:
+
+* YAML
+
+== INSTALL:
+
+* sudo gem install lifestreamable
+
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2010 Benoit Goyette
+
+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/Rakefile

@@ -0,0 +1,21 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/lifestreamable'
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+# $hoe = Hoe.spec 'lifestreamable' do
+#   self.developer 'FIXME full name', 'FIXME email'
+#   self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+#   self.rubyforge_name       = self.name # TODO this is default value
+#   # self.extra_deps         = [['activesupport','>= 2.0.2']]
+# 
+# end
+
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/generators/lifestreamable_migration/lifestreamable_migration_generator.rb

@@ -0,0 +1,20 @@
+class LifestreamableMigrationGenerator < Rails::Generator::Base
+  default_options :skip_migration => false
+  
+  def manifest
+    record do |m|
+      unless options[:skip_migration]
+        m.migration_template "migration.rb", 'db/migrate', :migration_file_name => "create_lifestreams"
+      end
+    end
+  end
+  
+protected
+
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on("--skip-migration", "Don't generate a migration") { |v| options[:skip_migration] = v }
+  end
+  
+end

data/generators/lifestreamable_migration/templates/migration.rb

@@ -0,0 +1,21 @@
+class CreateLifestreams < ActiveRecord::Migration
+  def self.up
+    create_table :lifestreams do |t|
+      t.string :owner_type
+      t.integer :owner_id
+      t.string :stream_type
+      t.string :reference_type
+      t.integer :reference_id
+      t.text :object_data_hash
+      t.timestamps
+    end
+
+    add_index(:lifestreams, [:owner_id, :owner_type], :name=>'lifestreams_profil_id' )
+    add_index(:lifestreams, :stream_type, :name=>'lifestreams_stream_type' )
+    add_index(:lifestreams, [:reference_id, :reference_type], :name=>'lifestreams_stream_object' )
+  end
+
+  def self.down
+    drop_table :lifestreams
+  end
+end

data/lib/lifestreamable/create_observer.rb

@@ -0,0 +1,10 @@
+module Lifestreamable
+  class CreateObserver < Lifestreamable::Observer
+    observe :"lifestreamable/dummy"
+    def after_create(model)
+      if model.lifestreamable?
+        Lifestreamable::Lifestreamer.push model.get_action_instead_of(:create), model.get_payload
+      end
+    end
+  end
+end

data/lib/lifestreamable/destroy_observer.rb

@@ -0,0 +1,10 @@
+module Lifestreamable
+  class DestroyObserver < Lifestreamable::Observer
+    observe :"lifestreamable/dummy"
+    def before_destroy(model)
+      if model.lifestreamable?
+        Lifestreamable::Lifestreamer.push model.get_action_instead_of(:destroy), model.get_payload
+      end
+    end
+  end
+end

data/lib/lifestreamable/lifestream.rb

@@ -0,0 +1,108 @@
+module Lifestreamable
+  class Lifestream < ActiveRecord::Base
+    DEFAULT_LIMIT_PER_PAGE = 25
+    DEFAULT_PAGE = 0
+    
+    belongs_to :owner, :polymorphic => true
+    belongs_to :reference, :polymorphic => true
+
+
+    def object_data
+      YAML.load(self.object_data_hash)
+    end
+    alias_method :object_hash, :object_data
+
+    class << self
+      #
+      # CREATION DU LIFESTREAM
+      #
+      def process(action, struct)
+        # put explicitly the actions accepted
+        case action
+          when :create
+            create get_payload(struct)
+          when :update
+            l = Lifestream.find_by_reference_type_and_reference_id_and_stream_type(struct.reference_type, struct.reference_id, struct.stream_type)
+            l.update_attributes get_payload(struct) unless l.blank?
+          when :destroy
+            l = Lifestream.find_by_reference_type_and_reference_id_and_stream_type(struct.reference_type, struct.reference_id, struct.stream_type)
+            l.destroy unless l.blank?
+          else
+            raise LifestreamableException.new "unknown action #{action} in Lifestreamable::Lifestream.process"
+        end
+      end
+
+
+      # FINDERS 
+
+      def find_by_reference_type_and_reference_id_and_stream_type(reference_type, reference_id, stream_type)
+        find(:last, :conditions=>['reference_type = ? and reference_id = ? and stream_type = ?', reference_type, reference_id,  stream_type])
+      end
+      
+      def find_lifestream_for_owner(owner, *options)
+        opts = get_options_for_find owner, options[0]
+        results = find :all, opts
+      end
+
+      def find_lifestream_for_group(owner, group, *options)
+        opts = get_options_for_group_find owner, group, options[0]
+        results = find :all, opts
+      end
+
+    protected
+
+      def get_options_for_find(owner, options)
+        opt = options.blank? ? {} : options.to_options
+        set_basic_options!(opt)
+        cond = get_condition_for_find(owner)
+        opt[:conditions] = if opt[:conditions].blank?
+          cond
+        else
+          cond[0]+= " AND #{opt[:conditions][0]}"
+          cond += opt[:conditions][1..-1]
+          cond
+        end
+        opt
+      end
+      
+      def get_options_for_group_find(owner, group, options)
+        opt = options.blank? ? {} : options.to_options
+        set_basic_options!(opt)
+        cond = get_condition_for_group_find(owner, group)
+        opt[:conditions] = if opt[:conditions].blank?
+          cond
+        else
+          cond[0]+= " AND #{opt[:conditions][0]}"
+          cond += opt[:conditions][1..-1]
+          cond
+        end
+        opt
+      end
+      
+      def set_basic_options!(opt)
+        opt[:limit]=opt[:per_page] ? opt.delete(:per_page) : DEFAULT_LIMIT_PER_PAGE
+        opt[:offset]=opt[:page] ? (opt.delete(:page)-1)*opt[:limit] : DEFAULT_PAGE
+        opt[:order]=opt[:order] ? opt[:order] : 'id desc'
+      end
+
+      def get_condition_for_find(owner)
+        ['owner_type = ? and owner_id = ? ', owner.class.name, owner.id]
+      end
+      
+      def get_condition_for_group_find(owner, group)
+        ['owner_type = ? and owner_id in (?) ', owner.class.name, [owner.id] + group]
+      end
+      
+      def get_payload(struct)
+        hash_from_struct(struct)
+      end
+    
+      def hash_from_struct(struct)
+        h = {}
+        struct.each_pair {|k,v| h[k.to_sym]=v}
+        h
+      end
+    
+    end
+  end
+end

data/lib/lifestreamable/lifestreamable.rb

@@ -0,0 +1,194 @@
+# Pour le lifestream, on ajoute une methode a ActiveRecord::Base
+# pour savoir si on doit effacer une entree du lifestream a la
+# place de faire un update.
+# comme dans le cas de detail.youtube_username, si on efface
+# la valeur, on veut effacer l'entree dans le lifestream.
+# Meme chose pour l'insert, si on change le youtube user name,
+# on veut que ca insere une nouvelle rangee dans le lifestream.
+
+module Lifestreamable
+  Struct.new('LifestreamData', :reference_type, :reference_id, :owner_type, :owner_id, :stream_type, :object_data_hash)
+  TRUE_REGEX = /^[tT][rR][uU][eE]$/
+  FALSE_REGEX =  /^[fF][aA][lL][sS][eE]$/
+  
+  def self.included(base)
+    base.extend LifestreamableClassMethods
+  end
+
+  module LifestreamableClassMethods
+    @@lifestream_options={}
+  
+    def lifestream_options
+      @@lifestream_options
+    end
+    
+    def lifestreamable(options)
+      include LifestreamableInstanceMethods
+
+      options.to_options
+      options[:on].each do |option_on|
+        case option_on
+          when :update
+            Lifestreamable::UpdateObserver.instance.add_class_observer self.class_name.constantize
+          when :create
+            Lifestreamable::CreateObserver.instance.add_class_observer self.class_name.constantize
+          when :destroy
+            Lifestreamable::DestroyObserver.instance.add_class_observer self.class_name.constantize
+          else
+            raise Exception.new("option \"#{option_on}\" is not supported for Lifestreamable")
+        end
+      end
+      @@lifestream_options = {:data=>options[:data], :on=>options[:on], :type=>options[:type], :owner=>options[:owner], :when=>options[:when], :filter=>options[:filter],
+        :destroy_instead_of_update=>options[:destroy_instead_of_update], :create_instead_of_update=>options[:create_instead_of_update],
+        :create_instead_of_destroy=>options[:create_instead_of_destroy], :update_instead_of_destroy=>options[:update_instead_of_destroy]}
+    end
+    
+    def filter(lifestream)
+      puts "in lifestreamable.filter"
+      option = self.lifestream_options[:filter]
+      lifestream = case option
+        when Proc
+          option.call(self, lifestream)
+        when String, Symbol
+          send(option.to_s, lifestream) if respond_to?(option.to_s)
+        else
+          lifestream
+      end 
+      lifestream
+    end
+
+  end
+
+  module LifestreamableInstanceMethods
+    def lifestream_options
+      self.class.lifestream_options
+    end
+
+    def lifestreamable?
+      case self.lifestream_options[:when]
+        when NilClass, TrueClass, :true, TRUE_REGEX
+          true
+        when FalseClass, :false, FALSE_REGEX
+          false
+        when Proc
+          self.lifestream_options[:when].call(self)
+        when String, Symbol
+          send(self.lifestream_options[:when].to_s)
+      end 
+    end
+    
+    def get_payload
+      reference_type, reference_id = get_reference
+      owner_type, owner_id = get_owner
+      stream_type = get_stream_type
+      data = get_lifestream_data.to_yaml
+      Struct::LifestreamData.new reference_type, reference_id, owner_type, owner_id, stream_type, data   
+    end
+    
+    def get_action_instead_of(action)
+      case action
+        when :create
+          :create
+        when :update
+          if test_instead_option(lifestream_options[:create_instead_of_update])
+            :create
+          elsif test_instead_option(lifestream_options[:destroy_instead_of_update]) 
+          :destroy 
+          else
+            :update
+          end
+        when :destroy
+          if test_instead_option(lifestream_options[:create_instead_of_destroy])
+            :create 
+          elsif test_instead_option(lifestream_options[:destroy_instead_of_destroy])
+            :update 
+          else  
+            :destroy
+          end
+        else
+          raise LifestreamableException.new("The action #{action.to_s} is not a valid type of action")
+      end
+    end
+
+protected    
+    # if the option[:when] is not defined, then it's considered true
+    def get_reference
+      [self.class.name, self.id]
+    end
+
+    def get_owner
+      return_vals = case self.lifestream_options[:owner]
+        when Proc
+          self.lifestream_options[:owner].call(self)
+        when String, Symbol
+          send(self.lifestream_options[:owner].to_s)
+        else
+          raise LifestreamableException.new("The lifestreamable :owner option is invalid")
+      end 
+      
+      case return_vals
+        when NilClass
+          LifestreamableException.new("The lifestreamable :owner option Proc must return either an ActiveRecord::Base subclass or an array of [class_name, id]") 
+        when Array
+          if return_vals.length == 1
+            if return_vals.is_a?(ActiveRecord::Base)
+              return [return_vals.class.name, return_vals.id] 
+            else
+              LifestreamableException.new("The lifestreamable :owner option Proc evaluation returned only 1 value, but it's not an ActiveRecord::Base") 
+            end
+          else
+            return_vals[0,2]
+          end
+        when ActiveRecord::Base
+          return [return_vals.class.name, return_vals.id] 
+      end
+    end
+    
+    def get_stream_type
+      case self.lifestream_options[:type]
+        when NilClass
+          self.class.name.underscore
+        when Proc
+          self.lifestream_options[:type].call(self)
+        when String, Symbol
+          if self.respond_to?(self.lifestream_options[:type].to_s)
+            send(self.lifestream_options[:type].to_s)
+          else
+            self.lifestream_options[:type].to_s
+          end
+        else
+          raise LifestreamableException.new("The lifestreamable :type option is invalid")
+      end 
+    end
+    
+    def get_lifestream_data
+      case self.lifestream_options[:data]
+        when Proc
+          self.lifestream_options[:data].call(self)
+        when String, Symbol
+          send(self.lifestream_options[:data].to_s)
+        else
+          raise LifestreamableException.new("The lifestreamable :data option is invalid")
+      end 
+    end
+    
+private
+    def test_instead_option(option)
+      case option
+        when NilClass, FalseClass, :false, FALSE_REGEX
+          false
+        when TrueClass, :true, TRUE_REGEX
+          true
+        when Proc
+          option.call(self)
+        when String, Symbol
+          send(option.to_s)
+      end == true  # make sure we return true/false
+    end
+  end
+end
+
+ActiveRecord::Base.observers << :"lifestreamable/update_observer"
+ActiveRecord::Base.observers << :"lifestreamable/create_observer"
+ActiveRecord::Base.observers << :"lifestreamable/destroy_observer"
+ActiveRecord::Base.send(:include, Lifestreamable)

data/lib/lifestreamable/lifestreamed.rb

@@ -0,0 +1,88 @@
+module Lifestreamable
+  module Lifestreamed
+    def self.included(base)
+      base.extend LifestreamedClassMethods
+    end
+
+    module LifestreamedClassMethods
+      @@lifestreamed_options={}
+
+      def lifestreamed_options
+        @@lifestreamed_options
+      end
+  
+      def lifestreamed(*options)
+        include LifestreamedInstanceMethods
+        @@lifestreamed_options = options[0].blank? ? {} : options[0].to_options.clone if options[0]
+      end
+
+    end
+
+    module LifestreamedInstanceMethods
+      def lifestreamed_options
+        self.class.lifestreamed_options
+      end
+      
+      def lifestream(*options)
+        opt, do_filter = get_options_and_filter(options[0])
+        lifestream = Lifestreamable::Lifestream.find_lifestream_for_owner(self, opt) 
+        do_filter ? filter(lifestream) : lifestream
+      end
+      
+      def group_lifestream(group, *options)
+        opt, do_filter = get_options_and_filter(options[0])
+        lifestream = Lifestreamable::Lifestream.find_lifestream_for_group(self, group, opt)
+        do_filter ? filter(lifestream) : lifestream
+      end
+      
+    private
+    
+      def get_options_and_filter(options)
+        opt = options.blank? ? {} : options.to_options
+        order_opt = get_order_option(opt.has_key?(:order) ? opt[:order] : self.lifestreamed_options[:order] )
+        opt[:order]= order_opt unless order_opt.blank?
+        filter_option = opt.has_key?(:filter) ? opt.delete(:filter) : self.lifestreamed_options[:filter]
+        do_filter = get_filter_option( filter_option )
+        [opt, do_filter]
+      end
+
+      def get_filter_option(option)
+        puts "getting filter option"
+        case option
+          when NilClass, FalseClass, :false, Lifestreamable::FALSE_REGEX
+            false
+          when TrueClass, :true, Lifestreamable::TRUE_REGEX
+            true
+          when Proc # make sure we return true/false
+            option.call(self) == true
+          when String, Symbol  # make sure we return true/false
+            send(option.to_s) == true
+        end  
+      end
+      
+      def get_order_option(option)
+        case option
+          when Proc
+            option.call(self)
+          when String, Symbol
+            if self.respond_to?(option.to_s)
+              send(option.to_s)
+            else
+              option.to_s
+            end
+        end 
+      end
+      
+      def filter(lifestream)
+        lf = lifestream.clone
+        types = lf.collect {|l| l.reference_type}
+        types.uniq!
+        types.each {|l| 
+          lf = l.constantize.filter(lf) if l.constantize.respond_to?('filter')}
+        lf
+      end
+      
+    end
+  end
+end
+ActiveRecord::Base.send(:include, Lifestreamable::Lifestreamed)

data/lib/lifestreamable/lifestreamer.rb

@@ -0,0 +1,26 @@
+module Lifestreamable
+  module Lifestreamer
+    @@stack=[]
+    def self.push(action, lifestream_struct)
+      @@stack.push [action, lifestream_struct]
+      @@stack.uniq!
+    end
+    def self.generate_lifestream
+      while (lifestream_entry=@@stack.shift)
+        begin
+          Lifestream.process(lifestream_entry[0], lifestream_entry[1])
+        rescue Exception => e
+          puts e.message, e.backtrace
+          # TODO PUT SOMETHING HERE!!!
+        end
+      end
+    end
+    def self.clear
+      @@stack.clear
+    end
+    def self.inspect
+      @@stack.inspect
+    end
+  end
+end
+ActionController::Base.send(:after_filter, "Lifestreamable::Lifestreamer.generate_lifestream")

data/lib/lifestreamable/observer.rb

@@ -0,0 +1,20 @@
+module Lifestreamable
+  class Observer < ActiveRecord::Observer
+    
+    def add_class_observer(klass)
+      self.add_observer!(klass)
+    end
+    
+  end
+  class Dummy 
+    include Observable
+    class << self
+      def add_observer(*args)
+      end
+    end
+  end
+  
+end
+
+class LifestreamableException < Exception 
+end

data/lib/lifestreamable/update_observer.rb

@@ -0,0 +1,11 @@
+module Lifestreamable
+  class UpdateObserver < Lifestreamable::Observer
+    observe :"lifestreamable/dummy"
+    def after_update(model)
+      if model.lifestreamable?
+        Lifestreamable::Lifestreamer.push model.get_action_instead_of(:update), model.get_payload
+      end
+    end
+  end
+end
+

data/lib/lifestreamable.rb

@@ -0,0 +1,9 @@
+$:.unshift(File.dirname(__FILE__)) unless
+$:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require File.join(File.dirname(__FILE__),'lifestreamable/lifestreamable')
+require File.join(File.dirname(__FILE__),'lifestreamable/lifestreamed')
+
+module Lifestreamable
+  VERSION = '0.0.2'
+end

data/lifestreamable.gemspec

@@ -0,0 +1,52 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{lifestreamable}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Benoit Goyette"]
+  s.date = %q{2010-05-19}
+  s.description = %q{library to perform social network like lifetstream functions, this is the code used on the social network http://legrandclub.rds.ca}
+  s.email = %q{benoit.goyette@gmail.com}
+  s.files = ["History.txt",
+    "Manifest.txt",
+    "PostInstall.txt",
+    "README.rdoc",
+    "Rakefile",
+    "generators/lifestreamable_migration/lifestreamable_migration_generator.rb",
+    "generators/lifestreamable_migration/templates/migration.rb",
+    "lib/lifestreamable/create_observer.rb",
+    "lib/lifestreamable/destroy_observer.rb",
+    "lib/lifestreamable/lifestream.rb",
+    "lib/lifestreamable/lifestreamable.rb",
+    "lib/lifestreamable/lifestreamed.rb",
+    "lib/lifestreamable/lifestreamer.rb",
+    "lib/lifestreamable/observer.rb",
+    "lib/lifestreamable/update_observer.rb",
+    "lib/lifestreamable.rb",
+    "lifestreamable.gemspec",
+    "script/console",
+    "script/destroy",
+    "script/generate",
+    "test/test_helper.rb",
+    "test/test_lifestreamable.rb"]
+  s.homepage = %q{http://lab.pheromone.ca}
+  s.rdoc_options = ["--exclude", "."]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{lifestreamable}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{a rails plugin to collect and report user social actions.}
+
+
+  # if s.respond_to? :specification_version then
+  #   current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+  #   s.specification_version = 3
+  #   if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+  #   else
+  #   end
+  # else
+  # end
+end
+
+

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/lifestreamable.rb'}"
+puts "Loading lifestreamable gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'stringio'
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/lifestreamable'

data/test/test_lifestreamable.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestLifestreamable < Test::Unit::TestCase
+
+  def setup
+  end
+  
+  def test_truth
+    assert true
+  end
+  
+
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: lifestreamable
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Benoit Goyette
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-19 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: library to perform social network like lifetstream functions, this is the code used on the social network http://legrandclub.rds.ca
+email: benoit.goyette@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- History.txt
+- Manifest.txt
+- PostInstall.txt
+- README.rdoc
+- Rakefile
+- generators/lifestreamable_migration/lifestreamable_migration_generator.rb
+- generators/lifestreamable_migration/templates/migration.rb
+- lib/lifestreamable/create_observer.rb
+- lib/lifestreamable/destroy_observer.rb
+- lib/lifestreamable/lifestream.rb
+- lib/lifestreamable/lifestreamable.rb
+- lib/lifestreamable/lifestreamed.rb
+- lib/lifestreamable/lifestreamer.rb
+- lib/lifestreamable/observer.rb
+- lib/lifestreamable/update_observer.rb
+- lib/lifestreamable.rb
+- lifestreamable.gemspec
+- script/console
+- script/destroy
+- script/generate
+- test/test_helper.rb
+- test/test_lifestreamable.rb
+has_rdoc: true
+homepage: http://lab.pheromone.ca
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --exclude
+- .
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: lifestreamable
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: a rails plugin to collect and report user social actions.
+test_files: []
+