stic 0.1.0

data/lib/stic/config.rb

@@ -0,0 +1,26 @@
+module Stic
+
+  #
+  #
+  class Config
+    attr_reader :options, :files
+    delegate :[], to: :@options
+
+    def initialize(options = {})
+      @options = options
+      @files   = []
+    end
+
+    def load(file)
+      data = ::YAML.load(file.read) if file.exist?
+      options.deep_merge(data) if data.is_a?(Hash)
+      files << file
+    end
+
+    class << self
+      def load(file)
+        new.tap{|c| c.load file }
+      end
+    end
+  end
+end

data/lib/stic/errors.rb

@@ -0,0 +1,27 @@
+module Stic
+  class Error < StandardError
+    attr_reader :cause
+
+    def initialize(opts = {})
+      @cause = opts.fetch :cause, $!
+
+      super opts.fetch(:message) { self.message }
+    end
+  end
+
+  class BlobError < Error
+    attr_reader :blob
+
+    def initialize(opts = {})
+      @blob = opts.fetch :blob, nil
+
+      super opts
+    end
+  end
+
+  class InvalidMetadata < BlobError
+    def message
+      "Invalid metadata in #{blob.to_s}: (#{cause.class}) #{cause.message}"
+    end
+  end
+end

data/lib/stic/file.rb

@@ -0,0 +1,31 @@
+module Stic
+
+  # Represent an output blob containing data from a
+  # single source file.
+  #
+  # Subclasses can override the `render` method to
+  # implement processing logic.
+  #
+  class File < Blob
+    include Readable
+
+    # Return site relative URL.
+    #
+    # File blobs do not have a variable URL template by default so the
+    # {#url_template} is equal the {#relative_url} and consists of the blob
+    # {#path} and the blob file {#name}.
+    #
+    # As subclasses can override {#url_template} with custom behavior the file
+    # blob class does not override the placeholder replacement login in
+    # {#relative_url} but {#url_template} that returns a URL without
+    # placeholders.
+    #
+    # @return [Path] Relative blob URL.
+    #
+    # @see Blob#url_template
+    #
+    def url_template
+      path.dirname.join(name).as_absolute
+    end
+  end
+end

data/lib/stic/generator.rb

@@ -0,0 +1,92 @@
+module Stic
+
+  # A Generator generates blobs or specific subclasses based on some input.
+  #
+  # As an example see {Stic::Generators::Static} that generates blobs for
+  # static files.
+  #
+  # A generator will be initialized by the system and it's
+  # {#run} method will be invoked. The generator now can add
+  # blobs to the `site`. Subclass must override the {#run}
+  # method providing custom logic.
+  #
+  class Generator
+
+    # @!group Attributes
+
+    # The {Site} object.
+    #
+    # @return [Site] {Site} object.
+    #
+    attr_reader :site
+
+    # The generator specific configuration.
+    # The values are passed from {Site} and are loaded from
+    # `generators.<generator name>`.
+    #
+    # @return [HashWithIndifferentAccess] Option hash.
+    #
+    attr_reader :config
+
+    # @!group Construction
+
+    # Initialize new {Generator}.
+    #
+    # @param site [Site] {Site} object.
+    # @param config [Hash] Hash object containing options for all generators.
+    #   The generator picks it own options from the passed hash based on the
+    #   generator's {#name}.
+    #
+    def initialize(site, config)
+      @site   = site
+      @config = ::ActiveSupport::HashWithIndifferentAccess.new((config && config[name]) || {})
+    end
+
+    # @!group Accessors
+
+    # Return generator name. The name is derived from the class name as an
+    # underscore string with `_generator` striped from the end.
+    #
+    # @return [String] Generator name.
+    #
+    def name
+      self.class.name.underscore.gsub(/_generator$/, '')
+    end
+
+    # Check if generator is disabled.
+    #
+    # A generator can be disabled by setting the generator's `disable`
+    # configuration key to either 'true' or 'yes'.
+    #
+    # @return [Boolean] True unless generator is disabled.
+    #
+    def disabled?
+      %w(true yes).includes? config['disable'].to_s
+    end
+
+    # @!group Actions
+
+    # Run this {Generator}. This is the place to implement custom logic and
+    # add {Blob}s to the site.
+    #
+    # The {#run} method must be implemented by a subclass.
+    #
+    def run
+      raise NotImplementedError.new "#{self.class.name}#run not implemented."
+    end
+
+    protected
+
+    # Log a message to the site generation log. The message will be prefixed
+    # with the generator name. The message must be passed as a block that
+    # will be yielded when logging is enabled, has the required log level
+    # or is otherwise not disabled globally or for this generator.
+    #
+    # @yield Block to retrieve log message.
+    #
+    def log_msg(&block)
+      # TODO
+      # noop
+    end
+  end
+end

data/lib/stic/generators/page.rb

@@ -0,0 +1,28 @@
+module Stic::Generators
+
+  # The page generators adds page blobs for each page from
+  # define directory. Pages are printable content that
+  # may have a front matter and can be converted to HTML.
+  #
+  # The source path for pages will be taken from
+  # generator config key `path` and defaults to `./pages`.
+  #
+  # You can override the path in your site configuration:
+  #
+  #     generators:
+  #       pages:
+  #         path: ./custom_pages
+  #
+  class Page < ::Stic::Generators::Static
+
+    def path_default
+      'content'
+    end
+
+    def blob_class
+      ::Stic::Page
+    end
+  end
+
+  ::Stic::Site.generators << Page
+end

data/lib/stic/generators/static.rb

@@ -0,0 +1,45 @@
+module Stic::Generators
+
+  # The static generators adds file blobs for each static
+  # file to the generated output.
+  #
+  # The source path for static files will be taken from
+  # generator config key `path` and defaults to `./files`.
+  #
+  # You can override the path in your site configuration:
+  #
+  #     generators:
+  #       static:
+  #         path: ./custom_files
+  #
+  class Static < ::Stic::Generator
+
+    def path_default
+      'files'
+    end
+
+    def path
+      @path ||= config[:path] || path_default
+    end
+
+    def full_path
+      @full_path ||= site.source.join(path)
+    end
+
+    def blob_class
+      ::Stic::File
+    end
+
+    def run
+      full_path.glob('**/*').each do |source|
+        next unless source.file?
+
+        path = source.relative_from(full_path)
+
+        site << blob_class.new(site: site, source: source, path: path)
+      end
+    end
+  end
+
+  ::Stic::Site.generators << Static
+end

data/lib/stic/layout.rb

@@ -0,0 +1,57 @@
+module Stic
+  #
+  # = Stic::Layout
+  #
+  # A {Layout} allows to wrap a blob into a layout. The
+  # rendered layout itself my be wrapped into another
+  # layout.
+  #
+  class Layout
+    include SiteBase
+    include Readable
+    include Renderable
+    include Metadata
+
+    def render(blob, &block)
+      locals = blob.locals.merge(data: data)
+
+      if layout
+        layout.render(blob) { render_content(locals, &block) }
+      else
+        render_content locals, &block
+      end
+    end
+
+    def layout
+      @layout ||= layout_name.blank? ? nil : site.layout(layout_name)
+    end
+
+    # Return name of layout this layout should be wrapped in.
+    #
+    def layout_name
+      data[:layout]
+    end
+
+    def render_name
+      @path.basename
+    end
+
+    def to_s
+      "#<#{self.class.name}:#{object_id} #{source_path}>"
+    end
+
+    class << self
+      def load(site, source, config)
+        layouts = {}
+
+        source.join(config['layouts'] || 'layouts').glob('*').each do |path|
+          next unless path.file?
+
+          layouts[path.pure_name] = new site: site, source: path
+        end
+
+        layouts
+      end
+    end
+  end
+end

data/lib/stic/layoutable.rb

@@ -0,0 +1,28 @@
+module Stic
+
+  # Provide functionality to wrap the rendered output
+  # in a layout.
+  #
+  module Layoutable
+
+    def render(opts = {})
+      if layout && (opts[:layout].nil? || opts[:layout])
+        layout.render(self) { render(layout: false) }
+      else
+        super
+      end
+    end
+
+    def layout
+      @layout ||= layout_name.blank? ? nil : site.layout(layout_name)
+    end
+
+    def layout_name
+      @layout_name ||= data['layout'] || default_layout
+    end
+
+    def default_layout
+      'default'
+    end
+  end
+end

data/lib/stic/metadata.rb

@@ -0,0 +1,35 @@
+module Stic
+
+  # A metadata front matter is data blob usual at the
+  # beginning of a file. It contains additional meta
+  # information that can be used when rendering the file
+  # or by additional generators etc.
+  #
+  module Metadata
+    def initialize(*)
+      super
+      load_metadata
+    end
+
+    private
+
+    def load_metadata
+      data, @content = ::Stic::Metadata.parse(self, read)
+      @data.merge! data if data.is_a?(Hash)
+    end
+
+    class << self
+      def parsers
+        @parsers ||= []
+      end
+
+      def parse(file, blob)
+        parsers.each do |parser|
+          metadata, content = parser.parse(file, blob)
+          return [metadata, content] if metadata
+        end
+        [nil, blob]
+      end
+    end
+  end
+end

data/lib/stic/metadata/block_comment_yaml.rb

@@ -0,0 +1,34 @@
+module Stic::Metadata
+
+  # The BlockCommentYaml front matter parses YAML meta data
+  # from an block comment at the beginning of a page.
+  #
+  # @example
+  #   /**
+  #    * title: An Example
+  #    */
+  #
+  # @example
+  #   /*
+  #   title: An Example
+  #   */
+  #
+  # @example
+  #   /* title: An Example */
+  #
+  class BlockCommentYaml < ::Stic::Metadata::Yaml
+
+    BLOCK_COMMENT_YAML_REGEXP = \
+      %r{\A/\**\s*(?<data>.*?\n?)(\s*\*/\s*(\n|$)|^\s*\*/)(?<content>.*)\z}m
+
+    def regexp
+      BLOCK_COMMENT_YAML_REGEXP
+    end
+
+    def preprocess_data(blob, data)
+      data.gsub(/^\s*\*/, "\n")
+    end
+  end
+
+  ::Stic::Metadata.parsers << BlockCommentYaml.new
+end

data/lib/stic/metadata/comment_yaml.rb

@@ -0,0 +1,43 @@
+module Stic::Metadata
+
+  # The CommentYaml front matter parses YAML meta data from
+  # an line comment at the beginning of a page:
+  #
+  # @example Backslash style comments
+  #   // title: An Example
+  #   // author: John
+  #
+  # @example Hash style comments
+  #   # title: An Example
+  #   # author: John
+  #
+  class CommentYaml < ::Stic::Metadata::Yaml
+
+    def match(blob, str)
+      if (m = %r{\A(\s*(//|#)\s*)(.+:.+)}.match(str))
+        sep = m[1]
+        case sep.strip
+          when '#'
+            return nil if %w(md markdown).include? blob.path.ext
+        end
+
+        scan_data str, sep
+      end
+    end
+
+    def scan_data(str, sep)
+      data, content = [], []
+      str.each_line do |line|
+        if !line.starts_with?(sep) .. false
+          content << line
+        else
+          data << line[sep.length..-1]
+        end
+      end
+
+      {data: data.join("\n"), content: content.join("\n")}
+    end
+  end
+
+  ::Stic::Metadata.parsers << CommentYaml.new
+end