root/branches/facets/radiant/lib/radiant/admin_ui.rb

require 'simpleton'

module Radiant
  class AdminUI
    
    class DuplicateTabNameError < StandardError; end
    
    class Tab
      attr_accessor :name, :url, :visibility
      
      def initialize(name, url, options = {})
        @name, @url = name, url
        @visibility = [options[:for], options[:visibility]].flatten.compact
        @visibility = [:all] if @visibility.empty?
      end
      
      def shown_for?(user)
        visibility.include?(:all) or
          visibility.any? { |role| user.send("#{role}?") }
      end  
    end
    
    class TabSet
      def initialize
        @tabs = []
      end
    
      def add(name, url, options = {})
        options.symbolize_keys!
        before = options.delete(:before)
        after = options.delete(:after)
        tab_name = before || after
        if self[name]
          raise DuplicateTabNameError.new("duplicate tab name `#{name}'")
        else
          if tab_name
            index = @tabs.index(self[tab_name])
            index += 1 if before.nil?
            @tabs.insert(index, Tab.new(name, url, options))
          else
            @tabs << Tab.new(name, url, options)
          end
        end
      end
      
      def remove(name)
        @tabs.delete(self[name])
      end
      
      def size
        @tabs.size
      end
      
      def [](index)
        if index.kind_of? Integer
          @tabs[index]
        else
          @tabs.find { |tab| tab.name == index }
        end
      end
      
      def each
        @tabs.each { |t| yield t }
      end
      
      def clear
        @tabs.clear
      end
      
      include Enumerable
    end
    
    include Simpleton
    
    class PageAdmin      
      class EditUI
        attr_reader :regions
        
        def initialize
          @regions = HashWithIndifferentAccess.new
          @partials = []
        end
        
        def [](name_or_index)          
          case name_or_index
            when String, Symbol
              @partials.find {|p| p == name_or_index.to_s }
            when Integer
              @partials[name_or_index]
          end
        end
        
        def <<(partial)
          add partial
        end
        
        def add(partial, options = {})
          after = options.delete(:after)
          before = options.delete(:before)
          region = options.delete(:region)
          partial_name = before || after
          if region
            @regions[region] ||= []
            if partial_name
              index = @regions[region].empty? ? 0 : (@regions[region].index(partial_name) || @regions[region].size - 1)
              index += 1 if before.nil?
              @regions[region].insert(index, partial)
            else
              @regions[region] << partial
            end
          elsif partial_name
            index = @partials.index(partial_name) || size - 1
            index += 1 if before.nil?
            @partials.insert(index, partial)
          else
            @partials << partial
          end
          return self
        end
        
        def each(&block)
          @partials.each {|p| yield p }
        end
        
        def size
          @partials.size
        end
        
        def clear
          @partials.clear
          @regions.clear
        end
        include Enumerable
      end
      
      attr_reader :edit_partials
      def initialize
        @edit_partials = EditUI.new
      end
    end
    
    attr_accessor :tabs, :page
    
    def initialize
      @tabs = TabSet.new
      @page = PageAdmin.new
    end
    
  end
end