epuber-stylus 1.1.0

data/spec/runtime_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Stylus::Runtime do
+  it 'raises an error if the runtime is not available' do
+    allow(Stylus).to receive(:runtime) { double('An unavailable Runtime', available?: false) }
+
+    expect {
+      Stylus.version
+    }.to raise_error RuntimeError, %r[The Node.JS runtime is not available to Stylus.]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'rails'
+require 'rails/generators/test_case'
+
+require 'active_support/railtie'
+require 'action_controller/railtie'
+require 'sprockets'
+require 'sprockets/rails'
+require 'epuber-stylus'
+
+require 'active_support/core_ext/class/attribute_accessors'
+
+require 'support/helpers'
+require 'support/matchers'
+require 'support/generators/test_case'
+
+RSpec.configure do |config|
+  config.include Helpers
+
+  config.after :each do
+    Stylus.compress = false
+    Stylus.debug = false
+    Stylus.paths = []
+    Stylus.plugins.clear
+    Stylus.definitions.clear
+    Stylus.imports.clear
+  end
+end

data/spec/sprockets_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe 'Sprockets setup' do
+  let(:env) do
+    Sprockets::Environment.new do |assets|
+      assets.append_path fixture_root
+      assets.append_path 'javascripts'
+    end
+  end
+
+  it 'register the default Tilt template' do
+    expect(env).to receive(:register_engine).with('.styl', Tilt::StylusTemplate)
+    Stylus.setup(env)
+  end
+
+  it 'register a Rails specific Tilt template' do
+    expect(env).to receive(:register_engine).with('.styl', Stylus::Rails::StylusTemplate)
+    Stylus.setup(env, rails: true)
+  end
+
+  it 'register the import processor' do
+    expect(env).to receive(:register_preprocessor).with('text/css', Stylus::ImportProcessor)
+    Stylus.setup(env)
+  end
+
+  it 'copies the asset paths' do
+    Stylus.setup(env)
+    expect(Stylus.paths).to eq(env.paths)
+  end
+
+  it 'configure the debug and compress flags' do
+    Stylus.setup(env, debug: true, compress: true)
+    expect(Stylus.debug).to be_true
+    expect(Stylus.compress).to be_true
+  end
+end

data/spec/stylus_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe Stylus do
+  it 'compiles the given source' do
+    input, output = fixture(:simple)
+    expect(Stylus.compile(input)).to eq(output)
+  end
+
+  it 'accepts an IO object' do
+    input, output = fixture(:simple)
+    input = StringIO.new(input)
+    expect(Stylus.compile(input)).to eq(output)
+  end
+
+  it 'compress the file when the "compress" flag is given' do
+    input, output = fixture(:compressed)
+    expect(Stylus.compile(input, compress: true)).to eq(output.rstrip)
+  end
+
+  it 'handles the compress flag globally' do
+    Stylus.compress = true
+    input, output = fixture(:compressed)
+    expect(Stylus.compile(input)).to eq(output.rstrip)
+  end
+
+  it 'imports the given paths' do
+    path = fixture_root
+    input, output = fixture(:import)
+    expect(Stylus.compile(input, paths: path)).to eq(output)
+  end
+
+  it 'handles the import paths globally' do
+    Stylus.paths << fixture_root
+    input, output = fixture(:import)
+    expect(Stylus.compile(input)).to eq(output)
+  end
+
+  it 'implicit imports the given paths' do
+    path = File.expand_path('mixins/vendor.styl', fixture_root)
+    input, output = fixture(:implicit)
+    Stylus.import path
+    expect(Stylus.compile(input)).to eq(output)
+  end
+
+  it 'outputs both gem and library version' do
+    expect(Stylus.version).to match(/Stylus - gem .+ library .+/)
+  end
+
+  it 'converts CSS to Stylus' do
+    stylus, css = fixture(:stylesheet)
+    expect(Stylus.convert(css)).to eq(stylus)
+  end
+
+  it 'stores the given plugins' do
+    Stylus.use :one, :two, argument: true
+    expect(Stylus).to have(2).plugins
+  end
+
+  it 'includes the given plugins' do
+    Stylus.use :nib
+    input, output = fixture(:plugin)
+    expect(Stylus.compile(input)).to eq(output)
+  end
+
+  it 'stores the define calls' do
+    Stylus.define "mystring", "test"
+    expect(Stylus).to have(1).definitions
+  end
+
+  it 'defines a global variable string' do
+    Stylus.define "mystring", "test"
+    input, output = fixture(:definition)
+    expect(Stylus.compile(input)).to match(/content: 'test'/)
+  end
+
+  it 'defines a global variable literal' do
+    Stylus.define "mystring", "red", :literal => true
+    input, output = fixture(:definition)
+    expect(Stylus.compile(input)).to match(/content: red/)
+  end
+
+  it 'includes and imports "nib" automatically' do
+    Stylus.nib = true
+    input, output = fixture(:nib)
+    expect(Stylus.compile(input)).to eq(output)
+  end
+
+  it 'share variables between imported stylesheets' do
+    input, output = fixture(:variables)
+    path = fixture_root
+
+    expect(Stylus.compile(input, paths: path)).to eq(output)
+  end
+
+  describe 'The debug flag' do
+    let(:path) { fixture_path(:debug) }
+    let(:fixture) { File.read(path) }
+    let(:file) { File.new(path) }
+
+    before { Stylus.debug = true }
+
+    it 'turns the "linenos" option on' do
+      expect(Stylus.compile(file)).to match(/line 1 : #{path}/)
+    end
+
+    it 'skips the "linenos" option if no filename is given' do
+      expect(Stylus.compile(fixture)).to_not match(/line 1 : #{path}/)
+    end
+
+    it 'turns the "firebug" option on' do
+      expect(Stylus.compile(file)).to match(/@media -stylus-debug-info/)
+    end
+
+    it 'skips the "firebug" option if no filename is given' do
+      expect(Stylus.compile(fixture)).to_not match(/@media -stylus-debug-info/)
+    end
+  end
+end

data/spec/support/generators/test_case.rb

@@ -0,0 +1,59 @@
+# Extracted from generator_spec https://github.com/stevehodgkiss/generator_spec
+# But `RSpec::Rails::RailsExampleGroup` loads a truckload of things from rails and rspec-rails
+# That we don't need.
+
+module Generators
+  module TestCase
+    extend ActiveSupport::Concern
+    include FileUtils
+
+    included do
+      cattr_accessor :test_case, :test_case_instance
+
+      self.test_case = Class.new(Rails::Generators::TestCase) do
+        def fake_test_case; end
+        def add_assertion; end
+      end
+      self.test_case_instance = self.test_case.new(:fake_test_case)
+      self.test_case.tests described_class
+
+      before do
+        prepare_destination
+        create_routes
+        run_generator
+      end
+
+      destination File.expand_path('../tmp', __FILE__)
+    end
+
+    module ClassMethods
+      def tests(klass)
+        self.test_case.generator_class = klass
+      end
+
+      def arguments(array)
+        self.test_case.default_arguments = array
+      end
+
+      def destination(path)
+        self.test_case.destination_root = path
+      end
+    end
+
+    def file(relative)
+      File.expand_path(relative, destination_root)
+    end
+
+    def method_missing(method_sym, *arguments, &block)
+      self.test_case_instance.send(method_sym, *arguments, &block)
+    end
+
+    def respond_to?(method_sym, include_private = false)
+      if self.test_case_instance.respond_to?(method_sym)
+        true
+      else
+        super
+      end
+    end
+  end
+end

data/spec/support/generators/tmp/app/controllers/posts_controller.rb

@@ -0,0 +1,58 @@
+class PostsController < ApplicationController
+  before_action :set_post, only: [:show, :edit, :update, :destroy]
+
+  # GET /posts
+  def index
+    @posts = Post.all
+  end
+
+  # GET /posts/1
+  def show
+  end
+
+  # GET /posts/new
+  def new
+    @post = Post.new
+  end
+
+  # GET /posts/1/edit
+  def edit
+  end
+
+  # POST /posts
+  def create
+    @post = Post.new(post_params)
+
+    if @post.save
+      redirect_to @post, notice: 'Post was successfully created.'
+    else
+      render action: 'new'
+    end
+  end
+
+  # PATCH/PUT /posts/1
+  def update
+    if @post.update(post_params)
+      redirect_to @post, notice: 'Post was successfully updated.'
+    else
+      render action: 'edit'
+    end
+  end
+
+  # DELETE /posts/1
+  def destroy
+    @post.destroy
+    redirect_to posts_url, notice: 'Post was successfully destroyed.'
+  end
+
+  private
+    # Use callbacks to share common setup or constraints between actions.
+    def set_post
+      @post = Post.find(params[:id])
+    end
+
+    # Only allow a trusted parameter "white list" through.
+    def post_params
+      params[:post]
+    end
+end

data/spec/support/generators/tmp/app/helpers/posts_helper.rb

@@ -0,0 +1,2 @@
+module PostsHelper
+end

data/spec/support/helpers.rb

@@ -0,0 +1,63 @@
+module Helpers
+  def create_routes
+    destination = File.join(destination_root, 'config')
+
+    FileUtils.mkdir_p(destination)
+    FileUtils.touch File.join(destination, 'routes.rb')
+  end
+
+  def create_app(options = {})
+    Rails.application = nil
+
+    Class.new(Rails::Application).tap do |app|
+      config = app.config.assets
+      assets = app.assets
+      config.paths = []
+
+      assets.cache = ActiveSupport::Cache.lookup_store(:null_store)
+      config.compress = options[:compress]
+      config.debug    = options[:debug]
+      config.paths << fixture_root
+      config.paths << File.expand_path('javascripts')
+      yield(app) if block_given?
+
+      app.config.eager_load = false
+      app.config.active_support.deprecation = :log
+      app.initialize!
+    end
+  end
+
+  def fixture_root
+    File.expand_path('../../stylesheets', __FILE__)
+  end
+
+  def images_root
+    File.expand_path('../../images', __FILE__)
+  end
+
+  def output_root
+    File.expand_path('../../cases', __FILE__)
+  end
+
+  def fixture(name)
+    source = fixture_path(name)
+    output = css_path(name)
+    [source, output].map do |path|
+      File.read(path) if File.file?(path)
+    end
+  end
+
+  def css_path(name)
+    File.join(output_root, "#{name}.css")
+  end
+
+  def fixture_path(name)
+    File.join(fixture_root, "#{name}.styl")
+  end
+
+  def dependencies_on(asset)
+    context = env.context_class.new(env, asset.logical_path, asset.pathname)
+    context.evaluate(asset.pathname)
+    context._dependency_paths
+  end
+end

data/spec/support/matchers.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :exist do
+  match do |file_path|
+    File.exists?(file_path)
+  end
+end

data/spec/tilt/rails_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'epuber-stylus/tilt/rails'
+
+describe Stylus::Rails::StylusTemplate do
+  it 'registers the template for .styl files' do
+    expect(Tilt['application.styl']).to eq(Stylus::Rails::StylusTemplate)
+  end
+
+  it 'has a content-type' do
+    expect(Stylus::Rails::StylusTemplate.default_mime_type).to eq('text/css')
+  end
+
+  context 'when no resources other then css found' do
+    it 'compiles the given source without changes' do
+      result = fixture(:simple).last
+
+      app = create_app
+      expect(app.assets['simple'].to_s).to eq(result)
+    end
+  end
+
+
+  it 'substitutes asset_path with path' do
+    app = create_app do |app|
+      app.config.assets.paths << images_root
+      app.config.asset_host = 'http://localhost'
+    end
+    result = fixture(:asset_path).last
+    expect(app.assets['asset_path'].to_s).to eq(result)
+  end
+
+  it 'substitutes asset_url with url' do
+    app = create_app do |app|
+      app.config.assets.paths << images_root
+      app.config.asset_host = 'http://localhost'
+    end
+    result = fixture(:asset_url).last
+    expect(app.assets['asset_url'].to_s).to eq(result)
+  end
+
+  context 'when config.assets.digest = true' do
+    let(:app) do
+      create_app do |app|
+        app.config.assets.paths << images_root
+        app.config.asset_host = 'http://localhost'
+        app.config.assets.digest = true
+      end
+    end
+
+    it 'appends fingerprint to asset path' do
+      digested_image_path = app.assets['rails.png'].digest_path
+      expect(digested_image_path).to match(/^rails-(\w+)\.png$/)
+      asset = app.assets['digested_asset_path']
+      expect(asset.to_s).to eq("body {\n  background-image: url(\"http://localhost/assets/#{digested_image_path}\");\n}\n")
+    end
+
+    it 'appends fingerprint to asset url' do
+      digested_image_path = app.assets['rails.png'].digest_path
+      expect(digested_image_path).to match(/^rails-(\w+)\.png$/)
+      asset = app.assets['digested_asset_url']
+      expect(asset.to_s).to eq("body {\n  background-image: url(\"http://localhost/assets/#{digested_image_path}\");\n}\n")
+    end
+  end
+end