requirejs_optimizer 0.0.5

data/lib/generators/install_generator.rb

@@ -0,0 +1,26 @@
+module RequirejsOptimizer
+
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+
+    desc 'Set up for optimizing require.js modules'
+
+    def install
+      @main_name = ask("What is the name of your main module without the extension? (Leave blank for \"main\"):").tap { |s| s.replace "main" if s.blank? }
+      template "require.build.js", "app/assets/javascripts/modules/require.build.js"
+      copy_file "main.js.coffee", "app/assets/javascripts/modules/#{@main_name}.js.coffee"
+      copy_file "README", "app/assets/javascripts/modules/README"
+
+      say <<-README
+
+requirejs_optimzier doesn't include require.js for use in you're app. If you
+need it, you can get it via:
+
+    $ curl http://requirejs.org/docs/release/1.0.7/comments/require.js > vendor/assets/javascripts/require.js
+
+      README
+    end
+
+  end
+
+end

data/lib/generators/templates/README

@@ -0,0 +1,8 @@
+IMPORTANT
+=========
+All Require.js modules you want to create build(s) from need to go in `app/assets/javascripts/modules`
+
+Everything under `modules` is automatically added to the app's asset precompile list, so all of these
+files will get processed by the asset pipeline as part of a requirejs build. This is normal.
+
+You can delete this README file if you want, it's only here to let you know what's going on.

data/lib/generators/templates/main.js.coffee

@@ -0,0 +1,3 @@
+# The following assumes that app/assets/javascripts/modules/one/foo.js(.coffee) exists as require.js modules:
+#
+# require ['one/foo', 'two/bar'], (foo, bar) -> console.log(foo, bar)

data/lib/generators/templates/require.build.js

@@ -0,0 +1,6 @@
+({
+    appDir:    "../../../../tmp/assets"
+    , baseUrl: "./modules"
+    , dir:     "../../../../tmp/assets/build"
+    , name:    "<%= @main_name %>"
+})

data/lib/requirejs_optimizer/build.rb

@@ -0,0 +1,21 @@
+module RequirejsOptimizer
+
+  class Build
+
+    attr_accessor :steps
+
+    def initialize(*args)
+      @steps = args.inject({}) { |m, s| m[s.name] = s.new; m }
+    end
+
+    def run
+      @steps.each { |s| s.last.perform }
+    end
+
+    def step(name)
+      @steps[name]
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/errors.rb

@@ -0,0 +1,21 @@
+module RequirejsOptimizer
+
+  module Errors
+
+    # Raised if the node.js executable is unavailable
+    #
+    class NodeUnavailable < RuntimeError
+      def message
+        "Node wasn't found. Make sure the node executable is available somewhere in PATH"
+      end
+    end
+
+    class RjsOptimizationFailed < RuntimeError
+      def message
+        "R.js optimization failed. See STDOUT for details"
+      end
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/railtie.rb

@@ -0,0 +1,32 @@
+require 'pathname'
+
+# This will fail when initializing assets, but we don't need
+# generators for asset initialization anyway. Let it fail
+# silently
+#
+begin; require "generators/install_generator"
+rescue NameError => e; end
+
+class RequirejsOptimizerRailtie < Rails::Railtie
+
+  config.before_initialize do
+    Rails.application.config.assets.compress = false
+    javascripts_root_path = Rails.root.join(*%w(app/assets/javascripts/))
+    modules_path          = javascripts_root_path.join("modules", '**', '*.{coffee,js}')
+
+    modules = Dir[modules_path].reject { |f| f =~ /require\.build\.js$/ }.map do |path_with_filename|
+      filename = path_with_filename.gsub(/^#{javascripts_root_path}\/?/, '').gsub(/\.coffee$/, '')
+      filename = "#{filename}.js" unless File.extname(filename) == ".js"
+      filename
+    end
+
+    Rails.application.config.assets.precompile += modules
+  end
+
+  rake_tasks do
+    raketask = RequirejsOptimizer::Rake::Task.new
+    raketask.define_tasks
+    raketask.extend_default_precompile unless ENV['NO_RJS']
+  end
+
+end

data/lib/requirejs_optimizer/rake/task.rb

@@ -0,0 +1,50 @@
+require 'zlib'
+require 'rake/tasklib'
+
+module RequirejsOptimizer
+  class Rake::Task < ::Rake::TaskLib
+    include ::Rake::DSL
+    include ::RequirejsOptimizer::Rake::Utils
+
+    attr_accessor :name
+
+    def initialize(name="requirejs")
+      @name = name
+    end
+
+    def define_tasks
+      define_task_deeply(name, "Optimize assets using the r.js optimization tool") { default_build.run }
+      define_task_deeply("#{name}:nocopy", "Perform optimization but don't copy the files into public/assets") { nocopy_build.run }
+      define_task_deeply "#{name}:clean", "Remove the temp build directory (tmp/assets by default)", &Step::Clean.new
+    end
+
+    def extend_default_precompile
+      define_task_deeply("assets:precompile:nondigest") { invoke_or_reboot_rake_task @name }
+    end
+
+    private
+
+    def nocopy_build
+      RequirejsOptimizer::Build.new \
+        RequirejsOptimizer::Step::Clean,
+        RequirejsOptimizer::Step::Prepare,
+        RequirejsOptimizer::Step::Optimize,
+        RequirejsOptimizer::Step::Digestify,
+        RequirejsOptimizer::Step::Compress,
+        RequirejsOptimizer::Step::Manifest
+    end
+
+    def default_build
+      RequirejsOptimizer::Build.new \
+        RequirejsOptimizer::Step::Clean,
+        RequirejsOptimizer::Step::Prepare,
+        RequirejsOptimizer::Step::Optimize,
+        RequirejsOptimizer::Step::Digestify,
+        RequirejsOptimizer::Step::Compress,
+        RequirejsOptimizer::Step::Manifest,
+        RequirejsOptimizer::Step::Finalize
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/rake/utils.rb

@@ -0,0 +1,32 @@
+module RequirejsOptimizer
+
+  module Rake
+
+    module Utils
+
+      def define_task_deeply(name, taskdesc="", work_to_do=nil, &block)
+        current, *rest = *name.split(":")
+
+        if rest.any?
+          namespace(current) { define_task_deeply rest.join(":"), taskdesc, work_to_do || block }
+        else
+          desc taskdesc
+          task current, &(work_to_do || block)
+        end
+      end
+
+      # Not sure if we actually need this or not.
+      #
+      def invoke_or_reboot_rake_task(task)
+        if ENV['RAILS_GROUPS'].to_s.empty? || ENV['RAILS_ENV'].to_s.empty?
+          ruby_rake_task task
+        else
+          ::Rake::Task[task].invoke
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/step/base.rb

@@ -0,0 +1,19 @@
+module RequirejsOptimizer
+
+  module Step
+
+    class Base
+
+      def perform(*)
+        raise NotImplementedError
+      end
+
+      def to_proc
+        self.method(:perform).to_proc
+      end
+
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/step/clean.rb

@@ -0,0 +1,15 @@
+module RequirejsOptimizer
+
+  module Step
+
+    class Clean < Base
+
+      def perform(*)
+        FileUtils.rm_rf RequirejsOptimizer.build_dir
+      end
+
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/step/compress.rb

@@ -0,0 +1,21 @@
+module RequirejsOptimizer
+
+  module Step
+
+    class Compress < Base
+
+      def perform(*)
+        RequirejsOptimizer.target_files("*.{js,css}").each do |f|
+          gzip_file f
+        end
+      end
+
+      def gzip_file(path)
+        Zlib::GzipWriter.open("#{path}.gz") { |gz| gz.write(File.read(path)) }
+      end
+
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/step/digestify.rb

@@ -0,0 +1,27 @@
+module RequirejsOptimizer
+
+  module Step
+
+    class Digestify < Base
+
+      def initialize
+        Rails.application.initialize!(:assets) unless Rails.application.assets.present?
+      end
+
+      def perform(*)
+        RequirejsOptimizer.target_files.each do |f|
+          digestify_file f
+        end
+      end
+
+      def digestify_file(path)
+        digest = Rails.application.assets.file_digest(path).hexdigest
+        new_path = path.gsub(/\.([^\.]*)$/) { "-#{digest}.#{$1}" }
+        FileUtils.cp(path, new_path)
+      end
+
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/step/finalize.rb

@@ -0,0 +1,16 @@
+module RequirejsOptimizer
+
+  module Step
+
+    class Finalize < Base
+
+      def perform(*)
+        FileUtils.rm_r(Rails.root.join("public/assets"))
+        FileUtils.cp_r(RequirejsOptimizer.target_dir.to_s, Rails.root.join("public/assets"))
+      end
+
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/step/manifest.rb

@@ -0,0 +1,31 @@
+module RequirejsOptimizer
+
+  module Step
+
+    class Manifest < Base
+
+      def perform(*)
+        manifest_entries = RequirejsOptimizer.target_files.map do |f|
+          file_is_digestified = f =~ /-[0-9a-f]{32}\./
+          manifest_entry_for f if file_is_digestified
+        end
+        write_manifest manifest_entries.compact.join("\n")
+      end
+
+      private
+
+      def manifest_entry_for(file_at_path)
+        path_to_remove = RequirejsOptimizer.target_dir.to_s.gsub(/(\/)?$/) { $1 || '/' }
+        nondigest, digest = file_at_path.gsub(/-[0-9a-f]{32}\./, '.').gsub(/^#{path_to_remove}/, ''), file_at_path.gsub(/^#{path_to_remove}/, '')
+        "#{nondigest}: #{digest}"
+      end
+
+      def write_manifest(contents)
+        open(RequirejsOptimizer.target_dir.join("manifest.yml"), "w") { |f| f.write contents }
+      end
+
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/step/optimize.rb

@@ -0,0 +1,26 @@
+module RequirejsOptimizer
+
+  module Step
+
+    class Optimize < Base
+
+      def perform(*)
+        raise RequirejsOptimizer::Errors::NodeUnavailable unless node_exists?
+        raise RequirejsOptimizer::Errors::RjsOptimizationFailed unless optimize
+      end
+
+      private
+
+      def optimize
+        system("node #{RequirejsOptimizer.root.join 'bin', 'r.js'} -o app/assets/javascripts/modules/require.build.js")
+      end
+
+      def node_exists?
+        system("which node 2>&1 > /dev/null")
+      end
+
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/step/prepare.rb

@@ -0,0 +1,32 @@
+module RequirejsOptimizer
+
+  module Step
+
+    class Prepare < Base
+
+      def perform(*)
+        # Copy build directory into place
+        FileUtils.cp_r Rails.root.join('public', 'assets').to_s, RequirejsOptimizer.build_dir.to_s
+
+        remove_gzipped_files
+        remove_digestified_files
+      end
+
+      private
+
+      def remove_gzipped_files
+        FileUtils.rm RequirejsOptimizer.build_files("*.gz")
+      end
+
+      def remove_digestified_files
+        RequirejsOptimizer.build_files.each do |f|
+          file_is_digestified = f =~ /-[0-9a-f]{32}\./
+          FileUtils.rm(f) if file_is_digestified
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/requirejs_optimizer/version.rb

@@ -0,0 +1,3 @@
+module RequirejsOptimizer
+  VERSION = "0.0.5"
+end

data/lib/requirejs_optimizer.rb

@@ -0,0 +1,49 @@
+require 'sprockets'
+require 'fileutils'
+
+require "requirejs_optimizer/errors"
+require "requirejs_optimizer/step/base"
+require "requirejs_optimizer/step/clean"
+require "requirejs_optimizer/step/compress"
+require "requirejs_optimizer/step/digestify"
+require "requirejs_optimizer/step/finalize"
+require "requirejs_optimizer/step/manifest"
+require "requirejs_optimizer/step/optimize"
+require "requirejs_optimizer/step/prepare"
+
+require "requirejs_optimizer/build"
+require "requirejs_optimizer/rake/utils"
+require "requirejs_optimizer/rake/task"
+
+require "requirejs_optimizer/version"
+
+
+module RequirejsOptimizer
+
+  def self.root
+    Pathname.new(File.expand_path("../..", __FILE__))
+  end
+
+  def self.build_dir=(value)
+    @build_dir = value
+  end
+
+  def self.build_dir
+    Rails.root.join(@build_dir || "tmp/assets")
+  end
+
+  def self.target_dir
+    build_dir.join("build")
+  end
+
+  def self.build_files(file_glob="*.*")
+    Dir.glob(RequirejsOptimizer.build_dir.join('**', file_glob).to_s).reject { |f| f =~ /manifest\.yml$|build\.txt$/ }
+  end
+
+  def self.target_files(file_glob="*.*")
+    Dir.glob(RequirejsOptimizer.target_dir.join('**', file_glob).to_s).reject { |f| f =~ /manifest\.yml$|build\.txt$/ }
+  end
+
+end
+
+require "requirejs_optimizer/railtie" if defined?(Rails)

data/requirejs_optimizer.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/requirejs_optimizer/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Jesse Trimble"]
+  gem.email         = ["jesseltrimble@gmail.com"]
+  gem.description   = %q{A tool for optimizing Require.js modules using r.js under the asset pipeline.}
+  gem.summary       = %q{A tool for optimizing Require.js modules using r.js under the asset pipeline.}
+  gem.homepage      = ""
+
+  gem.add_dependency "rails", "~> 3.1"
+  gem.add_development_dependency "rspec"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "requirejs_optimizer"
+  gem.require_paths = ["lib"]
+  gem.version       = RequirejsOptimizer::VERSION
+end

data/spec/integrations/rake_task_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "Output from `rake -T`" do
+
+  def rake_t_output
+    `cd spec/rails_app && rake -T`
+  end
+
+  it "should include the default requirejs task" do
+    rake_t_output.should =~ /requirejs\s/
+  end
+
+  it "should include the clean task" do
+    rake_t_output.should =~ /requirejs:clean\s/
+  end
+
+end
+
+describe "the environment post-asset precompilation" do
+
+  it "has a public/assets directory that's identical in contents and structure to tmp/assets/build" do
+    result = `cd spec/rails_app && RAILS_ENV=production rake assets:clean assets:precompile --trace 2>&1`
+    $?.exitstatus.should == 0
+
+    public_files = Dir[Rails.root.join("public/assets/**/*").to_s].map { |f| f.gsub /^#{Rails.root.join("public/assets")}/, '' }
+    build_files = Dir[RequirejsOptimizer.target_dir.join("**/*").to_s].map { |f| f.gsub /^#{RequirejsOptimizer.target_dir}/, '' }
+
+    public_files.should =~ build_files
+  end
+
+end

data/spec/lib/requirejs_optimizer/rake/task_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module RequirejsOptimizer
+
+  module Rake
+
+    describe Task do
+
+      subject { Task.new("foo") }
+
+      describe "#initialize" do
+        its(:name) { should == "foo" }
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/requirejs_optimizer/rake/utils_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module RequirejsOptimizer
+
+  module Rake
+
+    describe Utils do
+
+      describe "#define_task_deeply" do
+
+        # Since #define_task_deeply recurses to do work, we can't test it with mocks
+        # so here we're creating a clean-room scenario with a class that responds
+        # to the part of the rake api that #define_task_deeply uses, but
+        # implements it differently so we can inspect what it's doing internally.
+        #
+        # Not the best approach, and definitely not what I consider a unit test,
+        # but it gets the job done. Any help here would be appreciated.
+        #
+        def klass
+          Class.new do
+
+            ####################
+            # What we're testing
+            include Utils
+            ####################
+
+            # Task assign's it's block to this for inspection
+            attr_accessor :task_block
+
+            # Adds the name it was called with to an array to track
+            # namespace calls.
+            #
+            def namespace(name)
+              @names ||= []
+              @names << name
+              yield if block_given?
+            end
+
+            # Calls #namespace to track the name, then stores the block
+            # it was given so we can inspect it from the test
+            #
+            def task(name, &block)
+              namespace(name)
+              self.task_block = block
+            end
+
+            # Joins the names we were given on : so we can verify things are
+            # recursing correclty.
+            #
+            def names
+              @names.join(":")
+            end
+
+          end
+        end
+
+        subject do
+          klass.new.tap { |k| k.stub(:desc) }
+        end
+
+        it "defines namespaces and tasks appropriately" do
+          subject.define_task_deeply("foo:bar:baz")
+          subject.names.should == "foo:bar:baz"
+        end
+
+        it "passes the given block to :task" do
+          expected_block = proc { called! }
+          subject.define_task_deeply "foo", &expected_block
+          subject.task_block.should == expected_block
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/requirejs_optimizer/step/clean_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module RequirejsOptimizer
+
+  module Step
+
+    describe Clean do
+
+      describe '#perform' do
+
+        it 'removes the temporary build directory' do
+          RequirejsOptimizer.stub(:build_dir).and_return("foo")
+          FileUtils.should_receive(:rm_rf).with('foo')
+          Clean.new.perform
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/requirejs_optimizer/step/compress_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module RequirejsOptimizer
+
+  module Step
+
+    describe Compress do
+
+      describe "#perform" do
+
+        it "creates gzipped files for all js/css files" do
+          Dir.should_receive(:glob).with(target_path_for("**", "*.{js,css}")).and_return(%w(file.css file-0123456789abcdef0123456789abcdef.css img.png))
+          subject.should_receive(:gzip_file).with('file-0123456789abcdef0123456789abcdef.css')
+          subject.should_receive(:gzip_file).with('file.css')
+          subject.should_receive(:gzip_file).with('img.png')
+
+          subject.perform
+        end
+
+      end
+
+    end
+
+  end
+
+end