social_stream 0.2.3 → 0.3.0

data/lib/generators/social_stream/templates/public/javascripts/rails.js

@@ -0,0 +1,146 @@
+jQuery(function ($) {
+    var csrf_token = $('meta[name=csrf-token]').attr('content'),
+        csrf_param = $('meta[name=csrf-param]').attr('content');
+
+    $.fn.extend({
+        /**
+         * Triggers a custom event on an element and returns the event result
+         * this is used to get around not being able to ensure callbacks are placed
+         * at the end of the chain.
+         *
+         * TODO: deprecate with jQuery 1.4.2 release, in favor of subscribing to our
+         *       own events and placing ourselves at the end of the chain.
+         */
+        triggerAndReturn: function (name, data) {
+            var event = new $.Event(name);
+            this.trigger(event, data);
+
+            return event.result !== false;
+        },
+
+        /**
+         * Handles execution of remote calls firing overridable events along the way
+         */
+        callRemote: function () {
+            var el      = this,
+                method  = el.attr('method') || el.attr('data-method') || 'GET',
+                url     = el.attr('action') || el.attr('href'),
+                dataType  = el.attr('data-type')  || 'script';
+
+            if (url === undefined) {
+              throw "No URL specified for remote call (action or href must be present).";
+            } else {
+                if (el.triggerAndReturn('ajax:before')) {
+                    var data = el.is('form') ? el.serializeArray() : [];
+                    $.ajax({
+                        url: url,
+                        data: data,
+                        dataType: dataType,
+                        type: method.toUpperCase(),
+                        beforeSend: function (xhr) {
+                            el.trigger('ajax:loading', xhr);
+                        },
+                        success: function (data, status, xhr) {
+                            el.trigger('ajax:success', [data, status, xhr]);
+                        },
+                        complete: function (xhr) {
+                            el.trigger('ajax:complete', xhr);
+                        },
+                        error: function (xhr, status, error) {
+                            el.trigger('ajax:failure', [xhr, status, error]);
+                        }
+                    });
+                }
+
+                el.trigger('ajax:after');
+            }
+        }
+    });
+
+    /**
+     *  confirmation handler
+     */
+    var jqueryVersion = $().jquery;
+
+    if ( (jqueryVersion === '1.4') || (jqueryVersion === '1.4.1') || (jqueryVersion === '1.4.2')){
+      $('a[data-confirm],input[data-confirm]').live('click', function () {
+          var el = $(this);
+          if (el.triggerAndReturn('confirm')) {
+              if (!confirm(el.attr('data-confirm'))) {
+                  return false;
+              }
+          }
+      });
+    } else {
+      $('body').delegate('a[data-confirm],input[data-confirm]', 'click', function () {
+          var el = $(this);
+          if (el.triggerAndReturn('confirm')) {
+              if (!confirm(el.attr('data-confirm'))) {
+                  return false;
+              }
+          }
+      });
+    }
+    
+
+
+    /**
+     * remote handlers
+     */
+    $('form[data-remote]').live('submit', function (e) {
+        $(this).callRemote();
+        e.preventDefault();
+    });
+
+    $('a[data-remote],input[data-remote]').live('click', function (e) {
+        $(this).callRemote();
+        e.preventDefault();
+    });
+
+    $('a[data-method]:not([data-remote])').live('click', function (e){
+        var link = $(this),
+            href = link.attr('href'),
+            method = link.attr('data-method'),
+            form = $('<form method="post" action="'+href+'"></form>'),
+            metadata_input = '<input name="_method" value="'+method+'" type="hidden" />';
+
+        if (csrf_param != null && csrf_token != null) {
+          metadata_input += '<input name="'+csrf_param+'" value="'+csrf_token+'" type="hidden" />';
+        }
+
+        form.hide()
+            .append(metadata_input)
+            .appendTo('body');
+
+        e.preventDefault();
+        form.submit();
+    });
+
+    /**
+     * disable-with handlers
+     */
+    var disable_with_input_selector           = 'input[data-disable-with]';
+    var disable_with_form_remote_selector     = 'form[data-remote]:has('       + disable_with_input_selector + ')';
+    var disable_with_form_not_remote_selector = 'form:not([data-remote]):has(' + disable_with_input_selector + ')';
+
+    var disable_with_input_function = function () {
+        $(this).find(disable_with_input_selector).each(function () {
+            var input = $(this);
+            input.data('enable-with', input.val())
+                .attr('value', input.attr('data-disable-with'))
+                .attr('disabled', 'disabled');
+        });
+    };
+
+    $(disable_with_form_remote_selector).live('ajax:before', disable_with_input_function);
+    $(disable_with_form_not_remote_selector).live('submit', disable_with_input_function);
+
+    $(disable_with_form_remote_selector).live('ajax:complete', function () {
+        $(this).find(disable_with_input_selector).each(function () {
+            var input = $(this);
+            input.removeAttr('disabled')
+                 .val(input.data('enable-with'));
+        });
+    });
+
+});

data/lib/generators/social_stream/templates/public/javascripts/ui.dropdownchecklist.js

@@ -460,20 +460,10 @@
             var text = self._formatText(selectOptions, options.firstItemChecksAll, firstOption);
             var controlLabel = controlWrapper.find(".ui-dropdownchecklist-text");
 
-            var image = $("<img>");
-            image.attr("src", "/images/btn/btn_security.png");
-            image.attr('alt', 'security');
-            image.attr('id','security_image');
-
-            var down = $("<img>");
-            down.attr("src","/images/btn/btn_down.png")
-
-
-
             //controlLabel.html(text);
-            controlLabel.html(image);
+            controlLabel.html(securityImage);
             controlLabel.append(" ");
-            controlLabel.append(down);
+            controlLabel.append(downImage);
             //controlLabel.attr("title", text);
             controlLabel.attr("title", "security");
 
@@ -784,4 +774,4 @@
         }
     });
 
-})(jQuery);
+})(jQuery);

data/lib/generators/social_stream/templates/public/stylesheets/header.css

@@ -104,4 +104,8 @@
 .btn_menu {
 	vertical-align: middle;
 	display: inline;
-}
+}
+
+#new_representation {
+	display: inline;
+}

data/lib/generators/social_stream/templates/relations.yml

@@ -0,0 +1,42 @@
+# Relations for Social Stream
+#
+# Define the relations and permissions supported by your application
+#
+user:
+  friend:
+    name: friend
+    permissions:
+      - [ create,  activity, weak_set ]
+      - [ read,    activity, star_set ]
+      - [ update,  activity, weak_set ]
+      - [ destroy, activity, weak_set ]
+  acquaintance:
+    name: acquaintance
+    parent: friend
+    permissions:
+      - [ read,    activity, star_set ]
+  public:
+    name: public
+    parent: acquaintance
+    permissions:
+      - [ read,    activity, star_set ]
+
+group:
+  member:
+    name: member
+    permissions:
+      - [ represent ]
+      - [ create,  activity, weak_set ]
+      - [ read,    activity, star_set ]
+      - [ update,  activity, weak_star_set ]
+      - [ destroy, activity, weak_star_set ]
+  partner:
+    name: partner
+    parent: member
+    permissions:
+      - [ read,    activity, star_set ]
+  public:
+    name: public
+    parent: partner
+    permissions:
+      - [ read,    activity, star_set ]

data/lib/social_stream/ability.rb

@@ -4,22 +4,23 @@ module SocialStream
 
     def initialize(user)
       can :create, Activity do |a|
-        # All ties authors must the user
-        a.tie.sender_subject == user &&
-          a.tie.permission?(user, 'create', 'activity')
+        # All ties' authors must be the user
+        a.tie.receiver_subject == user &&
+          a.tie.allows?(user, 'create', 'activity')
       end
 
       can :read, Activity do |a|
+        # This condition would not be neccesary if every actor had a public tie with others
         a.tie.relation.name == 'public' ||
-          a.tie.permission?(user, 'read', 'activity')
+          a.tie.allows?(user, 'read', 'activity')
       end
 
       can :update, Activity do |a|
-        a.tie.permission?(user, 'update', 'activity')
+        a.tie.allows?(user, 'update', 'activity')
       end
 
       can :destroy, Activity do |a|
-        a.tie.permission?(user, 'destroy', 'activity')
+        a.tie.allows?(user, 'destroy', 'activity')
       end
     end
   end

data/lib/social_stream/controllers/helpers.rb

@@ -0,0 +1,35 @@
+module SocialStream
+  module Controllers
+    # Common methods added to ApplicationController
+    module Helpers
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :current_subject
+      end
+
+      module InstanceMethods
+        # Current subject represented by the user. Defaults to the own user
+        def current_subject
+          current_subject_from_session ||
+            current_user
+        end
+
+        # Set represented subject
+        def current_subject= instance
+          session[:subject_type] = instance.class.to_s
+          session[:subject_id]   = instance.id
+        end
+
+        private
+
+        # Get represented subject from session
+        def current_subject_from_session
+          return unless session[:subject_type].present? && session[:subject_id].present?
+
+          session[:subject_type].constantize.find session[:subject_id]
+        end
+      end
+    end
+  end
+end

data/lib/social_stream/models/{activity_object.rb → object.rb}

@@ -3,7 +3,7 @@ require 'active_support/concern'
 module SocialStream
   module Models
     # Additional features for models that are Activity Objects
-    module ActivityObject
+    module Object
       extend ActiveSupport::Concern
 
       included do

data/lib/social_stream/models/{actor.rb → subject.rb}

@@ -2,8 +2,8 @@ require 'active_support/concern'
 
 module SocialStream
   module Models
-    # Additional features for models that are subtypes of actors
-    module Actor
+    # Additional features for models that are subtypes of actors, like User or Group
+    module Subject
       extend ActiveSupport::Concern
 
       included do
@@ -16,13 +16,18 @@ module SocialStream
                  :permalink,
                  :logo, :logo=,
                  :ties, :sent_ties, :received_ties,
-                 :active_ties_to,
+                 :ties_to,
+                 :sent_ties_allowing,
                  :pending_ties,
-                 :sender_subjects, :receiver_subjects,
+                 :relation, :relations,
+                 :actors, :subjects,
                  :suggestions, :suggestion,
-                 :wall, :wall_profile,
+                 :home_wall, :profile_wall,
                  :to => :actor!
 
+        has_one :profile, :through => :actor
+
+        accepts_nested_attributes_for :profile
 
         validates_presence_of :name
 
@@ -30,8 +35,6 @@ module SocialStream
 
         scope :with_sent_ties,     joins(:actor => :sent_ties)
         scope :with_received_ties, joins(:actor => :received_ties)
-
-        after_create :initialize_reflexive_ties
       end
 
       module InstanceMethods
@@ -42,32 +45,9 @@ module SocialStream
         def to_param
           permalink
         end
-
-        private
-
-        def initialize_reflexive_ties
-          self.class.relations.reflexive.each do |r|
-            Tie.create! :sender => self.actor,
-                        :receiver => self.actor,
-                        :relation => r
-          end
-        end
       end
 
       module ClassMethods
-        # Relations defined for this actor model.
-        def relations(to = to_s)
-          Relation.mode(to_s, to)
-        end
-
-        # Actor subtypes that may receive a tie from an instance of this class
-        def receiving_subject_classes
-          Relation.select("DISTINCT #{ Relation.quoted_table_name }.receiver_type").
-            where(:sender_type => to_s).
-            map(&:receiver_type).
-            map(&:constantize)
-        end
-
         def find_by_permalink(perm)
           joins(:actor).where('actors.permalink' => perm).first
         end

data/lib/social_stream/models/supertype.rb

@@ -2,6 +2,9 @@ require 'active_support/concern'
 
 module SocialStream #:nodoc:
   module Models
+    # Common methods for models that have subtypes. Currently, there are two supertypes:
+    # * Actor: participates in the social network and has ties with other actors. Its subtypes are subjects, like user or group
+    # * ActivityObject: created and managed by actors in activities. Its subtypes are objects, like post or comment
     module Supertype
       extend ActiveSupport::Concern
 
@@ -13,11 +16,11 @@ module SocialStream #:nodoc:
 
       module ClassMethods
         def subtypes
-          SocialStream.__send__ to_s.tableize
+          SocialStream.__send__ @subtypes_name.to_s.tableize # SocialStream.subjects # in Actor
         end
 
         def load_subtype_features
-          features = "SocialStream::Models::#{ to_s }".constantize
+          features = "SocialStream::Models::#{ @subtypes_name.to_s.classify }".constantize
 
           subtypes.each do |s|
             s = s.to_s.classify.constantize

data/lib/social_stream/rails.rb

@@ -20,12 +20,31 @@ require 'paperclip/social_stream'
 # Pagination
 require 'will_paginate'
 
-# FIXME: deprecate plugin
-Gem.path.map{ |p| File.expand_path(__FILE__) =~ /^#{ p }/ }.compact.present? ?
-  require('social_stream/rails/engine') :
-  require('social_stream/rails/railtie')
-
 module SocialStream
-  module Rails #:nodoc:
+  class Engine < ::Rails::Engine #:nodoc:
+    config.app_generators.authentication :devise
+    config.app_generators.javascript :jquery
+
+    config.to_prepare do
+      %w( actor activity_object ).each do |supertype|
+        supertype.classify.constantize.load_subtype_features
+      end
+
+      # https://rails.lighthouseapp.com/projects/8994/tickets/1905-apphelpers-within-plugin-not-being-mixed-in
+      ApplicationController.helper ActivitiesHelper
+      ApplicationController.helper TiesHelper
+    end
+
+    initializer "social_stream.inflections" do
+      ActiveSupport::Inflector.inflections do |inflect|
+        inflect.singular /^([Tt]ie)s$/, '\1'
+      end
+    end
+
+    initializer "social_stream.controller_helpers" do
+      ActiveSupport.on_load(:action_controller) do
+        include SocialStream::Controllers::Helpers
+      end
+    end
   end
 end

data/lib/social_stream/relations.rb

@@ -0,0 +1,46 @@
+module SocialStream
+  # Seed you database with initial data for SocialStream
+  #
+  module Relations
+    CONFIG = File.join(::Rails.root, 'config', 'relations.yml')
+
+    class << self
+      # Relations configuration
+      def config
+        @config ||= YAML.load_file(CONFIG)
+      end
+
+      def create(model)
+        cfg_rels = config[model.singularize.underscore]
+
+        if cfg_rels.nil?
+          raise "Undefined relations for actor #{ model }. Please, add an entry to #{ CONFIG }"
+        end
+
+        rels = {}
+
+        cfg_rels.each_pair do |name, cfg_rel|
+          rels[name] =
+            Relation.create! :sender_type =>   model,
+                             :receiver_type => cfg_rel['receiver_type'],
+                             :name =>          cfg_rel['name']
+
+          if (ps = cfg_rel['permissions']).present?
+            ps.each do |p| 
+              rels[name].permissions << 
+                Permission.find_or_create_by_action_and_object_and_function(*p)
+            end 
+          end
+        end
+
+        # Parent, relations must be set after creation
+        # FIXME: Can fix with ruby 1.9 and ordered hashes
+        cfg_rels.each_pair do |name, cfg_rel|
+          rels[name].update_attribute(:parent, rels[cfg_rel['parent']]) if cfg_rel['parent'].present?
+        end
+
+        rels.values
+      end
+    end
+  end
+end

data/lib/social_stream/version.rb

@@ -1,3 +1,3 @@
 module SocialStream
-  VERSION = "0.2.3".freeze
+  VERSION = "0.3.0".freeze
 end

data/lib/social_stream.rb

@@ -1,34 +1,34 @@
 # Provides your Rails application with social network and activity stream support
 module SocialStream
-  autoload :Ability,  'social_stream/ability'
-  autoload :Populate, 'social_stream/populate'
-  autoload :Seed,     'social_stream/seed'
+  autoload :Ability,   'social_stream/ability'
+  autoload :Populate,  'social_stream/populate'
+  autoload :Relations, 'social_stream/relations'
+
+  module Controllers
+    autoload :Helpers, 'social_stream/controllers/helpers'
+  end
 
   module Models
     autoload :Supertype, 'social_stream/models/supertype'
-    autoload :Actor, 'social_stream/models/actor'
-    autoload :ActivityObject, 'social_stream/models/activity_object'
+    autoload :Subject,   'social_stream/models/subject'
+    autoload :Object,    'social_stream/models/object'
   end
 
-  mattr_accessor :actors
-  @@actors = [ :user, :group ]
+  mattr_accessor :subjects
+  @@subjects = [ :user, :group ]
 
   mattr_accessor :devise_modules
   @@devise_modules = [ :database_authenticatable, :registerable, :recoverable,
                        :rememberable, :trackable ]
 
-  mattr_accessor :activity_objects
-  @@activity_objects = [ :post, :comment ]
+  mattr_accessor :objects
+  @@objects = [ :post, :comment ]
 
   class << self
     def setup
       yield self
     end
 
-    def seed!
-      Seed.new(File.join(::Rails.root, 'db', 'seeds', 'social_stream.yml'))
-    end
-
     # Load models for rewrite in application
     #
     # Use this method when you want to reopen some model in SocialStream in order

data/lib/tasks/db/populate.rake

@@ -16,7 +16,7 @@ namespace :db do
         klass.all.each do |i|
           logo = Dir[File.join(LOGOS_PATH, klass.to_s.tableize, "#{ i.id }.*")].first
 
-          if File.exist?(logo)
+          if logo.present? && File.exists?(logo)
             i.logo = File.new(logo)
             i.logo.reprocess!
             i.save!
@@ -27,13 +27,15 @@ namespace :db do
       # = Users
 
       # Create demo user if not present
-      if User.find_by_name('demonstration').blank?
-        User.create! :name => 'demonstration',
-                     :email => 'demonstration@social-stream.dit.upm.es',
+      if User.find_by_name('demo').blank?
+        User.create! :name => 'Demo',
+                     :email => 'demo@social-stream.dit.upm.es',
                      :password => 'demonstration',
                      :password_confirmation => 'demonstration'
       end
 
+      require 'forgery'
+
       9.times do
         User.create! :name => Forgery::Name.full_name,
                      :email => Forgery::Internet.email_address,
@@ -43,49 +45,41 @@ namespace :db do
 
       set_logos(User)
 
-      available_users = User.all
-
       # = Groups
+      available_actors = Actor.all
+
       10.times do
+        founder = available_actors[rand(available_actors.size)]
+
         Group.create :name  => Forgery::Name.company_name,
-                     :email => Forgery::Internet.email_address
+                     :email => Forgery::Internet.email_address,
+                     :_founder => founder.permalink
       end
 
       set_logos(Group)
 
-      available_groups = Group.all
+      # Reload actors to include groups
+      available_actors = Actor.all
 
       # = Ties
-      available_users.each do |u|
-        users = available_users.dup - Array(u)
-        user_relations = %w( friend ).map{ |r| Relation.mode('User', 'User').find_by_name(r) }
-
-        Forgery::Basic.number(:at_most => users.size).times do
-          user = users.delete_at((rand * users.size).to_i)
-          u.sent_ties.create :receiver => user.actor,
-                             :relation => user_relations.random
-        end
-
-        groups = available_groups.dup
-        group_relations = Relation.mode('User', 'Group').all
-
-        Forgery::Basic.number(:at_most => groups.size).times do
-          group = groups.delete_at((rand * groups.size).to_i)
-          u.sent_ties.create :receiver => group.actor,
-                             :relation => group_relations.random
+      available_actors.each do |a|
+        actors = available_actors.dup - Array(a)
+        relations = a.relations
+
+        Forgery::Basic.number(:at_most => actors.size).times do
+          actor = actors.delete_at((rand * actors.size).to_i)
+          a.sent_ties.create :receiver => actor,
+                             :relation => relations.random
         end
       end
 
       # = Posts
 
       SocialStream::Populate.power_law(Tie.all) do |t|
-        # Only Post from users
-        next if t.relation.sender_type == "Group"
-
         updated = Time.at(rand(Time.now))
 
         p = Post.create :text =>
-                      "This post should be for #{ I18n.t('other', :scope => t.relation.name) } of #{ t.receiver.name }.\n#{ Forgery::LoremIpsum.paragraph(:random => true) }",
+                      "This post should be for #{ t.relation.name } of #{ t.sender.name }.\n#{ Forgery::LoremIpsum.paragraph(:random => true) }",
                         :created_at => Time.at(rand(updated)),
                         :updated_at => updated,
                         :_activity_tie_id => t.id