css-rewrite 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc776cbf9f90435b4988cf29c875cbb2ce2e691c
-  data.tar.gz: afdc21aa137284b0242ade4d4355641b29f1718c
+  metadata.gz: ceec306108646763d41b4a97611cca6509506718
+  data.tar.gz: 67a34318674dfa93a473810229310ffbfe55adf1
 SHA512:
-  metadata.gz: f5218b6f5ddd5be6bbc8fd333c91833d9847c35c61ea2207a72b63cd2bee5537975cde43b8efe845e14910d0054b40a3ba113f674673b8103a3626bf71a50bdb
-  data.tar.gz: db6eb3a7cc43d1853b1d8f58663a74b935adc45bd4bc4f1981853efb3db2852eaec81f88926a45bdeac2c09a079f42929a395c816397959c58481d5aece2070e
+  metadata.gz: 162bf7a19c513fe517c99cdc620ac02f55aadeeb66347e38866ab2a20df7b80c67585a6c83de1177ef5bbdf9b1f1484b7f25aba1275dabe3c926b7a27c38c0dc
+  data.tar.gz: 6fccb97733b69087c09fd4b59fa970d4098ec2213913e83b14cefeec37523ffa9df1a517044d34e36c365dcf5f011e5371be96c5afd98f0be4436e544b367958

data/README.md

@@ -0,0 +1,76 @@
+## css-rewrite
+Rewrite URLs in your 3rd-party CSS files using the asset pipeline.
+
+## Installation
+
+`gem install css-rewrite`
+
+or put it in your Gemfile:
+
+```ruby
+gem 'css-rewrite'
+```
+
+## Rationale
+
+Have you ever pulled a 3rd-party JavaScript or CSS library into your Rails web app? It can take some effort to get it to play nicely with the asset pipeline. You have to hunt through the tangle of potentially minified CSS to find all the URLs to images and fonts that should be using the Rails asset URL helpers. In other words, instead of this:
+
+```css
+.some-selector {
+  background-image: url("puppy.png");
+}
+```
+
+you want this:
+
+```css
+.some-selector {
+  background-image: image-url("puppy.png");
+}
+```
+
+Every time the author of the CSS library publishes a new version, you have to pull it down and do the hunt-and-replace thing all over again. How tedious.
+
+That's where css-rewrite comes in. Rather than hunting for and converting URLs by hand, css-rewrite adds a post-processor to the asset pipeline that finds and replaces them for you. Whenever the file is served or precompiled, the URLs will point to the correct asset paths. No manual hunting or replacing necessary.
+
+### Ok I'm listening. How does it work?
+
+Behind the scenes, css-rewrite uses the [crass gem](https://github.com/rgrove/crass) to parse and reconstitute CSS. It searches through the parse tree crass generates looking for URLs. When it finds one, it yields it to you for replacement. You (or more accurately your application) can decide what the replacement URL should be using all the power afforded to you by the Ruby programming language.
+
+## How 'bout some examples?
+
+Sure! It's pretty straightforward. In an initializer (i.e. config/initializers/css_rewrite.rb), simply configure css-rewrite with a callback. Here's how you might configure it to resolve all URLs in application.css as if they were assets managed by the asset pipeline (which hopefully they are):
+
+```ruby
+CssRewrite.configure do |config|
+  config.rewrite(/application\.css$/) do |url|
+    ActionController::Base.helpers.asset_path(url)
+  end
+end
+```
+
+As you can see, the callback approach is pretty flexible; it gives you direct control over the replacement value of each URL. Here's another example that only replaces image URLs:
+
+```ruby
+CssRewrite.configure do |config|
+  config.rewrite(/application\.css$/) do |url|
+    if %w(.png .jpg .gif).include?(File.extname(url))
+      ActionController::Base.helpers.image_path(url)
+    end
+  end
+end
+```
+
+In this last example you'll notice that the block passed to `rewrite` can return `nil`. In such a case, css-rewrite will replace the URL with itself, i.e. won't change the URL at all. In addition, you can call `#rewrite` as many times as you want to set up different rewrite rules. When replacing URLs, css-rewrite will search through the rewriters that apply to the current file in the order they were added. The first one that returns something other than `nil` will be used for URL replacement. All the rewriters that come _after_ the matching one will be skipped. This happens on a per-URL basis.
+
+## Nice! What else do I need to know?
+
+That's pretty much it. The URL replacements should happen whenever the earmarked CSS files are requested by the browser or precompiled via `rake assets:precompile`.
+
+## License
+
+Licensed under the MIT license. See LICENSE for details.
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/lib/css-rewrite.rb

@@ -1,8 +1,6 @@
 module CssRewrite
-  autoload :CallRewriter,  'css-rewrite/call_rewriter'
   autoload :Config,        'css-rewrite/config'
   autoload :Postprocessor, 'css-rewrite/postprocessor'
-  autoload :RegexRewriter, 'css-rewrite/regex_rewriter'
   autoload :Rewriter,      'css-rewrite/rewriter'
 
   def self.configure

data/lib/css-rewrite/config.rb

@@ -10,8 +10,8 @@ module CssRewrite
 
     attr_reader :rewriters
 
-    def rewrite(*args, &block)
-      rewriters << Rewriter.create(*args, &block)
+    def rewrite(file_filter, &block)
+      rewriters << Rewriter.new(file_filter, &block)
     end
 
     private

data/lib/css-rewrite/postprocessor.rb

@@ -4,11 +4,19 @@ module CssRewrite
   class Postprocessor
     class << self
       def run(filename, source, context)
+        rewriters = find_rewriters(filename)
+        return source if rewriters.empty?
         tree = Crass.parse(source, preserve_comments: true)
 
         replace_urls(tree) do |url|
-          rewriter = Config.instance.rewriters.find { |re| re.matches?(url) }
-          rewriter ? rewriter.rewrite(url, filename) : url
+          rewritten_url = nil
+
+          rewriters.each do |rewriter|
+            rewritten_url = rewriter.rewrite(url)
+            break if rewritten_url
+          end
+
+          rewritten_url || url
         end
 
         Crass::Parser.stringify(tree)
@@ -25,6 +33,12 @@ module CssRewrite
 
       private
 
+      def find_rewriters(filename)
+        Config.instance.rewriters.select do |re|
+          re.matches?(filename)
+        end
+      end
+
       def replace_urls(root, &block)
         return unless root
 

data/lib/css-rewrite/rewriter.rb

@@ -1,13 +1,27 @@
 module CssRewrite
   class Rewriter
-    REWRITERS = [CssRewrite::RegexRewriter, CssRewrite::CallRewriter]
+    attr_reader :file_filter, :replacement_block
 
-    def self.create(*args, &block)
-      rewriter = REWRITERS.find do |rewriter|
-        rewriter.applies_to?(*args, &block)
+    def initialize(file_filter, &block)
+      @file_filter = file_filter
+      @replacement_block = block
+    end
+
+    def matches?(filename)
+      case file_filter
+        when String
+          file_filter == filename
+        when Regexp
+          !!(file_filter =~ filename)
+        else
+          if file_filter.respond_to?(:call)
+            file_filter.call(filename)
+          end
       end
+    end
 
-      rewriter.new(*args, &block)
+    def rewrite(url)
+      replacement_block.call(url)
     end
   end
 end

data/lib/css-rewrite/version.rb

@@ -1,3 +1,3 @@
 module CssRewrite
-  VERSION = '1.0.0'
+  VERSION = '2.0.0'
 end

data/spec/config_spec.rb

@@ -24,14 +24,10 @@ describe CssRewrite::Config do
     subject { described_class.instance }
 
     describe '#rewrite' do
-      it 'adds a call rewriter to the list of rewriters' do
-        expect { subject.rewrite {} }.to change { subject.rewriters.size }.by(1)
-        expect(subject.rewriters.first).to be_a(CssRewrite::CallRewriter)
-      end
-
-      it 'adds a regex rewriter to the list of rewriters' do
-        expect { subject.rewrite(/re/) {} }.to change { subject.rewriters.size }.by(1)
-        expect(subject.rewriters.first).to be_a(CssRewrite::RegexRewriter)
+      it 'adds a rewriter to the list of rewriters' do
+        expect { subject.rewrite('application.css') {} }.to(
+          change { subject.rewriters.size }.by(1)
+        )
       end
     end
   end

data/spec/postprocessor_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe CssRewrite::Postprocessor do
+  describe '.run' do
+    before do
+      CssRewrite.configure do |config|
+        config.rewrite(/application\.css$/) { |url| nil }
+      end
+    end
+
+    let(:filename) { Rails.root.join(*%w(app assets stylesheets application.css)).to_s }
+    let(:source) { File.read(filename) }
+    let(:context) { nil }
+
+    subject { described_class.run(filename, source, context) }
+
+    it 'defaults to using the original url' do
+      expect(subject).to eq(source)
+    end
+
+    context 'with more rewriters' do
+      before do
+        CssRewrite.configure do |config|
+          config.rewrite(/application\.css$/) do |url|
+            if url.end_with?('.png')
+              url.gsub(/\.png/, '.foo')
+            end
+          end
+
+          config.rewrite(/application\.css$/) do |url|
+            if url.end_with?('.jpg')
+              url.gsub(/\.jpg/, '.bar')
+            end
+          end
+        end
+      end
+
+      it 'stops after finding a matching rewriter' do
+        expect(subject).to(
+          eq(".my-class {\n  background-image: url('foo/bar.foo');\n}\n")
+        )
+      end
+    end
+  end
+end

data/spec/precompile_spec.rb

@@ -8,7 +8,7 @@ describe 'Asset precompile' do
 
   before do
     CssRewrite.configure do |config|
-      config.rewrite do |url, filename|
+      config.rewrite(/application\.css$/) do |url|
         url.chomp(File.extname(url)) + '.foo'
       end
     end

data/spec/rewriter_spec.rb

@@ -1,21 +1,22 @@
 require 'spec_helper'
 
 describe CssRewrite::Rewriter do
-  describe '.create' do
-    it 'creates a call rewriter from the given args' do
-      block = -> {}
-      rewriter = described_class.create(&block)
-      expect(rewriter).to be_a(CssRewrite::CallRewriter)
-      expect(rewriter.replacement_block).to eq(block)
+  let(:rewriter) { described_class.new(/application\.css$/, &block) }
+  let(:block) { -> (url) { url.gsub(/\.png$/, '.foo') } }
+
+  describe '#matches?' do
+    it "returns false if the filename doesn't match" do
+      expect(rewriter.matches?('something.js')).to eq(false)
+    end
+
+    it 'returns true if the filename matches' do
+      expect(rewriter.matches?('application.css')).to eq(true)
     end
+  end
 
-    it 'creates a regex rewriter' do
-      block = -> {}
-      regex = /re/
-      rewriter = described_class.create(regex, &block)
-      expect(rewriter).to be_a(CssRewrite::RegexRewriter)
-      expect(rewriter.replacement_block).to eq(block)
-      expect(rewriter.regex).to eq(regex)
+  describe '#rewrite' do
+    it 'uses the replacement block to modify the url' do
+      expect(rewriter.rewrite('path/to/image.png')).to eq('path/to/image.foo')
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: css-rewrite
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Cameron Dutro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-05 00:00:00.000000000 Z
+date: 2017-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sprockets
@@ -60,23 +60,21 @@ extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
+- README.md
 - Rakefile
 - css-rewrite.gemspec
 - lib/css-rewrite.rb
-- lib/css-rewrite/call_rewriter.rb
 - lib/css-rewrite/config.rb
 - lib/css-rewrite/postprocessor.rb
 - lib/css-rewrite/railtie.rb
-- lib/css-rewrite/regex_rewriter.rb
 - lib/css-rewrite/rewriter.rb
 - lib/css-rewrite/version.rb
 - spec/app/assets/stylesheets/application.css
-- spec/call_rewriter_spec.rb
 - spec/config/application.rb
 - spec/config_spec.rb
 - spec/log/test.log
+- spec/postprocessor_spec.rb
 - spec/precompile_spec.rb
-- spec/regex_rewriter_spec.rb
 - spec/rewriter_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/camertron/css-rewrite

data/lib/css-rewrite/call_rewriter.rb

@@ -1,21 +0,0 @@
-module CssRewrite
-  class CallRewriter
-    def self.applies_to?(*args, &block)
-      args.size == 0 && block.present?
-    end
-
-    attr_reader :replacement_block
-
-    def initialize(&block)
-      @replacement_block = block
-    end
-
-    def matches?(url)
-      true
-    end
-
-    def rewrite(url, filename)
-      replacement_block.call(url, filename)
-    end
-  end
-end

data/lib/css-rewrite/regex_rewriter.rb

@@ -1,22 +0,0 @@
-module CssRewrite
-  class RegexRewriter
-    def self.applies_to?(*args, &block)
-      args.size == 1 && args.first.is_a?(Regexp) && block_given?
-    end
-
-    attr_reader :regex, :replacement_block
-
-    def initialize(regex, &block)
-      @regex = regex
-      @replacement_block = block
-    end
-
-    def matches?(url)
-      !!(regex =~ url)
-    end
-
-    def rewrite(url, filename)
-      replacement_block.call(url, filename)
-    end
-  end
-end

data/spec/call_rewriter_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe CssRewrite::CallRewriter do
-  describe '.applies_to?' do
-    it 'applies if passed a block' do
-      expect(described_class.applies_to? {}).to eq(true)
-    end
-
-    it 'does not apply if passed any arguments' do
-      expect(described_class.applies_to?(1) {}).to eq(false)
-    end
-
-    it 'does not apply if not passed a block' do
-      expect(described_class.applies_to?).to eq(false)
-    end
-  end
-
-  context 'with a rewriter' do
-    subject { described_class.new(&block) }
-
-    let(:block) do
-      # replaces the extension with ".foo"
-      -> (url, filename) { url.chomp(File.extname(url)) + '.foo' }
-    end
-
-    describe '#matches?' do
-      it 'always matches' do
-        expect(subject.matches?('foo')).to eq(true)
-      end
-    end
-
-    describe '#rewrite' do
-      it 'invokes the replacement block' do
-        expect(subject.rewrite('foo.com/image.jpg', 'foo.css')).to eq(
-          'foo.com/image.foo'
-        )
-      end
-    end
-  end
-end

data/spec/regex_rewriter_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe CssRewrite::RegexRewriter do
-  describe '.applies_to?' do
-    it 'applies if passed a regex and a block' do
-      expect(described_class.applies_to?(/re/) {}).to eq(true)
-    end
-
-    it 'does not apply if passed no arguments' do
-      expect(described_class.applies_to? {}).to eq(false)
-    end
-
-    it 'does not apply if not passed a block' do
-      expect(described_class.applies_to?(/re/)).to eq(false)
-    end
-  end
-
-  context 'with a rewriter' do
-    subject { described_class.new(/.jpg\z/, &block) }
-
-    let(:block) do
-      # replaces the extension with ".foo"
-      -> (url, filename) { url.chomp(File.extname(url)) + '.foo' }
-    end
-
-    describe '#matches?' do
-      it 'matches if the regex matches' do
-        expect(subject.matches?('foo.jpg')).to eq(true)
-      end
-
-      it 'does not match if the regex fails to match' do
-        expect(subject.matches?('foo.png')).to eq(false)
-      end
-    end
-
-    describe '#rewrite' do
-      it 'invokes the replacement block' do
-        expect(subject.rewrite('foo.com/image.jpg', 'foo.css')).to eq(
-          'foo.com/image.foo'
-        )
-      end
-    end
-  end
-end