gumdrop 0.5.2 → 0.6.0

data/lib/gumdrop/generator.rb

@@ -3,7 +3,8 @@ module Gumdrop
   class Generator
     attr_reader :filename, :base_path, :params, :pages
     
-    def initialize(content, opts={})
+    def initialize(content, site, opts={})
+      @site= site
       @content= content
       if @content.is_a? Proc
         @filename= ""
@@ -23,9 +24,13 @@ module Gumdrop
         run_dsl_from_source IO.readlines(@content.path).join('')
       end
     end
+
+    def site
+      @site
+    end
     
     def data
-      Gumdrop.data
+      @site.data
     end
     
     def set(var_name, value)
@@ -40,16 +45,16 @@ module Gumdrop
       else
         "/#{@base_path}/#{name}"
       end
-      content= GeneratedContent.new(filepath, block, opts)
+      content= GeneratedContent.new(filepath, block, @site, opts)
       if opts.has_key? :template and !opts[:template].nil?
-        content.template = if Gumdrop.layouts.has_key?( opts[:template] )
-          Gumdrop.layouts[ opts[:template] ]
+        content.template = if @site.layouts.has_key?( opts[:template] )
+          @site.layouts[ opts[:template] ]
         else
-          Gumdrop.layouts[ "#{opts[:template]}.template" ]
+          @site.layouts[ "#{opts[:template]}.template" ]
         end.template
       end
-      
-      Gumdrop.site[content.uri]= content
+      @site.report "-generated: #{content.uri}", :info
+      @site.node_tree[content.uri]= content
     end
 
     # FIXME: Does redirect require abs-paths?
@@ -62,9 +67,9 @@ module Gumdrop
           EOF
         end
         opts[:from]= from
-        Gumdrop.redirects << opts
+        @site.redirects << opts
       else
-        Gumdrop.report "You must specify :to in a redirect", :warning
+        @site.report "You must specify :to in a redirect", :warning
       end
     end
     
@@ -93,7 +98,7 @@ module Gumdrop
 
         else
           # UNKNOWN Compressor type!
-          Gumdrop.report "Unknown javascript compressor type! (#{ opts[:compressor] })", :warning
+          @site.report "Unknown javascript compressor type! (#{ opts[:compressor] })", :warning
           content
         end
       end
@@ -104,13 +109,13 @@ module Gumdrop
         end
       end
       if opts[:prune] and opts[:root]
-        sp = File.expand_path( Gumdrop.config.source_dir )
+        sp = File.expand_path( @site.config.source_dir )
         rp = File.expand_path(opts[:root])
         relative_root = rp.gsub(sp, '')[1..-1]
         rrlen= relative_root.length - 1
-        Gumdrop.site.keys.each do |path|
+        @site.node_tree.keys.each do |path|
           if path[0..rrlen] == relative_root and name != path
-            Gumdrop.site.delete path
+            @site.node_tree.delete path
           end
         end
       end
@@ -131,14 +136,14 @@ module Gumdrop
   class GeneratedContent < Content
     # Nothing special, per se...
 
-    def initialize(path, block, params={})
+    def initialize(path, block, site, params={})
       @content_block= block
-      super(path, params)
+      super(path, site, params)
     end
 
-    def render(ignore_layout=false,  reset_context=true, locals={})
+    def render(context=nil, ignore_layout=false,  reset_context=true, locals={})
       if @content_block.nil?
-        super(ignore_layout, reset_context, locals)
+        super(context, ignore_layout, reset_context, locals)
       else
         @content_block.call
       end

data/lib/gumdrop/server.rb

@@ -1,4 +1,4 @@
-# Rework this to be nicer.. Extend Sintra::Base
+# Rework this to be nicer.. Extend Sintra::Base?
 
 require 'sinatra/base'
 require 'logger'
@@ -6,49 +6,68 @@ require 'logger'
 module Gumdrop
 
   class Server < Sinatra::Base
+    site_file= Gumdrop.fetch_site_file
+    unless site_file.nil?
+      site= Site.new site_file
+      site.scan()
 
-    set :port, Gumdrop.config.port if Gumdrop.config.port
+      set :port, site.config.server_port if site.config.server_port
+      
+      if site.config.proxy_enabled
+        require 'gumdrop/proxy_handler'
+        get     '/-proxy/*' do handle_proxy(params, env) end
+        post    '/-proxy/*' do handle_proxy(params, env) end
+        put     '/-proxy/*' do handle_proxy(params, env) end
+        delete  '/-proxy/*' do handle_proxy(params, env) end
+        patch   '/-proxy/*' do handle_proxy(params, env) end
+        options '/-proxy/*' do handle_proxy(params, env) end
+        site.report 'Enabled proxy at /-proxy/*', :info
+      end
 
+      get '/*' do
+        site.report "- - - - - - - - - - - - - - - - - - - - - - - - - - - - -"
 
-    server_log= 'logs/server.log'
-    
-    # get '/' do
-    #   redirect '/index.html'
-    # end
-    
-    Gumdrop.run dry_run:true, log:server_log, auto_run:true
-    
-    if Gumdrop.config.proxy_enabled
-      require 'gumdrop/proxy_handler'
-      Gumdrop.report 'Enabled proxy at /-proxy/*', :info
-      get '/-proxy/*' do
-        proxy_to= params[:splat][0]
-        proxy_parts= proxy_to.split('/')
-        host= proxy_parts.shift
-        path_info= "/#{proxy_parts.join('/')}"
-        #puts "HOST: #{host}  PATH_INFO: #{path_info}"
-        opts={ :to=>host, :path_info=>path_info  }
-        Gumdrop.handle_proxy opts, proxy_to, env
-      end
-      post '/-proxy/*' do
-        proxy_to= params[:splat][0]
-        proxy_parts= proxy_to.split('/')
-        host= proxy_parts.shift
-        path_info= "/#{proxy_parts.join('/')}"
-        #puts "HOST: #{host}  PATH_INFO: #{path_info}"
-        opts={ :to=>host, :path_info=>path_info  }
-        Gumdrop.handle_proxy opts, proxy_to, env
-      end
-      delete '/-proxy/*' do
-        proxy_to= params[:splat][0]
-        proxy_parts= proxy_to.split('/')
-        host= proxy_parts.shift
-        path_info= "/#{proxy_parts.join('/')}"
-        #puts "HOST: #{host}  PATH_INFO: #{path_info}"
-        opts={ :to=>host, :path_info=>path_info  }
-        Gumdrop.handle_proxy opts, proxy_to, env
+        file_path= get_content_path params[:splat].join('/'), site
+        site.report "[#{$$}] GET /#{params[:splat].join('/')} -> #{file_path}"
+        since_last_build= Time.now.to_i - site.last_run.to_i
+        # site.report "!>!>>>>> since_last_build: #{since_last_build}"
+        if since_last_build > site.config.server_timeout
+          site.report "[#{$$}] Rebuilding from Source (#{since_last_build} > #{site.config.server_timeout})"
+          site.rescan()
+        end
+        
+        if site.node_tree.has_key? file_path
+          content= site.node_tree[file_path]
+          if content.useLayout?
+            site.report "[#{$$}]  *Dynamic: #{file_path} (#{content.ext})"
+            content_type :css if content.ext == '.css' # Meh?
+            content_type :js if content.ext == '.js' # Meh?
+            content_type :xml if content.ext == '.xml' # Meh?
+            content.render 
+          else
+            site.report "[#{$$}]  *Static: #{file_path}"
+            send_file File.join( site.src_path, file_path)
+          end
+        else
+          site.report "[#{$$}]  *Missing: #{file_path}", :error
+          "#{file_path} Not Found"
+        end
+      end      
+
+      def get_content_path(file_path, site)
+        keys= [
+          file_path,
+          "#{file_path}.html",
+          "#{file_path}/index.html"
+        ]
+        if file_path == ""
+          "index.html"
+        else
+          keys.detect {|k| site.node_tree.has_key?(k) }
+        end
       end
-      put '/-proxy/*' do
+
+      def handle_proxy(params, env)
         proxy_to= params[:splat][0]
         proxy_parts= proxy_to.split('/')
         host= proxy_parts.shift
@@ -58,76 +77,9 @@ module Gumdrop
         Gumdrop.handle_proxy opts, proxy_to, env
       end
       
-    end
-
-    get '/*' do
-      # Gumdrop.log.info "[#{$$}] !>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
-      file_path= get_content_path params[:splat].join('/')
-      Gumdrop.log.info "[#{$$}] GET /#{params[:splat].join('/')} -> #{file_path}"
-      # Gumdrop.log.info " last built: #{Gumdrop.last_run}"
-      # Gumdrop.log.info "#{Gumdrop.config.inspect}"
-      
-      if Gumdrop.site.has_key? file_path
-        content= Gumdrop.site[file_path]
-        if content.useLayout?
-          # Only do a force_reload if the resource is dynamic!
-          if Gumdrop.config.force_reload
-            unless %w(.jpg .jpe .jpeg .gif .ico .png).include? File.extname(file_path).to_s
-              since_last_build= Time.now.to_i - Gumdrop.last_run.to_i
-              # Gumdrop.log.info "!>!>>>>> since_last_build: #{since_last_build}"
-              if since_last_build > 10
-                Gumdrop.log.info "[#{$$}] Rebuilding from Source"
-                Gumdrop.run dry_run:true, log:server_log
-              end
-            end
-          end
-          Gumdrop.log.info "[#{$$}]  *Dynamic: #{file_path} (#{content.ext})"
-          content_type :css if content.ext == '.css' # Meh?
-          content_type :js if content.ext == '.js' # Meh?
-          content_type :xml if content.ext == '.xml' # Meh?
-          content.render
-        else
-          Gumdrop.log.info "[#{$$}]  *Static: #{file_path}"
-          source_base_path= File.expand_path(Gumdrop.config.source_dir)
-          send_file File.join( source_base_path, file_path)
-        end
-      else
-        Gumdrop.log.error "[#{$$}]  *Missing: #{file_path}"
-        # Gumdrop.log.info "------------------------"
-        # Gumdrop.log.info Gumdrop.site.keys.join("\n")
-        # Gumdrop.log.info "------------------------"
-        puts "NOT FOUND: #{file_path}"
-        "#{file_path} Not Found"
-      end
-    end
-    
-
-    def get_content_path(file_path)
-      keys= [
-        file_path,
-        "#{file_path}.html",
-        "#{file_path}/index.html"
-      ]
-      if file_path == ""
-        "index.html"
-      else
-        keys.detect {|k| Gumdrop.site.has_key?(k) }
-      end
-    end
-    
-    if Gumdrop.config.auto_run
-      #Gumdrop.run dry_run:true 
       run!
-    end    
-
-    def self.start(opts={})
-      # Options
-      opts.reverse_merge! auto_run:true, cache_data:false
-      Gumdrop.config.merge! opts
-      Gumdrop.run dry_run:true, log:server_log
-      ::Gumdrop::Server
+    else
+      puts "Not in a valid Gumdrop site directory."
     end
-
   end
-    
-end
+end

data/lib/gumdrop/site.rb

@@ -0,0 +1,295 @@
+require 'pathname'
+
+# WORK IN PROGRESS!
+
+module Gumdrop
+
+  DEFAULT_OPTIONS= {
+    relative_paths: true,
+    proxy_enabled: true,
+    output_dir: "./output",
+    source_dir: "./source",
+    data_dir: './data',
+    log: './logs/build.log',
+    ignore: %w(.DS_Store .gitignore .git .svn .sass-cache),
+    server_timeout: 15,
+    # server_port: 4567
+  }
+
+  LOG_LEVELS = {
+    info: 0,
+    warning: 1,
+    error: 2
+  }
+
+  class Site
+    
+    attr_reader :opts,
+                :root_path, 
+                :root_path_parts,
+                :src_path,
+                :src_path_parts,
+                :blacklist,
+                :greylist,
+                :redirects,
+                :content_filters,
+                :layouts,
+                :partials,
+                :generators,
+                :config,
+                :data,
+                :sitefile,
+                :node_tree,
+                :last_run
+    
+
+    def initialize(sitefile, opts={})
+      @sitefile        = File.expand_path sitefile
+      @root_path       = File.dirname @sitefile
+      @root_path_parts = @root_path.split('/')
+      @opts            = opts
+      reset_all()
+    end
+
+    def contents(pattern=nil, opts={})
+      if pattern.nil?
+        if opts[:as] == :hash
+          @node_tree
+        else
+          @node_tree.values
+        end
+      else
+        nodes = opts[:as] == :hash ? {} : []
+        @node_tree.keys.each do |path|
+          if path_match path, pattern
+            if opts[:as] == :hash
+              nodes[path]= @node_tree[path]
+            else
+              nodes << @node_tree[path]
+            end
+          end
+        end
+        nodes
+      end
+    end
+
+    def scan
+      build_tree()
+      run_generators()
+      @last_run= Time.now
+      self
+    end
+
+    def rescan
+      reset_all()
+      scan()
+      @last_run= Time.now
+      self
+    end
+
+    def build
+      scan()
+      render()
+      @last_run= Time.now
+      self
+    end
+
+    def report(msg, level=:info)
+      # ll= @config.log_level
+      case level
+      when :info
+        @log.info msg
+      when :warning
+        @log.warn msg
+      else
+        puts msg
+        @log.error msg
+      end
+    end
+
+    # FIXME: Should a new Context be created for every page? For now
+    #        it's a single context for whole site
+    def render_context
+      @context ||= Context.new self
+      @context
+    end
+
+
+  private
+
+    def reset_all
+      @content_filters = []
+      @blacklist       = []
+      @greylist        = []
+      @redirects       = []
+      @last_run        = nil
+      @node_tree       = Hash.new {|h,k| h[k]= nil }
+      @layouts         = Hash.new {|h,k| h[k]= nil }
+      @partials        = Hash.new {|h,k| h[k]= nil }
+      @generators      = Hash.new {|h,k| h[k]= nil }
+      @config          = Gumdrop::Config.new DEFAULT_OPTIONS
+
+      load_sitefile()
+      
+      @data_path       = get_expanded_path(@config.data_dir)
+      @data            = Gumdrop::DataManager.new self, @data_path
+      @src_path        = get_expanded_path(@config.source_dir)
+      @src_path_parts  = @src_path.split('/')
+      @out_path        = get_expanded_path(@config.output_dir)
+
+      init_logging()
+    end
+
+    def init_logging
+      begin
+        @log           = Logger.new @config.log, 'daily'
+      rescue
+        @log           = Logger.new STDOUT
+      end
+      @log.formatter = proc do |severity, datetime, progname, msg|
+        "#{datetime}: #{msg}\n"
+      end
+    end
+
+    def get_expanded_path(path)
+      if (Pathname.new path).absolute?
+        path
+      else
+        File.expand_path File.join(@root_path, path)
+      end
+    end
+
+    def load_sitefile
+      source= IO.readlines( @sitefile ).join('')
+      dsl = SitefileDSL.new self
+      dsl.instance_eval source
+      dsl
+    end
+
+    def build_tree
+      report "[Scanning from #{src_path}]", :info
+      # Report blacklists and greylists
+      blacklist.each do |path|
+        report " blacklist: #{path}", :info
+      end
+      greylist.each do |path|
+        report "  greylist: #{path}", :info
+      end
+
+      # Scan Filesystem
+      #puts "Running in: #{root}"
+      Dir.glob("#{src_path}/**/*", File::FNM_DOTMATCH).each do |path|
+        unless File.directory? path or @config.ignore.include?( File.basename(path) )
+          file_path = (path.split('/') - @root_path_parts).join '/'
+          node= Content.new(file_path, self)
+          path= node.to_s
+          if blacklist.any? {|pattern| path_match path, pattern }
+            report "-excluding: #{path}", :info
+          else
+            node.ignored= greylist.any? {|pattern| path_match path, pattern }
+
+            # Sort out Layouts, Generators, and Partials
+            if File.extname(path) == ".template"
+              layouts[path]= node
+              layouts[File.basename(path)]= node
+
+            elsif File.extname(path) == ".generator"
+              generators[File.basename(path)]= Generator.new( node, self )
+
+            elsif File.basename(path).starts_with?("_")
+              partial_name= File.basename(path)[1..-1].gsub(File.extname(File.basename(path)), '')
+              partial_node_path= File.join File.dirname(path), partial_name
+              # puts "Creating partial #{partial_name} from #{path}"
+              partials[partial_name]= node
+              partials[partial_node_path]= node
+            else
+              @node_tree[path]= node
+            end
+          end
+        end
+      end
+      
+    end
+
+    def run_generators
+      report "[Executing Generators]", :info
+      generators.each_pair do |path, generator|
+        generator.execute()
+      end
+    end
+
+    def render
+      unless opts[:dry_run]
+        report "[Compiling to #{@out_path}]", :info
+        @node_tree.keys.sort.each do |path|
+          node= @node_tree[path]
+          unless node.ignored #greylist.any? {|pattern| path_match path, pattern }
+            # node= @node_tree[path]
+            output_path= File.join(@out_path, node.to_s)
+            FileUtils.mkdir_p File.dirname(output_path)
+            node.renderTo render_context, output_path, content_filters
+          else
+            report " -ignoring: #{node.to_s}", :info
+          end
+        end
+      end
+    end
+
+    # Match a path using a glob-like file pattern
+    def path_match(path, pattern)
+      File.fnmatch pattern, path, File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_CASEFOLD
+    end
+  end
+
+  class SitefileDSL
+
+    def initialize(site)
+      @site= site
+    end
+  
+    def generate(&block)
+      # Auto-generated, numerical, key for a site-level generator
+      @site.generators[@site.generators.keys.length] = Generator.new(block, @site)
+    end
+  
+    def content_filter(&block)
+      @site.content_filters << block
+    end
+  
+    def skip(path)
+      @site.blacklist << path
+    end
+    alias_method :blacklist, :skip
+
+    def ignore(path)
+      @site.greylist << path
+    end
+    alias_method :greylist, :ignore
+    alias_method :graylist, :ignore
+
+    def view_helpers(&block)
+      Gumdrop::ViewHelpers.class_eval &block
+    end
+
+    def configure(&block)
+      if block.arity > 0
+        block.call @site.config
+      else
+        @site.config.instance_eval &block
+      end
+    end
+  
+  end
+
+  class Config < HashObject
+    
+    def set(key, value)
+      self[key]= value
+    end
+    def get(key)
+      self[key]
+    end
+
+  end
+
+end

data/lib/gumdrop/version.rb

@@ -1,5 +1,5 @@
 module Gumdrop
   
-  VERSION = "0.5.2" unless defined?(::Gumdrop::VERSION)
+  VERSION = "0.6.0" unless defined?(::Gumdrop::VERSION)
   
 end

data/lib/gumdrop/view_helpers.rb

@@ -22,4 +22,4 @@ module Gumdrop
     
   end
   
-end
+end