dokkit 0.3.0 → 0.4.0

data/lib/dokkit/environment/basic.rb

@@ -0,0 +1,156 @@
+#                                                                          
+# File 'basic.rb' created on 01 mag 2008 at 15:37:33.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C)2006-2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'ostruct'
+require 'rake'
+require 'dokkit'
+require 'dokkit/environment'
+require 'dokkit/logging'
+require 'dokkit/factory'
+require 'dokkit/resource'
+require 'dokkit/tasklib'
+require 'dokkit/filters'
+require 'dokkit/cache'
+
+module Dokkit
+  module Environment
+    module Basic
+
+      # When included in a container, initialize it.
+      def initialize
+        add_lib_to_load_path
+        yield self if block_given?
+        define_tasks
+      end
+
+      # Add lib folder to the load path.
+      def add_lib_to_load_path
+        $: << 'lib'
+      end
+
+      # Define rake tasks for the environment.
+      def define_tasks
+        render
+        clean
+      end
+
+      # Setup a console logger.
+      def logger
+        @logger ||= Logging::Observer::Console.logger
+      end
+
+      # Setup cache.
+      def cache
+        @cache ||= Cache.new
+      end
+
+      # Return an OpenStruct object to setup documentation
+      # directories. Instantiate the object only once.
+      #
+      # configuration.document_dir :: set/get documents folder.
+      # configuration.config_dir :: set/get configs folder.
+      # configuration.layout_dir :: set/get layouts folder.
+      # configuration.data_dir :: set/get data folder.
+      # configuration.output_dir :: set/get output folder.
+      # configuration.cache_dir :: set/get cache folder.
+      #
+      def configuration
+        @configuration ||= OpenStruct.new({ 
+          :document_dir => 'doc/pages',
+          :config_dir => 'doc/configs',
+          :layout_dir => 'doc/layouts',
+          :data_dir => 'doc/data',
+          :output_dir => 'output',
+          :cache_dir => '.cache'
+        })
+      end
+
+      # Return a Dokkit::Environment::Helper::FileSelection object
+      # with the list of documents in configuration.document_dir
+      # folder and its subdir. The object is instantiated only
+      # once. By default all files in configuration.document_dir and
+      # subdirs are included.
+      def documents
+        @documents ||= Environment::Helper::FileSelection.new(configuration.document_dir) do |fs|
+          fs.include('**/*')
+          fs.exclude('**/*.yaml')
+        end
+      end
+
+      # Return a Dokkit::Environment::Helper::FileSelection object
+      # with the list of data files in configuration.data_dir folder
+      # and its subdir. The object is instantiated only once.
+      def data
+        @data ||= Environment::Helper::FileSelection.new(configuration.data_dir).include('**/*')
+      end
+
+      # Return a Dokkit::Environment::Helper::ExtMap object that map
+      # an extension code block to document files using glob patterns.
+      def extmap
+        @extmap ||= Helper::ExtMap.new(configuration.document_dir)
+      end
+      
+      # Construct a filter factory and register filters.
+      def filter_factory
+        @filter_factory ||= Dokkit::Factory.new do |factory|
+          factory.add('maruku-html' => lambda { Dokkit::Filter::MarukuHTML.new } )
+          factory.add('deplate-latex' => lambda { Dokkit::Filter::DeplateLatex.new } )
+          factory.add('deplate-html' => lambda { Dokkit::Filter::DeplateHTML.new } )
+          factory.add('deplate-text' => lambda { Dokkit::Filter::DeplateText.new } )
+        end
+      end
+
+      # Construct a resource factory to get resource instances
+      # (i.e. document and data). The object is instantiated only
+      # once.
+      def resource_factory
+        @resource_factory ||= Factory.new do |factory|
+          factory.add(:document => document_factory_block)
+          factory.add(:data => data_factory_block)
+        end
+      end
+      # Return a block that is able to construct a Document instance.
+      def document_factory_block
+        lambda do |source_fn|
+          Resource::Document.new(source_fn, 
+                                 configuration.marshal_dump, 
+                                 logger, 
+                                 cache, 
+                                 resource_factory,
+                                 filter_factory, 
+                                 &extmap[source_fn])
+        end
+      end
+      # Return a block that is able to construct a Data instance.
+      def data_factory_block
+        lambda do |source_fn|
+          Resource::Data.new(source_fn, configuration.marshal_dump)
+        end
+      end
+      # Define render tasklib.
+      def render
+        TaskLib::Render.new(logger, resource_factory, documents.files, data.files)   
+      end
+      # Define clean tasklib.
+      def clean
+        TaskLib::Clean.new(logger, configuration.marshal_dump)
+      end
+    end
+  end
+end
+
+module Dokkit
+  module Environment
+    module Basic
+      # Define a setup container.
+      class Container
+        include Dokkit::Environment::Basic
+      end
+    end
+  end
+end

data/lib/dokkit/environment/helpers/extmap.rb

@@ -0,0 +1,29 @@
+#                                                                          
+# File 'extmap.rb' created on 14 mag 2008 at 10:52:17.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C)2006-2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'dokkit/environment/helpers/fileselection'
+
+module Dokkit
+  module Environment
+    module Helper
+      class ExtMap < FileSelection
+        def initialize(base_dir)
+          super(base_dir)
+          @ext = { }
+        end
+        def map(&blk)
+          files.each { |fn| @ext[fn] = blk }
+          self
+        end
+        def [](resource)
+          @ext[resource]
+        end
+      end
+    end
+  end
+end

data/lib/dokkit/environment/helpers/fileselection.rb

@@ -0,0 +1,53 @@
+#                                                                          
+# File 'fileselection.rb' created on 01 mag 2008 at 16:31:18.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C)2006-2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'rake'
+
+module Dokkit
+  module Environment
+    module Helper
+      # FileSelection encapsulates the behaviour of Rake::FileList
+      # class. Objects of class FileSelection are capable to return
+      # the list of file in a directory. Objects are initialized with
+      # a base directory. File list can be refined with
+      # FileSelection#include and FileSelection#exclude instance
+      # methods.
+      class FileSelection
+        attr_reader :base_dir
+        alias :dir :base_dir
+        # Initialize a FileSelection object.
+        # base_dir :: the base dir for all inclusion/exclusion operations.
+        def initialize(base_dir = '.')
+          @base_dir = base_dir
+          @includes = []
+          @excludes = []
+          yield self if block_given?
+        end
+        # Include files to the list.
+        # patterns :: array of glob patterns
+        def include(*patterns)
+          patterns.each { |pattern| @includes << pattern }
+          self
+        end
+        # Exclude files from the list.
+        # patterns :: array of glob patterns
+        def exclude(*patterns)
+          patterns.each { |pattern| @excludes << pattern }
+          self
+        end
+        # Return an array containing the file list.
+        def files
+          FileList.new(@base_dir) do |fl|
+            fl.exclude *@excludes.collect { |exclude| File.join(@base_dir, exclude) } unless @excludes.empty?
+            fl.include *@includes.collect { |include| File.join(@base_dir, include) } unless @includes.empty?
+          end.uniq.select { |fn| not File.directory?(fn) }
+        end
+      end
+    end
+  end
+end

data/lib/dokkit/environment/helpers.rb

@@ -0,0 +1,20 @@
+#                                                                          
+# File 'helpers.rb' created on 04 mag 2008 at 17:44:17.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C)2006-2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'dokkit/environment/helpers/fileselection'
+require 'dokkit/environment/helpers/extmap'
+
+module Dokkit
+  module Environment
+    # Collect helper class that simplify the setup of
+    # documentation environment.
+    module Helper
+      
+    end
+  end
+end

data/{spec/data/test_build/Rakefile → lib/dokkit/environment.rb}

@@ -1,22 +1,11 @@
 #                                                                          
-# File 'Rakefile' created on 09 ott 2007 at 16:06:57.                    
+# File 'environment.rb' created on 04 mag 2008 at 17:34:56.                    
 #
 # See 'dokkit.rb' or +LICENSE+ for licence information.                      
 #                                                                          
-# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+# (C)2006-2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
 #                                                                          
-# Rakefile for website project model
-
-require 'tasks/all'
-
-task :clobber => 'clean:all'
-task :default => 'render:all'
-
-
-
-
-
-
-
 
+require 'dokkit/environment/basic'
+require 'dokkit/environment/helpers'
 

data/lib/dokkit/factory/factory.rb

@@ -0,0 +1,56 @@
+
+# File 'factory.rb' created on 25 apr 2008 at 19:43:56.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C)2006-2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+module Dokkit
+  class Factory
+
+    # Return stored instances.
+    attr_reader :instances
+
+    # Return stored factory method.
+    attr_reader :methods
+
+    # Initialize a Factory object. Configuration is made passing a
+    # code block.
+    def initialize
+      @instances, @methods = { }, { }
+      yield self if block_given?
+    end
+
+    # Add a factory method associated with the given class of objects.
+    # +factory_method+ is a class/method pair.
+    #
+    # Example:
+    # 
+    # factory.add(:bar => bar_factory_method) # add a method that
+    #                                         # instantiates Bar object
+    #
+    def add(factory_method)
+      @methods.merge! factory_method
+    end
+
+    # Construct an instance for the given class. Note that, if an
+    # instance of the same class has been already instantiated for a
+    # given parameters set, then *no* new instance will be created but
+    # the first one will be returned.
+    def get(key, *params)
+      get_instance(key, *params) || store_instance(key, *params)
+    end
+    
+    private
+    
+    def store_instance(key, *params)
+      @instances[ [key].concat(params) ] = @methods[key].call(*params)
+    end
+
+    def get_instance(key, *params)
+      @instances[ [key].concat(params) ]
+    end    
+
+  end
+end

data/lib/dokkit/factory.rb

@@ -0,0 +1,9 @@
+#                                                                          
+# File 'factory.rb' created on 04 mag 2008 at 17:37:33.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C)2006-2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+require 'dokkit/factory/factory'

data/lib/dokkit/filters/deplate.rb

@@ -1,39 +1,44 @@
 #--
 # Dokkit filter for Deplate
-# (c)2006 Andrea Fazzi (and contributors)
+# (c) 2006, 2007, 2008 Andrea Fazzi (and contributors)
 #
 # See 'dokkit.rb' or LICENSE for licence information.
 
-require 'deplate/converter'
-require 'deplate/core'
-require 'dokkit/filters'
-require 'dokkit/filters/base'
-require 'dokkit/deplate/fmt/latex-notemplate'
-require 'dokkit/deplate/fmt/html-notemplate'
+require 'deplate/deplate-string'
+require 'deplate/fmt/latex'
+
+class Deplate::Formatter::LaTeX
+  def initialize_deplate_sty; end
+end
 
 module Dokkit
-  module Filters
-    class DeplateHTML < Base
+  module Filter
+
+    class DeplateHTML
+
       def filter(text)
-        ::Deplate::Core.declare_formatter(::Deplate::Formatter::HTMLNoTemplate,'html-notemplate')        
-        ::Deplate::Converter.new('html-notemplate').convert_string(text)
+        DeplateString.new(text).to_html
       end      
+
     end    
-    class DeplateLatex < Base
+
+    class DeplateLatex
+
       def filter(text)
-        ::Deplate::Core.declare_formatter(::Deplate::Formatter::LatexNoTemplate,'latex-notemplate')        
-        ::Deplate::Converter.new('latex-notemplate').convert_string(text)
+        DeplateString.new(text).to_latex
       end      
+
     end        
-    class DeplateText < Base
+
+    class DeplateText
+
       def filter(text)
-        ::Deplate::Converter.new('plain').convert_string(text)
+        DeplateString.new(text).to_text
       end      
+
     end            
+
   end
 end
-    
-Dokkit::Filters.register('deplate-html') { Dokkit::Filters::DeplateHTML.new  }
-Dokkit::Filters.register('deplate-latex') { Dokkit::Filters::DeplateLatex.new }
-Dokkit::Filters.register('deplate-text') { Dokkit::Filters::DeplateText.new }
+
 

data/lib/dokkit/filters/maruku.rb

@@ -6,18 +6,19 @@
 # (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
 #                                                                          
 
-require 'dokkit/filters/base'
-require 'dokkit/filters'
 require 'maruku'
 
 module Dokkit
-  module Filters
-    class MarukuHTML < Base
+  module Filter
+    
+    class MarukuHTML
+      
       def filter(text)
         Maruku.new(text).to_html
       end
+      
     end
+    
   end
 end
 
-Dokkit::Filters.register('maruku-html') { Dokkit::Filters::MarukuHTML.new }

data/lib/dokkit/filters/nil.rb

@@ -6,18 +6,19 @@
 # (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
 #                                                                          
 
-require 'dokkit/filters/base'
-require 'dokkit/filters'
-
 module Dokkit
-  module Filters
-    class Nil < Base
+  module Filter
+
+    class Nil
+
       def filter(text)
         text
       end
+
     end
+
   end
 end
 
-Dokkit::Filters.register('nil') { Dokkit::Filters::Nil.new }
+
 

data/lib/dokkit/filters.rb

@@ -1,34 +1,12 @@
 #                                                                          
-# File 'filters.rb' created on 18 feb 2008 at 14:25:19.                    
+# File 'filters.rb' created on 04 mag 2008 at 17:39:39.                    
 #
 # See 'dokkit.rb' or +LICENSE+ for licence information.                      
 #                                                                          
-# (C) 2006, 2007 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+# (C)2006-2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
 #                                                                          
 
-require 'dokkit'
-require 'dokkit/consolelog'
+require 'dokkit/filters/nil'
+require 'dokkit/filters/deplate'
+require 'dokkit/filters/maruku'
 
-module Dokkit
-  module Filters
-    @filters = { }
-    @logger = Log::ConsoleLog.consolelog
-    def Filters.register(name, &blk)
-      @filters[name] = blk
-    end
-    def Filters.[](name)
-      filter = @filters[name]
-      if filter
-        @filters[name].call
-      else
-        @logger.error("Filter '#{name}' is not defined!")
-      end
-    end
-    def Filters.filters
-      return @filters
-    end
-    def Filters.clean
-      @filters = { }
-    end
-  end
-end

data/lib/dokkit/hash.rb

@@ -0,0 +1,82 @@
+#                                                                          
+# File 'hash.rb' created on 17 mar 2008 at 09:37:25.                    
+#
+# See 'dokkit.rb' or +LICENSE+ for licence information.                      
+#                                                                          
+# (C) 2008 Andrea Fazzi <andrea.fazzi@alca.le.it> (and contributors). 
+#                                                                          
+
+class Symbol
+  def include_clear?
+    nil
+  end
+  def delete_clear
+    nil
+  end
+end
+
+class String
+  def include_clear?
+    self == 'clear'
+  end
+  def delete_clear
+    nil
+  end
+end
+
+class Array
+  def include_clear?
+    include?('clear')
+  end
+  def delete_clear
+    delete('clear')
+    self
+  end
+end
+
+class Hash
+  # Hash#recursive_merge merges two arbitrarily deep hashes into a single hash. 
+  # The hash is followed recursively, so that deeply nested hashes that are at 
+  # the same level will be merged when the parent hashes are merged.
+  def recursive_merge!(other_hash, &blk)
+    if block_given?
+      merge!(other_hash, &blk)
+    else
+      merge!(other_hash) do |key, value, other_value|
+        recursive_store(key, value, other_value)
+      end
+    end
+  end
+  # Non-destructive version of Hash#recursive_merge method.
+  def recursive_merge(other_hash, &blk)
+    dup.recursive_merge!(other_hash, &blk)
+  end
+  
+  private
+  
+  def merge_value(value, other_value, &blk)
+    unless other_value.include_clear?
+      yield value, other_value
+    else
+      value = other_value.delete_clear
+    end
+  end
+  
+  def recursive_store(key, value, other_value)
+    if(value.class == Hash && other_value.class == Hash)
+      value.recursive_merge other_value
+    elsif(value.class == String && other_value.class == String)
+      merge_value(value, other_value) { |v, ov| v = ov }
+    elsif(value.class == Symbol && other_value.class == String)
+      merge_value(value, other_value) { |v, ov| v = ov }
+    elsif(value.class == Array && other_value.class == Array)
+      merge_value(value, other_value) { |v, ov| v.concat ov }
+    elsif(value.class == String && other_value.class == Array)
+      merge_value(value, other_value) { |v, ov| v.to_a.concat ov }
+    elsif(value.class == Array && other_value.class == String)
+      merge_value(value, other_value) { value << other_value }
+    else
+      store(key, other_value)
+    end
+  end  
+end

data/lib/dokkit/{logger.rb → logging/logger.rb}

@@ -9,65 +9,71 @@
 #require 'dokkit'
 
 module Dokkit
-  module Log
-    ERROR = 0
-    WARNING = 1
-    INFO = 2
-    DEBUG = 3
-    class LogMessage
-      attr_reader :text
-      attr_reader :level
-      def initialize(text, level)
-        @text, @level = text, level
-      end
-    end
+  module Logging
+
+    # Define logger constants.
+    OFF, ERROR, WARNING, INFO, DEBUG = (-1..3).to_a
+
+    # Logger instance send log message to all its attached observers.
     class Logger
-      class << self
-        def logger
-          @logger ||= Logger.new
-        end
-        def clear
-          @logger = nil
-        end
-      end
+
       attr_reader :observers
       attr_reader :last_message
       attr_reader :level
+
       def initialize
         @observers = []
         @level = INFO
       end
+
+      # Set the logging level.
       def level=(new_level)
-        new_level = Log::DEBUG if new_level > Log::DEBUG
-        new_level = Log::ERROR if new_level < Log::ERROR
+        new_level = DEBUG if new_level > DEBUG
+        new_level = OFF if new_level < ERROR
         @level = new_level
       end
+
+      # Attach an observer to the logger instance.
       def attach(observer)
         (@observers << observer).last
       end
+
+      # Detach the observer from the logger instance.
       def detach(observer)
         @observers.delete(observer)
       end
+
+      # Notify log messages to all attached observers.
       def notify
         @observers.each { |observer| observer.update }
       end
+
       def message(message)
         @last_message = message
         notify
         @last_message
       end
+
+      # Send an info message to observers.
       def info(text)
-        message({ :text => text, :level => Log::INFO }) if level >= INFO
+        message({ :text => text, :level => INFO }) if level >= INFO
       end
+
+      # Send an error message to the observers.
       def error(text)
         message({ :text => text, :level => ERROR }) if level >= ERROR
       end
+
+      # Send a warning message to the observers.
       def warn(text)
         message({ :text => text, :level => WARNING }) if level >= WARNING
       end
+
+      # Send a debug message to the observers.
       def debug(text)
-        message({ :text => text, :level => Log::DEBUG }) if level >= DEBUG
+        message({ :text => text, :level => DEBUG }) if level >= DEBUG
       end      
+
     end
   end
 end