gumdrop 0.8.0 → 1.0.0

data/lib/gumdrop/support/compressor.rb

@@ -0,0 +1,52 @@
+
+module Gumdrop::Support
+
+  module Compressor
+
+    def compress(content, opts)
+      case opts
+      when Symbol, String
+        do_compress content, opts.to_s.to_sym
+      when Hash
+        do_compress content, opts[:with].to_s.to_sym, opts
+      else
+        # UNKNOWN Compressor type!
+        log.warn "Unknown javascript compressor type!"
+        content
+      end
+    end
+
+  private
+
+    def do_compress(content, type, opts={})
+      case type
+        when :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)
+
+        else
+          # UNKNOWN Compressor type!
+          log.warn "Unknown javascript compressor type! (#{ type })"
+          content
+      end
+    end
+
+  end
+  
+  Gumdrop::Generator::DSL.send :include, Compressor
+
+end
+

data/lib/gumdrop/support/sprockets.rb

@@ -1,34 +1,25 @@
-# sprockets.rb
-begin
-  require 'sprockets'
-  has_sprockets= true
-rescue LoadError
-  has_sprockets= false
-end
 
 module Gumdrop::Support
 
   module Sprockets # mixes in to generator
-    include BasePackager
     
-    def sprockets(name, opts)
-      if has_sprockets
-        env = Sprockets::Environment.new @site.root_path
-        env.append_path @site.src_path
-        opts[:paths].each do |path|
-          env.append_path(path)
-        end
-        content= env[ opts[:src] ].to_s
-        page name do
-          compress_output(content, opts)
-        end
-        keep_src(name, content, opts)
-        prune_src(name, opts)
-      else
-        throw "Sprockets can't be loaded. Please add it to your Gemfile."
+    def sprockets(source_file, opts={})
+      require 'sprockets'
+      source_path = source_file || opt[:main] || opt[:from]
+      env = ::Sprockets::Environment.new site.root
+      env.append_path site.source_path
+      env.append_path File.dirname(source_path)
+      [opts[:paths]].flatten.each do |path|
+        env.append_path(path) unless path.nil?
       end
+      content= env[ source_path ].to_s
+    rescue LoadError
+      raise StandardError, "Sprockets can't be loaded. Please add it to your Gemfile."
     end
 
   end
 
+  Gumdrop::Generator::DSL.send :include, Sprockets
+
 end
+

data/lib/gumdrop/support/stitch.rb

@@ -9,26 +9,37 @@ end
 module Gumdrop::Support
 
   module Stitch # mixes in to generator
-    include BasePackager
-
-    def stitch(name, opts)
-      if has_stitch
-        content= Stitch::Package.new(opts).compile
-        page name do
-          compress_output(content, opts)
-        end
-        keep_src(name, content, opts)
-        prune_src(name, opts)
-      else
-        throw "Stitch can't be loaded. Please add it to your Gemfile."
-      end
+    
+    # Stitch::Package.new options:
+    #   :identifier=>'app',   # variable name for the library
+    #   :paths=>['./app'],
+    #   :root=>'./app', 
+    #   :dependencies=>[],    # List of scripts to prepend to top of file (non moduled)
+    def stitch(source_file, opts={})
+      require 'stitch-rb'
+      content= site.resolve source_file
+      path = content.nil? ? source_file : content.source_path
+      stitch_opts= {} #{ root: content.source_path }
+      stitch_opts.merge! opts
+      stitch_opts[:paths] ||= []
+      stitch_opts[:paths] << File.dirname(path)
+      ::Stitch::Package.new(stitch_opts).compile
+    rescue LoadError
+      raise StandardError, "Stitch can't be loaded. Please add it to your Gemfile."
     end
 
   end
 
+  Gumdrop::Generator::DSL.send :include, Stitch
+
 end
 
-if defined?(Stitch)
+
+#
+# These cause weird side effects, need to pull them out into a js-app
+# specific template!
+#
+if false # defined?(Stitch)
 
   class Stitch::Source
     # Patch for gumdrop style filenames

data/lib/gumdrop/support/yaml_doc_template.rb

@@ -0,0 +1,29 @@
+require 'yaml'
+
+module Tilt
+  class YamlDocTemplate < Template
+
+    def render(scope=Object.new, locals={}, &block)
+      yamldoc= Gumdrop::Util::YamlDoc.new(@data)
+      scope.set yamldoc.data if scope.respond_to? :set
+      yamldoc.body
+    end
+
+  protected
+
+    def prepare
+
+    end
+
+    def evaluate(scope, locals, &block)
+      method = compiled_method(locals.keys)
+      method.bind(scope).call(locals, &block)
+    end
+  end
+end
+
+ 
+ Tilt.register Tilt::YamlDocTemplate, 'yamldoc'
+ Tilt.register Tilt::YamlDocTemplate, 'yamdoc'
+ Tilt.register Tilt::YamlDocTemplate, 'yd'
+

data/lib/gumdrop/util/configurable.rb

@@ -0,0 +1,44 @@
+module Gumdrop::Util
+
+  module Configurable
+    module ClassMethods
+
+      def config_accessor(*keys)
+        keys.each do |key|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{key}; config[#{key.inspect}]; end
+            def #{key}=(value); config[#{key.inspect}]= value; end
+          RUBY
+        end
+      end
+
+    end
+    
+    module InstanceMethods
+
+      def config
+        @config ||= HashObject.new
+      end
+
+      def configure(&block)
+        if block.arity == 1
+          block.call config
+        else
+          config.instance_eval &block
+        end
+        config_did_change
+      end
+
+      def config_did_change
+        # Override me!
+      end
+
+    end
+    
+    def self.included(receiver)
+      receiver.extend         ClassMethods
+      receiver.send :include, InstanceMethods
+    end
+  end
+
+end

data/lib/gumdrop/util/core_ex.rb

@@ -0,0 +1,84 @@
+require 'pathname'
+
+class Hash
+
+  def to_symbolized_hash
+    new_hash= {}
+    self.each {|k,v| new_hash[k.to_sym]= v }
+    new_hash
+  end
+
+  def to_hash_object
+    Gumdrop::Util::HashObject.from self
+  end
+
+  def ends_with?(string)
+    self[0..(string.length)] == string
+  end
+
+  def starts_with?(string)
+    self[0..(string.length)] == string
+  end
+
+end
+
+class String
+  
+  def / (other)
+    File.join self, other
+  end
+
+  def relative
+    dup.relative!
+  end
+
+  def relative!
+    sub! /^[\/]/, ''
+    self
+  end
+
+  def expand_path(relative_to=nil)
+    if (Pathname.new self).absolute?
+      self
+    elsif relative_to.nil?
+      File.expand_path self
+    else
+      File.expand_path relative_to / self
+    end
+  end
+
+  def path_match?(pattern)
+    File.fnmatch pattern, self, File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_CASEFOLD
+  end
+
+  # alias_method :starts_with?, :start_with?
+  # alias_method :ends_with?, :end_with?
+
+end
+
+
+# module PathTools
+
+#   def / (other)
+#     self.join other.to_s
+#   end
+
+#   def - (other)
+#     Pathname.new self.to_s.gsub(other, '')
+#   end
+
+#   def match?(other)
+#     fnmatch? pattern, File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_CASEFOLD
+#   end
+
+# end
+
+# class Pathname
+#   include PathTools
+# end
+
+# class String
+#   def to_pathname
+#     Pathname.new self
+#   end
+# end

data/lib/gumdrop/util/eventable.rb

@@ -0,0 +1,35 @@
+require 'onfire'
+
+module Gumdrop::Util
+
+  module Eventable
+    include ::Onfire
+
+    def event_block(target)
+      fire "before_#{target}".to_sym
+      data= HashObject.new
+      result= data.payload= yield(data)
+      fire target, data
+      fire "after_#{target}".to_sym, data
+      data.return_value || result
+    end
+
+    def fire(event, data=nil)
+      data= case
+        when data.nil?
+          HashObject.from site:Gumdrop.site
+        when data.is_a?(Hash)
+          HashObject.from(data).merge site:Gumdrop.site 
+        else
+          data
+        end
+      event_for(event, self, data).bubble!
+    end
+
+    def clear_events
+      @event_table ||= Onfire::EventTable.new
+    end
+
+  end
+
+end

data/lib/gumdrop/util/hash_object.rb

@@ -0,0 +1,70 @@
+module Gumdrop::Util
+
+  class HashObject < Hash
+
+    # All keys are symbols, internally
+    def [](key)
+      super(key.to_sym)
+    end
+    def []=(key, value)
+      super(key.to_sym, value)
+    end
+  
+    def method_missing(sym, *args, &block)
+      if self.has_key? sym.to_s or self.has_key? sym
+        self[sym]
+      elsif sym.to_s.ends_with? '='
+        key= sym.to_s.chop
+        self[key]= args[0]
+      else
+        # super sym, *args, &block # ???
+        nil
+      end
+    end
+
+    def get(key)
+      self[key]
+    end
+    def set(key,value=nil)
+      if key.is_a? Hash
+        key.each do |k,v|
+          self[k]= v
+        end
+      else
+        self[key]= value
+      end
+    end
+
+    def has_key?(key)
+      super key.to_sym
+    end
+
+    def store(key,value)
+      super(key.to_sym, value)
+    end
+
+    def merge(other_hash=nil, &block)
+      unless other_hash.nil?
+        super(other_hash.to_symbolized_hash, &block)
+      else
+        super(other_hash, &block)
+      end
+    end
+
+    def merge!(other_hash=nil, &block)
+      unless other_hash.nil?
+        super(other_hash.to_symbolized_hash, &block)
+      else
+        super(other_hash, &block)
+      end
+    end
+
+    def self.from(hash={})
+      h= new
+      h.merge!(hash)
+      h
+    end
+  
+  end
+
+end

data/lib/gumdrop/util/loggable.rb

@@ -0,0 +1,44 @@
+require 'logger'
+
+module Gumdrop  
+  
+  module Util
+    module Loggable
+      def log
+        Gumdrop.log
+      end
+    end
+  end
+
+  class << self
+
+    LOG_LEVELS= {
+        debug: Logger::DEBUG,
+         info: Logger::INFO,
+         warn: Logger::WARN,
+        error: Logger::ERROR,
+        fatal: Logger::FATAL,
+      unknown: Logger::UNKNOWN
+    }
+
+    def log
+      @log ||= begin
+        log= Logger.new STDOUT
+        log.level= LOG_LEVELS[:warn]
+        log
+      end
+    end
+
+    def init_logging
+      level= (site.config.log_level || :warn).to_sym
+      @log = Logger.new site.config.log || STDOUT
+      @log.level=  LOG_LEVELS[level]
+      # @log.formatter = proc { |severity, datetime, progname, msg|
+      #   # original_formatter.call(severity, datetime, progname, msg.dump)
+      #   "#{msg}\n"
+      # }
+    end
+
+  end
+
+end

data/lib/gumdrop/util/pager.rb

@@ -0,0 +1,51 @@
+module Gumdrop::Util
+
+  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.from({
+          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 → util}/proxy_handler.rb

@@ -25,8 +25,8 @@ module Gumdrop
   
   def self.handle_proxy(proxy, proxy_url, env)
     if proxy[:secure] && !HTTPS_ENABLED
-      $stderr.puts "~ WARNING: HTTPS is not supported on your system, using HTTP instead.\n"
-      $stderr.puts"    If you are using Ubuntu, you can run `apt-get install libopenssl-ruby`\n"
+      log.warn "~ WARNING: HTTPS is not supported on your system, using HTTP instead.\n"
+      log.warn "   If you are using Ubuntu, you can run `apt-get install libopenssl-ruby`\n"
       proxy[:secure] = false
     end
 
@@ -35,7 +35,7 @@ module Gumdrop
     url = proxy[:path_info] #proxy_url #env['PATH_INFO']
     params = env['QUERY_STRING']
     
-    puts "PROXY: -> #{url}"
+    log.info "PROXY: -> #{url}"
 
     # collect headers...
     headers = {}
@@ -98,7 +98,7 @@ module Gumdrop
       status = response.code # http status code
       protocol = proxy[:secure] ? 'https' : 'http'
 
-      $stderr.puts "~ PROXY: #{http_method.upcase} #{status} #{url} -> #{protocol}://#{http_host}:#{http_port}#{http_path}\n"
+      log.log "~ PROXY: #{http_method.upcase} #{status} #{url} -> #{protocol}://#{http_host}:#{http_port}#{http_path}\n"
 
       # display and construct specific response headers
       response_headers = {}
@@ -122,12 +122,13 @@ module Gumdrop
           end
         end
 
-        $stderr << "   #{key}: #{value}\n"
+        #$stderr << "   #{key}: #{value}\n"
+
         response_headers[key] = value
       end
 
       if [301, 302, 303, 307].include?(status.to_i) && proxy[:redirect] != false
-        $stderr.puts '~ REDIRECTING: '+response_headers['location']+"\n"
+        log.warn '~ REDIRECTING: '+response_headers['location']+"\n"
 
         uri = URI.parse(response_headers['location']);
         http_host = uri.host

data/lib/gumdrop/util/scanner.rb

@@ -0,0 +1,47 @@
+module Gumdrop::Util
+
+  class Scanner
+    include Loggable
+
+    attr_reader :options
+
+    def initialize(base_path, opts={}, &block)
+      @source_glob= base_path / "**" / "*"
+      @options= opts
+      @src_path= base_path
+      @validator= block || method(:_default_validator)
+    end
+
+    def each
+      Dir.glob(@source_glob, File::FNM_DOTMATCH).each do |path|
+        rel_path= _relative(path)
+        unless should_skip? rel_path, path
+          yield path, rel_path
+        else
+          log.debug " excluding: #{ rel_path }"
+        end
+      end
+    end
+
+    def should_skip?(path, full_path)
+      return true if File.directory?(full_path)
+      @validator.call(path, full_path) || false
+    end
+
+  private
+
+    def _default_validator(src,full)
+      true
+    end
+
+    def _relative(path)
+      relpath= path.gsub @src_path, ''
+      if relpath[0]== '/'
+        relpath[1..-1]
+      else
+        relpath
+      end
+    end
+  end
+
+end

data/lib/gumdrop/util/site_access.rb

@@ -0,0 +1,16 @@
+module Gumdrop::Util
+  module SiteAccess
+    include Eventable    
+    include Loggable
+
+    def site
+      Gumdrop.site
+    end
+
+    # for event bubbling
+    def parent
+      site
+    end
+
+  end
+end

data/lib/gumdrop/util/view_helpers.rb

@@ -0,0 +1,50 @@
+module Gumdrop
+  
+  module Util
+    module ViewHelpers
+      
+      def hidden(&block)
+        #no-op
+      end
+      
+      def markdown(source)
+        eng= Gumdrop::Renderer.for 'markdown'
+        unless eng.nil?
+          eng.new(source).render
+        else
+          raise StandardError, "Markdown is not available: Include a Markdown engine in your Gemfile!"
+        end
+      end
+      
+      def textile(source)
+        eng= Gumdrop::Renderer.for 'textile'
+        unless eng.nil?
+          eng.new(source).render
+        else
+          raise StandardError, "Textile is not available: Include a Textile engine in your Gemfile!"
+        end
+      end
+      
+      def config
+        site.config
+      end
+
+      def data
+        site.data
+      end
+
+      def gumdrop_version
+        ::Gumdrop::VERSION
+      end
+      
+    end
+  end
+  
+  class << self
+
+    def view_helpers(&block)
+      Util::ViewHelpers.class_eval &block
+    end
+
+  end
+end