kinbote 0.0.1 → 0.0.2

data/lib/kinbote/site.rb

@@ -1,8 +1,9 @@
 module Kinbote
   class Site
     include Util
-        
-    attr_reader :pages, :attributes, :kinbote_path, :config
+    attr_reader :kinbote_path, :config
+    
+    BAD_PAGE_SLUGS = ["kinbote"]
     
     def initialize
       @pages = []
@@ -10,31 +11,87 @@ module Kinbote
       @values = []
       @kinbote_path = nil
       @config = {}
+      @messages = []
     end
     
-    def set_kinbote_path(path)
-      return if @kinbote_path
-      @kinbote_path = path
+    def load
+      load_pages
     end
     
-    def read_config
-      if File.exist?("#{@kinbote_path}/config/site.yml")
-        @config = YAML::load_file("#{@kinbote_path}/config/site.yml")
-      else
-        @config = {"title" => "Kinbote Site"}
+    def reload
+      read_config
+      reload_pages
+    end
+    
+    def find_page(slug)
+      @pages.each do |page|
+        return page if page.slug == slug
       end
-      @config.each do |key, value|
-        Site.send(:define_method, slugify(key).gsub("-", "_").to_sym, Proc.new{ @config[key] }) if !Site.respond_to?(slugify(key).gsub("-", "_").to_sym)
+      nil
+    end
+
+    def find_attribute(name, page = nil)
+      (page ? page.attributes : @attributes).each do |attribute|
+        return attribute if (attribute.name == name || attribute.varname == varify(name))
+      end
+      nil
+    end
+
+    def find_value(val, attribute, global = false)
+      (global ? @values : attribute.values).each do |value|
+        return value if (value.value == val && (attribute.name == value.attribute.name || attribute.varname == varify(value.attribute.name)))
+      end
+      nil
+    end
+    
+    def create_page(title, file=nil, attributes=nil)
+      if BAD_PAGE_SLUGS.include?(slugify(title))
+        add_message("#{title} #{file ? "(#{file})" : ""} is an invalid page title")
+        return false
       end
+      @pages << Page.new(title, file, attributes)
     end
     
+    def delete_page(slug)
+      page = find_page(slug)
+      @attributes.map{|att| att.remove_page(page)}
+      @attributes.delete_if{|att| att.pages.size == 0}
+      page.delete_files([:html, :css])
+      @pages.delete_if{|p| p.slug == page.slug}
+      Page.add_metadata
+    end
+    
+    def remove_page_attributes(page)
+      @attributes.map{|att| att.remove_page(page)}
+      @attributes.delete_if{|att| att.pages.size == 0}
+    end
+    
+    def pages
+      @pages.sort{|x, y| x.title <=> y.title }
+    end
+    
+    def attributes
+      sorted_attributes(@attributes)
+    end
+
+    def kinbote_path= (path); @kinbote_path = path; end
+    
+    def add_attribute(attribute); @attributes << attribute; end
+    def add_value(value); @values << value; end
+    
+    def add_message(message); @messages << message if !@messages.include?(message); end
+    def has_messages?; @messages.size > 0; end
+    def render_messages; m = Array.new(@messages); @messages = []; m; end
+    
+  private
+  
     def load_pages
       Dir.glob("#{@kinbote_path}/views/pages/**/*.{haml}").each do |file|
         title, attributes = file_attributes(file)
-        @pages << Page.new(title, file, attributes)
+        create_page(title, file, attributes)
       end
     end
-
+    
     def reload_pages
       files = Dir.glob("#{@kinbote_path}/views/pages/**/*.{haml}")
       files.each do |file|
@@ -42,17 +99,17 @@ module Kinbote
         title, attributes = file_attributes(file)
         page = find_page(slug)
         if page
-          next if File.size(file) == page.get_filesize
+          next if File.size(file) == page.file_size(:html)
           page.set_attributes(attributes.merge({"title" => [title]}))
-          page.set_filesize
+          page.reset_file_size(:html)
         else
-          @pages << Page.new(title, file, attributes)
+          create_page(title, file, attributes)
         end
       end
       slugs = files.map{|file| slug_from_file(file)}
       @pages.map{|page| delete_page(page.slug) if !slugs.include?(page.slug)}
     end
-
+    
     def file_attributes(file)
       title = slug_from_file(file)
       attributes = {}
@@ -73,102 +130,12 @@ module Kinbote
       end
       [title, attributes]
     end
-
-    def find_page(slug)
-      @pages.each do |page|
-        return page if page.slug == slug
-      end
-      nil
-    end
-
-    def find_attribute(name, page = nil)
-      (page ? page.attributes : @attributes).each do |attribute|
-        return attribute if (attribute.name == name || attribute._varname == name)
-      end
-      nil
-    end
-
-    def find_value(val, attribute, global = false)
-      (global ? @values : attribute.values).each do |value|
-        return value if (value.value == val && attribute.name == value.attribute.name)
-      end
-      nil
-    end
-    
-    def create_page(title)
-      @pages << Page.new(title)
-    end
-    
-    def add_attribute(attribute)
-      @attributes << attribute
-    end
-    
-    def add_value(value)
-      @values << value
-    end
     
-    def remove_page_attributes(page)
-      @attributes.map{|att| att.remove_page(page)}
-      @attributes.delete_if{|att| att.pages.size == 0}
-    end
-
-    def delete_page(slug)
-      page = find_page(slug)
-      @attributes.map{|att| att.remove_page(page)}
-      @attributes.delete_if{|att| att.pages.size == 0}
-      page.delete_files
-      @pages.delete_if{|p| p.slug == page.slug}
-      add_kinbote_haml
-    end
-    
-    def add_kinbote_haml(page = nil)
-      fname = "#{@kinbote_path}/views/#{page ? page.path : "index"}"
-      f_new = File.open("#{fname}.haml.new", "w")
-      File.read("#{fname}.haml").to_a.each do |line|
-        break if line.include?("-# Kinbote")
-        f_new.puts line
-      end
-      if page
-        kinbote_haml(f_new, "page_attributes_title")
-        kinbote_haml(f_new, "page_attributes", ["Title: #{page.title}"] + page.values.map{|v| "#{v.attribute.name}: #{v.value}"})
-        kinbote_haml(f_new, "header")
-        kinbote_haml(f_new, "specific", page.attributes.map{|a| a._varname})
-        kinbote_haml(f_new, "related", page.attributes.map{|a| a.name.downcase == "date" ? nil : a.name}.compact)
-        kinbote_haml(f_new, "related2", page.attributes.map{|a| "#{a.name}\", \"#{a.values.first.value}"})
-        kinbote_haml(f_new, "related_any")
-      else
-        kinbote_haml(f_new, "home", @attributes.map{|a| a._varname})
-      end
-      f_new.close
-      FileUtils.mv("#{fname}.haml.new", "#{fname}.haml")
-      page.set_filesize if page
-      add_kinbote_haml if page
-    end
-
-    def kinbote_haml(f, example_name, replacements=nil)
-      return if replacements && replacements.size == 0 && example_name != "page_attributes"
-      File.read("#{@kinbote_path}/.kinbote/views/examples/#{example_name}.haml").to_a.each do |line|
-        if replacements && line.include?("$ALL_VALS$")
-          replacements.each do |r|
-            f.puts(line.gsub("$ALL_VALS$", r))
-          end
-        elsif replacements && line.include?("$ALL_VALS_COMMENTED$")
-          replacements.each_with_index do |r, i|
-            if i == replacements.size - 1
-              f.puts(line.gsub("$ALL_VALS_COMMENTED$", r))
-            else
-              f.puts(line.gsub("- ", "-# ").gsub("$ALL_VALS_COMMENTED$", r))
-            end
-          end
-        elsif replacements && line.include?("$FIRST_VAL$")
-          f.puts(line.gsub("$FIRST_VAL$", replacements.first))
-        elsif replacements && line.include?("$LAST_VAL$")
-          f.puts(line.gsub("$LAST_VAL$", replacements.last))
-        else
-          f.puts(line)
-        end
+    def read_config
+      @config = (File.exist?("#{@kinbote_path}/config/site.yml") ? YAML::load_file("#{@kinbote_path}/config/site.yml") : {"title" => "Kinbote Site"})
+      @config.each do |key, value|
+        Site.send(:define_method, varify(key).to_sym, Proc.new{ @config[key] }) if !Site.respond_to?(varify(key).to_sym)
       end
-      f.puts "" 
     end
 
   end

data/lib/kinbote/util.rb

@@ -6,11 +6,15 @@ module Kinbote
       slug = slug[0, slug.size - 1] if slug[-1, 1] == '-'
       slug
     end
+  
+    def varify(str)
+      slugify(str).gsub('-', '_')
+    end
 
     def dir_from_file(file)
       file.split("/")[0...-1].join("/") + "/"
     end
-    
+  
     def file_without_extension(file)
       file.split(".")[0...-1].join(".")
     end
@@ -18,11 +22,11 @@ module Kinbote
     def slug_from_file(file)
       file.split("/").last.split(".").first
     end
-    
+  
     def type_from_file(file)
       file.split(".").last
     end
-    
+  
     def output_path(file)
       if type_from_file(file) == "haml"
         "#{$site.kinbote_path}/www/#{view_path(file)}".gsub(".haml", ".html")
@@ -30,11 +34,11 @@ module Kinbote
         "#{$site.kinbote_path}/www/#{view_path(file)}".gsub("/sass/", "/css/").gsub(".sass", ".css")
       end
     end
-    
+  
     def view_path(file)
       file[$site.kinbote_path.size + 7, file.size]
     end
-    
+  
     def print_state
       @attributes.each do |a|
         puts "#{a.name} : #{a.pages.map{|p| p.slug}.join(',')}"
@@ -44,5 +48,13 @@ module Kinbote
       end
     end
     
+    def sorted_attributes(attributes)
+      attributes.sort!{|x, y| x.name <=> y.name }
+      attributes.each_with_index do |attribute, i|
+        attributes.insert(0, attributes.delete_at(i)) if attribute.varname == "date"
+      end
+      attributes
+    end
+  
   end
 end

data/lib/kinbote/value.rb

@@ -1,45 +1,27 @@
 module Kinbote
   class Value
-    attr_accessor :value, :attribute
-  
-    def initialize(value, page, attribute, global_value = nil)
+    include Kinfile
+    attr_reader :value, :attribute
+
+    def initialize(value, page, attribute, global=nil)
       @value = value.to_s
       @attribute = attribute
-      @global_value = global_value || self
+      @global = global || self
       @pages = [page]
-      @css = File.exist?(file_name(:css))
     end
-  
+
     def add_page(page)
       remove_page(page)
       @pages << page
     end
-  
+
     def remove_page(page)
-      @global_value.pages.delete_if{|p| p.slug == page.slug}
+      @global.pages.delete_if{|p| p.slug == page.slug}
       @pages.delete_if{|p| p.slug == page.slug}
     end
-  
-    def create_css
-      FileUtils.mkdir_p(file_name(:css, true)) if !File.exist?(file_name(:css, true))
-      File.open(file_name(:css), "w") if !File.exist?(file_name(:css))
-      @global_value.css!
-    end
-  
-    def file_name(type, dir = nil)
-      if type == :css
-        return "#{$site.kinbote_path}/views/sass/attributes/#{@attribute}/#{!dir ? "#{@value}.sass" : ""}"
-      end
-    end
-  
-    def css_files
-      @global_value.css? ? ["/css/attributes/#{@attribute}/#{@value}"] : [] 
-    end
 
-    def pages; @global_value == self ? @pages : @global_value.pages; end
+    def pages; @global == self ? @pages : @global.pages; end
     def to_s; @value; end
-    def css!; @global_value == self ? @css = true : @global_value.css!; end
-    def css?; @global_value == self ? @css : @global_value.css?; end
-  
+    
   end
 end

data/lib/sinatra/kinbote.rb

@@ -11,22 +11,21 @@ module Kinbote
     
     configure do
       $site = Site.new
-      $site.load_pages
+      $site.load
     end
     
     before do
-      $site.set_kinbote_path(options.kinbote_path)
-      $site.read_config
-      $site.reload_pages
+      $site.kinbote_path = options.kinbote_path
+      $site.reload
     end
 
     not_found do
-      status 404
+      set_user_variables
       haml :'404'
     end
 
     error do
-      status 500
+      set_user_variables
       haml :'500'
     end
 
@@ -51,17 +50,17 @@ module Kinbote
     end
 
     post '/kinbote/pages/*/css' do
-      $site.find_page(params[:splat].first).create_css
+      $site.find_page(params[:splat].first).create_file(:css)
       redirect '/kinbote/pages'
     end
 
     post '/kinbote/attributes/css' do
-      $site.find_attribute(params["attribute"]).create_css
+      $site.find_attribute(params["attribute"]).create_file(:css)
       redirect '/kinbote/attributes'
     end
 
     post '/kinbote/values/css' do
-      $site.find_value(params["value"], $site.find_attribute(params["attribute"]), true).create_css
+      $site.find_value(params["value"], $site.find_attribute(params["attribute"]), true).create_file(:css)
       redirect '/kinbote/attributes'
     end
 
@@ -71,9 +70,8 @@ module Kinbote
     end
 
     post '/kinbote/pages/*' do
-      p params
       @p = $site.find_page(params[:splat].first)
-      @p.set_attributes(kv_to_attributes(params["page"]["keys"], params["page"]["values"]))
+      @p.set_attributes(params["page"]["keys"], params["page"]["values"])
       redirect "/kinbote/pages/#{@p.slug}"
     end
 
@@ -82,7 +80,7 @@ module Kinbote
     end
 
     post '/kinbote/publish' do
-      set_user_globals
+      set_user_variables
       publish
       redirect '/kinbote'
     end
@@ -90,7 +88,7 @@ module Kinbote
     # -----------------------------------------------------------------------------------------
 
     get '/' do
-      set_user_globals
+      set_user_variables
       haml :index
     end
 
@@ -106,7 +104,7 @@ module Kinbote
     end
 
     get '/*.html' do
-      set_user_globals
+      set_user_variables
       @page = $site.find_page(params[:splat].first)
       haml :"#{@page ? "#{@page.path}" : "404"}"
     end

data/lib/sinatra/kinbote_helpers.rb

@@ -6,21 +6,11 @@ module Sinatra
         haml("snippets/#{path}".to_sym, :layout => false)
       end
       
-      def set_user_globals
+      def set_user_variables
         @site = $site
         @pages = $site.pages
         @attributes = $site.attributes
-        @attributes.each{|att| eval("@#{att._varname} = att")}
-      end
-      
-      def kv_to_attributes(keys, values)
-        attributes = {}
-        keys.each_with_index do |key, i|
-          next if key.size == 0
-          attributes[key] = [] if !attributes.has_key?(key)
-          attributes[key] << values[i] if !attributes[key].include?(values[i])
-        end
-        attributes
+        @attributes.each{|att| eval("@#{att.varname} = att if !@#{att.varname}")}
       end
       
       def publish