RubyGems - stic - Versions diffs - 0.1.0 - Mend

stic 0.1.0

Files changed (640) hide show

data/lib/stic/metadata/html_yaml.rb ADDED

@@ -0,0 +1,27 @@
+module Stic::Metadata
+  # The HtmlYaml front matter parses YAML meta data from
+  # an HTML comment at the beginning of a page:
+  #
+  # ```
+  # <!--
+  # title: An Example
+  # --><html>...
+  # ```
+  #
+  # ```
+  # <!-- title: An Example -->
+  # <html>...
+  # ```
+  #
+  class HtmlYaml < ::Stic::Metadata::Yaml
+    HTML_YAML_REGEXP = /\A<!--\s*(?<data>.*?\n?)(-->\s*(\n|$)|^-->\s*\n?)(?<content>.*)\z/m
+    def regexp
+      HTML_YAML_REGEXP
+    end
+  end
+  ::Stic::Metadata.parsers << HtmlYaml.new
+end

data/lib/stic/metadata/parser.rb ADDED

@@ -0,0 +1,21 @@
+module Stic::Metadata
+  # A Metadata::Parser can be used to parse metadata from
+  # a file blob. This class defines the required interface
+  # and can be used to derive specialized implementations.
+  #
+  class Parser
+    # Parse given string blob. Return [data, content] if
+    # blob parsing was successful or [nil, content]
+    # otherwise.
+    #
+    # First argument will be corresponding file blob object
+    # e.g. to check file extension if front matter is
+    # restricted to specific file format.
+    #
+    def parse(blob, str)
+      raise NotImplementedError.new "#{self.class.name}#parse must be implemented by subclass."
+    end
+  end
+end

data/lib/stic/metadata/yaml.rb ADDED

@@ -0,0 +1,52 @@
+require 'yaml'
+module Stic::Metadata
+  # The YAML front matter is parses YAML meta data embraced
+  # in three dashes from the beginning of a file.
+  #
+  # @example
+  #   ---
+  #   title: An Example
+  #   ---
+  #
+  class Yaml < ::Stic::Metadata::Parser
+    DASHED_YAML_REGEXP =
+      /\A(?<data>---?\s*\n.*?\n?)^(---\s*$\n?)(?<content>.*)\z/m
+    # Return Regexp to match YAML frontmatter and content.
+    # Must provide two named match groups named `data` and
+    # `content`.
+    def regexp
+      DASHED_YAML_REGEXP
+    end
+    def preprocess_data(blob, data)
+      data
+    end
+    def preprocess_content(blob, content)
+      content
+    end
+    def match(blob, str)
+      regexp.match(str)
+    end
+    def parse(blob, str)
+      if (match = match(blob, str))
+        begin
+          [
+            ::YAML.load(preprocess_data(blob, match[:data])),
+            preprocess_content(blob, match[:content])
+          ]
+        rescue Psych::SyntaxError => err
+          raise Stic::InvalidMetadata.new blob: blob
+        end
+      end
+    end
+  end
+  ::Stic::Metadata.parsers << Yaml.new
+end

data/lib/stic/page.rb ADDED

@@ -0,0 +1,34 @@
+module Stic
+  #
+  #
+  class Page < File
+    include ::Stic::Renderable
+    include ::Stic::Metadata
+    include ::Stic::Layoutable
+    def url_template
+      path.replace_extensions(target_extension).as_absolute
+    end
+    def target_extension
+      return data[:format] if data.key?(:format)
+      case path.extensions.first
+        when 'css', 'scss', 'sass', 'styl', 'less'
+          'css'
+        when 'js', 'coffeescript'
+          'js'
+        else
+          'html'
+      end
+    end
+    def default_layout
+      if target_extension == 'html'
+        super
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/stic/readable.rb ADDED

@@ -0,0 +1,103 @@
+module Stic
+  #
+  # = Stic::Readable
+  #
+  # Include this module for blobs that have a source file.
+  # It provides methods for reading and storing the source
+  # file.
+  #
+  module Readable
+    # @!group Attributes
+    # The full path to source file.
+    #
+    # @return [Path] Base path.
+    #
+    attr_reader :source
+    # The virtual path to this file including file name. This path
+    # represents the target in the generated output.
+    #
+    # The path will be used to derive the {#url_template}.
+    #
+    # @return [Path] File blob path.
+    #
+    attr_reader :path
+    # The blob file name. Will be used as file name in {#url_template} and
+    # therefor in {#relative_target_path} etc. The {#name} will be taken from
+    # {#path}'s file name if not specified in the constructor.
+    #
+    # @return [String] File blob name.
+    #
+    attr_reader :name
+    # @!group Construction
+    # Initialize new file blob object.
+    #
+    # @param opts [Hash] Initialization options.
+    # @option opts [#to_s] :source *Required* Full source path. See {#source}.
+    # @option opts [#to_s] :path   Output path.
+    #   Will use source path if not given. See {#path}.
+    # @option opts [String] :name  Optional blob file name. See {#name}.
+    #
+    def initialize(opts = {})
+      super
+      source = opts.delete(:source) { raise ::ArgumentError.new 'Argument `:source` required.' }
+      path   = opts.delete(:path)   { source }
+      @source = Path(source).expand
+      @path   = Path(path).as_relative
+      @name   = opts.delete(:name) || @path.name
+    end
+    # @!group Accessors
+    # Return full source path.
+    #
+    # @return [Path] (Absolute) source path.
+    #
+    def source_path
+      source
+    end
+    # Return final output as string.
+    #
+    # On file blob this will just returned the unchanged {#content}.
+    #
+    # @return [String] Blob output.
+    #
+    def render
+      content
+    end
+    # Return file content.
+    #
+    # This method caches file content and should be
+    # favored over {#read}.
+    #
+    # @return [String] Blob content.
+    #
+    def content
+      @content ||= read
+    end
+    # @!group Actions
+    # Read and return raw content.
+    #
+    # It directly read the content from file every time
+    # called and should be avoided in favor of {#content}.
+    #
+    # It can be overridden by subclasses implementing
+    # special input reading behavior.
+    #
+    # @return [String] Red content.
+    #
+    def read
+      source_path.read
+    end
+  end
+end

data/lib/stic/renderable.rb ADDED

@@ -0,0 +1,40 @@
+module Stic
+  #
+  # Provide functionality to render content using
+  # Tilt with multiple engines.
+  #
+  module Renderable
+    #
+    # Return rendered content.
+    #
+    def render(opts = {})
+      render_content locals
+    end
+    # Render blob content without layout.
+    #
+    def render_content(locals, &block)
+      renderer.render(locals.merge(data: data), &block)
+    end
+    def renderer
+      @renderer ||= begin
+        Renderer.new(self)
+      end
+    end
+    # Return the file name for rendering. Should include all
+    # file extensions to determine the template engines.
+    #
+    def render_name
+      name
+    end
+    # Return variables that should be available as locals
+    # in render context.
+    #
+    def locals
+      {site: site}
+    end
+  end
+end

data/lib/stic/renderer.rb ADDED

@@ -0,0 +1,31 @@
+module Stic
+  class Renderer
+    attr_reader :blob, :path, :name
+    def initialize(blob)
+      @blob = blob
+      @path = blob.source_path
+    end
+    def render(locals, &block)
+      engines = Tilt.templates_for(path.basename)
+      engines.reduce(blob.content) do |content, engine|
+        engine.new(path){ content.to_s }.render(Environment, locals, &block)
+      end.html_safe
+    end
+    # A module to include additional rendering helper functions.
+    #
+    # @example
+    #   module MyHelpers
+    #     def help
+    #       "Help here!"
+    #     end
+    #   end
+    #   Stic::Renderer::Environment.extend MyHelpers
+    #
+    module Environment
+    end
+  end
+end

data/lib/stic/site.rb ADDED

@@ -0,0 +1,174 @@
+module Stic
+  # The {Site} is the main class representing the hole site project.
+  #
+  # It contains the configuration, source and target paths and provides
+  # all functionality to invoke {Generator}s, manage and access {Blob}s and
+  # write the rendered site project.
+  #
+  # @example
+  #   site = ::Stic::Site.lookup
+  #   site.run
+  #   site.write
+  #
+  class Site
+    # @!group Attributes
+    # The project's source path.
+    #
+    # @return [Path] The source path.
+    #
+    attr_reader :source
+    # The project's target path.
+    #
+    # @return [Path] The target path.
+    #
+    attr_reader :target
+    # The project's configuration object. Will be initialized with the values
+    # loaded from configuration file found in project's source directory.
+    #
+    # @return [Config] The project configuration.
+    #
+    attr_reader :config
+    # The list of initialized {Generator}s. They will be initialized within
+    # the {#initialize} method.
+    #
+    # @return [Array<Generator>] Initialized {Generator} instances.
+    #
+    attr_reader :generators
+    # @!group Construction
+    # Initializes new {Site} object.
+    #
+    # @param source [String, Path] The source directory where the rendered site
+    #   should be written to.
+    # @param config [Config] The configuration that should be used. Usually
+    #   loaded from configuration file located in the source directory.
+    #
+    def initialize(source, config)
+      @config  = config
+      @source  = Path.new source
+      @target  = Path.new(source).join('site').expand
+      @blobs   = []
+      @layouts = []
+      @generators = self.class.generators.map do |generator_class|
+        generator_class.new self, config['generators']
+      end
+    end
+    # @!group Accessors
+    # Get layout with given name.
+    #
+    def layout(name)
+      @layouts.fetch(name)
+    end
+    # Return list of {Blob}s.
+    #
+    # You can pass a class as `:type` option that will be used to filter the
+    # returned {Blob}s by Inheritance. Only {Blob}s of given class or {Blob}s
+    # that inherit given class will be returned.
+    #
+    # @param opts [Hash] Option hash.
+    # @option opts [Class] :type Class used as a filter.
+    #
+    def blobs(opts = {})
+      return @blobs if opts[:type].nil?
+      @blobs.select{|blob| blob.class <= opts[:type] }
+    end
+    # @!group Actions
+    # Run all registered and initialized {Generator}s.
+    #
+    # A block can be passed that will be called before each {Generator} is run.
+    #
+    # @yield [generator] Called before given {Generator} will be run.
+    # @yieldparam generator [Generator] {Generator} to be run next.
+    #
+    # @return [Self]
+    #
+    def run(&block)
+      @layouts = Layout.load(self, @source, @config)
+      generators.each do |generator|
+        block.call generator if block
+        generator.run
+      end
+      self
+    end
+    # Write all added {Blob}s to their destination.
+    #
+    # A block can be passed that will be called before each {Blob} is written.
+    #
+    # @yield [blob] Called before given {Blob} will be written.
+    # @yieldparam blob [Blob] {Blob} that will be written next.
+    #
+    # @return [Self]
+    #
+    def write(&block)
+      blobs.each do |blob|
+        block.call blob if block
+        blob.write
+      end
+      self
+    end
+    # Cleanup target directory. That will remove all files and directories
+    # not referenced by any {Blob}.
+    #
+    # @return [Self]
+    #
+    def cleanup
+      paths = blobs.map(&:target_path)
+      # Cleanup not longer referenced files
+      target.glob('**/*').each do |path|
+        if path.file? && !paths.include?(path)
+          path.unlink
+        elsif path.directory? && !paths.any?{|p| p.path.starts_with? path.to_s }
+          path.rm_rf
+        end
+      end
+      self
+    end
+    # Add new {Blob} to site.
+    #
+    # You should not add {Blob}s with same `target_url` or
+    # `relative_target_path` as they later would override the previous file.
+    #
+    # @param blob [Blob] {Blob} to add.
+    #
+    def <<(blob)
+      blobs << blob
+    end
+    class << self
+      # Try to find a stic site in given directory or above.
+      # If no directory is given the current working
+      # directory will be used.
+      #
+      def lookup(dir = Path.getwd)
+        file = Path.new(dir).lookup(/^stic.ya?ml$/)
+        file ? new(file.dirname, Stic::Config.load(file)) : nil
+      end
+      # Return list of available generator classes.
+      def generators
+        @generators ||= []
+      end
+    end
+  end
+end