dust-cms 0.0.05

data/app/models/dust/block.rb

@@ -0,0 +1,114 @@
+module Dust
+  class Block < ActiveRecord::Base
+    attr_accessible :title, :body, :partial_name, :where_to_show, :show, :show_title, :classes, :weight, :column_span, :column_offset
+
+    default_scope :order => 'weight ASC'
+
+    include ActionView::Helpers::TextHelper
+    include ActionView::Helpers::SanitizeHelper
+
+    validates_presence_of :title
+    validates_uniqueness_of :title
+
+    def self.regions
+      pretty_regions = []
+      Dust.config.regions.each do |region|
+        pretty_regions << [region.humanize.titleize, region]
+      end
+      Dust::Page.all.each do |page|
+        pretty_regions.concat page.sections.map{ |s| ["#{page.nav_link} | #{s.title}", s.title.parameterize] } unless page.sections.blank?
+      end
+      pretty_regions
+    end
+
+    def self.grid
+      grid = OpenStruct.new
+      grid.columns = (1..12).map{ |i| [i.to_words.titleize, "#{i.to_words} columns"] }
+      grid.offsets = (1..12).map{|i| ["Offset by #{i.to_words.titleize}", "offset-by-#{i.to_words}"]}
+      grid
+    end
+
+    def self.page(search, page)
+      search(search).paginate(:per_page => 12, :page => page)
+    end
+
+    def self.search(search)
+      if search
+        where("title LIKE ? OR body LIKE ?", "%#{search}%", "%#{search}%").where("show_title = ? OR 'show' != ?", false, '')
+      else
+        scoped
+      end
+    end
+
+    def final_classes
+      [column_span, column_offset, classes].join(" ")
+    end
+
+    def url_list
+      show.split("\r\n")
+    end
+
+    def show_me?(uri)
+      show = false
+      show = true if (url_list.include?(uri) || url_list.blank?)
+      show = true if (uri == "/" && url_list.include?("/#{Dust.config.root}"))
+      show
+    end
+
+    def self.find_active(uri)
+      blocks = Block.all
+      blocks.delete_if {|b| !b.show_me?(uri) }
+      blocks
+    end
+
+    def front_end_content
+      options = {
+        :block => self
+      }
+
+      Handlebar.render(body, options)
+    end
+
+    def pages
+      pages = []
+      Page.all.each do |page|
+        pages << page if url_list.include?(page.menu_item.url)
+        pages << page if url_list.blank?
+      end
+      puts url_list.inspect
+      puts pages.inspect
+      pages
+    end
+
+    def self.widget_list
+      files = []
+      paths = widget_filenames
+      puts paths
+      paths.each do |filename|
+        if filename[0] != "." # if file is not hidden
+          files.push filename.sub('_', '').gsub('.html.haml', '')
+        end
+      end
+      files
+    end
+
+    private
+
+    def self.widget_files
+      paths = []
+      Dir["#{Dust.root}/app/views/widgets/**/*"].each {|path| paths << path }
+      Dir["#{Rails.root}/app/views/widgets/**/**"].each {|path| paths << path }
+      paths
+    end
+
+    def self.widget_filenames
+      widget_files.select{ |p| File.file?(p) }.map { |f| widget_option(f) }
+    end
+
+    def self.widget_option(path)
+      partial_path = path.gsub("#{Dust.root}/app/views/widgets/", "").gsub("#{Rails.root}/app/views/widgets/", "")
+      partial_path
+    end
+
+  end
+end

data/app/models/dust/builder/page.rb

@@ -0,0 +1,84 @@
+module Dust
+  module Builder
+    class Page
+
+      def initialize(options={})
+        @page       = options[:page]
+        @sections   = options[:sections] || []
+        @page_attrs = options[:attrs] if options[:attrs]
+      end
+
+      def save
+        build_sections
+        update_blocks
+        if @page.errors.blank?
+          @page.save
+        else
+          false
+        end
+      end
+
+      def update
+        build_sections
+        update_blocks
+        if @page.errors.blank?
+          @page.update_attributes(@page_attrs)
+        else
+          false
+        end
+      end
+
+      private
+
+
+      def build_sections
+        @sections.each do |section_attr|
+          section = ::Dust::Section.find_or_create_by_id_and_page_id(section_attr[0], @page.id)
+
+          if section_attr[1]["_destroy"] == "1"
+            section.destroy
+          else
+            section_attr[1].delete("_destroy")
+            section.id = nil if section.new_record?
+            section.assign_attributes section_attr[1]
+
+            determine_validity_of(section)
+            @page.sections << section
+          end
+        end
+      end
+
+      def update_blocks
+        if @page.menu_item.url_changed? 
+          previous = @page.menu_item.url_was
+          current = @page.menu_item.url
+
+          @page.old_blocks.each do |block|
+            show = block.show.gsub(previous, current)
+            unless block.update_attributes(:show => show)
+              validate_block(block)
+            end
+          end
+        end
+      end
+
+      def validate_block(block)
+        @page.errors[:base] << "Block #{block.title} is not valid"
+        block.errors.full_messages.each do |error|
+          @page.errors[:base] << "Block | #{error}"
+        end
+      end
+
+      def determine_validity_of(section)
+        unless section.valid?
+          @page.errors[:base] << "Section #{section.title} is not valid"
+          section.errors.full_messages.each do |error|
+            @page.errors[:base] << "Section | #{error}"
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/app/models/dust/builder/site_wide.rb

@@ -0,0 +1,50 @@
+module Dust
+  module Builder
+    class SiteWide
+
+      include ActiveModel::Validations
+
+      attr_accessor :variables
+
+      def initialize(options={})
+        @options = options[:options]
+        @variables = []
+      end
+
+      def update
+        build_variables
+        if self.errors.blank?
+          update_variables
+        else
+          false
+        end
+      end
+
+      private
+
+      def update_variables
+        @variables.each do |var|
+          var.save
+        end
+      end
+
+      def build_variables
+        @options.each do |option|
+          variable = Dust::SiteWide.find option[0]
+          variable.assign_attributes option[1]
+          determine_validity_of variable
+        end
+      end
+
+      def determine_validity_of(variable)
+        unless variable.valid?
+          variable.errors.full_messages.each do |error|
+            self.errors[:base] << "#{variable.category}:#{variable.name} | #{error}"
+          end
+        end
+        @variables << variable
+      end
+
+    end
+  end
+end

data/app/models/dust/contact.rb

@@ -0,0 +1,34 @@
+module Dust
+  class Contact < ActiveRecord::Base
+    attr_accessible :name, :email, :company_name, :phone, :address, :city, :state, :zip, :message, :hear
+    
+    validates_presence_of :name
+    validates_presence_of :email
+    validates_format_of :email, :with => /^([^\s]+)((?:[-a-z0-9]\.)[a-z]{2,})$/i, :message => "Should look like an email address."
+    validates_presence_of :message
+
+    def self.total_on(date)
+      where("date(created_at) = ?", date)
+    end
+    
+    def self.page(search, page, date)
+      search(search, date).order("created_at DESC").paginate(:per_page => 12, :page => page)
+    end
+
+    def deliver_messages
+      Dust.config.mailer.contact_confirmation(self).deliver
+      Dust.config.mailer.contact_request(self).deliver
+    end
+
+    def self.search(search, date)
+      if search
+        where("name LIKE ? OR email LIKE ? OR message LIKE ?", "%#{search}%", "%#{search}%", "%#{search}%")
+      elsif date
+        where("date(created_at) IS ?", (Time.at(date.to_i / 1000)).to_date)
+      else
+        scoped
+      end
+    end
+
+  end
+end

data/app/models/dust/gallery/album.rb

@@ -0,0 +1,14 @@
+module Dust
+  module Gallery
+    class Album < ActiveRecord::Base
+      include Dust::Menu::ItemDependency
+
+      attr_accessible :description, :position, :title
+      acts_as_nested_set
+
+      validates_presence_of :title, :description
+
+      has_many :photos, :dependent => :destroy
+    end
+  end
+end

data/app/models/dust/gallery/photo.rb

@@ -0,0 +1,23 @@
+module Dust
+  module Gallery
+    class Photo < ActiveRecord::Base
+      attr_accessible :description, :lft, :parent_id, :rgt, :title, :album_id, :filename
+      acts_as_nested_set
+
+      mount_uploader :filename, Dust.config.uploader
+
+      belongs_to :album
+
+      validates_presence_of :album_id
+
+      def url
+        filename.url
+      end
+
+      def success
+        true
+      end
+
+    end
+  end
+end

data/app/models/dust/handlebar.rb

@@ -0,0 +1,59 @@
+module Dust
+  class Handlebar < Mustache
+
+    def app_config
+      raw_config = File.read("#{Rails.root}/config/app_config.yml")
+      yaml_data = YAML.load(raw_config) 
+      Hashie::Mash.new(yaml_data)
+    end
+
+    def block(id)
+      @block = Block.find_by_id(id)
+      @block.front_end_content
+    end
+
+    def method_missing(name, *args, &block)
+      if name.to_s =~ /^block_(\d+)/
+        block($1)
+      else
+        return super
+      end
+    end
+
+    def respond_to?(method)
+      if method.to_s =~ /^block_(\d+)/
+        method.to_s =~ /^block_(\d+)/
+      else
+        super
+      end
+    end
+
+    def blocks
+      Block.all
+    end
+    
+    def menu
+      MenuItem.all
+    end
+
+    def slides
+      Nivo::Slide.rotate.map{ |slide|
+        {
+        :image         => slide.image.url
+        }
+      }
+    end
+    
+    def recent
+      Post.recent.map{ |post|
+        {
+        :title         => post.title,
+        :content          => post.preview,
+        :published_at  => post.published_date,
+        :slug          => post.kind == "workshop" ? "workshops" : "resources"
+        }
+      }
+    end
+    
+  end
+end

data/app/models/dust/map.rb

@@ -0,0 +1,21 @@
+module Dust
+  class Map
+
+    attr_accessor :address, :width, :height, :content
+
+    def initialize(options={})
+      @address = options[:address] ||= "Lalana Ramboatiana, Antananarivo, Madagascar"
+      @width   = options[:width] ||= 400
+      @height  = options[:height] ||= 400
+      @content = options[:content]||= "Madagascar Royal Palace"
+    end
+    
+    def self.find(map_name)
+      maps = Hashie::Mash.new(YAML.load(File.read("#{Rails.root}/config/maps.yml")))
+      map_options = maps[map_name] ||= {}
+      return Map.new map_options
+    end
+
+  end
+end
+

data/app/models/dust/menu/item_dependency.rb

@@ -0,0 +1,66 @@
+
+module Dust
+  class Menu
+    module ItemDependency
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessible :filename, :nav_link, :active, :menu
+        has_one :menu_item, :as => :linkable, :dependent => :destroy, :autosave => true, :class_name => Dust::MenuItem
+
+        auto_build :menu_item
+      end
+
+      def match_path
+        menu_item.url
+      end
+
+      def filename
+        self.menu_item.url.gsub("/", "")
+      end
+
+      def filename=(filename)
+        self.menu_item.url = "/#{filename}"
+      end
+
+      def active
+        self.menu_item.active
+      end
+
+      def active=(active)
+        self.menu_item.active = active
+      end
+
+      def nav_link
+        self.menu_item.title
+      end
+
+      def nav_link=(filename)
+        self.menu_item.title = filename
+      end
+
+      def menu
+        self.menu_item.menu_id
+      end
+
+      def menu=(menu_id)
+        self.menu_item.menu_id = menu_id
+      end
+
+      module ClassMethods
+        def find_by_filename(filename)
+          filename = "/#{filename}"
+          where(:menu_items => {:url => filename}).joins(:menu_item).first
+        end
+
+        def new_with_menu_item(options={})
+          item = self.new
+          item.build_menu_item
+          item.assign_attributes options
+          item
+        end
+      end
+
+    end
+  end
+end

data/app/models/dust/menu.rb

@@ -0,0 +1,11 @@
+module Dust
+  class Menu < ActiveRecord::Base
+    attr_accessible :desc, :title, :nestable
+
+    has_many :menu_items, :dependent => :destroy
+
+    def active_items
+      menu_items.roots.where(:active => true)
+    end
+  end
+end

data/app/models/dust/menu_item.rb

@@ -0,0 +1,64 @@
+module Dust
+  class MenuItem < ActiveRecord::Base
+    attr_accessible :title, :url, :active, :lft, :rgt, :parent_id, :menu_id
+
+    acts_as_nested_set
+
+    belongs_to :menu
+    belongs_to :linkable, :polymorphic => true
+    validates_uniqueness_of :url
+
+    scope :sitemap, :select => 'url, created_at, updated_at', :limit => 50000
+
+    def self.page(search, page)
+      search(search).order("title").paginate(:per_page => 12, :page => page)
+    end
+
+    def self.manage(search)
+      roots.search(search).order("title")
+    end
+
+    def self.search(search)
+      if search
+        where("title LIKE ?", "%#{search}%")
+      else
+        scoped
+      end
+    end
+
+    def self.menu
+      list = self.roots
+      list.where("active = ?", true)
+    end
+
+    def edit_linkable
+      "/#{root.linkable_type.downcase.pluralize}/#{root.linkable_id}/edit"
+    end
+
+    def destroy_linkable
+      "/#{root.linkable_type.downcase.pluralize}/#{root.linkable_id}"
+    end
+
+    def children_urls
+      self.descendants.map{ |item| item.url }
+    end
+
+    REGEX = '^(http|https):\/\/[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(([0-9]{1,5})?\/.*)?$'
+
+    def html_options?(uri)
+      mash = Hashie::Mash.new 
+
+      mash.class = "last" if self == self.self_and_siblings.all(:conditions => ['active = ?', true]).last
+      mash.target = "_blank" if url.match(REGEX)
+      mash.class = "active" if self.is_active? uri
+      mash.class = "active last" if (self.is_active? uri) and self == self.self_and_siblings.last
+      mash
+    end
+
+    def is_active?(uri)
+      true if uri == url or children_urls.include?(uri) or (uri == "/" and self.url == "/welcome")
+    end
+
+  end
+end
+

data/app/models/dust/page.rb

@@ -0,0 +1,52 @@
+module Dust
+  class Page < ActiveRecord::Base
+    attr_accessible :meta_title, :meta_description, :description, :classes
+    has_many :sections
+
+    include ActionView::Helpers::TextHelper
+    include ActionView::Helpers::SanitizeHelper
+    include Dust::Menu::ItemDependency
+
+    validates_presence_of :meta_title
+    after_create :create_starter_block
+    has_many :blocks, 
+      :finder_sql => proc{"SELECT `blocks`.* FROM `blocks` WHERE `blocks`.`show` LIKE \"%/#{filename}%\" ORDER BY weight ASC"}
+    has_many :old_blocks, :class_name => Block,
+      :finder_sql => proc{"SELECT `blocks`.* FROM `blocks` WHERE `blocks`.`show` LIKE \"%#{menu_item.url_was}%\" ORDER BY weight ASC"}
+
+    #-- ActiveRecord Queries --#
+    def self.page(search, page)
+      search(search).order("meta_title").paginate(:per_page => 12, :page => page)
+    end
+
+    def self.search(search)
+      if search
+        where("meta_title LIKE ? OR meta_description LIKE ?", "%#{search}%", "%#{search}%")
+      else
+        scoped
+      end
+    end
+
+    def front_end_content
+      options = { :page => self }
+      Handlebar.render(content, options)
+    end
+
+    def create_description
+      meta_description
+    end
+
+    def create_starter_block
+      Block.new(
+        :show_title => true,
+        :title => "#{self.meta_title} Page Content", 
+        :body => "<h1> #{self.meta_title} </h1> <p>New content.</p>", 
+        :classes => "twelve columns", 
+        :where_to_show => Dust.config.default_region,
+        :show => "/#{self.filename}",
+        :weight => 0
+      ).save
+    end
+
+  end
+end

data/app/models/dust/post.rb

@@ -0,0 +1,39 @@
+module Dust
+  class Post < ActiveRecord::Base
+    include Dust::Menu::ItemDependency
+    mount_uploader :file, ImageUploader
+
+    attr_accessible :body, :file, :published, :published_date, :share, :share_type, :title
+
+    validates_presence_of :title, :body, :published_date
+
+    def share_types
+      ['Facebook', 'Twitter']
+    end
+
+    def published_date
+      self.published_at ? self.published_at.strftime("%Y/%m/%d") : Time.now.strftime("%Y/%m/%d")
+    end
+
+    def published_date=(date_str)
+      self.published_at = Time.parse date_str
+    end
+
+    def slug
+      "#{published_date}/#{url_title.parameterize}"
+    end
+
+    def url_title
+      title.blank? ? "empty-title" : title
+    end
+
+    def filename
+      url_title
+    end
+
+    def filename=(filename="")
+      self.menu_item.url = "/post/#{slug}"
+    end
+  end
+end
+

data/app/models/dust/role.rb

@@ -0,0 +1,9 @@
+module Dust
+  class Role < ActiveRecord::Base
+    
+    has_many :users
+    
+    attr_accessible :name
+    
+  end
+end

data/app/models/dust/section.rb

@@ -0,0 +1,11 @@
+module Dust
+  class Section < ActiveRecord::Base
+    belongs_to :page
+    attr_accessible :classes, :position, :title
+    acts_as_nested_set
+    default_scope roots
+
+    validates_presence_of :title
+    validates_uniqueness_of :title
+  end
+end

data/app/models/dust/session.rb

@@ -0,0 +1,28 @@
+module Dust
+  class Session
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
+
+    attr_accessor :username, :password, :user, :remember_me
+
+    validates_presence_of :username, :password
+    validate :found_user?
+
+    def initialize(attributes=nil, user=nil)
+      attributes ||= {}
+      @user = user
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+
+    def found_user?
+      errors[:base] << "User not found" unless @user
+    end
+
+    def persisted?
+      false
+    end
+  end
+end