gumdrop 0.8.0 → 1.0.0

data/lib/gumdrop/data_manager.rb

@@ -1,214 +0,0 @@
-require 'yaml'
-require 'ostruct'
-
-module Gumdrop
-
-  # Supported Data File Types:
-  DATA_DOC_EXTS= %w(json yml yaml ymldb yamldb yamldoc ymldoc)
-
-  class DataManager
-    attr_reader :cache
-  
-    def initialize(site, data_dir="./data")
-      @site= site
-      @dir= File.expand_path data_dir
-      @cache= {}
-    end
-  
-    def method_missing(key, value=nil)
-      cache_dataset(key)
-      @cache[key]
-    end
-  
-    def set(key, value)
-      @cache[key]= value
-    end
-  
-    def reset
-      @cache={}
-    end
-
-    def site(pattern=nil, opts={})
-      @site.contents(pattern, opts)
-    end
-    
-    def pager_for(key, opts={})
-      base_path= opts.fetch(:base_path, 'page')
-      page_size= opts.fetch(:page_size, 5)
-      data= if key.is_a? Symbol
-        cache_dataset(key)
-        @cache[key]
-      else
-        key
-      end
-      Pager.new( data, base_path, page_size )
-    end
-  
-    # Exposing these publicly because, well, they're useful:
-    def load_from_file( filename )
-      ext=File.extname(filename)
-      if ext == '.yamldoc' or ext == '.ymldoc'
-        load_from_yamldoc filename
-      elsif ext == '.yamldb' or ext == '.ymldb'
-        load_from_yamldb filename
-      elsif ext == '.yaml' or ext == '.yml' or ext == '.json'
-        hashes2ostruct( YAML.load_file(filename)  )
-      else
-        # raise "Unknown data type (#{ext}) for #{filename}"
-        Gumdrop.report "Unknown data type (#{ext}) for #{filename}", :warning
-        nil
-      end
-    end
-    def load_yamldoc(filename, source=nil)
-      load_from_yamldoc filename, source
-    end
-
-  
-  private
-  
-    def cache_dataset(key)
-      @cache[key]= load_data(key) unless @cache.has_key? key
-    end
-
-    def load_data(key)
-      path=get_filename key 
-      return nil if path.nil?
-      if File.directory? path
-        load_from_directory path
-      else
-        load_from_file path
-      end
-    end
-
-    def load_from_yamldb( filename )
-      docs=[]
-      File.open(filename, 'r') do |f|
-        YAML.load_documents(f) do |doc|
-          docs << hashes2ostruct( doc ) unless doc.has_key?("__proto__")
-        end
-      end
-      docs
-    end
-
-    def load_from_yamldoc( filename, source=nil )
-      source = File.read(filename) if source.nil?
-
-      if source =~ /^(\s*---(.+)---\s*)/m
-        yaml = $2.strip
-        content = source.sub($1, '')
-        data= YAML.load(yaml)
-      else
-        content= source
-        data={}
-      end
-
-      content_set= false
-      data.each_pair do |key, value|
-        if value == '_YAMLDOC_'
-          data[key]= content
-          content_set= true
-        end
-      end
-
-      data['content']= content unless content_set
-      
-      hashes2ostruct(data)
-    end
-
-    def load_from_directory( filepath )
-      all=[]
-      Dir[ File.join "#{filepath}", "{*.#{ DATA_DOC_EXTS.join ',*.'}}" ].each do |filename|
-        # Gumdrop.report ">> Loading data file: #{filename}"
-        id= File.basename filename
-        obj_hash= load_from_file filename
-        obj_hash._id = id
-        all << obj_hash
-      end
-      all
-    end
-
-    def get_filename(path)
-      lpath= local_path_to(path)
-      if File.directory? lpath
-        lpath
-      else
-        DATA_DOC_EXTS.each do |ext|
-          lpath= local_path_to("#{path}.#{ext}")
-          return lpath if File.exists? lpath
-        end
-        Gumdrop.report "No data found for #{path}", :warning
-        nil
-      end
-    end
-
-    def local_path_to(filename)
-      File.join(@dir.to_s, filename.to_s)
-    end
-
-    def hashes2ostruct(object)
-      return case object
-      when Hash
-        object = object.clone
-        object.each do |key, value|
-          object[key] = hashes2ostruct(value)
-        end
-        OpenStruct.new(object)
-      when Array
-        object = object.clone
-        object.map! { |i| hashes2ostruct(i) }
-      else
-        object
-      end
-    end
-
-  end
-
-  class Pager
-    attr_reader :all, :pages, :base_url, :current_page, :page_sets
-
-    def initialize(articles, base_path="/page", page_size=5)
-      @all= articles
-      @page_size= page_size
-      @base_path= base_path
-      @page_sets= @all.in_groups_of(page_size, false)
-      @pages= []
-      @current_page=1
-      @page_sets.each do |art_ary|
-        @pages << HashObject.new({
-          items: art_ary,
-          page: @current_page,
-          uri: "#{base_path}/#{current_page}",
-          pager: self
-        })
-        @current_page += 1
-      end
-      @current_page= nil
-    end
-
-    def length
-      @pages.length
-    end
-
-    def first
-      @pages.first
-    end
-
-    def last
-      @pages.last
-    end
-
-    def each
-      @current_page=1
-      @pages.each do |page_set|
-        yield page_set
-        @current_page += 1
-      end
-      @current_page= nil
-    end
-
-    def [](key)
-      @pages[key]
-    end
-  end
-
-end

data/lib/gumdrop/support/base_packager.rb

@@ -1,60 +0,0 @@
-module Gumdrop
-  module Support
-    module BasePackager
-
-      def compress_output(content, opts)
-        case opts[:compress]
-
-        when true, :jsmin
-          require 'jsmin'
-          JSMin.minify content
-
-        when :yuic
-          require "yui/compressor"
-          compressor = YUI::JavaScriptCompressor.new(:munge => opts[:obfuscate])
-          compressor.compress(content)
-
-        when :uglify
-          require "uglifier"
-          Uglifier.compile( content, :mangle=>opts[:obfuscate])
-
-        when :packr
-          require 'packr'
-          Packr.pack(content, :shrink_vars => true, :base62 => false, :private=>false)
-
-        when false
-          content
-
-        else
-          # UNKNOWN Compressor type!
-          @site.report "Unknown javascript compressor type! (#{ opts[:compressor] })", :warning
-          content
-        end
-      end
-      
-      def keep_src(name, content, opts)
-        if opts[:keep_src] or opts[:keep_source]
-          ext= File.extname name
-          page name.gsub(ext, "#{opts.fetch(:source_postfix, '-src')}#{ext}") do
-            content
-          end
-        end
-      end
-      
-      def prune_src(name, opts)
-        if opts[:prune] and opts[:root]
-          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
-          @site.content_hash.keys.each do |path|
-            if path[0..rrlen] == relative_root and name != path
-              @site.content_hash.delete path
-            end
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/gumdrop/support/callbacks.rb

@@ -1,30 +0,0 @@
-module Gumdrop::Support
-  module Callbacks
-    
-    # For defining callbacks
-    def callback(*callback_names)
-      callback_names.each do |name|
-        class_eval <<-EOF
-          def #{name}(*args, &block)
-            if block
-              @_#{name} = [] if @_#{name}.nil?
-              @_#{name} << block
-            elsif @_#{name} and !@_#{name}.nil?
-              @_#{name}.each do |cb|
-                cb.call(*args)
-              end
-            end
-          end
-          def clear_#{name}()
-            @_#{name} = nil
-          end
-        EOF
-      end
-    end
-  
-    alias_method :callbacks, :callback
-    alias_method :define_callback, :callback
-    alias_method :define_callbacks, :callback
-  
-  end
-end

data/lib/gumdrop/support/hash_object.rb

@@ -1,22 +0,0 @@
-module Gumdrop
-
-  class HashObject < ActiveSupport::HashWithIndifferentAccess
-  
-    def method_missing(sym, *args, &block)
-      if self.has_key? sym
-        self[sym]
-
-      elsif sym.to_s.ends_with? '='
-        key= sym.to_s.chop.to_sym
-        self[key]= args[0]
-
-      else
-        # FIXME: Return super() or nil for Model#method_missing?
-        # super sym, *args, &block
-        nil
-      end
-    end
-  
-  end
-
-end

data/lib/gumdrop/view_helpers.rb

@@ -1,25 +0,0 @@
-module Gumdrop
-  
-  module ViewHelpers
-    
-    def hidden(&block)
-      #no-op
-    end
-    
-    def markdown(source)
-      m= Tilt['markdown'].new { source }
-      m.render
-    end
-    
-    def textile(source)
-      m= Tilt['textile'].new { source }
-      m.render
-    end
-    
-    def gumdrop_version
-      ::Gumdrop::VERSION
-    end
-    
-  end
-  
-end

data/notes.md

@@ -1,347 +0,0 @@
-# General
-
-Gumdrop is based on personal and project code from several years ago. It's been slowly updated and improved over time. But I've not been able to give it a lot of sustained effort to get it where I want it.
-
-Since I started, Jekyl, MiddleMan, and other static site tools have been released. While they are all good in their own ways, each miss something that I want. The main difference, at this point in time, are generators. I want to have a static site, but still have data-driven pages.
-
-Anyway, this is just a place for me to put down my thoughts on what I want to do to get it servicable as a 1.0 candidate:
-
-
-# Architectural Changes
-
-- Rendering should be abstracted from Content objects
-- Building should be abstracted from Site object
-- Generators should be able to unload themselves and any pages they created
-- There should be discreet ways of knowing whether a Content object is renderable or not (other than file ext)
-- DSL generators should accept a name, and optional base_path (applied to all generated page paths)
-- Callbacks should have the site var in scope
-- Reporting/logging needs to be abstracted from Site and all dependant objects (Loggable module?)
-- Project Templates should be abstracted from CLI::Internal (and External) into a module
-- Make `DataManager` more OO -- abstract data providers. Each provider would specifiy the file extensions they handle.
-- Bundler.require site.config.env.to_sym
-
-## Nice to Haves
-
-- Server should be able to selectively render individual content without rescanning/building the whole tree
-
-# Impl Notes
-
-## Content
-
-- Content objects can know their `level` based on their `full_path` (basically count the slashes)
-
-```rb
-contentA = Content.new "source/page.html.erb"
-contentB = Content.new "source/logo.png"
-
-contentA.binary? #=> false
-contentB.binary? #=> true
-```
-
-Possible `binary?` method (from ptools):
-
-```rb
-class Content
-  def initialize(source_path, generator=nil, &block)
-    @source_path= source_path
-    @filename= File.basename(source_path)
-    @generator=generator
-    @block= block
-    # etc...
-  end
-
-  def binary?(file)
-    @is_binary ||= begin
-      s = (File.read(file, File.stat(file).blksize) || "").split(//)
-      ((s.size - s.grep(" ".."~").size) / s.size.to_f) > 0.30
-    end
-  end
-
-  def generated?
-    !@generator.nil?
-  emd
-
-  def body # Memoize this?
-    if @block
-      @block.call
-    else
-      File.read @source_path
-    end
-  end
-end
-```
-
-## Events/Observable
-
-Use Observable internally?
-
-```ruby
-module Eventable
-  include Observable
-
-  def fire(action, data={}, sender=self)
-    changed
-    notify_observers(sender, action, data)
-  end
-end
-
-# Usage
-class MyClass
-  includes Eventable
-
-  def execute
-    fire :my_action, ex:'data'
-  end
-end
-
-```
-
-Listeners would always have the same signature:
-
-```ruby
-class Listener
-  def update(sender, action, data)
-    puts "(#{ sender.inspect }) #{action}: #{ data.inspect }"
-  end
-end
-```
-Have the site listen and bubble the events?
-
-```ruby
-class Site
-  includes Eventable
-
-  def # wherever
-    renderer= HtmlRenderer.new
-    renderer.add_observer self
-    renderer.draw # whatever
-
-    #done
-    renderer.delete_observers
-  end
-
-  def update(sender, action, data)
-    fire action, data, sender
-  end
-end
-```
-
-## Rendering
-
-```rb
-
-class RenderContext
-  include ViewHelpers
-
-  attr_reader :content, :site, :state
-  # attr_writer :content, :renderer
-
-  def initialize(content, renderer, parent_context=nil)
-    @content= content
-    @renderer= renderer
-    @site= renderer.site
-    @state= {}
-    @parent= parent_context
-  end
-
-  def render(*args) # Not exactly sure yet
-    content= # extract/lookup a content object from args
-             # maybe allow relative lookups from content?
-    @renderer.draw_partial content
-  end
-
-  def get(key)
-    @state[key]
-  end
-
-  def set(key, value)
-    @state[key]= value
-  end
-
-  def method_missing(*stuff)
-    # try to get/set from @state
-    # else try to get from @parent unless @parent.nil?
-    # else try and get it from @content
-    # else return nil ???
-  end
-end
-
-class Renderer
-  includes Eventable
-
-  attr_reader :site, :context
-
-  def initialize(site)
-    @site= site
-  end
-
-  def draw(content, opts={})
-    return nil if content.binary?
-    @context= RenderContext.new site, content, self
-    output= _render_content content, opts
-    fire :render, content:content, output:output
-    output
-  end
-
-  def draw_partial(content, opts={})
-    return nil if content.binary?
-    opts.defaults! no_layout:true
-    _sub_context content
-      output= _render_content content, opts
-      fire :render_partial, content:content, output:output
-    _revert_context
-    output
-  end
-
-private
-
-  def _render_content(content, opts)
-    output= content.body
-    _render_pipeline(content.filename).each do |template|
-      output= _render_text output, template
-    end
-    output- _render_layout output unless opts[:no_layout]
-    output
-  end
-
-  def _render_text(text, tmpl, opts)
-    # Tilt Code
-    tmpl.new(opts).render(text) # pass opts on through?
-  end
-
-  def _render_layout(text)
-    # Look for @context[:layout] or site.config.default_template
-  end
-
-  def _render_pipeline(path)
-    # path.split('.') # then sort out how to:
-    # return an array of Tilt templates based on file exts
-    []
-  end
-
-  def _sub_context(content)
-    @old_context= @context
-    @context= Context.new site, content, self, @old_context
-  end
-
-  def _revert_context
-    @context = @old_context
-  end
-end
-
-
-```
-
-## Building
-
-```ruby
-class Builder
-  include Eventable
-
-  attr_accessor :site, :renderer
-
-  def initialize(site=nil, renderer=nil)
-    @site= site
-    @renderer= renderer.nil? ? Renderer.new(site) : renderer
-  end
-
-  def execute()
-    fire :build_start
-    site.contents.each do |content|
-      if content.binary?
-        _copy content.src_path => _output_path(content)
-      else
-        output = renderer.draw content
-        _write output => _output_path(content)
-      end
-    end
-    fire :build_end
-  rescue => ex
-    fire :exception, source:self, ex:ex
-  end
-
-private
-
-  def _copy(files)
-    files.each_pair do |from,to|
-      # File.write code
-      fire :copy, from:from, to:to
-    end
-  end
-
-  def _write(files)
-    files.each_pair do |text,to|
-      # File.write code
-      fire :write, from:from, to:to
-    end
-  end
-end
-
-
-# Usage
-site= Gumdrop.local_site #=> Site
-renderer= HtmlRenderer.new
-builder= Builder.new site, renderer
-builder.execute()
-```
-
-# Logging via Events?
-
-- Only two levels? `:info` and `:warn`? Or add `:error`
-
-```ruby
-# Mixin to your class:
-module Loggable
-  
-  # Assumes Eventable? or:
-  # include Eventable
-
-  def log(level, msg=nil)
-    if msg.nil?
-      msg= level
-      level= :info
-    end
-    fire :log, level:level, message:msg
-  end
-
-  def warn(msg)
-    log :warn, msg
-  end
-
-end
-
-# Loggers
-class ConsoleLogger
-  def initialize(levels, format='%<level>s : %<message>s')
-    @listen_for= levels
-    @format= format
-  end
-  def update(sender, action, data)
-    if action == :log
-      if @listen_for.include? data.level
-        data[:sender]= sender.to_s
-        data[:time]= Time.new
-        puts sprintf(@format, data)
-      end
-    end
-  end
-end
-```
-
-Or maybe not... I think maybe this:
-
-```ruby
-module Loggable
-  def log
-    Gumdrop.logger
-  end
-end
-
-module Gumdrop
-  class << self
-    attr_accessor :logger
-  end
-end
-```
-
-