kinbote 0.0.1

data/lib/kinbote/page_match.rb

@@ -0,0 +1,12 @@
+module Kinbote
+  class PageMatch
+    attr_accessor :page, :attribute, :value
+  
+    def initialize(page, attribute, value = nil)
+      @page = page
+      @attribute = attribute
+      @value = value
+    end
+  
+  end
+end

data/lib/kinbote/site.rb

@@ -0,0 +1,175 @@
+module Kinbote
+  class Site
+    include Util
+        
+    attr_reader :pages, :attributes, :kinbote_path, :config
+    
+    def initialize
+      @pages = []
+      @attributes = []
+      @values = []
+      @kinbote_path = nil
+      @config = {}
+    end
+    
+    def set_kinbote_path(path)
+      return if @kinbote_path
+      @kinbote_path = path
+    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"}
+      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)
+      end
+    end
+    
+    def load_pages
+      Dir.glob("#{@kinbote_path}/views/pages/**/*.{haml}").each do |file|
+        title, attributes = file_attributes(file)
+        @pages << Page.new(title, file, attributes)
+      end
+    end
+
+    def reload_pages
+      files = Dir.glob("#{@kinbote_path}/views/pages/**/*.{haml}")
+      files.each do |file|
+        slug = slug_from_file(file)
+        title, attributes = file_attributes(file)
+        page = find_page(slug)
+        if page
+          next if File.size(file) == page.get_filesize
+          page.set_attributes(attributes.merge({"title" => [title]}))
+          page.set_filesize
+        else
+          @pages << Page.new(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 = {}
+      in_atts = false
+      File.read(file).to_a.each do |line|
+        in_atts = true if line.include?("-# Kinbote Page Attributes")
+        in_atts = false if line.include?("-# Kinbote Sample Code")
+        if in_atts && line.include?(":") && line.split(":").size == 2
+          key = line.split(":").first.chomp.strip
+          value = line.split(":").last.chomp.strip
+          if key.downcase == "title"
+            title = value if key.downcase == "title"
+            next
+          else
+            attributes.has_key?(key) ? (attributes[key] << value) : (attributes[key] = [value])
+          end
+        end
+      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
+      end
+      f.puts "" 
+    end
+
+  end
+end

data/lib/kinbote/util.rb

@@ -0,0 +1,48 @@
+module Kinbote
+  module Util
+    
+    def slugify(str)
+      slug = str.downcase.gsub(/'/, '').gsub(/[^a-z0-9]+/, '-')
+      slug = slug[0, slug.size - 1] if slug[-1, 1] == '-'
+      slug
+    end
+
+    def dir_from_file(file)
+      file.split("/")[0...-1].join("/") + "/"
+    end
+    
+    def file_without_extension(file)
+      file.split(".")[0...-1].join(".")
+    end
+
+    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")
+      elsif type_from_file(file) == "sass"
+        "#{$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(',')}"
+        a.values.each do |v|
+          puts "  #{v.value} : #{v.pages.map{|p| p.slug}.join(',')}"
+        end
+      end
+    end
+    
+  end
+end

data/lib/kinbote/value.rb

@@ -0,0 +1,45 @@
+module Kinbote
+  class Value
+    attr_accessor :value, :attribute
+  
+    def initialize(value, page, attribute, global_value = nil)
+      @value = value.to_s
+      @attribute = attribute
+      @global_value = global_value || 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}
+      @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 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

@@ -0,0 +1,115 @@
+require 'sinatra/base'
+require 'sinatra/kinbote_helpers'
+
+module Kinbote
+  class Server < Sinatra::Base
+    register Sinatra::KinboteHelpers
+    include Util
+    
+    set :haml, {:format => :html5}
+    set :sass, {:syntax => :scss}
+    
+    configure do
+      $site = Site.new
+      $site.load_pages
+    end
+    
+    before do
+      $site.set_kinbote_path(options.kinbote_path)
+      $site.read_config
+      $site.reload_pages
+    end
+
+    not_found do
+      status 404
+      haml :'404'
+    end
+
+    error do
+      status 500
+      haml :'500'
+    end
+
+    # -----------------------------------------------------------------------------------------
+
+    get '/kinbote' do
+      haml :'../.kinbote/views/site', :layout => :'../.kinbote/views/layout'
+    end
+
+    get '/kinbote/pages' do
+      haml :'../.kinbote/views/pages', :layout => :'../.kinbote/views/layout'
+    end
+
+    post '/kinbote/pages/new' do
+      $site.create_page(params["page"]["title"])
+      redirect '/kinbote/pages'
+    end
+
+    post '/kinbote/pages/*/delete' do
+      $site.delete_page(params[:splat].first)
+      redirect '/kinbote/pages'
+    end
+
+    post '/kinbote/pages/*/css' do
+      $site.find_page(params[:splat].first).create_css
+      redirect '/kinbote/pages'
+    end
+
+    post '/kinbote/attributes/css' do
+      $site.find_attribute(params["attribute"]).create_css
+      redirect '/kinbote/attributes'
+    end
+
+    post '/kinbote/values/css' do
+      $site.find_value(params["value"], $site.find_attribute(params["attribute"]), true).create_css
+      redirect '/kinbote/attributes'
+    end
+
+    get '/kinbote/pages/*' do
+      @p = $site.find_page(params[:splat].first)
+      haml :'../.kinbote/views/page', :layout => :'../.kinbote/views/layout'
+    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"]))
+      redirect "/kinbote/pages/#{@p.slug}"
+    end
+
+    get '/kinbote/attributes' do
+      haml :'../.kinbote/views/attributes', :layout => :'../.kinbote/views/layout'
+    end
+
+    post '/kinbote/publish' do
+      set_user_globals
+      publish
+      redirect '/kinbote'
+    end
+
+    # -----------------------------------------------------------------------------------------
+
+    get '/' do
+      set_user_globals
+      haml :index
+    end
+
+    get '/css/pages/*.css' do
+      @page = $site.find_page(params[:splat].first)
+      content_type 'text/css', :charset => 'utf-8'
+      sass :"#{@page.path}"
+    end
+
+    get '/css/*.css' do
+      content_type 'text/css', :charset => 'utf-8'
+      sass :"sass/#{params[:splat].first}"
+    end
+
+    get '/*.html' do
+      set_user_globals
+      @page = $site.find_page(params[:splat].first)
+      haml :"#{@page ? "#{@page.path}" : "404"}"
+    end
+    
+  end
+end

data/lib/sinatra/kinbote_helpers.rb

@@ -0,0 +1,63 @@
+module Sinatra
+  module KinboteHelpers
+    module Helpers
+
+      def snippet(path)
+        haml("snippets/#{path}".to_sym, :layout => false)
+      end
+      
+      def set_user_globals
+        @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
+      end
+      
+      def publish
+        FileUtils.rm_rf("#{$site.kinbote_path}/www")
+        FileUtils.mkdir_p("#{$site.kinbote_path}/www/css/pages")
+        FileUtils.copy_entry("#{$site.kinbote_path}/public", "#{$site.kinbote_path}/www")
+        files = Dir.glob("#{$site.kinbote_path}/views/**/*.{haml,sass}")
+        files.each do |file|
+          next if file.include?("/.kinbote/") || file.include?("/snippets/") || file.include?("/layout.haml")
+          slug = (file.include?("/views/pages/") ? slug_from_file(file) : nil)
+          @page = (slug ? $site.find_page(slug) : nil)
+          type = type_from_file(file)
+          if @page && type == "haml"
+            File.open("#{$site.kinbote_path}/www/#{@page.slug}.html", 'w') {|f| f.write(haml(:"#{@page.path}")) }
+          elsif @page && type == "sass"
+            File.open("#{$site.kinbote_path}/www/css/pages/#{@page.slug}.css", 'w') {|f| f.write(sass(:"#{@page.path.gsub(".haml", ".sass")}")) }
+          elsif type == "haml"
+            FileUtils.mkdir_p("#{dir_from_file(output_path(file))}")
+            File.open(output_path(file), "w") {|f| f.write(render(type.to_sym, :"#{file_without_extension(view_path(file))}"))}
+          elsif type == "sass"
+            FileUtils.mkdir_p("#{dir_from_file(output_path(file))}")
+            File.open(output_path(file), "w") {|f| f.write(render(type.to_sym, :"#{file_without_extension(view_path(file))}"))}
+          end
+        end
+        return if !$site.config.has_key?("remote_host") || !$site.config.has_key?("remote_user") || !$site.config.has_key?("remote_pw") 
+        Net::SCP.start($site.config["remote_host"], $site.config["remote_user"], :password => $site.config["remote_pw"] ) do |scp|
+          scp.upload!("#{$site.kinbote_path}/www", $site.config["remote_path"], :recursive => true)
+        end 
+      end
+    
+    end
+  
+    def self.registered(app)
+      app.helpers KinboteHelpers::Helpers
+    end
+  
+  end
+
+  register KinboteHelpers
+end