gumdrop 0.8.0 → 1.0.0

data/lib/gumdrop/data.rb

@@ -0,0 +1,185 @@
+# require 'ostruct'
+
+module Gumdrop
+
+  class DataManager
+    include Util::SiteAccess
+
+    attr_reader :cache
+  
+    def initialize(data_dir="./data")
+      @dir= File.expand_path data_dir
+      # reset
+      @cache= Hash.new &method(:_cache_dataset)
+    end
+
+    def dir=(path)
+      @dir= File.expand_path path
+    end
+  
+    def method_missing(key, value=nil)
+      @cache[key]
+    end
+  
+    def set(key, value)
+      @cache[key]= value
+    end
+  
+    def reset
+      @cache.clear
+    end
+
+    def contents(pattern=nil, opts={})
+      if pattern.nil?
+        site.contents.all
+      else
+        site.contents(pattern, opts)
+      end
+    end
+    
+    def pager_for(key, opts={})
+      data= case key
+        when Symbol
+          @cache[key]
+        when Array
+          key
+        else
+          raise "pager_for requires a lookup symbol or array data."
+        end
+      base_path= opts.fetch(:base_path, 'page')
+      page_size= opts.fetch(:page_size, 5)
+      Util::Pager.new( data, base_path, page_size )
+    end
+  
+  private
+  
+    def _cache_dataset(hash, key)
+      hash[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_file( filename )
+      ext=File.extname(filename)[1..-1]
+      provider= Data::Provider.for ext
+      case
+        when provider.nil?
+          raise "Unknown data type (#{ext}) for #{filename}"
+        when provider.available?
+          data= provider.data_for filename
+          log.debug "    loaded: #{filename}"
+          data
+        else
+          raise "Unavailable data type (#{ext}) for #{filename}"
+      end
+    end
+
+    def _load_from_directory( filepath )
+      all=[]
+      Dir[ filepath / _supported_type_glob ].each do |filename|
+        id= File.basename(filename).gsub(File.extname(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
+        _registered_data_types.each do |ext|
+          lpath= _local_path_to("#{path}.#{ext}")
+          return lpath if File.exists? lpath
+        end
+        log.warn "No data found for #{path}"
+        nil
+      end
+    end
+
+    def _local_path_to(filename)
+      File.join(@dir.to_s, filename.to_s)
+    end
+
+    def _registered_data_types
+      Data::Provider.registered_exts
+    end
+
+    def _supported_type_glob
+      "{*.#{ _registered_data_types.join ',*.'}}"
+    end
+
+  end
+
+  module Data
+    # Base class for Data Proviers
+    class Provider
+      
+      def available?
+        raise "available? must be implemented! (#{self.class})"
+      end
+
+      def data_for(filepath)
+        raise "data_for must be implemented! (#{self.class})"
+      end
+
+      def supply_data(object)
+        case object
+          when Hash
+            object = object.clone
+            object.each do |key, value|
+              object[key] = supply_data(value)
+            end
+            # OpenStruct.new(object)
+            Gumdrop::Util::HashObject.from object
+          when Array
+            object = object.clone
+            object.map! { |item| supply_data(item) }
+          else
+            object
+        end
+      end
+
+      class << self
+
+        def extensions(*extnames)
+          provider_class= self
+          @@providers ||= {}
+          extnames.each do |ext|
+            @@providers[ext.to_s]= provider_class
+          end
+        end
+        alias_method :extension, :extensions
+
+        def registered_exts
+          @@providers.keys
+        end
+
+        def for(ext)
+          case
+            when provider_class= @@providers[ext]
+              provider_class.new
+            when provider_class= @@providers[".#{ ext }"]
+              provider_class.new
+            else
+              nil
+          end
+        end
+      end
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) / 'data_providers' / '*.rb'].each do |lib|
+  require lib
+end

data/lib/gumdrop/data_providers/csv.rb

@@ -0,0 +1,18 @@
+module Gumdrop::Data
+  class CSVDataProvider < Provider
+    
+    extension :csv
+
+    def available?
+      require 'csv'
+      true
+    rescue LoadError
+      false
+    end
+
+    def data_for(filepath)
+      supply_data CSV.read(filepath)
+    end
+
+  end
+end

data/lib/gumdrop/data_providers/pstore.rb

@@ -0,0 +1,25 @@
+module Gumdrop::Data
+  class PStoreDataProvider < Provider
+
+    extension :pstore
+
+    def available?
+      require 'pstore'
+      true
+    rescue LoadError
+      false
+    end
+
+    def data_for(filepath)
+      data={}
+      store= PStore.new(filepath)
+      store.transaction true do 
+        store.roots.each do |root|
+          data[root]= store[root]
+        end
+      end
+      supply_data data
+    end
+
+  end
+end

data/lib/gumdrop/data_providers/sqlite.rb

@@ -0,0 +1,43 @@
+module Gumdrop::Data
+  class SqliteDataProvider < Provider
+
+    extensions :sqlite, :sqlite3, :db
+
+    def available?
+      require 'sqlite3'
+      true
+    rescue LoadError
+      false
+    end
+
+    def data_for(filepath)
+      @db= SQLite3::Database.new( filepath )
+      @live= SqliteLiveData.new @db, self
+    end
+
+  end
+
+  class SqliteLiveData
+    attr_reader :db, :provider
+
+    def initialize(db, provider)
+      @db= db
+      @provider= provider
+      @data_hash= Hash.new &method(:load_data_for)
+    end
+
+    def load_data_for(hash, table_name)
+      data=[]
+      db.results_as_hash = true
+      db.execute( "select * from #{ table_name.to_s };" ) do |row|
+        data << row.reject {|key,col| key.is_a? Fixnum }
+      end
+      hash[table_name]= provider.supply_data data
+    end
+
+    def method_missing(key, *args)
+      @data_hash[key]
+    end
+
+  end
+end

data/lib/gumdrop/data_providers/xml.rb

@@ -0,0 +1,15 @@
+module Gumdrop::Data
+  class XMLDataProvider < Provider
+
+    extension :xml
+
+    def available?
+      true
+    end
+
+    def data_for(filepath)
+      supply_data Hash.from_xml File.read(filepath)
+    end
+
+  end
+end

data/lib/gumdrop/data_providers/yaml_and_json.rb

@@ -0,0 +1,18 @@
+module Gumdrop::Data
+  class YAMLandJSONDataProvider < Provider
+
+    extensions :yaml, :yml, :json
+
+    def available?
+      require 'yaml'
+      true
+    rescue LoadError
+      false
+    end
+
+    def data_for(filepath)
+      supply_data YAML.load_file(filepath)
+    end
+
+  end
+end

data/lib/gumdrop/data_providers/yamldb.rb

@@ -0,0 +1,18 @@
+module Gumdrop::Data
+  class YAMLDBDataProvider < YAMLandJSONDataProvider
+
+    extension :yamldb
+
+
+    def data_for(filepath)
+      docs=[]
+      File.open(filepath, 'r') do |f|
+        YAML.load_documents(f) do |doc|
+          docs << supply_data( doc ) #unless doc.has_key?("__proto__")
+        end
+      end
+      docs
+    end
+
+  end
+end

data/lib/gumdrop/data_providers/yamldoc.rb

@@ -0,0 +1,12 @@
+module Gumdrop::Data
+  class YAMLDocDataProvider < YAMLandJSONDataProvider
+
+    extension :yamldoc
+
+    def data_for(filepath)
+      yamldoc= Gumdrop::Util::YamlDoc.new File.read(filepath), true
+      supply_data yamldoc.data
+    end
+
+  end
+end

data/lib/gumdrop/generator.rb

@@ -1,124 +1,148 @@
 module Gumdrop
 
   class Generator
+    include Util::SiteAccess
 
-    include Support::Stitch
-    include Support::Sprockets
-
-
-    attr_reader :filename, :base_path, :params, :pages
-    
-    def initialize(content, site, opts={})
-      @site= site
-      @content= content
-      if @content.is_a? Proc
-        @filename= ""
-        @base_path= ""
-      else
-        @filename= content.filename || ""
-        @base_path= content.slug || ""
-      end
-      @params= HashObject.new
+    def initialize(content=nil, opts={}, &block) # block?
+      @content= content || block
+      @dsl= DSL.new self
       @pages= []
+      @filename= content.nil? ? (opts[:filename] || '') : content.filename
+      @base_path= content.nil? ? (opts[:base_path] || '') : content.slug 
     end
-    
-    # This should probably not be accessible to the generators
-    def execute
-      if @content.is_a? Proc
-        instance_eval &@content
-      else
-        instance_eval File.read(@content.path)
+
+    def unload
+      pages.each do |content|
+        site.contents.remove content
       end
+      @dsl= DSL.new self
     end
 
-    def site
-      @site
-    end
-    
-    def data
-      @site.data
+    def reload
+      unload
+      execute
     end
 
-    def config
-      @site.config
-    end
-    
-    def set(var_name, value)
-      params[var_name]= value
+    def pages
+      @pages
     end
 
-    def unload
-      @pages.each do |content|
-        @site.content_hash.delete content.uri
-      end
-    end
-    
-    def page(name, opts={}, &block)
-      name= name[1..-1] if name.starts_with?('/')
-      opts= params.reverse_merge(opts)
-      filepath= if @base_path.empty?
-        File.join @site.src_path, name
-      else
-        File.join @site.src_path, @base_path, @name
-      end
-      content= GeneratedContent.new(filepath, block, @site, self, opts)
-      if opts.has_key? :template and !opts[:template].nil?
-        content.template = if @site.layouts.has_key?( opts[:template] )
-          @site.layouts[ opts[:template] ]
+    def gen_page(name, opts={}, params={}, &block)
+      event_block :generate_item do
+        name.relative!
+        opts= params.reverse_merge(opts)
+        filepath= if @base_path.empty?
+            site.source_path / name
+          else
+            site.source_path / @base_path / name
+          end
+        if block.nil?
+          handler= _render_inline_content opts
+          content= site.contents.create filepath, self, &handler          
         else
-          @site.layouts[ "#{opts[:template]}.template" ]
-        end.template
+          content= site.contents.create filepath, self, &block
+        end
+        content.params.merge! opts
+        content.params.merge! opts[:params] if opts.has_key?(:params)
+        log.debug " generated: #{content.uri}"
+        @pages << content
       end
-      content.ignore site.greylist.any? {|pattern| site.path_match name, pattern }
-      unless content.ignored
-        content.ignore site.blacklist.any? {|pattern| site.path_match name, pattern }
-      end      
-      @site.report " generated: #{content.uri}", :info
-      @site.content_hash[content.uri]= content
-      @pages << content
-      content
     end
 
-    # FIXME: Does redirect require abs-paths?
-    def redirect(from, opts={})
-      if opts[:to]
-        page from do
-          <<-EOF
-          <meta http-equiv="refresh" content="0;url=#{ opts[:to] }">
-          <script> window.location.href='#{ opts[:to] }'; </script>
-          EOF
+    def execute
+      log.debug "(Generator '#{ @filename }')"
+      if @content.is_a? Proc
+        if @content.arity == 1
+          @content.call @dsl
+        else
+          @dsl.instance_eval &@content
         end
-        opts[:from]= from
-        @site.redirects << opts
       else
-        @site.report "You must specify :to in a redirect", :warning
+        @dsl.instance_eval @content.body
       end
+      log.debug "   created: #{ @pages.size } pages"
     end
-    
-  end
-  
-  class GeneratedContent < Content
-    # Nothing special, per se...
-
-    def initialize(path, block, site, generator, params={})
-      super(path, site, params)
-      @content_block= block
-      @generated= true
-      @generator= generator
+
+    def _render_inline_content(opts)
+      Proc.new {
+        renderer= site.active_renderer || Renderer.new
+        content= site.resolve(opts[:render], opts)
+        opts[:inline_render]= true
+        renderer.draw content, opts
+      }
     end
 
-    def render(context=nil, ignore_layout=false,  reset_context=true, locals={})
-      if @content_block.nil?
-        super(context, ignore_layout, reset_context, locals)
-      else
-        @content_block.call
+    class DSL
+      include Util::SiteAccess
+      include Util::ViewHelpers
+
+      attr_reader :params
+
+      def initialize(generator)
+        @generator= generator
+        @params= Util::HashObject.new
+      end
+
+      def data
+        site.data
+      end
+
+      def config
+        site.config
+      end
+
+      def options
+        site.options
+      end
+
+      def env
+        site.env
+      end
+
+      def mode
+        site.mode
       end
+
+      def set(var_name, value)
+        @params[var_name]= value
+      end
+      def get(var_name)
+        @params[var_name]
+      end
+
+      def page(name, opts={}, &block)
+        @generator.gen_page name, opts, @params, &block
+      end
+      alias_method :content, :page
+
+      def file(name, opts={}, &block)
+        opts[:layout]= opts[:layout] || false
+        page name, opts, &block
+      end
+
     end
+  end
+
+
+  class << self
 
-    def useLayout?
-      !@content_block.nil? or !template.nil?
+    # Generate a page (based on data or whatever) from your
+    # Gumdrop file like this:
+    #
+    #   Gumdrop.generate 'label' do |gen|
+    #     gen.file 'my-page.html' do
+    #       # whatever you return is set as the page contents.
+    #       "hello!"
+    #     end
+    #   end
+    #
+    def generate(name=nil, opts={}, &block)
+      opts[:filename]= name unless opts[:filename]
+      site.generators << Generator.new(nil, opts, &block)
     end
 
   end
-  
+
 end
+
+