static 0.0.1

data/lib/collection.rb

@@ -0,0 +1,112 @@
+class Collection
+  attr_accessor :name, :attrs, :base, :listing, :entries, :contents
+  include FileBase
+  def initialize base, where, name
+    set_home where
+    @base = base
+    @name = name
+    @attrs = []
+    @listing = []
+    @entries = []
+    setup_location 'collections'
+    set_home path+name
+  end
+
+  def file_name
+    name.as_file
+  end
+
+  def self.start base, where, name, attrs
+    return nil if self.collection_exists?(base, where, name)
+    c = self.new base, where, name
+    c.attrs << attrs
+    c.attrs.flatten!
+    c.write_attribute_file
+    c.load_attributes
+    c.write_display_file
+    copy base+'.templates/disco/link_list', c.home
+    c.write_publish_file
+    c.write '', c.home+'listing'
+    c.mkdir c.home+'entries'
+    c
+  end
+
+  def self.collection_exists?(base, where, name)
+    exists?(:folder, base) && exists?(:folder, where+'collections/'+name) && exists?(:file, where+"collections/#{name}/attributes")
+  end
+  def self.load base, where, name
+    return nil unless self.collection_exists?(base, where, name)
+    c = self.new base, where, name
+    c.load_attributes
+    c.load_listing
+    c.sanitize_listing
+    c.load_entries
+    c
+  end
+
+  def save_listing
+   File.open(home+'listing',  'w') { |yf| YAML.dump(@listing,  yf) }
+  end
+
+  def sanitize_listing
+    tmp = []
+    @listing.each { |item|
+      entry = load_entry(item)
+      add = false
+      entry.each { |key, value|
+        add = true if value and key != 'date' and key != :id
+      }
+      tmp << item if add
+    }
+    @listing = tmp
+  end
+
+  def write_attribute_file
+    write_template base+'.templates/disco/attributes', attributes
+  end
+  def write_display_file
+    write_template base+'.templates/disco/display', blueprint
+  end
+  def write_publish_file
+    write_template base+'.templates/disco/publish', publish
+  end
+  def write_link_list_file
+    write_template base+'.templates/disco/link_list', publish
+  end
+  def publish
+    home+'publish'
+  end
+  def blueprint
+    home+'display'
+  end
+  def attributes
+    home+'attributes'
+  end
+  def load_attributes
+    File.open( home+'attributes' ) { |yf| @attrs = YAML::load( yf )[name] }
+  end
+  def load_listing
+    File.open( home+'listing' ) { |yf| @listing = YAML::load( yf ) }
+    @listing ||= []
+    @listing = @listing.sort.reverse
+  end
+  def load_entries
+    listing.each {|entry| entries <<  load_entry(entry) }
+    entries
+  end
+  def load_entry(file)
+    tmp = nil
+    File.open( home+'entries/'+file ) {|yf| tmp = YAML::load( yf )[name].merge({:id => file})}
+    tmp
+  end
+  def add_entry title=nil
+    timestamp = Time.now.to_i.to_s 
+    title ||=  timestamp
+    load_listing
+    listing.unshift timestamp
+    write_template home+'attributes', home+'entries/'+timestamp
+    return home+'entries/'+timestamp
+  end
+end
+
+

data/lib/extentions/class.rb

@@ -0,0 +1,43 @@
+
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/lib/extentions/string.rb

@@ -0,0 +1,10 @@
+
+
+class String
+  def as_file; self.gsub(/([!?,]|[^a-zA-Z0-9\.]$)/, '').gsub(/[^a-zA-Z0-9\.\/]/, '_').downcase end
+  def as_folder; self.as_file+((self.as_file=~/\/$/||self=='') ? '' : '/') end
+  def as_ext; self[0,0]='.' unless self[0,1]=='.'|| self==''; self end
+  def as_file_title; self.as_file.gsub /_/, ' ' end
+  def filename_as_symbol; self.as_file.to_sym end
+end
+

data/lib/filebase.rb

@@ -0,0 +1,84 @@
+
+require 'erb'
+require 'fileutils'
+
+module FileBase
+  include FileUtils
+
+  Home = ''
+  def home; (@home||Home).as_folder end
+  def set_home(here)
+    mkdir here unless exists? :folder, here
+    @home=here
+  end
+  
+  def location; (@location||'').as_folder end
+  def set_location where; @location=where end
+  def setup_location where; @location=where; mkdir path unless exists? :folder, path end
+  def reset_location; @location='' end
+  def has_location?; location!='' end
+
+  def path; home+location end
+  def file_path; home+location+filename end
+  
+  def exists? type, item
+    return false unless File.exist? item
+    truth = case type
+    when :folder
+       return(File.directory?(item))
+    when :file
+       return(!File.directory?(item))
+    else
+       return(true)
+    end
+  end
+
+  def items_under(pth, match=nil)
+    match||=''
+    folders = []
+    files = []
+    Dir.entries(pth).each { |item| (exists?(:folder, pth.as_folder+item) ? folders << item : files << item) unless item[0,1]=='.' or not item=~/#{match}/}
+    {:folders => folders, :files => files}
+  end
+
+  
+  def move(from, to=home)
+    FileUtils.mv from, to
+  end
+
+  def copy(from, to=home)
+    FileUtils.cp_r from, to
+  end
+
+  def mkdir where, force=false
+    begin 
+      Dir.mkdir where
+    rescue
+      raise $! unless force
+      destroy where
+      mkdir where
+    end
+    where
+  end
+ 
+  def make_dir path, force=false
+    mkdir path, force
+    puts 'creating '+path
+  end
+
+  def destroy what
+    FileUtils.rm_rf what
+    puts 'destroying '+what
+  end
+  
+  def write(contents, where)
+    File.open(where, 'w'){ |f| f << contents }
+  end
+  def write_template what, where
+    write ERB.new(File.read(what)).result(binding), where
+  end
+
+  alias loc location
+  alias loc= set_location
+end
+

data/lib/generator.rb

@@ -0,0 +1,20 @@
+class Generator
+  include Singleton
+  cattr_accessor :act_on, :actors
+  
+  def self.load(what)
+    self.actors ||= []
+    self.actors << self.act_on if self.act_on
+    self.act_on = what
+  end
+
+  def self.unload
+    self.act_on = self.actors.shift
+  end
+
+  def self.method_missing(sym, *args)
+    act_on.send(sym, *args)
+  end
+end
+
+

data/lib/page.rb

@@ -0,0 +1,124 @@
+  class Page
+    include FileBase
+
+    cattr_accessor :pages
+    @@pages=[]
+    attr_accessor :name, :subs, :page_location, :contents, :stylesheets, :index, :site_location, :site_base, :breadcrumbs
+    @@templates = {}
+    
+    def initialize(name, home, location, generate_to, subs=nil, index=nil)
+      @home = home
+      @page_location = location
+      @name = name
+      @subs = subs
+      @site_base = generate_to.as_folder
+      @index = index
+      @breadcrumbs = []
+      @stylesheets = []
+      pages << self
+    end
+
+    def file_name
+      name.as_file
+    end
+    def to_s
+      name.downcase
+    end
+    def self.find(name)
+      item = nil
+      name = name.to_s
+      self.pages.each{ |p| item = p if p.file_name==name.as_file}
+      item
+    end
+
+    def index?; @index end
+
+    def generate collection_name
+      stylesheets << contents['stylesheets'] if contents['stylesheets']
+      mkdir in_site_location unless exists?(:folder, in_site_location) or index?
+      collection = load_collection(collection_name) if collection_name
+      if collection
+        Generator.class_eval { cattr_accessor :include_text } 
+        Generator.include_text = File.read home+"blueprint/#{page_location}_#{collection_name}_for_#{file_name}/#{collection.first}"
+        write ::Rbml::Processor.new.instance_eval(File.read(home+'layout/structure/default.rbml')), in_site_location+'index.html'
+  puts 'writing the index'
+        collection.each { |col|
+        Generator.include_text = File.read home+"blueprint/#{page_location}_#{collection_name}_for_#{file_name}/#{col}"
+        write ::Rbml::Processor.new.instance_eval(File.read(home+'layout/structure/default.rbml')), in_site_location+col+'.html'
+  puts "writing the entry for #{col}"
+        } 
+        Generator.class_eval { @include_text = nil } 
+      else
+        write ::Rbml::Processor.new.instance_eval(File.read(home+'layout/structure/default.rbml')), in_site_location+'index.html'
+      end
+      puts "writing #{in_site_location}index.html"
+    end
+
+    def load_collection name
+      stuff = nil
+      File.open(home+ 'blueprint/'+page_location+"_#{name}_for_#{file_name}/page.list") { |yf| stuff  = YAML::load( yf ) }
+      stuff
+    end
+
+    def in_site_location
+      (index? ? site_base : ( has_subs? && subs.kind_of?(Array) ? site_base+page_location : site_base+page_location+name.as_file )).as_folder
+    end
+    def in_site_link
+      in_site_location.sub(site_base, '')
+    end
+    def level
+      tmp = (index? || has_subs? && subs.kind_of?(Array)) ? '' : '../' 
+      tmp+page_location.gsub(/\w+\//, '../')
+    end
+
+    def menu_title
+      case subs
+      when Array : name
+      when String : subs
+      else
+        nil
+      end
+    end
+    
+    def load_contents
+      File.open(home+ 'contents/'+page_location+name.as_file+'.copy') { |yf| @contents  = YAML::load( yf ) }
+    end
+
+    def extentions
+      {
+        :contents  => '.copy',
+        :blueprint => '.rbml',
+        :page      => '.html'
+      }
+    end
+
+    def make(type)
+      page_path =  home+type.to_s+'/'+page_location
+      mkdir page_path unless exists? :folder, page_path
+      template_file = case type
+      when :contents : {:main => home+'.templates/page.copy', :sub => home+'.templates/submenu.copy'}
+      when :blueprint : {:main => home+'layout/contents.erbml', :sub => home+'layout/submenu.erbml'}
+      end
+
+      if subs && subs.kind_of?(Array) 
+        unless exists?(:file, page_path+'submenu'+extentions[type])
+          write_template template_file[:sub], page_path+'submenu'+extentions[type] 
+          puts "writing #{page_path}submenu#{extentions[type]}"
+        else
+          puts "#{page_path}submenu#{extentions[type]} already exists"
+        end
+      end
+      unless exists?(:file, page_path+name.as_file+extentions[type])
+      write_template template_file[:main], page_path+name.as_file+extentions[type]
+      puts "writing #{page_path}#{name.as_file}#{extentions[type]}"
+      else
+        puts "#{page_path}#{name.as_file}#{extentions[type]} already exists"
+      end
+    end
+
+    def has_subs?
+      subs && !subs.empty? 
+    end
+  end
+
+

data/lib/site.rb

@@ -0,0 +1,144 @@
+class Site
+  include FileBase
+
+  attr_accessor :name, :map, :info, :pages, :main_links, :site_loc
+
+  def initialize(where, name, generate_to, templates=nil)
+    set_home where+name
+    @name = name
+    @pages = []
+    @main_links = []
+    mkdir generate_to unless exists? :folder, generate_to
+    @site_loc = generate_to + name
+  end
+
+  def self.load(where, name, generate_to, templates)
+    return nil unless self.site_exists?(where, name)
+    s = self.new(where, name, generate_to, templates)
+    s.load_info
+    s.load_pages
+    s
+  end
+
+  def self.site_exists?(where, name)
+    (exists?(:folder, where+name) && exists?(:folder, where+name+'/project_info'))
+  end
+  def self.start where, name, generate_to, templates
+    return nil if self.site_exists?(where, name)
+    site = Site.new(where, name, generate_to, templates)
+    site.mkdir(site.home+'project_info')
+    site.setup_location 'project_info'
+    site.write_template templates+'site.map', site.path+'site.map'
+    site.write_template templates+'site.info', site.path+'site.info'
+    site.setup_location '.templates'
+    site.copy templates+'page.copy', site.path+'page.copy'
+    site.copy templates+'submenu.copy', site.path+'submenu.copy'
+    site.load_info
+    site
+  end
+
+  def load_info(file=nil)
+    File.open(home+ 'project_info/site.map') { |yf| @map  = YAML::load( yf ) } unless file=='site.info'
+    File.open(home+'project_info/site.info') { |yf| @info = YAML::load( yf ) } unless file=='site.map'
+  end
+
+  def save_info(file=nil)
+    File.open(home+'project_info/site.map',  'w') { |yf| YAML.dump(@map,  yf) } unless file=='site.info'
+    File.open(home+'project_info/site.info', 'w') { |yf| YAML.dump(@info, yf) } unless file=='site.map'
+  end
+
+  def set_layout(name, address)
+    copy address+name, home+'layout/' unless exists? :folder, home+'layout' rescue puts $! 
+    info['layout'] = {'name' => name, 'address' => address}
+  end
+  
+  def load_pages
+    gather_pages
+    make_breadcrumbs
+  end
+  def gather_pages(page=nil, first_time=true, parent=nil)
+    index = nil
+    if first_time
+      reset_location
+      @pages = []
+      page ||= map
+    else
+      index = true if @pages.empty?
+    end
+    case page
+    when String : pages << Page.new(page, home, location, site_loc, parent, index)
+    when Array then
+      tmp = page.dup
+      gather_pages(tmp.shift, false, parent) while(tmp.size > 0)
+    when Hash then
+      page.each { |page_name, sub_pages|
+        unless first_time 
+          set_location(pages.empty? ? location : location+page_name )
+          pages << Page.new(page_name, home, location, site_loc, sub_pages, index) 
+        else
+          page_name = nil
+        end
+        gather_pages(sub_pages, false, page_name)
+        set_location location.sub(page_name.as_file+'/', '') if page_name
+      }
+    else
+      return nil
+    end
+  end
+
+  def make_breadcrumbs
+    pages.each do |page|
+      page.breadcrumbs << page.name.as_file
+      page.subs.each { |p|
+        if p.kind_of?(Hash)
+          p.each{ |k, v|
+            tmp = Page.find(k)
+            tmp.breadcrumbs << page.breadcrumbs }
+        else
+          tmp = Page.find(p).breadcrumbs << page.breadcrumbs  
+        end
+      } if page.has_subs? && page.subs.kind_of?(Array)
+      page.breadcrumbs.flatten!
+    end
+  end
+  
+  def load_main_links
+    map['site_map'].each { |page|
+      case page
+      when String
+        main_links << page
+      when Hash
+        page.each { |name, subs| main_links << name }
+      end
+    }
+  end
+
+  def build_header
+puts info.inspect
+    write_template home+"layout/page_head.erbml", home+'layout/structure/page_head.rbml'
+    write_template home+"layout/main_navigation.erbml", home+'layout/structure/main_navigation.rbml'
+  end
+
+  def build(type)
+    setup_location(type.to_s)
+    if type == :blueprint
+      @main_links = []
+      load_main_links 
+      build_header 
+    end
+    pages.each{|page|  page.make(type)}
+  end
+
+  def generate
+    mkdir site_loc unless exists? :folder, site_loc
+    copy home+'layout/stylesheets', site_loc rescue puts $!
+    pages.each do |page|
+      page.stylesheets = []
+      Generator.load(page)
+      page.load_contents
+      page.stylesheets << info['stylesheets'] 
+      page.generate info['paginate'] ? info['paginate'][page.file_name] : nil
+    end
+  end
+end
+

data/lib/static.rb

@@ -0,0 +1,96 @@
+
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+
+require 'yaml'
+require 'erb'
+require 'singleton'
+
+require 'extentions/string'
+require 'extentions/class'
+
+require 'filebase'
+
+require 'site'
+require 'page'
+
+require 'collection'
+require 'generator'
+
+
+require 'rubygems'
+require 'rbml'
+
+require 'xhtml'
+
+$ENV = {}
+$ENV['EDITOR'] = 'vi'
+
+module Static
+  VERSION = '0.0.1'
+  include FileBase
+
+  def start_site name
+    site = Site.start($ENV['SITE_BANK'], name, $ENV['STATIC_VIEWING'], $ENV['TEMPLATE_HOME'])
+    site
+  end
+
+  def load_site name
+    Site.load($ENV['SITE_BANK'], name, $ENV['STATIC_VIEWING'], $ENV['TEMPLATE_HOME']) if name
+  end
+
+  def set_layout which, force
+    return nil unless which
+    destroy $active_site.home+'layout/' if force
+    $active_site.set_layout(which, $ENV['LAYOUT_HOME']) unless exists? :folder, $active_site.home+'layout/'
+    $active_site.save_info('site.info')
+  end
+
+  def start_collection name, attrs=[]
+    Collection.start $ENV['STATIC_HOME'], $active_site.home, name, attrs
+  end
+  def load_collection name
+    Collection.load $ENV['STATIC_HOME'], $active_site.home, name.to_s
+  end
+
+  def assign_pagination collection, page
+    collection = collection.to_s
+    page = page.to_s
+    $active_site.info['paginate'] ||= {}
+    $active_site.info['paginate'].merge!({page => collection}) unless $active_site.info['paginate'].include?({page => collection})
+    $active_site.save_info
+  end
+
+  def paginate page, publishing_to=nil
+    @page = Page.find(page)
+    Generator.load(load_collection($active_site.info['paginate'][@page.file_name]))
+    Generator.class_eval {
+      def self.entry_bank
+        if @tmp_entries and @tmp_entries.empty?
+          @tmp_entries = nil
+          return @tmp_entries
+        end
+        @tmp_entries ||= self.act_on.entries.dup
+        @tmp_entries
+      end
+    }
+    publishing_to ||= "#{@page.home}blueprint/#{@page.page_location}_#{Generator.act_on.name}_for_#{@page.file_name}/"
+    mkdir publishing_to, :force 
+    @page_list = []
+    while(Generator.entry_bank and Generator.entry_bank)
+      rbml = ::Rbml::Processor.new
+      #Generator.contents = {:id => entry_bank.first[:id]}
+      publish_file = File.read(Generator.act_on.home+'publish')
+      id = Generator.entry_bank.first[:id]
+      puts "writing partial for #{id}"
+      write rbml.render('xhtml', rbml.load_language('xhtml'), :partial => true) { eval(publish_file) }, publishing_to+id
+      @page_list << id
+    end
+    File.open(publishing_to+'page.list',  'w') { |yf|  YAML.dump(@page_list,  yf) }
+    write_template Generator.act_on.home+'link_list', "#{@page.home}blueprint/#{@page.page_location}/#{@page.file_name}_#{Generator.act_on.name}_links.rbml"
+puts "writing link list #{@page.file_name}_#{Generator.act_on.name}_links"
+    @page_list = nil
+    Generator.unload
+  end
+end
+