social_stream-base 0.5.0

data/lib/generators/social_stream/base/templates/public/stylesheets/default/spheres.css

@@ -0,0 +1,226 @@
+.ui-radio-state-disabled, .ui-radio-state-checked-disabled, .ui-radio-state-disabled-hover, .ui-radio-state-checked-disabled-hover {
+	color: #999;
+}
+
+span.ui-checkbox, span.ui-radio {
+	display: block;
+	float: left;
+	width: 16px;
+	height: 17px;
+	background: url(/images/icon_checkbox.png) 0 -40px no-repeat;
+	cursor: pointer;
+}
+
+span.ui-helper-hidden {
+	display: none;
+}
+
+label {
+	display: block;
+	font-family: sans-serif;
+	padding: 2px;
+	margin-left: 20px;
+}
+
+label.ui-checkbox {
+	cursor: pointer;
+}
+
+span.ui-radio-state-hover, span.ui-checkbox-state-hover {
+	background-position: 0 -114px;
+}
+
+span.ui-checkbox-state-checked {
+	background-position: 0 -1px;
+}
+
+span.ui-checkbox-state-checked-hover {
+	background-position: 0 -75px;
+}
+
+span.ui-radio-state-checked-disabled-hover,span.ui-radio-state-checked-disabled, span.ui-radio-state-checked {
+	background-position: 0 -161px;
+}
+
+span.ui-radio-state-checked-hover {
+	background-position: 0 -200px;
+}
+
+form {
+	overflow: hidden;
+	height: 1%;
+	margin: 20px 0;
+}
+
+.ui-helper-hidden-accessible {
+	position: absolute;
+	left: -999em;
+}
+
+#wrapper_section{
+	width: 95%;
+	margin-left: 10px;
+}
+
+.checked-option{
+	background-color: #dfecf1;
+}
+
+.pageTitle{
+	color: black;
+	padding: 0px 10px 0px 0px;
+	font-size: 15px;
+}
+
+.sectionTitle{
+	background-color: #dfecf1;
+	color: #4d539d;
+	padding: 15px 20px 15px 20px;
+}
+
+.privacy_add_element{
+	text-align: right;
+	padding: 5px 0px 5px 0px;
+	margin: 0px 10px 15px 0px;
+}
+
+input.privacy_input_new{
+	background-color: #dfecf1;
+	border: 1px solid #1F4A75;
+	color: #1F4A75;
+}
+
+span.privacy_span_new {
+	font-family: sans-serif;
+  margin-right: 10px;
+}
+
+#tableCheckBoxOptions {
+	border: none;
+	width: 100%;
+	padding: 5px 0px 5px 0px;
+}
+
+.tableCheckBoxOptions td {
+	width: 250px;
+}
+
+.checkboxOptionLeft{
+	text-align: left;
+	margin-left: 30px;
+	margin-right: 15px;
+	cursor: pointer;
+}
+
+.checkboxOptionRight{
+	text-align: left;
+	margin-left: 15px;
+	margin-right: 30px;
+}
+
+.checkboxPermissionOptionLeft{
+  text-align: left;
+  margin-left: 5px;
+  margin-right: 3px;
+}
+
+.checkboxPermissionOptionRight{
+  text-align: left;
+  margin-left: 3px;
+  margin-right: 5px;
+}
+
+.selectNew{
+	padding: 0px 0px 0px 0px;
+	margin: 0px 0px 0px 0px;
+}
+
+#slider-range{
+  height:120px;
+  margin-left: auto;
+  margin-right: auto;
+  background-color: #1f4a75;
+}
+
+.slider-div{
+	float: right;
+	margin-right: 5px;
+}
+
+.slider-header, .slider-footer{
+	text-align: center;
+	border: 0; 
+	color: #1f4a75; 
+	font-weight: bold;
+	width: 100%;
+}
+
+.slider-header {
+	margin-bottom: 10px;
+}
+
+.slider-footer {
+	margin-top: 10px;
+}
+
+.privacy_block_section{
+	margin-top: 50px;
+}
+
+.first_block_section{
+  margin-top: 10px;
+}
+
+#permissions_list_block{
+	width: 50%;
+	float: left;
+	text-align: center;
+	display: block;
+}
+
+#privacy_rules{
+	width: 45%;
+	float: right;
+	text-align: center;
+	display: block;
+	border:1px solid #1F4A75;
+}
+
+#columns_container{
+    width: 100%;
+		margin:0 auto;
+}
+
+.privacy_rules_list{
+	text-decoration: none;
+	margin: 20px 10px 20px 50px;
+	text-align: left;
+  list-style-type: square;
+}
+
+.privacy_rules_list li{
+	font-family: sans-serif;
+	padding: 5px 0px 5px 0px;
+}
+
+#relation_custom_permissions_input fieldset{
+	border: 0px;
+	text-align: left;
+}
+
+#relation_custom_permissions_input legend{
+	display: none;
+}
+
+#relation_custom_permissions_input input{
+	display: none;
+}
+
+#loading {
+	background: url('images/loading.gif') no-repeat center center;
+	height: 128px;
+	width: 100%;
+	margin-top: 64px;
+	cursor: wait;
+}
+

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

@@ -0,0 +1,43 @@
+# Default relations for Social Stream
+#
+# Define the default relations and permissions supported by your application
+# Though subjects can customize their own relations, these are the defaults
+# to start up 
+#
+# Detailed information on permissions is available at:
+# http://rdoc.info/gems/social_stream/Permission
+#
+user:
+  friend:
+    name: friend
+    permissions:
+      - [ follow ]                            # follow the activities of the friend
+      - [ create,  activity ]                 # let the friend create activities
+      - [ read,    activity, weak_star_ties ] # friend can read activities from the other friends and below
+      - [ update,  activity ]                 # update her activities
+      - [ destroy, activity ]                 # delete her activities
+    sphere: personal
+  acquaintance:
+    name: acquaintance
+    parent: friend # friend relation is stronger than acquaintance
+    permissions:
+      - [ read,    activity, weak_star_ties ]
+    sphere: personal
+
+group:
+  member:
+    name: member
+    permissions:
+      - [ represent ]                         # let the member act as the group
+      - [ create,  activity ]                 # let them member create activities
+      - [ read,    activity, weak_star_ties ] # read activities from other members
+      - [ update,  activity ]                 # update her activities
+      - [ destroy, activity ]                 # delete her activities
+      - [ read,    tie,      weak_star_ties ]
+    sphere: organization
+  partner:
+    name: partner
+    parent: member # member is stronger than partner
+    permissions:
+      - [ read,    activity, weak_star_ties ]
+    sphere: external_relations

data/lib/paperclip/social_stream.rb

@@ -0,0 +1,6 @@
+# Create new Paperclip::Interpolations method for subtype class
+module Paperclip::Interpolations #:nodoc:
+  def subtype_class attachment, style_name
+    attachment.instance.actor.subject_type.to_s.underscore
+  end
+end

data/lib/social_stream/ability.rb

@@ -0,0 +1,83 @@
+module SocialStream
+  class Ability
+    include CanCan::Ability
+
+    # Create a new ability for this user, who is currently representing subject
+    def initialize(subject)
+
+      # Activity Objects
+      (SocialStream.objects - [ :actor ]).map{ |obj|
+        obj.to_s.classify.constantize
+      }.each do |klass|
+        can :create, klass do |k| # can :create, Post do |post|
+          k._activity_tie.sender_id == subject.actor_id &&
+            k._activity_tie.receiver.allow?(subject, 'create', 'activity')
+        end
+
+        can :read, klass do |k| # can :read, Post do |post|
+          k.post_activity.tie.allow?(subject, 'read', 'activity')
+        end
+
+        can :update, klass do |k| # can :update, Post do |post|
+          k.post_activity.tie.allow?(subject, 'update', 'activity')
+        end
+
+        can :destroy, klass do |k| # can :destroy, Post do |post|
+          k.post_activity.tie.sender_id == Actor.normalize_id(subject) ||
+            k.post_activity.tie.allow?(subject, 'destroy', 'activity')
+        end
+      end
+
+      # Activities
+      can :create, Activity do |a|
+        a.tie.allow?(subject, 'create', 'activity')
+      end
+
+      can :read, Activity do |a|
+        a.tie.allow?(subject, 'read', 'activity')
+      end
+
+      can :update, Activity do |a|
+        a.tie.allow?(subject, 'update', 'activity')
+      end
+
+      can :destroy, Activity do |a|
+        a.tie.allow?(subject, 'destroy', 'activity')
+      end
+
+      # Users
+      can :read, User
+
+      can :update, User do |u|
+        u.represented_by?(subject)
+      end
+
+      # Groups
+      can :read, Group
+
+      can :create, Group do |g|
+        subject.present? &&
+          g._founder == subject.slug
+      end
+
+      can :update, Group do |g|
+        g.represented_by?(subject)
+      end
+
+      can :destroy, Group do |g|
+        g.represented_by?(subject)
+      end
+
+      can :read, Profile
+
+      # Profile
+      can :update, Profile do |p|
+        p.subject.represented_by?(subject)
+      end
+
+      # Privacy
+      can [:create, :read, :update, :destroy], Sphere, :actor_id => subject.try(:actor_id)
+      can [:create, :read, :update, :destroy], Relation::Custom, :sphere => { :actor_id => subject.try(:actor_id) }
+    end
+  end
+end

data/lib/social_stream/base/version.rb

@@ -0,0 +1,5 @@
+module SocialStream
+  module Base
+    VERSION = "0.5.0".freeze
+  end
+end

data/lib/social_stream/base.rb

@@ -0,0 +1,58 @@
+module SocialStream
+  # {SocialStream::Base} provides with the minimal functionality for a web-based
+  # social network: {User users }, {Group groups } and the {Tie ties } between them,
+  # as well as basic activities: {Post posts } and {Comment comments}
+  module Base
+    class Engine < ::Rails::Engine #:nodoc:
+      config.app_generators.authentication :devise
+      config.app_generators.messages :mailboxer
+      config.app_generators.taggings :acts_as_taggable_on
+
+      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 SubjectsHelper
+        ApplicationController.helper LocationHelper
+        ApplicationController.helper ToolbarHelper
+        ApplicationController.helper ProfilesHelper
+        ApplicationController.helper PermissionsHelper
+        ApplicationController.helper NotificationsHelper
+        ApplicationController.helper ContactsHelper
+      
+        ActsAsTaggableOn::TagsHelper
+      end
+
+      initializer "social_stream-base.inflections" do
+        ActiveSupport::Inflector.inflections do |inflect|
+          inflect.singular /^([Tt]ie)s$/, '\1'
+        end
+      end
+
+     initializer "social_stream-base.mime_types" do
+        Mime::Type.register 'application/xrd+xml', :xrd
+      end
+
+      initializer "social_stream-base.controller_helpers" do
+        ActiveSupport.on_load(:action_controller) do
+          include SocialStream::Controllers::Helpers
+        end
+      end
+
+      initializer "social_stream-base.avatars_for_rails" do
+        AvatarsForRails.setup do |config|
+          config.avatarable_model = :actor
+          config.current_avatarable_object = :current_actor
+          config.avatarable_filters = [:authenticate_user!]
+          config.avatarable_styles = { :representation => "20x20>",
+                                       :contact        => "30x30>",
+                                       :actor          => '35x35>',
+                                       :profile        => '94x94'}
+        end
+      end
+    end
+  end
+end

data/lib/social_stream/controllers/helpers.rb

@@ -0,0 +1,83 @@
+module SocialStream
+  module Controllers
+    # Common methods added to ApplicationController
+    module Helpers
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :current_subject
+      end
+
+      module ClassMethods
+        # Add to controllers that have nested subjects. Examples are:
+        #
+        #   class ProfilesController < InheritedResources::Base
+        #     belongs_to_subjects(:singleton => true) # provides /users/demo/profile
+        #   end
+        #
+        #   class ActivitiesController < InheritedResources::Base
+        #     belongs_to_subjects # provides /users/demo/activities
+        #   end
+        #
+        def belongs_to_subjects(options = {})
+          opts = { :polymorphic => true, :finder => :find_by_slug! }.update(options)
+
+          args = SocialStream.subjects + [ opts ]
+
+          belongs_to *args
+        end
+      end
+
+      module InstanceMethods
+        # Current subject represented by the user. Defaults to the own user
+        def current_subject
+          @current_subject ||=
+            current_subject_from_params  ||
+            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
+
+          @current_subject = instance
+        end
+          
+        def current_actor
+            return current_subject.actor
+        end
+          
+
+        # Override Cancan#current_ability method to use {#current_subject}
+        def current_ability
+          @current_ability ||=
+            Ability.new(current_subject)
+        end
+
+        private
+
+        # Get represented subject from params[:s]
+        def current_subject_from_params
+          return unless params[:s].present?
+
+          subject = Actor.find_by_slug!(params[:s]).subject
+
+          unless subject.represented_by?(current_user)
+            raise CanCan::AccessDenied.new("Not authorized!", :represent, subject.name)
+          end
+
+          self.current_subject = subject
+        end
+
+        # 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/object.rb

@@ -0,0 +1,77 @@
+require 'active_support/concern'
+
+module SocialStream
+  module Models
+    # Additional features for models that are Activity Objects
+    module Object
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :_activity_tie_id
+        attr_accessor :_activity_parent_id
+
+        belongs_to :activity_object, :dependent => :destroy, :autosave => true
+        has_many   :activity_object_activities, :through => :activity_object
+
+        delegate :post_activity,
+                 :like_count,
+                 :to => :activity_object
+
+        alias_method_chain :create_activity_object, :type
+        before_create :create_activity_object
+
+        unless self == Actor
+          before_create :create_post_activity
+          before_update :create_update_activity
+
+          validates_presence_of :_activity_tie
+        end
+      end
+
+      module InstanceMethods
+        # All the activities with this object
+        def activities
+          Activity.
+            includes(:activity_objects => self.class.to_s.underscore).
+            where("#{ self.class.quoted_table_name }.id" => self.id)
+        end
+
+        # The activity in which this object was posted
+        #
+        # FIXME: Currently it only supports direct objects
+        def post_activity
+          (activities.includes(:activity_verb) & ActivityVerb.verb_name('post')).first
+        end
+
+        # Create corresponding ActivityObject including this class type
+        def create_activity_object_with_type(attributes = {}) #:nodoc:
+          create_activity_object_without_type attributes.update(:object_type => self.class.to_s)
+        end
+
+        def _activity_tie
+          @_activity_tie ||= Tie.find(_activity_tie_id)
+        end
+
+        private
+
+        def create_post_activity
+          create_activity "post"
+        end
+
+        def create_update_activity
+          create_activity "update"
+        end
+
+        def create_activity(verb)
+          a = Activity.new :verb      => verb,
+                           :_tie      => _activity_tie,
+                           :parent_id => _activity_parent_id
+
+          a.activity_objects << activity_object
+
+          a.save!
+        end
+      end
+    end
+  end
+end

data/lib/social_stream/models/subject.rb

@@ -0,0 +1,114 @@
+require 'active_support/concern'
+
+module SocialStream
+  module Models
+    # {Subject Subjects} are subtypes of {Actor}. {SocialStream} provides two
+    # {Subject Subjects}, {User} and {Group}
+    #
+    # Each {Subject} is defined in +config/initializers/social_stream.rb+
+    #
+    # This module provides additional features for models that are subjects,
+    # extending them. Including the module in each {Subject} model is not required!
+    # After declared in +config/initializers/social_stream.rb+, {SocialStream} is
+    # responsible for adding subject features to each model.
+    #
+    # = Scopes
+    # There are several scopes available for subjects 
+    #
+    # alphabetic:: sort subjects by name
+    # search:: simple search by name
+    # distinct_initials:: get only the first letter of the name
+    # followed:: sort by most following incoming {Tie ties}
+    # liked:: sort by most likes
+    #
+    module Subject
+      extend ActiveSupport::Concern
+      
+      included do
+        belongs_to :actor,
+                   :validate => true,
+                   :autosave => true
+        
+        has_one :profile, :through => :actor
+        
+        validates_presence_of :name
+        
+        accepts_nested_attributes_for :profile
+        
+        scope :alphabetic, joins(:actor).merge(Actor.alphabetic)
+
+        scope :letter, lambda{ |param|
+          joins(:actor).merge(Actor.letter(param))
+        }
+
+        scope :search, lambda{ |param|
+          joins(:actor).merge(Actor.search(param))
+        }
+        
+        scope :tagged_with, lambda { |param|
+          if param.present?
+            joins(:actor => :activity_object).merge(ActivityObject.tagged_with(param))
+          end
+        }
+
+        scope :distinct_initials, joins(:actor).merge(Actor.distinct_initials)
+
+        scope :followed, lambda { 
+          joins(:actor).
+            order("actors.follower_count DESC")
+        }
+
+        scope :liked, lambda { 
+          joins(:actor => :activity_object).
+            order('activity_objects.like_count DESC')
+        }
+
+        scope :most, lambda { |m|
+          types = %w( followed liked )
+
+          if types.include?(m)
+            __send__ m
+          end
+        }
+
+      end
+      
+      module InstanceMethods
+        def actor!
+          actor || build_actor(:subject_type => self.class.to_s)
+        end
+        
+        def to_param
+          slug
+        end
+
+        # Delegate missing methods to {Actor}, if they exist there
+        def method_missing(method, *args, &block)
+          super
+        rescue NameError => subject_error 
+          # These methods must be raised to avoid loops (the :actor association calls here again)
+          exceptions = [ :_actor_id ]
+          raise subject_error if exceptions.include?(method)
+
+          actor!.__send__ method, *args, &block
+        end
+
+        # {Actor} handles some methods
+        def respond_to? *args
+          super || actor!.respond_to?(*args)
+        end
+      end
+      
+      module ClassMethods
+        def find_by_slug(perm)
+          includes(:actor).where('actors.slug' => perm).first
+        end
+        
+        def find_by_slug!(perm)
+          find_by_slug(perm) ||
+            raise(ActiveRecord::RecordNotFound)
+        end 
+      end
+    end
+  end
+end