adva-core 0.0.1

data/app/controllers/admin/base_controller.rb

@@ -0,0 +1,21 @@
+require 'adva/controller/internal_redirect'
+require 'inherited_resources'
+require 'inherited_resources/helpers'
+
+class Admin::BaseController < InheritedResources::Base
+  include UrlHelper
+
+  respond_to :html
+  layout 'admin'
+
+  helper_method :account, :tabs
+  delegate :account, :to => :site
+
+  def self.responder
+    Adva::Responder
+  end
+
+  def tabs
+    @tabs ||= Adva::View::Tabs.new
+  end
+end

data/app/controllers/admin/pages_controller.rb

@@ -0,0 +1,9 @@
+class Admin::PagesController < Admin::SectionsController
+  purges :create, :update
+  
+  def update
+    update! do |success, failure|
+      failure.html { render :show }
+    end
+  end
+end

data/app/controllers/admin/sections_controller.rb

@@ -0,0 +1,36 @@
+class Admin::SectionsController < Admin::BaseController
+  belongs_to :site
+
+  before_filter :set_params_for_nested_resources, :only => [:new, :create, :edit, :update]
+  before_filter :protect_last_section, :only => :destroy
+
+  helper :sections
+  abstract_actions :except => [:index, :destroy]
+
+  purges :destroy
+
+  def create
+    resource.save
+    respond_with *resources
+  end
+
+  protected
+
+    def set_params_for_nested_resources
+      params[:section] ||= { :type => 'Page' }
+      if params[:section][:type] == 'Page'
+        # FIXME! this seems to insert tons of empty articles on update if :article_attributes is empty.
+        # shouldn't happen with a regular form submit but still seems a bit ugly
+        params[:section][:article_attributes] ||= { :body => '' } if params[:action] == 'new'
+      else
+        params[:section].delete(:article_attributes)
+      end
+    end
+
+    def protect_last_section
+      if site.sections.count == 1
+        flash[:error] = t(:'flash.actions.destroy.alert', :resource_name => resource.class.model_name)
+        respond_with(resources)
+      end
+    end
+end

data/app/controllers/admin/sites_controller.rb

@@ -0,0 +1,18 @@
+class Admin::SitesController < Admin::BaseController
+  purges :update, :destroy
+
+  before_filter :set_params_for_nested_resources, :only => [:new, :edit]
+  before_filter :set_account, :only => :create
+
+  helper :sections
+
+  protected
+
+    def set_params_for_nested_resources
+      params[:site] ||= { :host => request.host, :sections_attributes => [{ :name => '' }] }
+    end
+
+    def set_account
+      params[:site][:account_id] = Account.first.id # TODO
+    end
+end

data/app/controllers/articles_controller.rb

@@ -0,0 +1,3 @@
+class ArticlesController < BaseController
+  belongs_to :page, :singleton => true
+end

data/app/controllers/base_controller.rb

@@ -0,0 +1,22 @@
+require 'inherited_resources'
+require 'inherited_resources/helpers'
+require 'simple_table'
+
+ActionView::Base.send(:include, SimpleTable) # TODO should be in simple_table
+
+class BaseController < InheritedResources::Base
+  begin_of_association_chain :site
+  tracks :resource, :resources, :collection, :site => %w(.title .name .sections)
+
+  layout 'default'
+  helper_method :account, :site
+  delegate :account, :to => :site
+
+  def self.responder
+    Adva::Responder
+  end
+
+  def site
+    @site ||= Site.by_host(request.host_with_port)
+  end
+end

data/app/controllers/installations_controller.rb

@@ -0,0 +1,28 @@
+class InstallationsController < BaseController
+  defaults :resource_class => Site, :instance_name => 'site'
+  
+  layout 'simple'
+  helper :sections
+
+  before_filter :set_params_for_nested_resources, :only => [:new, :create]
+  before_filter :protect_install,  :only => [:new, :create]
+
+  def create
+    @site = Site.install(params)
+    respond_with resource
+  end
+
+  protected
+    def set_params_for_nested_resources
+      params[:site] ||= {}
+      params[:site].reverse_merge!(:host => request.host_with_port, :title => params[:site][:name], :account_attributes => {})
+      params[:site][:sections_attributes] ||= [{ :type => 'Page', :name => I18n.t(:'section.default_name', :default => 'Home') }]
+    end
+    
+    def protect_install
+      if Site.find_by_host(request.host_with_port)
+        flash[:error] = t(:'flash.installation.protected', :host => request.host_with_port)
+        redirect_to admin_sites_url # TODO figure out how to remove the user dependency
+      end
+    end
+end

data/app/controllers/pages_controller.rb

@@ -0,0 +1,2 @@
+class PagesController < BaseController
+end

data/app/controllers/sections_controller.rb

@@ -0,0 +1,3 @@
+class SectionsController < BaseController
+  abstract_actions :except => :index
+end

data/app/helpers/form_helper.rb

@@ -0,0 +1,13 @@
+module FormHelper
+  def fieldset(&block)
+    content_tag(:fieldset, &block)
+  end
+
+  def column(&block)
+    content_tag(:div, :class => 'column', &block)
+  end
+
+  def button_group(&block)
+    content_tag(:div, :class => 'buttons', &block)
+  end
+end

data/app/helpers/sections_helper.rb

@@ -0,0 +1,7 @@
+module SectionsHelper
+  def section_types_option_values
+    Section.types.map do |type|
+      [t(:"section.types.#{type.demodulize.underscore}"), type]
+    end
+  end
+end

data/app/helpers/url_helper.rb

@@ -0,0 +1,18 @@
+require 'core_ext/ruby/module/include_anonymous'
+
+module UrlHelper
+  def self.included(base)
+    base.send(:helper_method, public_instance_methods)
+  end
+
+  include do
+    def public_url
+      public_url_for(resources.reject { |r| r.respond_to?(:new_record?) && r.new_record? })
+    end
+
+    def public_url_for(resources, options = {})
+      resources -= [:admin, site]
+      resources.empty? ? "http://#{site.host}" : polymorphic_url(resources, options)
+    end
+  end
+end

data/app/models/account.rb

@@ -0,0 +1,3 @@
+class Account < ActiveRecord::Base
+  has_many :sites, :dependent => :destroy
+end

data/app/models/article.rb

@@ -0,0 +1,2 @@
+class Article < Content
+end

data/app/models/content.rb

@@ -0,0 +1,4 @@
+class Content < ActiveRecord::Base
+  belongs_to :site
+  belongs_to :section
+end

data/app/models/page.rb

@@ -0,0 +1,17 @@
+class Page < Section
+  has_one :article, :foreign_key => 'section_id', :inverse_of => :section, :dependent => :destroy
+  validates_presence_of :article
+  accepts_nested_attributes_for :article
+  before_validation :ensure_default_article
+
+  def body=(body)
+    ensure_default_article
+    article.body = body
+  end
+
+  protected
+
+    def ensure_default_article
+      build_article(:site => site, :section => self, :title => name) unless article.present?
+    end
+end

data/app/models/section.rb

@@ -0,0 +1,59 @@
+class Section < ActiveRecord::Base
+  extend ActiveSupport::Memoizable
+
+  belongs_to :site, :inverse_of => :sections
+
+  # unfortunate, but moving this to a adva-categories/section_slice breaks because
+  # class_inheritable_attributes get out of sync and crash. this might change if we
+  # were able to load code slices lazily
+  if Adva.engine?(:categories)
+    has_many :categories, :foreign_key => :section_id
+    accepts_nested_attributes_for :categories
+  end
+
+  validates_presence_of :site, :name, :slug
+
+  has_slug :scope => :site_id
+  acts_as_nested_set # FIXME must scope to site_id
+  serialize :options # FIXME should be in has_options, but the class_inheritable_accessor :serialized_attributes seems to get out of sync
+
+  # validates_uniqueness_of :slug, :scope => [:site_id, :parent_id]
+
+  mattr_accessor :types
+  self.types ||= [] # FIXME model is loaded twice, at least in cucumber
+
+  class << self
+    def inherited(child)
+      types << child.name
+      super
+    end
+
+    def type_names
+      @type_names ||= types.map(&:underscore)
+    end
+  end
+
+  def type
+    read_attribute(:type) || 'Section'
+  end
+
+  def path
+    _path == site.home_section.send(:_path) ? '' : _path
+  end
+
+  def home?
+    root? && previous_sibling.nil?
+  end
+
+  def attributes_protected_by_default
+    default = [self.class.primary_key]
+    default << 'id' unless self.class.primary_key.eql? 'id'
+    default
+  end
+
+  protected
+
+    def _path
+      read_attribute(:path)
+    end
+end

data/app/models/site.rb

@@ -0,0 +1,26 @@
+class Site < ActiveRecord::Base
+  validates_presence_of :host, :name, :title
+  validates_uniqueness_of :host
+
+  belongs_to :account
+  has_many :sections, :inverse_of => :site, :dependent => :destroy
+  has_many :pages, :dependent => :destroy
+
+  accepts_nested_attributes_for :account, :sections
+
+  has_one  :home_section, :class_name => 'Section', :conditions => 'parent_id IS NULL', :order => 'lft'
+
+  class << self
+    def install(params)
+      User.skip_callbacks do # TODO remove user dependency, test failure
+        site = Site.create!(params[:site])
+        site.account.users.first.confirm!
+        site
+      end
+    end
+
+    def by_host(host)
+      Site.count == 1 ? Site.first : Site.find_by_host(host) # TODO figure out how we want to do this ...
+    end
+  end
+end

data/app/views/admin/pages/_menu.html.rb

@@ -0,0 +1,30 @@
+class Admin::Pages::Menu < Adva::View::Menu::Admin::Actions
+  include do
+    def main
+      if resource.try(:persisted?)
+        label(resource.name)
+        item(:'.show', show_path)
+      else
+        item(:'.sections', index_path)
+      end
+    end
+
+    def right
+      if resource.try(:persisted?)
+        item(:'.view', public_url)
+        item(:'.destroy', resource_path, :method => :delete, :confirm => t(:'.confirm_destroy', :model_name => resource.class.model_name.human))
+      else
+        item(:'.new', new_path)
+      end
+    end
+
+    protected
+
+      def active?(url, options)
+        # hmmm ...
+        types = Section.types.map { |type| type.underscore.pluralize }.join('|')
+        return false if url =~ %r(/admin/sites/\d+/#{types}/\d+$) && request.path != url
+        super
+      end
+  end
+end

data/app/views/admin/pages/new.html.rb

@@ -0,0 +1,19 @@
+class Admin::Pages::New < Adva::View::Form
+  include do
+    def to_html
+      h2 :'.title'
+      render 'admin/sections/select_type'
+      super
+    end
+
+    def fields
+      fieldset do
+        form.hidden_field :type
+        form.input :name
+        form.simple_fields_for(:article) do |a|
+          a.input :body
+        end
+      end
+    end
+  end
+end

data/app/views/admin/pages/show.html.rb

@@ -0,0 +1,25 @@
+class Admin::Pages::Show < Adva::View::Form
+  include do
+    def to_html
+      h2 :'.title'
+      super
+    end
+
+    def fields
+      form.simple_fields_for(:article) do |a|
+        a.input :body
+      end
+    end
+  
+    def buttons
+      form.button :submit
+    end
+
+    def sidebar
+      tab :options do
+        form.input :name
+        form.input :slug
+      end
+    end
+  end
+end

data/app/views/admin/sections/_menu.html.rb

@@ -0,0 +1,12 @@
+class Admin::Sections::Menu < Adva::View::Menu::Admin::Actions
+  include do
+    def main
+      item(:'.sections', index_path)
+    end
+  
+    def right
+      item(:'.new', new_path)
+      item(:'.reorder', index_path, :activate => false)
+    end
+  end
+end

data/app/views/admin/sections/_section.html.rb

@@ -0,0 +1,7 @@
+class Admin::Sections::Section < Minimal::Template
+  include do
+    def to_html
+      p { link_to(section.name, [:admin, section.site, section]) }
+    end
+  end
+end

data/app/views/admin/sections/_select_type.html.rb

@@ -0,0 +1,16 @@
+class Admin::Sections::SelectType < Minimal::Template
+  def to_html
+    simple_form_for(resources, :as => :section, :url => { :action => :new }, :html => { :method => :get, :class => 'section_type' }) do |f|
+      fieldset do
+        f.label :type
+        div :class => :radio_group do
+          section_types_option_values.each do |name, value|
+            f.radio_button :type, value, :class => :section_type
+            f.label "type_#{value.underscore}", name, :class => :inline
+          end
+          f.submit 'Select', :class => :inline
+        end
+      end
+    end
+  end
+end

data/app/views/admin/sections/index.html.rb

@@ -0,0 +1,28 @@
+class Admin::Sections::Index < Minimal::Template
+  include do
+    def to_html
+    	table_for collection, :collection_name => :sections, :class => 'sections list tree' do |t|
+    		t.column :section
+    		t.column :actions, :class => :actions
+
+    		t.row(:class => 'section') do |r, section|
+    			r.add_class "level_#{section.level}"
+    			r.cell link_to_section(section)
+          r.cell links_to_actions([:view, :edit, :destroy], section)
+    		end
+    	end
+    end
+
+    def link_to_section(section)
+      status(section) + capture { link_to(section.name, url_for([:admin, site, section])) } # :class => section.state
+    end
+
+    def link_to_view(section)
+      capture { link_to(:'.view', public_url_for([section]), :class => :view) }
+    end
+
+    def status(section)
+      capture { span(t(:'.published'), :title => t(:'.published'), :class => 'status published') }
+    end
+  end
+end