rake-pipeline 0.5.0 → 0.7.0

data/lib/rake-pipeline/cli.rb

@@ -0,0 +1,56 @@
+require "thor"
+
+module Rake
+  class Pipeline
+    class CLI < Thor
+      class_option :assetfile, :default => "Assetfile", :aliases => "-c"
+      default_task :build
+
+      desc "build", "Build the project."
+      method_option :pretend, :type => :boolean, :aliases => "-p"
+      method_option :clean, :type => :boolean, :aliases => "-C"
+      def build
+        if options[:pretend]
+          project.output_files.each do |file|
+            say_status :create, relative_path(file)
+          end
+        else
+          options[:clean] ? project.clean : project.cleanup_tmpdir
+          project.invoke
+        end
+      end
+
+      desc "clean", "Remove the pipeline's temporary and output files."
+      method_option :pretend, :type => :boolean, :aliases => "-p"
+      def clean
+        if options[:pretend]
+          project.files_to_clean.each do |file|
+            say_status :remove, relative_path(file)
+          end
+        else
+          project.clean
+        end
+      end
+
+      desc "server", "Run the Rake::Pipeline preview server."
+      def server
+        require "rake-pipeline/server"
+        Rake::Pipeline::Server.new.start
+      end
+
+    private
+      def project
+        @project ||= Rake::Pipeline::Project.new(options[:assetfile])
+      end
+
+      # @param [FileWrapper|String] path
+      # @return [String] The path to the file with the current
+      #   directory stripped out.
+      def relative_path(path)
+        pathstr = path.respond_to?(:fullpath) ? path.fullpath : path
+        pathstr.sub(%r|#{Dir.pwd}/|, '')
+      end
+    end
+  end
+end
+

data/lib/rake-pipeline/dsl.rb

@@ -1,146 +1,9 @@
 module Rake
   class Pipeline
-    # This class exists purely to provide a convenient DSL for
-    # configuring a pipeline.
-    #
-    # All instance methods of {DSL} are available in the context
-    # the block passed to +Rake::Pipeline.+{Pipeline.build}.
-    #
-    # When configuring a pipeline, you *must* provide both a
-    # root, and a series of files using {#input}.
-    class DSL
-      # @return [Pipeline] the pipeline the DSL should configure
-      attr_reader :pipeline
-
-      # Configure a pipeline with a passed in block.
-      #
-      # @param [Pipeline] pipeline the pipeline that the DSL
-      #   should configure.
-      # @param [Proc] block the block describing the
-      #   configuration. This block will be evaluated in
-      #   the context of a new instance of {DSL}
-      # @return [void]
-      def self.evaluate(pipeline, &block)
-        new(pipeline).instance_eval(&block)
-        copy_filter = Rake::Pipeline::ConcatFilter.new
-        copy_filter.output_name_generator = proc { |input| input }
-        pipeline.add_filter(copy_filter)
-      end
-
-      # Create a new {DSL} to configure a pipeline.
-      #
-      # @param [Pipeline] pipeline the pipeline that the DSL
-      #   should configure.
-      # @return [void]
-      def initialize(pipeline)
-        @pipeline = pipeline
-      end
-
-      # Define the input location and files for the pipeline.
-      #
-      # @example
-      #   !!!ruby
-      #   Rake::Pipeline.build do
-      #     input "app/assets", "**/*.js"
-      #     # ...
-      #   end
-      #
-      # @param [String] root the root path where the pipeline
-      #   should find its input files.
-      # @param [String] glob a file pattern that represents
-      #   the list of all files that the pipeline should
-      #   process. The default is +"**/*"+.
-      # @return [void]
-      def input(root, glob="**/*")
-        pipeline.input_root = root
-        pipeline.input_glob = glob
-      end
-
-      # Add a filter to the pipeline.
-      #
-      # In addition to a filter class, {#filter} takes a
-      # block that describes how the filter should map
-      # input files to output files.
-      #
-      # By default, the block maps an input file into
-      # an output file with the same name.
-      #
-      # Any additional arguments passed to {#filter} will
-      # be passed on to the filter class's constructor.
-      #
-      # @see Filter#outputs Filter#output (for an example
-      #   of how a list of input files gets mapped to
-      #   its outputs)
-      #
-      # @param [Class] filter_class the class of the filter.
-      # @param [Array] ctor_args a list of arguments to pass
-      #   to the filter's constructor.
-      # @param [Proc] block an output file name generator.
-      # @return [void]
-      def filter(filter_class, *ctor_args, &block)
-        filter = filter_class.new(*ctor_args, &block)
-        pipeline.add_filter(filter)
-      end
-
-      # Apply a number of filters, but only to files matching
-      # a particular pattern.
-      #
-      # Inside the block passed to {#match match}, you may
-      # specify any number of filters that should be applied
-      # to files matching the pattern.
-      #
-      # @param [String] pattern a glob pattern to match
-      # @param [Proc] block a block that supplies filters
-      # @return [Matcher]
-      #
-      # @example
-      #   !!!ruby
-      #   Pipeline.build do
-      #     input "app/assets"
-      #     output "public"
-      #
-      #     # compile coffee files into JS files
-      #     match "*.coffee" do
-      #       filter CompileCoffee do |input|
-      #         input.sub(/coffee$/, "js")
-      #       end
-      #     end
-      #
-      #     # because the previous step converted coffeee
-      #     # into JS, the coffee files will be included here
-      #     match "*.js" do
-      #       filter MinifyFilter
-      #       filter Rake::Pipeline::ConcatFilter, "application.js"
-      #     end
-      #   end
-      def match(pattern, &block)
-        matcher = pipeline.copy(Matcher, &block)
-        matcher.glob = pattern
-        pipeline.add_filter matcher
-        matcher
-      end
-
-      # Specify the output directory for the pipeline.
-      #
-      # @param [String] root the output directory.
-      # @return [void]
-      def output(root)
-        pipeline.output_root = root
-      end
-
-      # Specify the location of the temporary directory.
-      # Filters will store intermediate build artifacts
-      # here.
-      #
-      # This defaults "tmp" in the current working directory.
-      #
-      # @param [String] root the temporary directory
-      # @return [void]
-      def tmpdir(root)
-        pipeline.tmpdir = root
-      end
+    module DSL
     end
   end
 end
 
-
+require 'rake-pipeline/dsl/pipeline_dsl'
+require 'rake-pipeline/dsl/project_dsl'

data/lib/rake-pipeline/dsl/pipeline_dsl.rb

@@ -0,0 +1,168 @@
+module Rake
+  class Pipeline
+    module DSL
+      # This class is used by {ProjectDSL} to provide a convenient DSL for
+      # configuring a pipeline.
+      #
+      # All instance methods of {PipelineDSL} are available in the context
+      # the block passed to +Rake::Pipeline.+{Pipeline.build}.
+      class PipelineDSL
+        # @return [Pipeline] the pipeline the DSL should configure
+        attr_reader :pipeline
+
+        # Configure a pipeline with a passed in block.
+        #
+        # @param [Pipeline] pipeline the pipeline that the PipelineDSL
+        #   should configure.
+        # @param [Proc] block the block describing the
+        #   configuration. This block will be evaluated in
+        #   the context of a new instance of {PipelineDSL}
+        # @return [void]
+        def self.evaluate(pipeline, options, &block)
+          dsl = new(pipeline)
+
+          # If any before filters, apply them to the pipeline.
+          # They will be run in reverse of insertion order.
+          if before_filters = options[:before_filters]
+            before_filters.each do |klass, args, block|
+              dsl.filter klass, *args, &block
+            end
+          end
+
+          # Evaluate the block in the context of the DSL.
+          dsl.instance_eval(&block)
+
+          # If any after filters, apply them to the pipeline.
+          # They will be run in insertion order.
+          if after_filters = options[:after_filters]
+            after_filters.each do |klass, args, block|
+              dsl.filter klass, *args, &block
+            end
+          end
+
+          # the FinalizingFilter should always come after all
+          # user specified after filters
+          pipeline.finalize
+        end
+
+        # Create a new {PipelineDSL} to configure a pipeline.
+        #
+        # @param [Pipeline] pipeline the pipeline that the PipelineDSL
+        #   should configure.
+        # @return [void]
+        def initialize(pipeline)
+          @pipeline = pipeline
+        end
+
+        # Add an input location and files to a pipeline.
+        #
+        # @example
+        #   !!!ruby
+        #   Rake::Pipeline::Project.build do
+        #     input "app" do
+        #       input "assets", "**/*.js"
+        #       # ...
+        #     end
+        #   end
+        #
+        # @param [String] root the root path where the pipeline
+        #   should find its input files.
+        # @param [String] glob a file pattern that represents
+        #   the list of files that the pipeline should
+        #   process within +root+. The default is +"**/*"+.
+        # @return [void]
+        def input(root, glob="**/*")
+          pipeline.add_input root, glob
+        end
+
+        # Add a filter to the pipeline.
+        #
+        # In addition to a filter class, {#filter} takes a
+        # block that describes how the filter should map
+        # input files to output files.
+        #
+        # By default, the block maps an input file into
+        # an output file with the same name.
+        #
+        # Any additional arguments passed to {#filter} will
+        # be passed on to the filter class's constructor.
+        #
+        # @see Filter#outputs Filter#output (for an example
+        #   of how a list of input files gets mapped to
+        #   its outputs)
+        #
+        # @param [Class] filter_class the class of the filter.
+        # @param [Array] ctor_args a list of arguments to pass
+        #   to the filter's constructor.
+        # @param [Proc] block an output file name generator.
+        # @return [void]
+        def filter(filter_class, *ctor_args, &block)
+          filter = filter_class.new(*ctor_args, &block)
+          pipeline.add_filter(filter)
+        end
+
+        # Apply a number of filters, but only to files matching
+        # a particular pattern.
+        #
+        # Inside the block passed to {#match match}, you may
+        # specify any number of filters that should be applied
+        # to files matching the pattern.
+        #
+        # @param [String] pattern a glob pattern to match
+        # @param [Proc] block a block that supplies filters
+        # @return [Matcher]
+        #
+        # @example
+        #   !!!ruby
+        #   Rake::Pipeline::Project.build do
+        #     output "public"
+        #
+        #     input "app/assets" do
+        #       # compile coffee files into JS files
+        #       match "*.coffee" do
+        #         coffee_script
+        #       end
+        #
+        #       # because the previous step converted coffeee
+        #       # into JS, the coffee files will be included here
+        #       match "*.js" do
+        #         uglify
+        #         concat "application.js"
+        #       end
+        #     end
+        #   end
+        def match(pattern, &block)
+          matcher = pipeline.copy(Matcher, &block)
+          matcher.glob = pattern
+          pipeline.add_filter matcher
+          matcher
+        end
+
+        # Specify the output directory for the pipeline.
+        #
+        # @param [String] root the output directory.
+        # @return [void]
+        def output(root)
+          pipeline.output_root = root
+        end
+
+        # A helper method for adding a concat filter to
+        # the pipeline.
+        # If the first argument is an Array, it adds a new
+        # {OrderingConcatFilter}, otherwise it adds a new
+        # {ConcatFilter}.
+        #
+        # @see OrderingConcatFilter#initialize
+        # @see ConcatFilter#initialize
+        def concat(*args, &block)
+          if args.first.kind_of?(Array)
+            filter(Rake::Pipeline::OrderingConcatFilter, *args, &block)
+          else
+            filter(Rake::Pipeline::ConcatFilter, *args, &block)
+          end
+        end
+        alias_method :copy, :concat
+      end
+    end
+  end
+end

data/lib/rake-pipeline/dsl/project_dsl.rb

@@ -0,0 +1,108 @@
+module Rake
+  class Pipeline
+    module DSL
+      # This class exists purely to provide a convenient DSL for
+      # configuring a project.
+      #
+      # All instance methods of {ProjectDSL} are available in the context
+      # the block passed to +Rake::Pipeline::Project.+{Project.build}.
+      #
+      # When configuring a project, you *must* provide an output root
+      # and a series of files using at least one {#input} block.
+      class ProjectDSL
+        # @return [Project] the project the DSL should configure
+        attr_reader :project
+
+        # Configure a project with a passed in block.
+        #
+        # @param [Project] project the project that the ProjectDSL
+        #   should configure.
+        # @param [Proc] block the block describing the
+        #   configuration. This block will be evaluated in
+        #   the context of a new instance of {ProjectDSL}
+        # @return [void]
+        def self.evaluate(project, &block)
+          new(project).instance_eval(&block)
+        end
+
+        # Create a new {ProjectDSL} to configure a project.
+        #
+        # @param [Project] project
+        #   the project that the ProjectDSL should configure.
+        # @return [void]
+        def initialize(project)
+          @project = project
+          @before_filters = []
+          @after_filters = []
+          @project.before_filters = @before_filters
+          @project.after_filters = @after_filters
+        end
+
+        # Add a filter to every input block. The parameters
+        # to +before_filter+ are the same as the parameters
+        # to {PipelineDSL#filter}.
+        #
+        # Filters will be executed before the specified
+        # filters in reverse of insertion order.
+        #
+        # @see {PipelineDSL#filter}
+        def before_filter(klass, *args, &block)
+          @before_filters.unshift [klass, args, block]
+        end
+
+        # Add a filter to every input block. The parameters
+        # to +after_filter+ are the same as the parameters
+        # to {PipelineDSL#filter}.
+        #
+        # Filters will be executed after the specified
+        # filters in insertion order.
+        #
+        # @see {PipelineDSL#filter}
+        def after_filter(klass, *args, &block)
+          @after_filters.push [klass, args, block]
+        end
+
+        # Specify the default output directory for the project.
+        #
+        # Pipelines created in this project will place their
+        # outputs here unless the value is overriden in their
+        # {#input} block.
+        #
+        # @param [String] root the output directory.
+        # @return [void]
+        def output(root)
+          project.default_output_root = root
+        end
+
+        # Specify the location of the root temporary directory.
+        #
+        # Pipelines will store intermediate build artifacts
+        # in a subdirectory of this directory.
+        #
+        # This defaults to "tmp" in the current working directory.
+        #
+        # @param [String] root the temporary directory
+        # @return [void]
+        def tmpdir(root)
+          project.tmpdir = root
+        end
+
+        # Add a new pipeline with the given inputs to the project.
+        #
+        # @see Project.build_pipeline
+        def input(*inputs, &block)
+          # Allow pipelines without a specified block. This is possible
+          # if before and after filters are all that are needed for a
+          # given input.
+          block = proc {} unless block_given?
+          project.build_pipeline(*inputs, &block)
+        end
+        alias inputs input
+
+        def map(path, &block)
+          project.maps[path] = block
+        end
+      end
+    end
+  end
+end