nov-stylus 1.0.2

data/lib/stylus.rb

@@ -0,0 +1,174 @@
+require 'stylus/runtime'
+require 'stylus/source'
+require 'stylus/version'
+require 'stylus/railtie' if defined?(::Rails)
+## Stylus
+#
+# `stylus` is a bridge between your Ruby code and the [Stylus](https://github.com/LearnBoost/stylus)
+# library that runs on Node.js. It's aims to be a replacement for the
+# [stylus_rails](https://github.com/lucasmazza/stylus_rails) gem and to support the Rails 3.1 asset pipeline
+# (via [Tilt](https://github.com/rtomayko/tilt)) and other scenarios,
+# backed by the [ExecJS](https://github.com/sstephenson/execjs) gem.
+#
+### Usage
+#
+# To compile a `.styl` file or an arbitrary String to .CSS using stylus, just use the `compile` method.
+#
+# `Stylus.compile(File.new('application.styl'))`
+#
+# A hash of options for the stylus API is accepted.
+#
+# `Stylus.compile(File.read('application.styl'), :compress => true)`
+#
+module Stylus
+  extend Runtime
+  class << self
+    @@compress  = false
+    @@debug     = false
+    @@paths     = []
+    @@imports   = []
+    @@definitions = {}
+    @@plugins   = {}
+
+    # Stores a list of plugins to import inside `Stylus`, with an optional hash.
+    def use(*options)
+      arguments = options.last.is_a?(Hash) ? options.pop : {}
+      options.each do |plugin|
+        @@plugins[plugin] = arguments
+      end
+    end
+    alias :plugin :use
+
+    # Stores a list of stylesheets to import on every compile process.
+    def import(*paths)
+      if paths.any?
+        @@imports = @@imports.concat(paths)
+      end
+    @@imports
+    end
+    alias :imports :import
+
+
+    # Stores a list of defined variables to create on every compile process.
+    def define(variable, value, options = {})
+      literal = true if options[:literal]
+      @@definitions[variable] = { value: value, literal: literal }
+    end
+
+    # Retrieves all the registered plugins.
+    def plugins
+      @@plugins
+    end
+
+    # Retrieves all the registered variables.
+    def definitions
+      @@definitions
+    end
+
+    # Returns the global load path `Array` for your stylesheets.
+    def paths
+      @@paths
+    end
+
+    # Replaces the global load path `Array` of paths.
+    def paths=(val)
+      @@paths = Array(val)
+    end
+
+    # Returns the `debug` flag used to set the `linenos` and `firebug` option for Stylus.
+    def debug
+      @@debug
+    end
+    alias :debug? :debug
+
+    # Marks the `nib` plugin to be loaded and included on every stylesheet.
+    def nib=(flag)
+      if flag
+        use :nib
+        import :nib
+      end
+    end
+
+    # Sets the `debug` flag.
+    def debug=(val)
+      @@debug = val
+    end
+
+    # Returns the global compress flag.
+    def compress
+      @@compress
+    end
+    alias :compress? :compress
+
+    # Sets the global flag for the `compress` option.
+    def compress=(val)
+      @@compress = val
+    end
+
+    # Compiles a given input - a plain String, `File` or some sort of IO object that
+    # responds to `read`.
+    # It accepts a hash of options that will be merged with the global configuration.
+    # If the source has a `path`, it will be expanded and used as the :filename option
+    # So the debug options can be used.
+    def compile(source, options = {})
+      if source.respond_to?(:path) && source.path
+        options[:filename] ||= File.expand_path(source.path)
+      end
+      source  = source.read if source.respond_to?(:read)
+      options = merge_options(options)
+      exec('compile', source, options, plugins, imports, definitions)
+    end
+
+    # Converts back an input of plain CSS to the `Stylus` syntax. The source object can be
+    #  a `File`, `StringIO`, `String` or anything that responds to `read`.
+    def convert(source)
+      source = source.read if source.respond_to?(:read)
+      exec('convert', source)
+    end
+
+    # Returns a `Hash` of the given `options` merged with the default configuration.
+    # It also concats the global load path with a given `:paths` option.
+    def merge_options(options)
+      filename = options[:filename]
+
+      _paths  = options.delete(:paths)
+      options = defaults.merge(options)
+      options[:paths] = paths.concat(Array(_paths))
+      if filename
+        options = options.merge(debug_options)
+      end
+      options
+    end
+
+    # Returns the default `Hash` of options:
+    # the compress flag and the global load path.
+    def defaults
+      { compress: self.compress?, paths: self.paths }
+    end
+
+    # Returns a Hash with the debug options to pass to
+    # Stylus.
+    def debug_options
+      { linenos: self.debug?, firebug: self.debug? }
+    end
+
+    # Return the gem version alongside with the current `Stylus` version of your system.
+    def version
+      "Stylus - gem #{VERSION} library #{exec('version')}"
+    end
+
+    protected
+    def bundled_path
+      File.dirname(Stylus::Source.bundled_path)
+    end
+  end
+
+  # Exports the `.node_modules` folder on the working directory so npm can
+  # require modules installed locally.
+  ENV['NODE_PATH'] = [
+    File.expand_path('node_modules'),
+    File.expand_path('vendor/node_modules'),
+    bundled_path,
+    ENV['NODE_PATH']
+  ].join(File::PATH_SEPARATOR)
+end

data/spec/generators/assets_generator_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'rails/generators/stylus/assets/assets_generator'
+
+describe Stylus::Generators::AssetsGenerator do
+  include Generators::TestCase
+  arguments  %w(posts)
+
+  it 'generates a .styl file' do
+    expect(file('app/assets/stylesheets/posts.css.styl')).to exist
+  end
+end

data/spec/generators/controller_generator_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'rails/generators/rails/controller/controller_generator'
+require 'rails/generators/stylus/assets/assets_generator'
+
+describe Rails::Generators::ControllerGenerator do
+  include Generators::TestCase
+  arguments  %w(posts --stylesheet-engine=stylus)
+
+  it 'generates a .styl file' do
+    expect(file('app/assets/stylesheets/posts.css.styl')).to exist
+  end
+end

data/spec/generators/scaffold_generator_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'rails/generators/rails/scaffold/scaffold_generator'
+require 'rails/generators/stylus/assets/assets_generator'
+require 'rails/generators/stylus/scaffold/scaffold_generator'
+
+describe Rails::Generators::ScaffoldGenerator do
+  include Generators::TestCase
+  arguments  %w(posts --stylesheet-engine=stylus --orm=false)
+
+  it 'generates the default scaffold stylesheet' do
+    expect(file('app/assets/stylesheets/scaffold.css')).to exist
+  end
+
+  it 'generates a named .styl file' do
+    expect(file('app/assets/stylesheets/posts.css.styl')).to exist
+  end
+end

data/spec/import_processor_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Stylus::ImportProcessor do
+  let(:env) do
+    Sprockets::Environment.new do |assets|
+      assets.append_path fixture_root
+      Stylus.setup(assets)
+    end
+  end
+
+  it 'adds an imported stylesheet as a dependency' do
+    asset = env['import']
+    dependencies = dependencies_on(asset)
+
+    expect(dependencies).to include(fixture_path('mixins/vendor'))
+  end
+
+  context 'nested dependencies' do
+    it 'walks the dependency chain of imported files' do
+      asset = env['nested_import']
+      dependencies = dependencies_on(asset)
+
+      expect(dependencies).to include(fixture_path('mixins/nested'))
+      expect(dependencies).to include(fixture_path('mixins/vendor'))
+    end
+
+    it "adds files referenced in a directory's index file" do
+      asset = env['indexed_nested_import']
+      dependencies = dependencies_on(asset)
+
+      expect(dependencies).to include(fixture_path('indexed/index'))
+      expect(dependencies).to include(fixture_path('indexed/first_dep'))
+      expect(dependencies).to include(fixture_path('indexed/second_dep'))
+    end
+
+    it 'walks dependency chains through indexes' do
+      asset = env['indexed_recursive_import']
+      dependencies = dependencies_on(asset)
+
+      expect(dependencies).to include(fixture_path('indexed_nested_import'))
+      expect(dependencies).to include(fixture_path('indexed/index'))
+      expect(dependencies).to include(fixture_path('indexed/first_dep'))
+      expect(dependencies).to include(fixture_path('indexed/second_dep'))
+    end
+  end
+
+  it 'does not process non-stylus files' do
+    source = '@import "nib"'
+    template = Stylus::ImportProcessor.new('stylesheet.scss') { source }
+    context = double
+
+    expect(context).to_not receive(:depend_on)
+    template.render(context)
+  end
+
+  it 'swallows errors from files outside the Sprockets paths' do
+    source = '@import "nib"'
+    template = Stylus::ImportProcessor.new { source }
+    sprockets = double
+    expect(sprockets).to receive(:resolve).twice.and_raise(::Sprockets::FileNotFound)
+    expect(template).to receive(:stylus_file?).and_return(true)
+
+    expect {
+      template.render(sprockets)
+    }.to_not raise_error
+  end
+end

data/spec/rails_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe 'Rails integration' do
+  it "copies all folders from the Sprockets load path" do
+    app = create_app
+    Stylus.paths.should include fixture_root
+    Stylus.paths.should == app.assets.paths
+  end
+
+  it 'process .styl files with the asset pipeline' do
+    result = fixture(:simple).last
+
+    app = create_app
+    app.assets['simple'].to_s.should == result
+  end
+
+  it 'enables @import definitions' do
+    result = fixture(:import).last
+
+    app = create_app
+    app.assets['import'].to_s.should == result
+  end
+
+  it 'skips debug info by default' do
+    app = create_app
+    asset = app.assets['simple']
+    asset.to_s.should_not match(/line 1 : #{asset.pathname}/)
+  end
+
+  it 'provides debug info if required' do
+    app = create_app(:debug => true)
+    asset = app.assets['simple']
+    asset.to_s.should match(/line 1 : #{asset.pathname}/)
+  end
+
+  it 'compress the output if Rails is configured to compress them too' do
+    result = fixture(:compressed).last
+
+    app = create_app(:compress => true)
+    app.assets['compressed'].to_s.should == result
+  end
+
+  it 'loads the app normally even when the asset pipeline is disabled' do
+    pending "TODO: supress the sprockets-rails railtie to test this."
+  end
+end

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 '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)
+  end
+
+  it 'handles the compress flag globally' do
+    Stylus.compress = true
+    input, output = fixture(:compressed)
+    expect(Stylus.compile(input)).to eq(output)
+  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/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