vkhater-social_stream-base 0.11.2

data/lib/social_stream/ability.rb

@@ -0,0 +1,7 @@
+require 'social_stream/ability/base'
+
+module SocialStream
+  class Ability
+    include SocialStream::Ability::Base
+  end
+end

data/lib/social_stream/ability/base.rb

@@ -0,0 +1,101 @@
+module SocialStream
+  class Ability
+    module Base
+      include CanCan::Ability
+
+      # Create a new ability for this user, who is currently representing subject
+      def initialize(subject)
+        
+        #Download alias action
+        alias_action :download, :to => :show
+        
+        # Activity Objects
+        (SocialStream.objects - [ :actor, :comment ]).map{ |obj|
+          obj.to_s.classify.constantize
+        }.each do |klass|
+          can :create, klass do |k| # can :create, Post do |post|
+            k.build_post_activity.allow?(subject, 'create')
+          end
+
+          can :read, klass do |k| # can :read, Post do |post|
+            k.post_activity.allow?(subject, 'read')
+          end
+
+          can :update, klass do |k| # can :update, Post do |post|
+            k.post_activity.allow?(subject, 'update')
+          end
+
+          can :destroy, klass do |k| # can :destroy, Post do |post|
+            k.post_activity.allow?(subject, 'destroy')
+          end
+        end
+
+        can :create, Comment do |c|
+          c._activity_parent.allow?(subject, 'read')
+        end
+
+        can :read, Comment do |c|
+          c.post_activity.allow?(subject, 'read')
+        end
+
+        can :update, Comment do |c|
+          c.post_activity.allow?(subject, 'update')
+        end
+
+        can :destroy, Comment do |c|
+          c.post_activity.allow?(subject, 'destroy')
+        end
+
+        # Activities
+        can :create, Activity do |a|
+          a.allow?(subject, 'create')
+        end
+
+        can :read, Activity do |a|
+          a.allow?(subject, 'read')
+        end
+
+        can :update, Activity do |a|
+          a.allow?(subject, 'update')
+        end
+
+        can :destroy, Activity do |a|
+          a.allow?(subject, 'destroy')
+        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.author_id == Actor.normalize_id(subject)
+        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], Relation::Custom, :actor_id => subject.try(:actor_id)
+      end
+    end
+  end
+end

data/lib/social_stream/base/dependencies.rb

@@ -0,0 +1,47 @@
+# Database foreign keys
+require 'foreigner'
+# jQuery
+require 'jquery-rails'
+# Permalinks:
+require 'stringex'
+# Hierarchical relationships in Activity and Relation:
+require 'ancestry'
+# Messages
+require 'mailboxer'
+# User authentication
+require 'devise'
+# Authorization
+require 'cancan'
+# REST controllers
+require 'inherited_resources'
+# Scopes in controllers
+require 'has_scope'
+# Logo attachments
+require 'paperclip'
+require 'paperclip/social_stream'
+require 'avatars_for_rails'
+# Pagination
+require 'kaminari'
+# Oauth
+require 'omniauth/oauth'
+#Tags
+require 'acts-as-taggable-on'
+require 'acts_as_taggable_on/social_stream'
+# HTML forms
+require 'formtastic'
+#Background tasks
+require 'resque/server'
+#Simple Navigation for menu
+require 'simple-navigation'
+# Modernizr.js library
+require 'modernizr-rails'
+# Sphinx search engine
+require 'thinking-sphinx'
+# Syntactically Awesome Stylesheets
+require 'sass-rails'
+# Autolink text blocks
+require 'rails_autolink'
+# SocialCheesecake
+require 'social_cheesecake'
+
+

data/lib/social_stream/base/engine.rb

@@ -0,0 +1,69 @@
+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
+
+      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
+          include SocialStream::Controllers::CancanDeviseIntegration
+        end
+      end
+
+      initializer "social_stream-base.toolbar_config" do
+        SocialStream::ToolbarConfig.module_eval do
+          include SocialStream::ToolbarConfig::Base
+        end
+      end
+
+      initializer "social_stream-base.views.settings" do
+        SocialStream::Views::Settings.module_eval do
+          include SocialStream::Views::Settings::Base
+        end
+      end
+
+      initializer "social_stream-base.views.sidebar" do
+        SocialStream::Views::Sidebar.module_eval do
+          include SocialStream::Views::Sidebar::Base
+        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        => '119x119'}
+        end
+      end
+
+      initializer "social_stream-base.mailboxer", :before => :load_config_initializers do
+        Mailboxer.setup do |config|
+          config.email_method = :mailboxer_email
+        end
+      end
+
+      config.to_prepare do
+        ApplicationController.rescue_handlers += [["CanCan::AccessDenied", :rescue_from_access_denied]]
+      end
+    end
+  end
+end

data/lib/social_stream/base/version.rb

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

data/lib/social_stream/controllers/cancan_devise_integration.rb

@@ -0,0 +1,33 @@
+module SocialStream
+  module Controllers
+    # Common methods added to ApplicationController
+    module CancanDeviseIntegration
+      extend ActiveSupport::Concern
+      
+      module InstanceMethods
+
+        private
+
+        # Catch some authorization errors:
+        #
+        # * Redirect to home when the user changes the session and the resource
+        #   is not accesible with the new representation
+        #
+        # * Redirect to login if the user is trying to access a protected resource
+        #   and she is not authenticated
+        def rescue_from_access_denied(exception)
+          if user_signed_in?
+            if params[:s].present? && controller_name != 'home'
+              redirect_to :home
+            else
+              raise exception
+            end
+          else
+            redirect_to new_user_session_path
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/social_stream/controllers/helpers.rb

@@ -0,0 +1,135 @@
+module SocialStream
+  module Controllers
+    # Common methods added to ApplicationController
+    module Helpers
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :current_subject,
+                      :profile_subject,
+                      :profile_or_current_subject,
+                      :profile_subject_is_current?
+      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
+          current_subject.actor
+        end
+
+        # Returns the {SocialStream::Models::Subject subject} that is in the path, or
+        # the {#current_subject} if some {User} is logged in.
+        #
+        # Requirements: the controller must inherit from +InheritedResources::Base+ and the method
+        # {ClassMethods#belongs_to_subjects} must be called
+        #
+        #   class PostsController < InheritedResources::Base
+        #     belongs_to_subjects :optional => true
+        #   end
+        #
+        #   # /users/demo/posts
+        #   profile_subject #=> User demo
+        #
+        #   # /groups/test/posts
+        #   profile_subject #=> Group test
+        #
+        #   # /posts
+        #   profile_subject #=> current_subject
+        #
+        #
+        def profile_subject
+          @profile_subject ||= association_chain[-1] || current_subject
+        end
+
+        # Go to sign in page if {#profile_subject} is blank
+        def profile_subject!
+          @profile_subject ||= association_chain[-1] || warden.authenticate!
+        end
+
+        # Profile subject is suitable for paths like:
+        #   /users/demo/posts
+        #
+        # This method tries {#profile_subject} first and then {#current_subject}
+        def profile_or_current_subject
+          profile_subject || current_subject
+        rescue
+          current_subject
+        end
+
+        # A {User} must be logged in and is equal to {#profile_subject}
+        def profile_subject_is_current?
+          user_signed_in? && profile_subject == current_subject
+        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
+
+          if subject != current_user
+            flash[:notice] ||= ""
+            flash[:notice] += t('representation.notice',
+                                :subject => 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/controllers/objects.rb

@@ -0,0 +1,39 @@
+module SocialStream
+  module Controllers
+    module Objects
+      extend ActiveSupport::Concern
+
+      included do
+        inherit_resources
+
+        before_filter :set_author_ids, :only => [ :new, :create, :update ]
+
+        load_and_authorize_resource :except => :index
+
+        respond_to :html, :js
+
+        # destroy method must be before the one provided by inherited_resources
+        include SocialStream::Controllers::Objects::UpperInstanceMethods
+      end
+
+      # Methods that should be included after the included block
+      module UpperInstanceMethods
+        def destroy
+          @post_activity = resource.post_activity
+
+          destroy!
+        end
+      end
+
+      module InstanceMethods
+
+        protected
+
+        def set_author_ids
+          resource_params.first[:author_id] = current_subject.try(:actor_id)
+          resource_params.first[:user_author_id] = current_user.try(:actor_id)
+        end
+      end
+    end
+  end
+end

data/lib/social_stream/d3.rb

@@ -0,0 +1,53 @@
+module SocialStream
+  # Methods for d3.js library
+  # http://mbostock.github.com/d3/
+  module D3
+    class Force
+      def initialize(ties, view)
+        @view = view
+
+        @force =
+          ties.inject({ :nodes => [], :links => [] }) { |result, t|
+            add_node(result[:nodes], t.sender)
+            add_node(result[:nodes], t.receiver)
+
+            add_link(result[:links], t, result[:nodes])
+
+            result
+          }
+      end
+
+      def to_json
+        @force.to_json
+      end
+
+      private
+
+      def node(actor)
+        { 
+          :name     => actor.name,
+          :logo     => @view.image_path(actor.logo.url(:representation)),
+          :group    => SocialStream.subjects.index(actor.subject_type.underscore.to_sym) + 1
+        }
+      end
+
+      def add_node(nodes, actor)
+        return if nodes_actor_index(nodes, actor)
+
+        nodes << node(actor)
+      end
+
+      def add_link(links, tie, nodes)
+        links << {
+          :source => nodes_actor_index(nodes, tie.sender),
+          :target => nodes_actor_index(nodes, tie.receiver),
+          :value  => 1
+        }
+      end
+
+      def nodes_actor_index(nodes, actor)
+        nodes.index(nodes.find{ |n| n[:name] == actor.name })
+      end
+    end
+  end
+end