burp_cms 1.3.0

data/app/lib/burp/access.rb

@@ -0,0 +1,63 @@
+module Burp
+  class Access
+    
+    def initialize(data)
+    end
+    
+    # If true no http auth check will be made. (Ment as a way to remove Burp's default auth method.)
+    def may_skip_http_auth
+      false
+    end
+    
+    # Static pages in the CMS
+    def may_view_static_page(action)
+      true
+    end
+    
+    
+    
+    # CMS pages
+    def may_view_page_list
+      true
+    end
+    
+    def may_create_new_page
+      true
+    end
+    
+    def may_edit_page(page)
+      true
+    end
+    
+    def may_update_page(page)
+      true
+    end
+    
+    def may_remove_page(page)
+      true
+    end
+    
+    def may_view_page_data(page)
+      true
+    end
+    
+    def may_view_page(page)
+      true
+    end
+    
+    
+    # CMS files
+    def may_view_file_list
+      true
+    end
+    
+    def may_upload_a_file
+      true
+    end
+    
+    def may_view_file(path)
+      true
+    end
+    
+  end
+end

data/app/lib/burp/group.rb

@@ -0,0 +1,110 @@
+
+module Burp
+  class Group
+  
+    attr_reader :id
+    attr_accessor :children
+    attr_accessor :name
+  
+    def initialize(name,options = {})
+      @name = name
+      @children = (options[:children] || options['children']) || []
+    end
+
+    def to_html(request = nil)
+      
+      if first_link
+        first_link_in_group = %{<span class="first-link-in-group #{first_link.current_class(request)}">#{first_link.to_html(request,name)}</span>}
+      else
+        first_link_in_group = ""
+      end
+      
+      
+      %{
+      <section #{id ? "id='#{id}'" : ""} class="group"><span class="group-name">#{name}</span>
+        #{first_link_in_group}
+        <ul class="children">
+          #{children.inject("") do |x,link|  x += "<li class=\"child #{link.is_a?(Group) ? "group" : "link" } #{link.current_class(request)}\">#{link.to_html(request)}</li>" end}
+        </ul>
+      </section>
+      }.html_safe      
+    end
+    
+    def current?(request = nil)
+      children.each do |child|
+        return true if child.current?(request)
+      end
+      false
+    end
+
+    def current_class(request = nil)
+      "current-section" if current?(request)
+    end
+    
+    def first_link
+      children.select {|v| v.is_a? Link}.first
+    end
+    
+    def self.from_yaml(yaml)
+      from_hash(YAML.load(yaml))
+    end
+    
+    def self.from_hash(hash)
+      group = Group.new((hash[:name] || hash['name']),hash)
+      group.children.map!{|child| (child[:url] || child['url']) ? Link.from_hash(child) : Group.from_hash(child)}
+      
+      group
+    end
+    
+    def to_hash
+      {:name => name, :children => children.map{|child| child.to_hash}}
+    end
+    
+    def to_yaml
+      to_hash.to_yaml
+    end
+    
+    def to_menu
+      menu = Menu.new(self.name)
+      menu.children = Group.from_yaml(self.to_yaml).children
+      
+      menu
+    end
+    
+    def links
+      children.map {|child| child.is_a?(Group) ? child.links : child}.flatten
+    end
+    
+    def to_param
+      id
+    end
+    
+    def update_id(parent_id)
+      @id = {:parent_id => parent_id, :hash => self.hash}.hash
+      children.each_with_index do |child,index|
+        child.update_id("#{self.id}#{index}")
+      end
+    end
+    
+    def all_children
+      children+children.map do |child|
+        child.is_a?(Group) ? child.all_children : nil
+      end.flatten.compact
+    end
+    
+    
+    
+    def <=>(other)
+      other.is_a?(Group) || other.is_a?(Link) ? name <=> other.name : 0
+    end
+
+    def eql?(other)
+      self.class == other.class && self.hash == other.hash
+    end
+
+    def hash
+      to_hash.hash
+    end
+    
+  end
+end

data/app/lib/burp/link.rb

@@ -0,0 +1,66 @@
+module Burp
+  class Link
+    
+    attr_reader :id
+    attr_accessor :url,:name
+
+    def initialize(options)
+      self.name = options.keys.first
+      self.url = options.values.first
+
+      raise ArgumentError.new("Missing a url") unless url
+      raise ArgumentError.new("Missing a name") unless name
+    end
+
+    def current?(request = nil)
+      request && request.path == url
+    end
+
+    def current_class(request = nil)
+      current?(request) ? "current-url" : ""
+    end
+
+    def to_html(request = nil,name = nil)
+      %{<a class="#{current_class(request)}" #{id ? "id='#{id}'" : ""} href="#{url}">#{name || self.name}</a>}.html_safe
+    end
+    
+    def to_param
+      id
+    end
+    
+    def self.from_yaml(yaml)
+      from_hash(YAML::load(yaml))
+    end
+
+    def self.from_hash(hash)
+      Link.new((hash[:name] || hash['name']) => (hash[:url] || hash['url']))
+    end
+    
+    def to_hash
+      {:name => name, :url => url}
+    end
+
+    def to_yaml
+      to_hash.to_yaml
+    end
+    
+    
+    def update_id(parent_id)
+      @id = {:parent_id => parent_id, :hash => self.hash}.hash
+    end
+    
+    
+    def <=>(other)
+      other.is_a?(Group) || other.is_a?(Link) ? name <=> other.name : 0
+    end
+
+    def eql?(other)
+      self.class == other.class && self.hash == other.hash
+    end
+
+    def hash
+      to_hash.hash
+    end
+    
+  end
+end

data/app/lib/burp/page.rb

@@ -0,0 +1,23 @@
+module Burp
+  
+
+  class Page 
+
+    attr_accessor :snippets,:title
+
+    def initialize(options = {})
+      @snippets = options[:snippets] || {}
+      @title = options[:title] || ""
+    end
+
+    def [](location_name)
+      ("<!-- snippet data-type=\"start\" data-name=\"#{location_name}\" -->"+(@snippets[location_name.to_sym] || "<h2>#{location_name.to_s}</h2>")+"<!-- snippet data-type=\"end\" data-name=\"#{location_name}\" -->").html_safe
+    end
+
+    def []=(location_name,value)
+      @snippets[location_name.to_sym] = value
+    end
+
+  end
+
+end

data/app/lib/burp/util/upload_handler.rb

@@ -0,0 +1,84 @@
+
+require 'fileutils'
+
+module Burp
+  module Util
+
+    class UploadHandler
+  
+      def self.handle file_or_file_name,request
+    
+        tempfile = handle_raw_data(file_or_file_name,request)
+    
+        shasum = `shasum #{tempfile.path}`.match(/^([0-9a-f]{40})/i)[1]
+        new_dir = "/tmp/#{shasum}_#{Time.now.to_i}/"
+        new_path = "#{new_dir}#{tempfile.original_filename}"  
+    
+      
+        Dir.mkdir(new_dir)
+        FileUtils.mv(tempfile.path,new_path)
+    
+        tempfile.close(true)
+    
+        yield(UploadedFile.new(new_path,shasum))
+      ensure
+        File.unlink(new_path) if new_path && File.exist?(new_path)
+        Dir.rmdir(new_dir) if new_dir && File.exist?(new_dir)
+      end
+  
+      class UploadedFile
+    
+        def initialize path,shasum
+          @path = path
+          @shasum = shasum
+        end
+    
+        def path
+          @path
+        end
+    
+        def size 
+          File.size(self.path)
+        end
+    
+        def sha1sum
+          @shasum
+        end
+    
+      end
+  
+  
+      # http://github.com/valums/file-uploader
+      def self.handle_raw_data tempfile,request
+        if tempfile.is_a? String
+      
+      
+          file = Tempfile.new('foo',:encoding => 'ascii-8bit')
+          while s = request.env['rack.input'].read(16*1024)
+            file.write(s)
+          end
+          file.flush
+      
+          def file.original_filename
+            @file_name
+          end
+    
+          def file.tempfile 
+            self
+          end
+    
+          def file.original_filename= value
+            @file_name = value
+          end
+    
+          file.original_filename = File.basename(tempfile)
+    
+          file
+        else
+          tempfile
+        end
+      end
+  
+    end
+  end
+end

data/app/lib/burp/util.rb

@@ -0,0 +1,39 @@
+
+require 'fileutils'
+require 'RMagick'
+
+module Burp
+  module Util
+  
+    def self.commit(message = "auto commit")
+      raise "missing git repo in burp cms directory" unless File.exist?("#{Burp.content_directory}/.git")
+      `cd #{Burp.content_directory}; git add .; git commit -a -m "Burp: #{message}"`
+    end
+    
+    def self.create_smaller_images(file_path)
+      
+      upload_directory_path = "#{Burp.content_directory}uploads/"
+      
+      sizes = {:small => [200,300],:medium => [600,900], :large => [1000,1500]}
+      image = Magick::ImageList.new(file_path).first
+      image.auto_orient!
+      
+      sizes.each_pair do |key,value|
+        
+        FileUtils.mkdir_p("#{upload_directory_path}#{key.to_s}")
+        target_path = "#{upload_directory_path}#{key.to_s}/#{File.basename(file_path)}"
+        
+        if value[0] < image.columns # We only downscale
+          image.resize_to_fit(value[0],value[1]).write(target_path) { self.quality = 75 }
+        else
+          File.unlink(target_path) if File.exist?(target_path)
+          File.symlink("../#{File.basename(file_path)}",target_path)
+        end
+      end
+      image.destroy!
+    end
+    
+    
+    
+  end
+end

data/app/models/burp/file_model.rb

@@ -0,0 +1,45 @@
+module Burp
+  class FileModel
+  
+    attr_accessor :public_path
+  
+    def initialize(public_path)
+      self.public_path = public_path
+    end
+  
+    def self.all
+      @file_paths = Dir.glob("#{Burp.content_directory}uploads/*").select{|path| File.file?(path) }
+      @file_paths = @file_paths.map {|path| path.gsub("#{Burp.content_directory}uploads/","/burp/files/") }
+      @file_paths.map {|path| FileModel.new(path)}.sort.reverse
+    end
+  
+    def to_param
+      public_path
+    end
+    
+    def on_disk_path
+      public_path.gsub("/burp/files/","#{Burp.content_directory}uploads/")
+    end
+    
+    def mtime
+      @mtime_cache ||= File.mtime(on_disk_path)
+    end
+    
+    def size
+      @size_cache ||= File.size(on_disk_path)
+    end
+  
+    def <=>(other)
+      other.is_a?(FileModel) ? self.mtime <=> other.mtime : 0
+    end
+
+    def eql?(other)
+      self.class == other.class && self.hash == other.hash
+    end
+
+    def hash
+      public_path.hash
+    end
+  
+  end
+end

data/app/models/burp/menu.rb

@@ -0,0 +1,60 @@
+module Burp
+  class Menu < Group
+   
+    def initialize(name,options = {})
+      raise "Name cant be blank" if name.blank?
+      self.name = name
+      super(name,options)
+    end
+    
+    def self.all
+      Dir.glob(Burp.content_directory + "menus/*.yaml").map do |menu_path|
+        Menu.find(menu_path.match(/\/(\w*?)\.yaml$/)[1])
+      end
+    end
+    
+    def self.count
+      Dir.glob(Burp.content_directory + "menus/*.yaml").length
+    end
+    
+    def self.find(name)
+      menu = Menu.new(name)
+      if(menu.load)
+        menu
+      else
+        nil
+      end
+    end
+    
+    def to_param
+      name
+    end
+
+    def load
+      if File.exist?(path)
+        group = Group.from_yaml(File.read(path))
+        self.children = group.children
+        
+        true
+      else
+        false
+      end
+    end
+   
+    def save
+     raise "Name cant be blank" if name.blank?
+
+     File.open(path,'w') do |file|
+       file.write(self.to_yaml)
+     end
+
+     Burp::Util.commit("Saved #{self.name}")
+    end
+    
+    private
+    
+    def path
+      Burp.content_directory + "menus/" +  name + ".yaml"
+    end
+  end
+end

data/app/models/burp/page_model.rb

@@ -0,0 +1,158 @@
+
+require 'fileutils'
+
+module Burp
+  class PageModel
+    
+    include ActiveModel::Validations
+    include ActiveModel::Conversion
+    extend ActiveModel::Naming
+
+    attr_accessor :path, :title, :snippets, :misc
+  
+    validates_presence_of :path, :message => "You must enter a path"
+    validates :path, :format => { :with => /^\//, :message => "Must start with a slash" }
+    validates :path, :format => { :with => /^[a-zA-Z0-9\-\.\/]+$/, :message => "Invalid path" }
+    validate do 
+      if File.exist?("#{on_disk_path}/page.json") && @original_path != path
+        errors.add(:path, "Path already taken, #{path}")
+        false
+      else
+        true
+      end
+    end
+    
+    
+  
+    def initialize(values = {:path => '', :snippets => {}})
+      
+      values.each_entry do |key,value|
+        self.send("#{key}=".to_sym,value) if self.respond_to?("#{key}=".to_sym)
+      end
+    
+      @original_path = values[:original_path]
+    end
+
+    def self.find(path)
+    
+      fixed_path = path == '/' ? '/#root' : path
+      on_disk_path =  Burp.content_directory+"pages/" + fixed_path
+      on_disk_path = on_disk_path.gsub('//','/')
+
+      if File.directory?(on_disk_path) && File.exist?("#{on_disk_path}/page.json")
+      
+        data = {}
+        Dir.glob(on_disk_path+"/*.html").each do |snippet_path|
+          name = File.basename(snippet_path).split('.').first
+          data[name.to_sym] = File.read(snippet_path).html_safe
+        end
+      
+        page_data = File.exist?("#{on_disk_path}/page.json") ? JSON.parse(File.read("#{on_disk_path}/page.json")) : {}
+      
+        PageModel.new(:snippets => data,:title => page_data['title'],:misc => page_data['misc'],:path => path, :original_path => path)
+      else
+        nil
+      end
+    end
+    
+    def to_param
+      path == "/" ? "/$root" : path
+    end
+    
+    def id
+      to_param
+    end
+  
+    def self.all_paths
+      ((Dir.glob("#{Burp.content_directory}pages/**/*.html") + Dir.glob("#{Burp.content_directory}pages/**/*.json")).map {|path| File.dirname(path.gsub(Burp.content_directory+"pages/","/")).gsub("/#root",'/') }).uniq
+    end
+  
+    def self.all
+      all_paths.map {|path| find(path) }
+    end
+  
+    def save
+      if valid?
+        remove_dir
+        remove_dir(@original_path) unless @original_path.blank?
+        create_target_dir
+        save_metadata
+        save_snippets
+      
+        Burp::Util.commit("Saved #{self.path}")
+        
+        true
+      else
+        false
+      end
+    end
+  
+    def remove
+      raise "Path must start with a slash '/'" unless path.start_with?("/")
+      remove_dir
+      Burp::Util.commit("Removed #{self.path}")
+    end
+    
+    def root_fixed_path(path = self.path)
+      path == '/' ? '/#root' : path
+    end
+    
+    def persisted?
+      !!@original_path
+    end
+    
+    def self.model_name
+      ActiveModel::Name.new(PageModel,nil,"Page")
+    end
+
+    private
+  
+    def save_metadata
+    
+      File.open("#{on_disk_path}/page.json","w:utf-8") do |file|
+        file.write(JSON.pretty_generate({:title => title,:misc => misc}))
+      end
+    
+    end
+  
+    def save_snippets
+      snippets.each_entry do |name,value|
+        File.open("#{on_disk_path}/#{name}.html","w:utf-8") do |file|
+          file.write(value)
+        end
+      end
+    end
+  
+    def create_target_dir
+      FileUtils.mkdir_p(on_disk_path)
+    end
+  
+    def cleanup_target
+      remove_dir
+    end
+  
+    def remove_dir(path = self.path)
+      Dir.glob("#{on_disk_path(path)}/*.html").each do |path|
+        File.unlink(path)
+      end
+      
+      Dir.glob("#{on_disk_path(path)}/*.json").each do |path|
+        File.unlink(path)
+      end
+
+      # We only remove the dir if its actualy empyt
+      if(Dir.glob("#{on_disk_path(path)}/*").length == 0)
+        directory_path = on_disk_path(path)
+        while(directory_path.start_with?(Burp.content_directory+"pages/") && Dir.glob("#{directory_path}/*").length == 0)
+          FileUtils.rmdir(directory_path)
+          directory_path = File.dirname(directory_path)
+        end
+      end
+    end
+  
+    def on_disk_path(path = self.path)
+      on_disk_path = "#{Burp.content_directory}pages/#{root_fixed_path(path)}"
+    end
+
+  end
+end