typo 3.99.0

data/lib/generators/sidebar/templates/components/plugins/sidebars/controller_template.rb

@@ -0,0 +1,20 @@
+class Plugins::Sidebars::<%= class_name %>Controller < Sidebars::ComponentPlugin
+  # display_name "<%= class_name.underscore.humanize %>" # Default
+  description "Describe your sidebar here"
+
+  # Declare your settings.
+
+  setting :title,     display_name
+
+  # Check the other sidebars for the sort of thing you can do with
+  # setting declarations. Expect more documentation when it's
+  # written.
+
+  # setting :key,       'some text'
+  # setting :selection, 'foo', :choices => %{foo bar baz}
+  # setting :flag,       true, :input_type => :checkbox
+
+  def content
+
+  end
+end

data/lib/generators/sidebar/templates/components/plugins/sidebars/views/content_template.rhtml

@@ -0,0 +1,4 @@
+<h3><%%=h title %></h3>
+<div>
+  <!-- Your content goes here -->
+</div>

data/lib/jabber_notify.rb

@@ -0,0 +1,32 @@
+require 'jabber4r/jabber4r'
+
+class JabberNotify
+  @@jabber = nil
+
+  def self.send_message(user, subject, body, html)
+    return if user.jabber.blank?
+
+    begin
+      STDERR.puts "** Sending #{body} to #{user.jabber} via jabber."
+      message = session.new_message(user.jabber)
+      message.subject = subject
+      message.body = body
+      message.xhtml = html
+      message.send
+    rescue => err
+      logger.error "Attempt to use jabber failed: #{err.inspect}" if logger
+    end
+  end
+
+  private
+  def self.session
+    return @@jabber if @@jabber
+
+    address = this_blog.jabber_address
+    unless address =~ /\//
+      address = address + '/typo'
+    end
+
+    @@jabber ||= Jabber::Session.bind(address, this_blog.jabber_password)
+  end
+end

data/lib/login_system.rb

@@ -0,0 +1,85 @@
+module LoginSystem
+
+  protected
+
+  # overwrite this if you want to restrict access to only a few actions
+  # or if you want to check if the user has the correct rights
+  # example:
+  #
+  #  # only allow nonbobs
+  #  def authorize?(user)
+  #    user.login != "bob"
+  #  end
+  def authorize?(user)
+     true
+  end
+
+  # overwrite this method if you only want to protect certain actions of the controller
+  # example:
+  #
+  #  # don't protect the login and the about method
+  #  def protect?(action)
+  #    if ['action', 'about'].include?(action)
+  #       return false
+  #    else
+  #       return true
+  #    end
+  #  end
+  def protect?(action)
+    true
+  end
+
+  # login_required filter. add
+  #
+  #   before_filter :login_required
+  #
+  # if the controller should be under any rights management.
+  # for finer access control you can overwrite
+  #
+  #   def authorize?(user)
+  #
+  def login_required
+
+    if not protect?(action_name)
+      return true
+    end
+
+    if session[:user] and authorize?(session[:user])
+      return true
+    end
+
+    # store current location so that we can
+    # come back after the user logged in
+    store_location
+
+    # call overwriteable reaction to unauthorized access
+    access_denied
+    return false
+  end
+
+  # overwrite if you want to have special behavior in case the user is not authorized
+  # to access the current operation.
+  # the default action is to redirect to the login screen
+  # example use :
+  # a popup window might just close itself for instance
+  def access_denied
+    redirect_to :controller=>"/accounts", :action =>"login"
+  end
+
+  # store current uri in  the session.
+  # we can return to this location by calling return_location
+  def store_location
+    session[:return_to] = request.request_uri
+  end
+
+  # move to the last store_location call or to the passed default one
+  def redirect_back_or_default(default)
+    if session[:return_to].nil?
+      redirect_to default
+    else
+      redirect_to_url session[:return_to]
+      session[:return_to] = nil
+    end
+  end
+
+end

data/lib/migrator.rb

@@ -0,0 +1,28 @@
+module Migrator
+  mattr_accessor :offer_migration_when_available
+  @@offer_migration_when_available = true
+
+  def self.migrations_path
+    "#{RAILS_ROOT}/db/migrate"
+  end
+
+  def self.available_migrations
+    Dir["#{migrations_path}/[0-9]*_*.rb"].sort_by { |name| name.scan(/\d+/).first.to_i }
+  end
+
+  def self.current_schema_version
+    ActiveRecord::Migrator.current_version rescue 0
+  end
+
+  def self.max_schema_version
+    available_migrations.size
+  end
+
+  def self.db_supports_migrations?
+    ActiveRecord::Base.connection.supports_migrations?
+  end
+
+  def self.migrate(version = nil)
+    ActiveRecord::Migrator.migrate("#{migrations_path}/", version)
+  end
+end

data/lib/rails_patch/active_record.rb

@@ -0,0 +1,36 @@
+module ActiveRecord
+  class Base
+    def self.find_boolean(find_type, field, value=true, *options)
+      self.find(find_type,
+                :conditions => ["#{field} = ?", value], *options)
+    end
+  end
+
+  # Horrible monkey patch 'til Rails fixes this
+  module ConnectionAdapters
+    class MysqlAdapter
+      def change_column(table_name, column_name, type, options ={ }) #:nodoc:
+        if options[:default].nil?
+          options[:default] =
+            select_one("SHOW COLUMNS FROM #{table_name} LIKE '#{column_name}'")["Default"]
+        end
+        change_column_sql = "ALTER TABLE #{table_name} CHANGE #{column_name} #{column_name} #{type_to_sql(type, options[:limit])}"
+        add_column_options!(change_column_sql, options)
+        execute(change_column_sql)
+      end
+    end
+
+    class SqliteAdapter
+      def change_column(table_name, column_name, type, options ={ }) #:nodoc:
+        alter_table(table_name) do |definition|
+          definition[column_name].instance_eval do
+            self.type    = type
+            self.limit   = options[:limit] if options[:limit]
+            self.default = options[:default] unless options[:default].nil?
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/rails_patch/components.rb

@@ -0,0 +1,14 @@
+module ActionController #:nodoc:
+  module Components
+    module InstanceMethods
+      private
+
+      # By default, this logs *WAY* too much data for us when we're doing sidebars--I've seen ~2M
+      # per hit.  This has a negative impact on performance.
+      alias_method :component_logging_with_unfiltered_options, :component_logging
+      def component_logging(options, &block)
+        component_logging_with_unfiltered_options(options.reject {|k,v| k==:params}, &block)
+      end
+    end
+  end
+end

data/lib/sidebars/component_plugin.rb

@@ -0,0 +1,5 @@
+module Sidebars
+  class Sidebars::ComponentPlugin < Sidebars::Plugin
+    self.template_root = File.join RAILS_ROOT, "components"
+  end
+end

data/lib/sidebars/plugin.rb

@@ -0,0 +1,241 @@
+module Sidebars
+  class Field
+    attr_accessor :key
+    attr_accessor :options
+    include ApplicationHelper
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::FormTagHelper
+    include ActionView::Helpers::FormOptionsHelper
+
+    def initialize(key = nil, options = { })
+      @key, @options = key.to_s, options
+    end
+
+    def label_html(sidebar)
+      content_tag('label', options[:label] || key.humanize.gsub(/url/i, 'URL'))
+    end
+
+    def input_html(sidebar)
+      text_field_tag(input_name(sidebar), sidebar.config[key], options)
+    end
+
+    def line_html(sidebar)
+      label_html(sidebar) +  "<br />" + input_html(sidebar) + "<br />"
+    end
+
+    def input_name(sidebar)
+      "configure[#{sidebar.id}][#{key}]"
+    end
+
+    class SelectField < self
+      def input_html(sidebar)
+        select_tag(input_name(sidebar),
+                   options_for_select(options[:choices], sidebar.config[key]),
+                   options)
+      end
+    end
+
+    class TextAreaField < self
+      def input_html(sidebar)
+        html_options = { "rows" => "10", "cols" => "30", "style" => "width:255px"}.update(options.stringify_keys)
+        text_area_tag(input_name(sidebar), sidebar.config[key], html_options)
+      end
+    end
+
+    class RadioField < self
+      def input_html(sidebar)
+        options[:choices].collect do |choice|
+          value = value_for(choice)
+          radio_button_tag(input_name(sidebar), value,
+                           value == sidebar.config[key], options) +
+            content_tag('label', label_for(choice))
+        end.join("<br />")
+      end
+
+      def label_for(choice)
+        choice.is_a?(Array) ? choice.last : choice.to_s.humanize
+      end
+
+      def value_for(choice)
+        choice.is_a?(Array) ? choice.first : choice
+      end
+    end
+
+    class CheckBoxField < self
+      def input_html(sidebar)
+        check_box_tag(input_name(sidebar), 1, !sidebar.config[key].blank?, options)
+      end
+
+      def line_html(sidebar)
+        input_html(sidebar) + ' ' + label_html(sidebar) + '<br >'
+      end
+    end
+
+    def self.build(key, options)
+      field = class_for(options).new(key, options)
+    end
+
+    def self.class_for(options)
+      case options[:input_type]
+      when :text_area
+        TextAreaField
+      when :textarea
+        TextAreaField
+      when :radio
+        RadioField
+      when :checkbox
+        CheckBoxField
+      when :select
+        SelectField
+      else
+        if options[:choices]
+          SelectField
+        else
+          self
+        end
+      end
+    end
+  end
+
+
+  class Sidebars::Plugin < ApplicationController
+    include ApplicationHelper
+
+    helper :theme
+
+    #  skip_before_filter :get_the_blog_object
+    #  skip_after_filter :flush_the_blog_object
+
+    @@subclasses = { }
+
+    class << self
+      def inherited(child)
+        @@subclasses[self] ||= []
+        @@subclasses[self] |= [child]
+        super
+      end
+
+      def subclasses
+        @@subclasses[self] ||= []
+        @@subclasses[self] + extra =
+          @@subclasses[self].inject([]) {|list, subclass| list | subclass.subclasses }
+      end
+
+      def available_sidebars
+        @@available_sidebars ||= Sidebars::Plugin.subclasses.select do |sidebar|
+          sidebar.subclasses.empty?
+        end
+      end
+
+
+      # The name that needs to be used when refering to the plugin's
+      # controller in render statements
+      def component_name
+        if (self.to_s=~/::([a-zA-Z]+)Controller/)
+          "plugins/sidebars/#{$1}".underscore
+        else
+          raise "I don't know who I am: #{self.to_s}"
+        end
+      end
+
+      # The name that's stored in the DB.  This is the final chunk of the
+      # controller name, like 'xml' or 'flickr'.
+      def short_name
+        component_name.split(%r{/}).last
+      end
+
+      @@display_name_of = { }
+      @@description_of  = { }
+
+      # The name that shows up in the UI
+      def display_name(new_dn = nil)
+        # This is the default, but it's best to override it
+        self.display_name = new_dn if new_dn
+        @@display_name_of[self] || short_name.humanize
+      end
+
+      def display_name=(name)
+        @@display_name_of[self] = name
+      end
+
+      def description(new_desc = nil)
+        self.description = new_desc if new_desc
+        @@description_of[self] || short_name.humanize
+      end
+
+      def description=(desc)
+        @@description_of[self] = desc
+      end
+
+      @@fields = { }
+      @@default_config = { }
+      def setting(key, default=nil, options={ })
+        fields << Field.build(key, options)
+        default_config[key.to_s] = default
+        self.send(:define_method, key) do
+          @sb_config[key.to_s]
+        end
+        self.helper_method(key)
+      end
+
+      def default_config
+        @@default_config[self] ||= HashWithIndifferentAccess.new
+      end
+
+      def default_config=(newval)
+        @@default_config[self] = newval
+      end
+
+      def fields
+        @@fields[self] ||= []
+      end
+
+      def fields=(newval)
+        @@fields[self] = newval
+      end
+
+      def default_helper_module!
+      end
+    end
+
+    def index
+      @sidebar=params['sidebar']
+      @sb_config = @sidebar.config || self.class.default_config
+      content
+      render :action=>'content' unless performed?
+    end
+
+    def configure_wrapper
+      @sidebar=params['sidebar']
+      @sidebar.config ||= (self.class.default_config)
+      configure
+      render :action=>'configure' unless performed?
+    end
+
+    # This controller is used on to actually display sidebar items.
+    def content
+    end
+
+    # This controller is used to configure the sidebar from /admin/sidebar
+    def configure
+      render :partial => 'sidebar/row', :collection => self.class.fields
+    end
+
+    private
+    def sb_config(key)
+      config = @sidebar.class.default_config
+      config.merge!(@sidebar.config || {})
+      config[key.to_s]
+    end
+
+    # Horrid hack to make check_cache happy
+    def controller
+      self
+    end
+
+    def log_processing
+      logger.info "\n\nProcessing #{controller_class_name}\##{action_name} (for #{request_origin})"
+    end
+
+  end
+end