RubyGems - stic - Versions diffs - 0.1.0 - Mend

stic 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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