gumdrop 0.8.0 → 1.0.0

data/lib/gumdrop/site.rb

@@ -1,414 +1,359 @@
-require 'pathname'
-
 module Gumdrop
 
-  DEFAULT_OPTIONS= {
+  WEB_PAGE_EXTS= %w(.html .htm)
+  JETSAM_FILES= %w(**/.DS_Store .git* .git/**/* .svn/**/* **/.sass-cache/**/* Gumdrop)
+
+  DEFAULT_CONFIG= {
     relative_paths: true,
-    relative_paths_for: ['.html', '.htm', '.php'],
+    relative_paths_exts: WEB_PAGE_EXTS,
+    default_layout: 'site',
+    layout_exts: WEB_PAGE_EXTS,
     proxy_enabled: false,
     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,
-    env: 'production'
+    log: STDOUT,
+    log_level: :info,
+    ignore: JETSAM_FILES,
+    blacklist: [],
+    server_timeout: 5,
+    server_port: 4567,
+    env: :production,
+    file_change_test: :checksum
   }
 
   class Site
+    include Util::Configurable
+    include Util::Eventable
+    include Util::Loggable
 
-    extend Support::Callbacks
-    
-    attr_reader :opts,
-                :root_path, 
-                :src_path,
-                :out_path,
-                :data_path,
-                :blacklist,
-                :greylist,
-                :redirects,
-                :content_filters,
-                :layouts,
-                :partials,
-                :generators,
-                :config,
-                :data,
-                :sitefile,
-                :content_hash,
-                :last_run
-
-    callbacks :on_start, 
-              :on_before_scan,
-              :on_scan, 
-              :on_before_generate,
-              :on_generate, 
-              :on_before_render,
-              :on_render,
-              :on_before_render_item,
-              :on_render_item,
-              :on_end
+    config_accessor :source_dir, :output_dir, :data_dir,
+                    :mode, :env, :ignore, :blacklist
 
-    def initialize(sitefile, opts={})
-      @sitefile  = File.expand_path sitefile
-      @root_path = File.dirname @sitefile
-      @opts      = opts
-      @last_run  = nil
-      reset_all()
-    end
+    attr_reader :sitefile, :options, :root, :contents, :data, 
+                :layouts, :generators, :partials, :last_run
 
-    def opts=(opts={})
-      @opts= opts
-    end
+    # hmmm... 
+    attr_accessor :active_renderer, :active_builder
 
-    def contents(*args)
-      opts= args.extract_options!
-      pattern= args.first || nil
+    # You shouldn't call this yourself! Access it via Gumdrop.site
+    def initialize(sitefile, opts={})
+      Gumdrop.send :set_current_site, self
+      @sitefile= sitefile.expand_path
+      @options= Util::HashObject.from opts
+      _options_updated!
+      @root= File.dirname @sitefile
+      @last_run= 0
+      clear
+    end
+
+    def options=(opts={})
+      @options.merge!(opts)
+      _options_updated!
+    end
+
+
+    def clear()
+      @contents= ContentList.new
+      @layouts= SpecialContentList.new ".layout"
+      @partials= SpecialContentList.new
+      @generators= []
+      @data= DataManager.new
+      @is_scanned= false
+      _reset_config!
+      _load_sitefile
+      self
+    end
 
-      if pattern.nil? or pattern.empty?
-        if opts[:as] == :hash
-          @content_hash
-        else
-          @content_hash.values
-        end
-      
-      else
-        if pattern.is_a? Array
-          nodes= opts[:as] == :hash ? {} : []
-          pattern.each do |subpattern|
-            if opts[:as]== :hash
-              nodes.merge! match_nodes(subpattern, opts)
-            else
-              nodes << match_nodes(subpattern, opts)
-            end
-          end
-          opts[:as]== :hash ? nodes : nodes.flatten
-        else
-          match_nodes(pattern, opts)
-        end
+    def scan(force=false)
+      if !@is_scanned or force
+        clear if @is_scanned # ????
+        _content_scanner
+        @is_scanned= true
+        generate
       end
+      self
     end
 
-    def rescan
-      on_start(self)
-      reset_all()
-      scan()
-      @last_run= Time.now
-      # TODO: should on_before_render and on_render be called for rescan()?
-      on_end(self)
+    def scan_only # For testing... 
+      if !@is_scanned or force
+        clear if @is_scanned # ????
+        _content_scanner
+      end
       self
     end
 
-    def build(force_reset=false)
-      on_start(self)
-      report "[#{ Time.new }]"
-      reset_all() if force_reset
-      scan()
-      render()
-      @last_run= Time.now
-      on_end(self)
-      report "[Done]"
+    def generate
+      _execute_generators
       self
     end
-    
-    def rebuild
-      build true
-    end
 
-    def report(msg, level=:info)
-      case level
-        when :info
-          unless @opts[:quiet]
-            if @opts[:subdued]
-              print "."
-            else
-              @log.info msg 
-            end
-          end
-        when :warning, :warn
-          @log.warn msg
-      else
-        print "!" if @opts[:subdued]
-        @log.error msg
+    def in_blacklist?(path)
+      blacklist.any? do |pattern|
+        path.path_match? pattern
       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
-
-    # 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
+    def ignore_path?(path)
+      config.ignore.any? do |pattern|
+        path.path_match? pattern
+      end
     end
 
-  private
-
-    def scan
-      build_tree()
-      run_generators()
-      self
+    def source_path
+      @source_path ||= source_dir.expand_path(root)
     end
 
-
-    def reset_all
-      @content_filters = []
-      @blacklist       = []
-      @greylist        = []
-      @redirects       = []
-
-      @content_hash    = 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
-      @config.env      = @opts[:env] if @opts.has_key? :env
-
-      clear_on_start()
-      clear_on_before_scan()
-      clear_on_scan()
-      clear_on_before_generate()
-      clear_on_generate()
-      clear_on_before_render()
-      clear_on_render()
-      clear_on_before_render_item()
-      clear_on_render_item()
-      clear_on_end()
-
-      load_sitefile()
-      
-      @data_path       = get_expanded_path(@config.data_dir)
-      @src_path        = get_expanded_path(@config.source_dir)
-      @out_path        = get_expanded_path(@config.output_dir)
-
-      @data            = Gumdrop::DataManager.new self, @data_path
-
-      init_logging()
+    def output_path
+      @output_path ||= output_dir.expand_path(root)
     end
 
-    def match_nodes(pattern, opts={})
-      nodes = opts[:as] == :hash ? {} : []
-      @content_hash.keys.each do |path|
-        if path_match path, pattern
-          if opts[:as] == :hash
-            nodes[path]= @content_hash[path]
-          else
-            nodes << @content_hash[path]
-          end
-        end
-      end
-      nodes
+    def data_path
+      @data_path ||= data_dir.expand_path(root)
     end
 
-    def init_logging
-      begin
-        @log = Logger.new @config.log, 'daily'
-      rescue
-        target= if @opts[:quiet]
-          nil
+    def resolve(path=nil, opts={})
+      case 
+        when path.is_a?(Content)
+          path
+        when !path.nil?
+          contents.first(path) || partials.first(path)
+        when opts[:page]
+          contents.first opts[:page]
+        when opts[:partial]
+          partials.first opts[:partial]
+        when opts[:layout]
+          layouts.first opts[:layout]
+        when opts[:generator]
+          generators.first opts[:generator]
         else
-          STDOUT
-        end
-        @log = Logger.new target
-        # report "Using STDOUT for logging because of exception: #{ $! }" unless target.nil?
-      end
-      @log.formatter = proc do |severity, datetime, progname, msg|
-        # "#{datetime}: #{msg}\n"
-        "  #{msg}\n"
+          nil
       end
     end
 
-    def get_expanded_path(path)
-      if (Pathname.new path).absolute?
-        path
-      else
-        File.expand_path File.join(@root_path, path)
-      end
+    # Events stop bubbling here.
+    def parent
+      nil
     end
 
-    def load_sitefile
-      source= File.read( @sitefile )
-      dsl = Sitefile.new self
-      dsl.instance_eval source
-      dsl
+    def config_did_change
+      Gumdrop.init_logging
     end
 
-    def build_tree
-      report "[Scanning from #{src_path}]", :info
-      on_before_scan(self)
-      # Report blacklists and greylists
-      blacklist.each do |path|
-        report " blacklist: #{path}", :info
-      end
-      greylist.each do |path|
-        report "  greylist: #{path}", :info
-      end
+  private
+
+    def _reset_config!
+      config.clear.merge! DEFAULT_CONFIG
+      config.env= @options.env.to_sym if @options.env
+      config.mode= @options.mode.nil? ? :unknown : @options.mode.to_sym
+    end
+
+    def _options_updated!
+      config.env= @options.env.to_sym if @options.env
+      config.mode= @options.mode.nil? ? :unknown : @options.mode.to_sym
+    end
+
+    def _load_sitefile
+      clear_events
+      load sitefile
+      data.dir= data_path
+    rescue Exception => ex
+      msg= "There is an error in your Gumdrop file!"
+      # $stderr.puts msg
+      log.error msg
+      log.error ex
+      raise ex
+    end
+
+    def _content_scanner
+      log.info "Gumdrop v#{ Gumdrop::VERSION } - #{ Time.new }"
+      log.debug "(config)"
+      log.debug config
+      log.debug "(options)"
+      log.debug @options
+      log.debug "[Scanning: #{source_path}]"
+      # Report ignore list      
+      ignore.each {|p| log.debug "  ignoring: #{p}" }
       # Scan Filesystem
-      Dir.glob("#{src_path}/**/*", File::FNM_DOTMATCH).each do |path|
-        unless File.directory? path or @config.ignore.include?( File.basename(path) )
-          node= Content.new(path, self)
-          path= node.to_s
-          if blacklist.any? {|pattern| path_match path, pattern }
-            report " excluding: #{path}", :info
-          else
-            node.ignore 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
-              @content_hash[path]= node
-            end
-          end
+      event_block :scan do
+        scanner= Util::Scanner.new(source_path, {}, &method(:_scanner_validator)) 
+        scanner.each do |path, rel|
+          content= Content.new(path)
+          layouts.add content and next if content.layout?
+          partials.add content and next if content.partial?
+          generators << Generator.new(content) and next if content.generator?
+          contents.add content
+          log.debug " including: #{ rel }"
         end
+        contents.keys.size
       end
-      on_scan(self)
+      @is_scanned= true
     end
 
-    def run_generators
-      report "[Executing Generators]", :info
-      on_before_generate(self)
-      generators.each_pair do |path, generator|
-        generator.execute()
-      end
-      on_generate(self)
+    def _scanner_validator(source_path, full_path)
+      return true if ignore_path? source_path
+      # in_blacklist? source_path
+      false
     end
 
-    def render
-      unless opts[:dry_run]
-        report "[Compiling to #{@out_path}]", :info
-        on_before_render(self)
-        nodes= if opts[:assets]
-          contents(opts[:assets])
-        else
-          contents()
-        end
-        nodes.each do |node|
-          render_content(node, render_context, content_filters)
+    def _execute_generators
+      log.debug "[Executing Generators]"
+      event_block :generate do
+        generators.each do |generator|
+          generator.execute()
         end
-        on_render(self)
       end
     end
 
-    def render_content(node, ctx, filters)
-      unless node.ignore?
-        output_path= File.join(@out_path, node.to_s)
-        FileUtils.mkdir_p File.dirname(output_path)
-        begin
-          on_before_render_item(self, node)
-          node.renderTo ctx, output_path, filters
-          on_render_item(self, node)
-        rescue => ex
-          report "[!>EXCEPTION<!]: #{ node.to_s }", :error
-          report [ex.to_s, ex.backtrace].flatten.join("\n"), :error
-          exit 1 unless @opts[:resume]
-        end
+  end
+
+  class << self
+
+    # This will look for a nearby Gumdrop file and load the Site
+    # the first time it is called. Each time after it will just
+    # return the already created Site.
+    def site(opts={}, force_new=false)
+      opts= opts.to_symbolized_hash
+      unless @current_site.nil? or force_new
+        @current_site.options= opts unless opts.empty?
+        @current_site
       else
-        report "  ignoring: #{ node.to_s }", :info
+        site_file= fetch_site_file
+        unless site_file.nil?
+          Site.new site_file, opts
+        else
+          nil
+        end
       end
     end
-  end
 
-  class Sitefile
+    # Listen for life-cycle events in your Gumdrop file like this:
+    #
+    #   Gumdrop.on :start do |event|
+    #     puts "Here we go!"
+    #   end
+    #
+    # Complete list of events fired by Gumdrop:
+    #
+    #   :start
+    #   :before_scan
+    #   :scan
+    #   :after_scan
+    #   :before_generate
+    #   :generate
+    #   :after_generate
+    #   :before_generate_item
+    #   :generate_item
+    #   :after_generate_item
+    #   :before_build
+    #   :build
+    #   :after_build
+    #   :before_checksum
+    #   :checksum
+    #   :after_checksum
+    #   :before_render
+    #   :render
+    #   :after_render
+    #   :before_render_item
+    #   :render_item
+    #   :after_render_item
+    #   :before_write
+    #   :write
+    #   :after_write
+    #   :before_copy_file
+    #   :copy_file
+    #   :after_copy_file
+    #   :before_write_file
+    #   :write_file
+    #   :after_write_file
+    #   :end
+    #
+    # In the block parem `event` you will have access to :site, the 
+    # current executing site instance, and :payload, where applicable.
+    #
+    # :render_item is a special event because you can add/override the
+    # compiled output by modifying `event.data.return_value`
+    #
+    def on(event_type, options={}, &block)
+      site.on event_type, options, &block
+    end
+
+    # Yield a configuration object. You can update Gumdrop behavior
+    # as well as add your own config information.
+    def configure(&block)
+      site.configure &block
+    end
 
-    def initialize(site)
-      @site= site
+    # Short cut to the current Site config object.
+    def config
+      site.config
     end
-  
-    def generate(&block)
-      # Auto-generated, numerical, key for a site-level generator
-      @site.generators[@site.generators.keys.length] = Generator.new(block, @site)
+
+    # The env Gumdrop is run in -- You can set this in the congig
+    # or, better, via command line: `gumdrop build -e test`
+    def env
+      site.env
     end
-  
-    def content_filter(&block)
-      @site.content_filters << block
+    
+    # Mostly for internal use, but you can update/change it in the
+    # configure block.
+    def mode
+      site.mode
     end
-  
-    def skip(path)
-      @site.blacklist << path
+
+    # Returns true if this, or a parent, folder has a Gumdrop file.
+    def in_site_folder?(filename="Gumdrop")
+      !fetch_site_file(filename).nil?
     end
-    alias_method :blacklist, :skip
 
-    def ignore(path)
-      @site.greylist << path
+    # Specified paths will be added to the ignore list, preventing
+    # matching files from appearing in the source tree
+    def ignore(*paths)
+      paths.each do |path|
+        if path.is_a? Array
+          config.ignore.concat path
+        else
+          config.ignore << path
+        end
+      end      
     end
-    alias_method :greylist, :ignore
-    alias_method :graylist, :ignore
 
-    def view_helpers(&block)
-      Gumdrop::ViewHelpers.class_eval &block
+    # Specified paths will not be renderd to output (matching against
+    # the source tree).
+    def blacklist(*paths)
+      paths.each do |path|
+        if path.is_a? Array
+          config.blacklist.concat path
+        else
+          config.blacklist << path
+        end
+      end      
     end
 
-    def configure(&block)
-      if block.arity > 0
-        block.call @site.config
+  protected
+
+    # Walks up the filesystem, starting from Dir.pwd, looking for
+    # a Gumdrop file. Returns nil if not found.
+    def fetch_site_file(filename="Gumdrop")
+      here= Dir.pwd
+      found= File.file?  here / filename
+      # TODO: Should be smarter -- This is a hack for Windows support "C:\"
+      while !found and File.directory?(here) and File.dirname(here).length > 3
+        here= File.expand_path here /'..'
+        found= File.file?  here / filename
+      end
+      if found
+        File.expand_path here / filename
       else
-        @site.config.instance_eval &block
+        nil
       end
     end
 
-    def tasks(&block)
-      Gumdrop::CLI::Internal.class_eval &block
-    end
-    
-    # Callbacks
-    def on_start(&block)
-      @site.on_start &block
-    end
-    def on_before_scan(&block)
-      @site.on_before_scan &block
-    end
-    def on_scan(&block)
-      @site.on_scan &block
-    end
-    def on_before_generate(&block)
-      @site.on_before_generate &block
-    end
-    def on_generate(&block)
-      @site.on_generate &block
-    end
-    def on_before_render(&block)
-      @site.on_before_render &block
-    end
-    def on_render(&block)
-      @site.on_render &block
-    end
-    def on_before_render_item(&block)
-      @site.on_before_render &block
-    end
-    def on_render_item(&block)
-      @site.on_render &block
-    end
-    def on_end(&block)
-      @site.on_end &block
-    end
-  
-  end
-
-  class Config < HashObject
-    
-    def set(key, value)
-      self[key]= value
-    end
-    def get(key)
-      self[key]
+    def set_current_site(site)
+      @current_site= site
     end
 
   end
 
-end
+end
+