gumdrop 0.8.0 → 1.0.0

data/lib/gumdrop/cli/internal.rb

@@ -14,29 +14,33 @@ module Gumdrop::CLI
     method_option :env, default:'production', aliases:'-e'
     method_option :assets, aliases:'-a', type: :array, desc:"List of assets to render."
     method_option :quiet, default:false, aliases:'-q', type: :boolean
-    method_option :subdued, default:false, aliases:'-s', type: :boolean, desc:"Subdued output (....)"
     method_option :resume, default:false, aliases:'-r', type: :boolean, desc:"Auto resume rendering after any errors"
-    def build()
-      Gumdrop.run(options)
+    method_option :force, default:false, aliases:'-f', type: :boolean, desc:"Ignore file checksums and create all files"
+    def build
+      if options[:quiet]
+        Gumdrop.configure do |c|
+          c.log_level= :warn
+        end
+      end
+      Gumdrop.run options.merge(mode:'build')
     end
 
     desc 'server', 'Run development server'
-    method_option :env, default:'production', aliases:'-e'
     def server
+      Gumdrop.site.options = options.merge(mode:'build')
       Gumdrop::Server
     end
 
     desc 'watch', "Watch filesystem for changes and recompile"
-    method_option :env, default:'production', aliases:'-e'
     method_option :quiet, default:false, aliases:'-q', type: :boolean
     method_option :subdued, default:false, aliases:'-s', type: :boolean, desc:"Subdued output (....)"
     method_option :resume, default:false, aliases:'-r', type: :boolean, desc:"Auto resume rendering after any errors"
     def watch
-      Gumdrop.run options
-      paths= [SITE.src_path]
-      paths << SITE.data_path if File.directory? SITE.data_path
+      Gumdrop.run options.merge(mode:'merge')
+      paths= [Gumdrop.site.source_dir, Gumdrop.site.sitefile] #? Sitefile too?
+      paths << Gumdrop.site.data_dir if File.directory? Gumdrop.site.data_dir
       Listen.to(*paths, :latency => 0.5) do |m, a, r|
-        SITE.rebuild
+        Gumdrop.rebuild options.merge(mode:'merge')
       end
     end
 
@@ -50,26 +54,54 @@ module Gumdrop::CLI
       else
         say "Creating template:  #{name}"
         say "  ~/.gumdrop/templates/#{name}"
-        site_root= Gumdrop.site_dirname
+        site_root= Gumdrop.site.root
         FileUtils.mkdir_p File.dirname(template_path)
-        FileUtils.cp_r File.join(site_root, "."), template_path
+        FileUtils.cp_r (site_root / "."), template_path
       end
     end
 
-    private
-      
-      def home_path(name="")
-        File.expand_path File.join("~", ".gumdrop", name)
-      end
 
-      def home_template_path(template)
-        home_path 'tempaltes', template
+    desc 'uris', "Print list of the uri that will be generated."
+    def uris
+      Gumdrop.configure do |c|
+        c.log_level= :error
       end
+      Gumdrop.site.scan
 
-      def local_path(name="")
-        File.join( ".", name ) # ?
+      say "Gumdrop found:"
+      say ""
+      Gumdrop.site.contents.keys.sort.each do |uri|
+        content= Gumdrop.site.contents[uri]
+        blackout= Gumdrop.site.in_blacklist?(uri) ? 'X' : ' '
+        generated= content.generated? ? '*' : ' '
+        binary= content.binary? ? '!' : ' '
+        say " #{blackout + generated + binary} #{content.uri}"
       end
+      say ""
+      say "Legend:"
+      say "  X = On on the blacklist"
+      say "  * = Generated (not on fs)"
+      say "  ! = Binary file"
+    end
+
+    desc "version", "Displays Gumdrop version"
+    def version
+      say "Gumdrop v#{ Gumdrop::VERSION }"
+    end
+
+
+  private
+    
+    def home_path(name="")
+      File.expand_path "~" /".gumdrop" / name
+    end
+
+    def home_template_path(template)
+      home_path 'templates' / template
+    end
+
+    def local_path(name="")
+      "." / name
+    end
   end
 end
-
-SITE= Gumdrop::Site.new Gumdrop.fetch_site_file unless defined?( SITE )

data/lib/gumdrop/cli.rb

@@ -0,0 +1,21 @@
+module Gumdrop
+
+  class << self
+
+    # Allows addition of CLI commands from Gumdrop file:
+    #
+    #  Gumdrop.cli do
+    #    desc 'ping'
+    #    method_option :loud, default:false
+    #    def ping
+    #      say options[:loud] ? 'PONG!' : 'pong'
+    #    end
+    #  end
+    #
+    def cli(&block)
+      CLI::Internal.class_eval &block
+    end
+
+  end
+
+end

data/lib/gumdrop/content.rb

@@ -1,36 +1,34 @@
-
 module Gumdrop
-  
+
+  # All content (layouts, partials, images, html, js css, etc) found in
+  # the source directory are represented as a Content object in memory
   class Content
+    include Util::SiteAccess
 
-    MUNGABLE_RE= Regexp.new(%Q<(href|data|src)([\s]*)=([\s]*)('|"|&quot;|&#34;|&#39;)?\\/([\\/]?)>, 'i')
-    LAYOUTLESS_EXTS= %w(.css .js .xml)
-    
-    attr_reader :full_path, :path, :params, :site
+    attr_reader :source_path, :params
     
-    def initialize(path, site, params={})
-      @site= site
-      @params= HashObject.new params
-      @full_path= path
+    def initialize(source_path, generator=nil, &block)
+      @source_path= source_path
+      @generator= generator
+      @ignore= false
+      @block= block
+      @params= Util::HashObject.new
     end
 
-    def slug
-      @slug ||= uri.gsub('/', '-').gsub(ext, '')
-    end
+    # TODO: Use a Pathname for all path operations instead of File.*
+    #       Add support for relative_to and relative_from to 
+    #       ContentList (find?)
 
-    def ignored
-      @ignored ||= false
-    end
-    def ignore(state=true)
-      @ignored= state
+    def params=(value={})
+      @params.merge! value
     end
 
-    def generated
-      @generated ||= false
+    def slug
+      @slug ||= uri.gsub('/', '-').gsub(ext, '')
     end
 
     def path
-      @path ||= get_source_path
+      @path ||= _source_path
     end
 
     def level
@@ -38,11 +36,11 @@ module Gumdrop
     end
 
     def source_filename
-      @source_filename ||= File.basename @full_path
+      @source_filename ||= File.basename source_path
     end
 
     def filename
-      @filename ||= get_target_filename
+      @filename ||= _target_filename
     end
 
     def type
@@ -54,92 +52,98 @@ module Gumdrop
     end
 
     def uri
-      @uri ||= get_uri
+      @uri ||= _uri
     end
 
-    def template
-      @template ||= unless Tilt[@full_path].nil?
-        Tilt.new @full_path
-      else
-        nil
+    def binary?
+      @is_binary ||= begin
+        if generated? or has_block? or missing?
+          false
+        else
+          # from ptools
+          s = (File.read(source_path, File.stat(source_path).blksize) || "").split(//)
+          ((s.size - s.grep(" ".."~").size) / s.size.to_f) > 0.30
+        end
       end
     end
-    def template=(t)
-      @template = t
+
+    # Can I call #body() ?
+    def exists?
+      has_block? or File.exists? @source_path
     end
-    
-    def render(context=nil, ignore_layout=false, reset_context=true, locals={})
-      context= site.render_context if context.nil?
-      if reset_context
-        default_layout= LAYOUTLESS_EXTS.include?(ext) ? nil : 'site'
-        context.reset_data 'current_depth'=>level, 'current_slug'=>slug, 'page'=>self, 'layout'=>default_layout, 'params'=>params
-      end
-      context.set_content self, locals
-      content= render_all(context)
-      return relativize content, context if ignore_layout
-      begin
-        layout= context.get_template()
-        while !layout.nil? and !layout.template.nil?
-          content = layout.template.render(context, content:content) { content }
-          layout= context.get_template()
-        end
-      rescue => ex
-        raise StandardError, "Layout: #{ex.to_s}", ex.backtrace
-      end
-      relativize content, context
-    rescue => ex
-      raise StandardError, "Rendering exception: #{ex.to_s}", ex.backtrace
+
+    def missing?
+      !exists?
     end
-    
-    def renderTo(context, output_path, filters=[], opts={})
-      return copyTo(output_path, opts) unless useLayout?
-      site.report " rendering: #{uri}"
-      output= render(context)
-      filters.each {|f| output= f.call(output, self) }
-      File.open output_path, 'w' do |f|
-        f.write output
-      end
+
+    def generated?
+      !@generator.nil?
     end
-          
-    # This probably belongs to the BUILD, not here
-    def copyTo(output, layout=nil, opts={})
-      do_copy= if File.exists? output
-        !FileUtils.identical? @full_path, output
-      else
-        true
-      end
-      if do_copy
-        site.report "   copying: #{uri}"
-        FileUtils.cp_r @full_path, output, opts
-      else
-        site.report "    (same): #{uri}"
-      end
+
+    def has_block?
+      !@block.nil?
     end
-    
-    def mtime
-      if File.exists? @full_path
-        File.new(@full_path).mtime
-      else
-        Time.now
-      end
+
+    def partial?
+      source_filename[0] == "_"
     end
-    
-    def useLayout?
-      !template.nil?
+
+    def layout?
+      ext == '.layout'
     end
 
-    def ignore?
-      ignored
+    def generator?
+      ext == '.generator'
     end
-    
+
+    def body # Memoize this?
+      @body ||= case
+        when has_block?
+          @block.call
+        when missing?, binary?
+          nil
+        else
+          File.read @source_path
+        end
+    end
+
+    def mtime
+      @mtime ||= if exists? and !generated?
+          File.new(@source_path).mtime
+        else
+          Time.now
+        end
+    end
+
     def to_s
       uri
     end
-  
+
+    def method_missing(sym, *args, &block)
+      if params.has_key? sym
+        params[sym]
+      else
+        super
+      end
+    end
+
   private
 
-    def get_source_path
-      path= @full_path.sub site.src_path, ''
+    def _uri
+      # Do I need to do anything for windoze here to make sure
+      # the slashes are / and not \ ?
+      uri=  File.dirname(path) / filename
+      if uri.starts_with? './'
+        uri[2..-1]
+      elsif uri.starts_with? '/'
+        uri[1..-1]
+      else
+        uri
+      end
+    end
+
+    def _source_path
+      path= @source_path.gsub site.source_path, ''
       if path[0] == '/'
         path[1..-1] 
       else
@@ -147,61 +151,120 @@ module Gumdrop
       end
     end
 
-    def get_target_filename
+    def _target_filename
       filename_parts= source_filename.split('.')
       ext= filename_parts.pop
-      while !Tilt[ext].nil?
+      while !Renderer.for(ext).nil?
         ext= filename_parts.pop
       end
       filename_parts << ext # push the last file ext back on there!
-      filename_parts.join('.')
-    end
-
-    def render_all(ctx)
-      if generated or !File.exists?(@full_path)
-        content= template.render(ctx)
+      fname= filename_parts.join('.')
+      if partial?
+        fname[1..-1]
       else
-        content= File.read @full_path
-        exts= source_filename.gsub filename, ''
-        exts.split('.').reverse.each do |ext|
-          unless ext.blank?
-            templateClass= Tilt[".#{ext}"]
-            template= templateClass.new(@full_path) do
-              content
-            end
-            content= template.render(ctx)
-          end
-        end
+        fname
       end
+    end
+
+    def self.path_match?(path, pattern)
+       File.fnmatch pattern, path, File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_CASEFOLD
+    end
+  end
+
+  class ContentList < Hash 
+
+    def create(path, generator=nil, &block)
+      content= Content.new path, generator, &block
+      add content #, path
+    end
+
+    def add(content, uri=nil)
+      uri= content.uri if uri.nil?
+      self[uri]= content
       content
     end
 
-    def get_uri
-      uri= File.join File.dirname(path), filename
-      if uri.starts_with? './'
-        uri[2..-1]
-      else
-        uri
-      end
+    def remove(content)
+      uri = content.is_a? String ? content : content.uri
+      self.delete uri
     end
 
-    def relativize(content, ctx)
-      if site.config.relative_paths and !ctx.force_absolute
-        if site.config.relative_paths_for == :all or site.config.relative_paths_for.include?(ext)
-          path_to_root= ctx.path_to_root
-          content.force_encoding("UTF-8") if content.respond_to? :force_encoding
-          content = content.gsub MUNGABLE_RE do |match|
-            if $5 == '/'
-              "#{ $1 }#{ $2 }=#{ $3 }#{ $4 }/"
-            else
-              "#{ $1 }#{ $2 }=#{ $3 }#{ $4 }#{ path_to_root }"
-            end
-          end
+    # Returns Array of content objects
+    def all(pattern=nil)
+      pattern.nil? ? values : find(pattern)
+    end
+
+    # Scans the filenames (keys) and uses fnmatch to find maches
+    def find(pattern)
+      patterns= [pattern].flatten
+      contents=[]
+      self.each_pair do |path, content|
+        patterns.each do |pattern|
+          contents << content if Content.path_match? path, pattern
         end
       end
-      content
+      contents
+    end
+
+    def get(key)
+      self[key]
+    end
+
+    def first(pattern)
+      find(pattern).first
     end
+
+  end
+
+  # Keeps a ref to content at full path and just the basename
+  class SpecialContentList < ContentList
     
+    def initialize(default_ext=false)#, *args)
+      @ext= default_ext || ".html"  # ???
+      super()
+    end
+
+    def add(content, uri=nil)
+      uri= content.uri if uri.nil?
+      buri = File.basename uri
+      self[uri]= content
+      self[buri]= content
+      content
+    end
+
+    def remove(content)
+      uri = content.is_a? String ? content : content.uri
+      self.delete uri
+      self.delete File.basename uri
+    end
+
+    # Find isn't fuzzy for Special Content. It looks for full
+    # uri or the uri's basename, optionally tacking on @ext
+    def find(uri)
+      _try_variations_of(uri) do |path|
+        content= get path
+        return [content] unless content.nil?
+      end unless uri.nil?
+      []
+    end
+
+  private
+
+    def _try_variations_of(uri)
+      # try the uri
+      yield uri
+      # plus default ext
+      yield uri + @ext
+      urip= Pathname.new uri
+      # just the filename
+      yield urip.basename
+      # filename plus default extension
+      yield urip.basename + @ext
+      # filename minus the ext
+      yield urip.basename.to_s.gsub urip.extname, ''
+      # uri minus ext
+      yield uri.gsub urip.extname, ''
+    end
+
   end
-  
 end