rake-pipeline-fork 0.8.0

data/lib/rake-pipeline/filters/concat_filter.rb

@@ -0,0 +1,63 @@
+module Rake
+  class Pipeline
+    # A built-in filter that simply accepts a series
+    # of inputs and concatenates them into output files
+    # based on the output file name generator.
+    #
+    # @example
+    #   !!!ruby
+    #   Pipeline.build do
+    #     input "app/assets", "**/*.js"
+    #     output "public"
+    #
+    #     # create a concatenated output file for each
+    #     # directory of inputs.
+    #     filter(Rake::Pipeline::ConcatFilter) do |input|
+    #       # input files will look something like:
+    #       #   javascripts/admin/main.js
+    #       #   javascripts/admin/app.js
+    #       #   javascripts/users/main.js
+    #       #
+    #       # and the outputs will look like:
+    #       #   javascripts/admin.js
+    #       #   javascripts/users.js
+    #       directory = File.dirname(input)
+    #       ext = File.extname(input)
+    #
+    #       "#{directory}#{ext}"
+    #     end
+    #   end
+    class ConcatFilter < Rake::Pipeline::Filter
+      # @param [String] string the name of the output file to
+      #   concatenate inputs to.
+      # @param [Proc] block a block to use as the Filter's
+      #   {#output_name_generator}.
+      def initialize(string=nil, &block)
+        block = proc { string } if string
+        super(&block)
+      end
+
+      # @method encoding
+      # @return [String] the String +"BINARY"+
+      processes_binary_files
+
+      # implement the {#generate_output} method required by
+      # the {Filter} API. In this case, simply loop through
+      # the inputs and write their contents to the output.
+      #
+      # Recall that this method will be called once for each
+      # unique output file.
+      #
+      # @param [Array<FileWrapper>] inputs an Array of
+      #   {FileWrapper} objects representing the inputs to
+      #   this filter.
+      # @param [FileWrapper] a single {FileWrapper} object
+      #   representing the output.
+      def generate_output(inputs, output)
+        inputs.each do |input|
+          output.write input.read
+        end
+      end
+    end
+  end
+end

data/lib/rake-pipeline/filters/gsub_filter.rb

@@ -0,0 +1,56 @@
+module Rake
+  class Pipeline
+    # A built in filter that applies String#gsub behavior.
+    #
+    # @example
+    #   !!!ruby
+    #   Pipeline.build do
+    #     input "app/assets", "**/*.js"
+    #     output "public"
+    #
+    #     # replace javascript comments
+    #     filter(Rake::Pipeline::GsubFilter, /\//\w+$/, '')
+    #   end
+    class GsubFilter < Filter
+      # Arguments mimic String#gsub with one notable exception. 
+      # String#gsub accepts a block where $1, $2, and friends are
+      # accessible. Due to Ruby's scoping rules of these variables
+      # they are not accssible inside the block itself. Instead they
+      # are passed in as additional arguments. Here's an example:
+      #
+      # @example
+      #   !!!ruby
+      #   Rake::Pipeline::GsubFilter.new /(\w+)\s(\w+)/ do |entire_match, capture1, capture2|
+      #     # process the match
+      #   end
+      #
+      # @see String#gsub
+      def initialize(*args, &block)
+        @args, @block = args, block
+        super() { |input| input }
+      end
+
+      # Implement the {#generate_output} method required by
+      # the {Filter} API. In this case, simply loop through
+      # the inputs and write String#gsub content to the output.
+      #
+      # @param [Array<FileWrapper>] inputs an Array of
+      #   {FileWrapper} objects representing the inputs to
+      #   this filter.
+      # @param [FileWrapper] a single {FileWrapper} object
+      #   representing the output.
+      def generate_output(inputs, output)
+        inputs.each do |input|
+          if @block
+            content = input.read.gsub(*@args) do |match|
+              @block.call match, *$~.captures
+            end
+            output.write content
+          else
+            output.write input.read.gsub(*@args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rake-pipeline/filters/ordering_concat_filter.rb

@@ -0,0 +1,38 @@
+class Rake::Pipeline
+  # A filter that concats files in a specified order.
+  #
+  # @example
+  #   !!!ruby
+  #   Rake::Pipeline.build do
+  #     input "app/assets", "**/*.js"
+  #     output "public"
+  #
+  #     # Concat each file into libs.js but make sure
+  #     # that jQuery and Ember come first.
+  #     filter Rake::Pipeline::OrderingConcatFilter, ["jquery.js", "ember.js"], "libs.js"
+  #   end
+  class OrderingConcatFilter < ConcatFilter
+
+    # @param [Array<String>] ordering an Array of Strings
+    #   of file names that should come in the specified order
+    # @param [String] string the name of the output file to
+    #   concatenate inputs to.
+    # @param [Proc] block a block to use as the Filter's
+    #   {#output_name_generator}.
+    def initialize(ordering, string=nil, &block)
+      @ordering = ordering
+      super(string, &block)
+    end
+
+    # Extend the {#generate_output} method supplied by {ConcatFilter}.
+    # Re-orders the inputs such that the specified files come first.
+    # If a file is not in the list it will come after the specified files.
+    def generate_output(inputs, output)
+      @ordering.reverse.each do |name|
+        file = inputs.find{|i| i.path == name }
+        inputs.unshift(inputs.delete(file)) if file
+      end
+      super
+    end
+  end
+end

data/lib/rake-pipeline/filters/pipeline_finalizing_filter.rb

@@ -0,0 +1,21 @@
+require 'set'
+module Rake
+  class Pipeline
+    # @private
+    #
+    # A built-in filter that copies a pipeline's generated files over
+    # to its output.
+    class PipelineFinalizingFilter < ConcatFilter
+
+      # @return [Array[FileWrapper]] a list of the pipeline's
+      # output files, excluding any files that were originally
+      # inputs to the pipeline, meaning they weren't processed
+      # by any filter and should not be copied to the output.
+      def input_files
+        pipeline_input_files = Set.new pipeline.input_files
+
+        Set.new(super) - pipeline_input_files
+      end
+    end
+  end
+end

data/lib/rake-pipeline/graph.rb

@@ -0,0 +1,178 @@
+require "set"
+
+module Rake
+  class Pipeline
+    # The goal of this class is to make is easy to implement dynamic
+    # dependencies in additional_dependencies without having to parse
+    # all the files all of the time.
+    #
+    # To illustrate, imagine that we have two source files with the
+    # following inline dependencies:
+    #
+    # * application.scss
+    #   * _core.scss
+    # * admin.scss
+    #   * _admin.scss
+    #
+    # And further imagine that `_admin.scss` has an inline dependency
+    # on `_core.scss`.
+    #
+    # On initial build, we will scan all of the source files, find
+    # the dependencies, and build a node for each file, annotating
+    # the source files with `:source => true`. We also store off the
+    # `mtime` of each file in its node. We link each file to its
+    # dependencies.
+    #
+    # The `additional_dependencies` are a map of the files to their
+    # children, which will be used when generating rake tasks.
+    #
+    # Later, let's say that we change `_admin.scss`. We will need
+    # to unlink its dependencies first (on `_core.scss`), rescan
+    # the file, and create nodes for its dependencies. If no new
+    # dependencies
+
+    class Graph
+      class MissingNode < StandardError
+      end
+
+      class Node
+        # @return [String] the identifier of the node
+        attr_reader :name
+
+        # @return [Set] a Set of parent nodes
+        attr_reader :parents
+
+        # @return [Set] a Set of child nodes
+        attr_reader :children
+
+        # @return [Hash] a Hash of metadata
+        attr_reader :metadata
+
+        # @param [String] name the identifier of the node
+        # @param [Hash] metadata an optional hash of metadata
+        def initialize(name, metadata={})
+          @name = name
+          @parents = Set.new
+          @children = Set.new
+          @metadata = metadata
+        end
+
+        # A node is equal another node if it has the same name.
+        # This is because the Graph ensures that only one node
+        # with a given name can be created.
+        #
+        # @param [Node] other the node to compare
+        def ==(other)
+          @name == other.name
+        end
+      end
+
+      def initialize
+        @map = {}
+      end
+
+      # @return [Array] an Array of all of the nodes in the graph
+      def nodes
+        @map.values
+      end
+
+      # Add a new node to the graph. If an existing node with the
+      # current name already exists, do not add the node.
+      #
+      # @param [String] name an identifier for the node.
+      # @param [Hash] metadata optional metadata for the node
+      def add(name, metadata={})
+        return if @map.include?(name)
+        @map[name] = Node.new(name, metadata)
+      end
+
+      # Remove a node from the graph. Unlink its parent and children
+      # from it.
+      #
+      # If the existing node does not exist, raise.
+      #
+      # @param [String] name an identifier for the node
+      def remove(name)
+        node = verify(name)
+
+        node.parents.each do |parent_node|
+          parent_node.children.delete node
+        end
+
+        node.children.each do |child_node|
+          child_node.parents.delete node
+        end
+
+        @map.delete(name)
+      end
+
+      # Add a link from the parent to the child. This link is a
+      # two-way link, so the child will be added to the parent's
+      # `children` and the parent will be added to the child's
+      # `parents`.
+      #
+      # The parent and child are referenced by node identifier.
+      #
+      # @param [String] parent the identifier of the parent
+      # @param [String] child the identifier of the child
+      def link(parent, child)
+        parent, child = lookup(parent, child)
+
+        parent.children << child
+        child.parents << parent
+      end
+
+      # Remove a link from the parent to the child.
+      #
+      # The parent and child are referenced by node identifier.
+      #
+      # @param [String] parent the identifier of the parent
+      # @param [String] child the identifier of the child
+      def unlink(parent, child)
+        parent, child = lookup(parent, child)
+
+        parent.children.delete(child)
+        child.parents.delete(parent)
+      end
+
+      # Look up a node by name
+      #
+      # @param [String] name the identifier of the node
+      # @return [Node] the node referenced by the specified identifier
+      def [](name)
+        @map[name]
+      end
+
+    private
+      # Verify that the parent and child nodes exist, and return
+      # the nodes with the specified identifiers.
+      #
+      # The parent and child are referenced by node identifier.
+      #
+      # @param [String] parent the identifier of the parent
+      # @param [String] child the identifier of the child
+      # @return [Array(Node, Node)] the parent and child nodes
+      def lookup(parent, child)
+        parent = verify(parent)
+        child = verify(child)
+
+        return parent, child
+      end
+
+      # Verify that a node with a given identifier exists, and
+      # if it does, return it.
+      #
+      # If it does not, raise an exception.
+      #
+      # @param [String] name the identifier of the node
+      # @raise [MissingNode] if a node with the given name is
+      #   not found, raise.
+      # @return [Node] the n
+      def verify(name)
+        node = @map[name]
+        raise MissingNode, "Node #{name} does not exist" unless node
+        node
+      end
+    end
+  end
+end

data/lib/rake-pipeline/manifest.rb

@@ -0,0 +1,86 @@
+require 'json'
+
+module Rake
+  class Pipeline
+    # A Manifest is a container for storing dynamic dependency information.
+    # A {DynamicFileTask} will use a {Manifest} to keep track of its dynamic
+    # dependencies. This allows us to avoid scanning a file for dynamic
+    # dependencies if its contents have not changed.
+    class Manifest
+      attr_accessor :entries
+      attr_accessor :manifest_file
+
+      def initialize(manifest_file="manifest.json")
+        @manifest_file ||= manifest_file
+        @entries = {}
+      end
+
+      # Get the manifest off the file system, if it exists.
+      def read_manifest
+        @entries = File.file?(manifest_file) ? JSON.parse(File.read(manifest_file)) : {}
+
+        # convert the manifest JSON into a Hash of ManifestEntry objects
+        @entries.each do |file, raw|
+          @entries[file] = Rake::Pipeline::ManifestEntry.from_hash(raw)
+        end
+
+        self
+      end
+
+      # Write a JSON representation of this manifest out to disk if we
+      # have entries to save.
+      def write_manifest
+        unless @entries.empty?
+          File.open(manifest_file, "w") do |file|
+            file.puts JSON.generate(as_json)
+          end
+        end
+      end
+
+      # Convert this Manifest into a hash suitable for converting to
+      # JSON.
+      def as_json
+        hash = {}
+
+        @entries.each do |name, entry|
+          hash[name] = entry.as_json
+        end
+
+        hash
+      end
+
+      # Look up an entry by filename.
+      def [](key)
+        @entries[key]
+      end
+
+      # Set an entry
+      def []=(key, value)
+        @entries[key] = value
+      end
+
+      def clear
+        entries.clear
+      end
+
+      def empty?
+        entries.empty?
+      end
+
+      def files
+        entries.inject({}) do |hash, pair| 
+          file = pair.first
+          entry = pair.last
+
+          hash.merge!(file => entry.mtime)
+
+          entry.deps.each_pair do |name, time| 
+            hash.merge!(name => time)
+          end
+
+          hash
+        end
+      end
+    end
+  end
+end