monologue 0.1.3 → 0.2.0.beta3

data/app/controllers/monologue/admin/users_controller.rb

@@ -0,0 +1,13 @@
+class Monologue::Admin::UsersController < Monologue::Admin::BaseController
+  def edit
+    @user = current_user
+  end
+
+  def update
+    @user = current_user
+    if @user.update_attributes(params[:user])
+      flash.notice = "User modified"
+    end
+    render :edit
+  end
+end

data/app/controllers/monologue/application_controller.rb

@@ -1,7 +1,20 @@
 class Monologue::ApplicationController < ApplicationController
-  
+
   layout Monologue.layout if Monologue.layout # TODO: find a way to test that. It was asked in issue #54 (https://github.com/jipiboily/monologue/issues/54)
 
+  before_filter :recent_posts, :all_tags
+
+  def recent_posts
+    @recent_posts = Monologue::Post.published.limit(3)
+  end
+
+  def all_tags
+    @tags = Monologue::Tag.all(:order => "name").select{|t| t.frequency>0}
+    #could use minmax here but it's only supported with ruby > 1.9'
+    @tags_frequency_min = @tags.map{|t| t.frequency}.min
+    @tags_frequency_max = @tags.map{|t| t.frequency}.max
+  end
+
   def not_found
     # fallback to the default 404.html page from main_app.
     file = Rails.root.join('public', '404.html')
@@ -12,13 +25,16 @@ class Monologue::ApplicationController < ApplicationController
       render :action => "404", :status => 404, :formats => [:html]
     end
   end
-  
-  
+
   private
 
     def current_user
-      @current_user ||= Monologue::User.find(session[:user_id]) if session[:user_id]
+      @monologue_current_user ||= Monologue::User.find(session[:monologue_user_id]) if session[:monologue_user_id]
     end
-  
-  helper_method :current_user
+
+    def monologue_page_cache_enabled?
+      current_user.nil? && Monologue::PageCache.enabled
+    end
+
+  helper_method :current_user, :monologue_page_cache_enabled?
 end

data/app/controllers/monologue/posts_controller.rb

@@ -1,24 +1,24 @@
 class Monologue::PostsController < Monologue::ApplicationController
-  caches_page :index, :show, :feed , :if => Proc.new { current_user.nil? }
+  caches_page :index, :show, :feed , :if => Proc.new { monologue_page_cache_enabled? }
 
   def index
     @page = params[:page].nil? ? 1 : params[:page]
     @posts = Monologue::Post.published.page(@page)
   end
-  
+
   def show
-    unless current_user
-      post = Monologue::Post.published.where("monologue_posts_revisions.url = :url", {:url => params[:post_url]}).first
-    else
+    if current_user
       post = Monologue::Post.default.where("monologue_posts_revisions.url = :url", {:url => params[:post_url]}).first
+    else
+      post = Monologue::Post.published.where("monologue_posts_revisions.url = :url", {:url => params[:post_url]}).first
     end
     if post.nil?
       not_found
       return
     end
-    @revision = post.posts_revisions.first
+    @revision = post.active_revision
   end
-  
+
   def feed
     @posts = Monologue::Post.published.limit(25)
   end

data/app/controllers/monologue/tags_controller.rb

@@ -0,0 +1,12 @@
+class Monologue::TagsController < Monologue::ApplicationController
+  caches_page :show , :if => Proc.new { monologue_page_cache_enabled? }
+  def show
+    @tag = Monologue::Tag.find_by_name(params[:tag])
+    if @tag
+      @page = nil
+      @posts = @tag.posts_with_tag
+    else
+      redirect_to :root ,:notice => "No post found with label \"#{params[:tag]}\""
+    end
+  end
+end

data/app/helpers/monologue/application_helper.rb

@@ -1,5 +1,9 @@
 module Monologue
   module ApplicationHelper
+    include Monologue::Engine.routes.url_helpers if ENV["RAILS_ENV"] == "test" # TODO: try and see why this is needed for specs to pass
+    #Number of sizes defined in the css
+    NUMBER_OF_LABEL_SIZES = 5
+
     def monologue_admin_form_for(object, options = {}, &block)
       options[:builder] = MonologueAdminFormBuilder
       form_for(object, options, &block)
@@ -8,5 +12,77 @@ module Monologue
     def monologue_accurate_title
       content_for?(:title) ? ((content_for :title) + " | #{Monologue.site_name}") : Monologue.site_name
     end
+
+    def sidebar_section_for(title, &block)
+      content_tag(:section, :class => 'widget') do
+        content_tag(:header, content_tag(:h1, title)) +
+            capture(&block)
+      end
+    end
+
+    def rss_head_link
+      tag("link", :href => feed_url, :rel => "alternate", :title => "RSS", :type => "application/rss+xml")
+    end
+
+    def rss_icon
+      social_icon("rss", feed_url, Monologue.show_rss_icon)
+    end
+
+    def github_icon
+      social_icon("github", "http://github.com/#{Monologue.github_username}", Monologue.github_username)
+    end
+
+    def twitter_icon
+      social_icon("twitter", "http://twitter.com/#{Monologue.twitter_username}", Monologue.twitter_username)
+    end
+
+    def linkedin_icon
+      social_icon("linkedin", Monologue.linkedin_url, Monologue.linkedin_url)
+    end
+
+    def googleplus_icon
+      social_icon("google-plus", Monologue.google_plus_account_url, Monologue.google_plus_account_url)
+    end
+
+    def facebook_icon
+      social_icon("facebook", Monologue.facebook_url, Monologue.facebook_url)
+    end
+
+    def absolute_image_url(url)
+       return url if url.starts_with? "http"
+       request.protocol + request.host + url
+    end
+
+    # TODO: That should be move in TagHelper if I manage to get that loaded
+    def tag_url(tag)
+      "#{Monologue::Engine.routes.url_helpers.root_path}tags/#{tag.name.downcase}"
+    end
+
+    def label_for_tag(tag, min, max)
+      "label-size-#{size_for_tag(tag, min, max)}"
+    end
+
+    def size_for_tag(tag, min, max)
+      #logarithmic scaling based on the number of occurrences of each tag
+      if min<max && tag.frequency>0
+        1 + ((NUMBER_OF_LABEL_SIZES-1)*(log_distance_to_min(tag.frequency, min))/log_distance_to_min(max, min)).round
+      else
+        1
+      end
+    end
+
+    private
+    def social_icon foundicon, url, setting
+      return if setting.nil? || !setting
+      content_tag :a, :href => url, :class => "social", :target => "_blank" do
+        content_tag :i, :class => "foundicon-#{foundicon}" do # using an empty content tag for foundicons to appear. TODO: try to do otherwise and use only tag method
+        end
+      end
+    end
+
+    def log_distance_to_min(value, min)
+      Math.log(value)-Math.log(min)
+    end
+
   end
 end

data/app/helpers/monologue/tags_helper.rb

@@ -0,0 +1,5 @@
+module Monologue
+  module TagsHelper
+
+  end
+end

data/app/models/monologue/post.rb

@@ -1,40 +1,54 @@
-module Monologue
-  class Post < ActiveRecord::Base
-    has_many :posts_revisions, :dependent => :destroy
+class Monologue::Post < ActiveRecord::Base
+  has_many :posts_revisions, :dependent => :destroy
+  has_many :taggings
+  has_many :tags, :through => :taggings, :dependent => :destroy
 
-    accepts_nested_attributes_for :posts_revisions
-    attr_accessible :posts_revisions_attributes
-    attr_accessible :published
+  accepts_nested_attributes_for :posts_revisions
+  attr_writer :tag_list
+  attr_accessible :posts_revisions_attributes, :published, :tag_list
 
-    
-    
-    scope :default, includes(:posts_revisions).where("posts_revision_id = monologue_posts_revisions.id").order("published_at DESC")
-    scope :published, default.where(:published => true).where("published_at <= ?", DateTime.now)
+  scope :default, includes(:posts_revisions).where("posts_revision_id = monologue_posts_revisions.id").order("published_at DESC")
+  scope :published, default.where(:published => true).where("published_at <= ?", DateTime.now)
 
-    validates :posts_revision_id, :uniqueness => true
+  default_scope includes(:tags)
 
-    def just_the_revision_one_before
-      self.posts_revisions.where("post_id = ?", self.id).order("monologue_posts_revisions.updated_at DESC").offset(1).limit(1).first
-    end
+  validates :posts_revision_id, :uniqueness => true
 
-    def latest_revision
-      self.posts_revisions.where("post_id = ?", self.id).order("monologue_posts_revisions.updated_at DESC").limit(1).first
-    end
+  # TODO: move that in a spec helper as it only used by tests
+  def just_the_revision_one_before
+    self.posts_revisions.where("post_id = ?", self.id).order("monologue_posts_revisions.updated_at DESC").offset(1).limit(1).first
+  end
 
-    def self.page p
-      per_page = Monologue.posts_per_page || 10
-      set_total_pages(per_page)
-      p = (p.nil? ? 0 : p.to_i - 1)
-      offset =  (p==0 ? 0 : p * per_page)
-      self.limit(per_page).offset(offset)
-    end
+  def latest_revision
+    self.posts_revisions.where("post_id = ?", self.id).order("monologue_posts_revisions.updated_at DESC").limit(1).first
+  end
 
-    def self.total_pages
-      @number_of_pages
-    end
+  def active_revision
+    Monologue::PostsRevision.find(self.posts_revision_id)
+  end
 
-    def self.set_total_pages per_page
-      @number_of_pages = self.count / per_page + ( self.count % per_page == 0 ? 0 : 1 )
+  def tag!(tags)
+    self.tags = tags.select { |t| t.present? }.map do |tag|
+      tag.strip!
+      if tag.present?
+        Monologue::Tag.find_or_create_by_name(tag)
+      end
     end
   end
+
+  def self.page p
+    per_page = Monologue.posts_per_page || 10
+    set_total_pages(per_page)
+    p = (p.nil? ? 0 : p.to_i - 1)
+    offset = (p==0 ? 0 : p * per_page)
+    self.limit(per_page).offset(offset)
+  end
+
+  def self.total_pages
+    @number_of_pages
+  end
+
+  def self.set_total_pages per_page
+    @number_of_pages = self.count / per_page + (self.count % per_page == 0 ? 0 : 1)
+  end
 end

data/app/models/monologue/posts_revision.rb

@@ -1,63 +1,61 @@
-module Monologue
-  class PostsRevision < ActiveRecord::Base
-    attr_accessible :title, :content, :url, :published_at
+class Monologue::PostsRevision < ActiveRecord::Base
+  attr_accessible :title, :content, :url, :published_at
 
-    before_validation :generate_url
+  before_validation :generate_url
 
-
-    after_save :latest_revision_is_current
-    
-    belongs_to :post
-    belongs_to :user
+  after_save :latest_revision_is_current
     
-    validates :title, :presence =>  true
-    validates :content, :presence =>  true
-    validates :url, :presence =>  true
-    validate :url_do_not_start_with_slash
-    validate :url_is_unique
-    validates :user_id, :presence =>  true
+  belongs_to :post
+  belongs_to :user
+  
+  validates :title, :presence =>  true
+  validates :content, :presence =>  true
+  validates :url, :presence =>  true
+  validate :url_do_not_start_with_slash
+  validate :url_is_unique
+  validates :user_id, :presence =>  true
 #    validates :post_id, :presence =>  true # TODO: do something about this validation on the first creation of a POST
-    validates :published_at, :presence =>  true
-    
-    def latest_revision_is_current
-      post = Monologue::Post.find(self.post_id)
-      post.posts_revision_id = self.id
-      post.save!
-    end
+  validates :published_at, :presence =>  true
+  
+  #isn't it post concern?'
+  def latest_revision_is_current
+    #post = Monologue::Post.find(self.post_id)
+    self.post.posts_revision_id = self.id
+    self.post.save!
+  end
 
-    def full_url
-      "#{Monologue::Engine.routes.url_helpers.root_path}#{self.url}"
-    end
+  def full_url
+    "#{Monologue::Engine.routes.url_helpers.root_path}#{self.url}"
+  end
 
-    def url_do_not_start_with_slash
-      errors.add(:url, I18n.t("activerecord.errors.models.monologue/posts_revision.attributes.url.start_with_slash")) if self.url.start_with?("/")
-    end
+  def url_do_not_start_with_slash
+    errors.add(:url, I18n.t("activerecord.errors.models.monologue/posts_revision.attributes.url.start_with_slash")) if self.url.start_with?("/")
+  end
 
-    def url_is_unique
-      errors.add(:url, I18n.t("activerecord.errors.models.monologue/posts_revision.attributes.url.unique")) if self.url_exists?
-    end
+  def url_is_unique
+    errors.add(:url, I18n.t("activerecord.errors.models.monologue/posts_revision.attributes.url.unique")) if self.url_exists?
+  end
 
-    def url_exists?
-      if self.post_id.nil?
-        return Monologue::PostsRevision.where("url = ?", self.url).count > 0
-      else
-        return Monologue::PostsRevision.where("url = ? and post_id <> ?", self.url, self.post_id).count > 0
-      end
+  def url_exists?
+    if self.post_id.nil?
+      return Monologue::PostsRevision.where("url = ?", self.url).count > 0
+    else
+      return Monologue::PostsRevision.where("url = ? and post_id <> ?", self.url, self.post_id).count > 0
     end
+  end
 
-    private 
-
-      def generate_url
-        year = self.published_at.class == ActiveSupport::TimeWithZone ? self.published_at.year : DateTime.now.year
-        self.title = "" if self.title.nil?
-        base_title = "#{year}/#{self.title.parameterize}"
-        url_empty = self.url.nil? || self.url.strip == ""
-        self.url = base_title if url_empty
-        while self.url_exists? && url_empty
-          i ||= 1
-          self.url = "#{base_title}-#{i}"
-          i += 1
-        end
+  private 
+
+    def generate_url
+      year = self.published_at.class == ActiveSupport::TimeWithZone ? self.published_at.year : DateTime.now.year
+      return if self.title.blank?
+      base_title = "#{year}/#{self.title.parameterize}"
+      url_empty = self.url.nil? || self.url.strip == ""
+      self.url = base_title if url_empty
+      while self.url_exists? && url_empty
+        i ||= 1
+        self.url = "#{base_title}-#{i}"
+        i += 1
       end
-  end
-end
+    end
+end

data/app/models/monologue/tag.rb

@@ -0,0 +1,16 @@
+class Monologue::Tag < ActiveRecord::Base
+  attr_accessible :name
+
+  validates :name, :uniqueness => true,:presence => true
+  has_many :taggings
+  has_many :posts,:through=> :taggings
+
+  def posts_with_tag
+    self.posts.published
+  end
+
+  def frequency
+    posts_with_tag.size
+  end
+
+end

data/app/models/monologue/tagging.rb

@@ -0,0 +1,4 @@
+class Monologue::Tagging < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :tag
+end

data/app/models/monologue/user.rb

@@ -3,4 +3,5 @@ class Monologue::User < ActiveRecord::Base
   attr_accessible :name, :email, :password, :password_confirmation
   has_secure_password
   validates_presence_of :password, :on => :create
+  validates_presence_of :name, :email
 end

data/app/sweepers/monologue/posts_sweeper.rb

@@ -1,29 +1,45 @@
 class Monologue::PostsSweeper < ActionController::Caching::Sweeper
   observe Monologue::Post
 
-
   def sweep(post)
+    if ActionController::Base.perform_caching && Monologue::PageCache.enabled && Monologue::PageCache.wipe_enabled && Monologue::PageCache.wipe_after_save && (ActionController::Base.page_cache_directory != Rails.public_path)
+      Monologue::TotalSweeper.wipe_all
+    else
+      sweep_for_single_post post
+    end
+  end
+
+  def sweep_for_single_post post
     return unless post.published
     root_path = Monologue::Engine.routes.url_helpers.root_path if root_path.nil? # TODO: why do I have to do this to make tests pass? There must be something much more clean to make tests pass
     page_cache_directory = Rails.public_path if page_cache_directory.nil? # TODO: we should not need this either...
+
+    # post
     if post.posts_revisions.count > 0
-      current_post_path = "#{page_cache_directory}#{post.just_the_revision_one_before.url}.html" unless post.just_the_revision_one_before.nil?
-      current_post_path = "#{page_cache_directory}#{post.posts_revisions.last.url}.html" if post.posts_revisions.count == 1
+      current_post_path = "#{page_cache_directory}#{root_path}#{post.just_the_revision_one_before.url}.html" unless post.just_the_revision_one_before.nil?
+      current_post_path = "#{page_cache_directory}#{root_path}#{post.posts_revisions.last.url}.html" if post.posts_revisions.count == 1
       File.delete current_post_path if File.exists? current_post_path
     end
 
+    # tags
+    tags_path = "#{page_cache_directory}#{root_path}tags"
+    FileUtils.rm_rf tags_path
+
+    # feed
     feed_file_path = "#{page_cache_directory}#{root_path}feed.rss"
     File.delete feed_file_path if File.exists? feed_file_path
 
+    # root
     root_file_path = "#{page_cache_directory}#{root_path.chomp("/")}.html"
     root_file_path = "#{page_cache_directory}/index.html" if root_path.chomp("/") == "" # TODO: add test for that? It would need another dummy app mounted at root...?
     File.delete root_file_path if File.exists? root_file_path
 
+    # paging
     FileUtils.rm_rf "#{page_cache_directory}/page" # remove pages
   end
 
   alias_method :after_create, :sweep
-  alias_method :after_update, :sweep 
+  alias_method :after_update, :sweep
   alias_method :after_destroy, :sweep
 
 end