static 0.1.3 → 1.0.0

data/lib/extentions/class.rb

@@ -1,43 +0,0 @@
-
-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

@@ -1,11 +0,0 @@
-
-
-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
-  def as_http; self =~ /^http\:\/\// ? "http://#{self.gsub(/^http\:\/\//, '').as_folder}" : "http://#{self.as_folder}" end
-end
-

data/lib/filebase.rb

@@ -1,84 +0,0 @@
-
-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

@@ -1,20 +0,0 @@
-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

@@ -1,135 +0,0 @@
-  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 included_in? page_name, all_levels=false
-      ans = (file_name == page_name.to_s or Page.find(page_name).subs.include? name)
-      subs.each { |sub| ans = Page.find(sub.as_file).included_in?(page_name, all_levels) } if all_levels and !ans
-      ans
-    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+'base/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+'base/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+'base/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 ) } rescue puts $!
-    end
-    def save_contents
-      File.open(home+ 'contents/'+page_location+name.as_file+'.copy',  'w') { |yf| YAML.dump(@contents,  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+'layout/copy/page.copy', :sub => home+'layout/copy/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])
-          unless type == :contents
-            write_template template_file[:sub], page_path+'_submenu'+extentions[type] 
-            puts "writing #{page_path}submenu#{extentions[type]}"
-          end
-        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

@@ -1,153 +0,0 @@
-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.copy(templates+'helpers', site.home) rescue puts $!
-    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.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
-    write_template home+"layout/page_head.erbml", home+'base/page_head.rbml'
-    write_template home+"layout/main_navigation.erbml", home+'base/main_navigation.rbml'
-  end
-
-  def build(type)
-    setup_location(type.to_s)
-    if type == :blueprint
-      @main_links = []
-      copy home+'layout/structure', home+'base'
-      begin
-        copy home+'layout/stylesheets', home+'base/stylesheets'
-        puts 'copied stylesheets'
-      rescue
-        puts "There are no stylesheets associated with this layout"
-      end
-      copy home+'layout/resources', home+'base/resources' rescue puts "There are no resources associated with this layout"
-      copy home+'layout/scripts', home+'base/scripts' rescue puts "There are no scripts associated with this layout"
-      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+'base/stylesheets', site_loc rescue puts $!
-    copy home+'base/resources', site_loc rescue puts $!
-    copy home+'base/scripts', site_loc rescue puts $!
-    pages.each do |page|
-      page.stylesheets = []
-      Generator.load(page)
-      page.load_contents
-      page.stylesheets << info['stylesheets'] if info['stylesheets']
-      page.generate info['paginate'] ? info['paginate'][page.file_name] : nil rescue puts "site generator -- #{$!}"
-      Generator.unload
-    end
-  end
-end
-