nov-stylus 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ab0aa9dc4ad044156ba701e1487792aee03a6f0e
+  data.tar.gz: a141a351f852c512760235d1449e25f17945d233
+SHA512:
+  metadata.gz: e80674050e314d3d58a6fc33d19bfd095d8ad845624a1db3b13c628dcb263882921fb3502ca8aed314b5b0cf64052c5bfc8640e7e7651238866f2251a93d70f3
+  data.tar.gz: 02a31e6e5314b220c7b607749df6c552aa15fa9b0ebb592c6234d71208d6702ab2376ae0839bc676f5cc2de2755b24799c95fa59ab5ac7c1323b7f51b146ba78

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+### 1.0.1
+
+* Prevent exceptions from files without extensions.
+
+### 1.0.0
+
+* Rails 4+ and Ruby 1.9.x/2.0.0 support.
+* Support for the `asset-path` and `asset-url` mixins, thanks to [@spilin](https://github.com/spilin).
+
+Please check [0-7-stable](https://github.com/lucasmazza/ruby-stylus/blob/0-7-stable/CHANGELOG.md) for previous changes.

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2012-2015 Lucas Mazza; 2015 Forge Software, LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,168 @@
+# Ruby Stylus
+
+[![Gem Version](https://badge.fury.io/rb/stylus.svg)](http://badge.fury.io/rb/stylus)
+[![Build Status](https://travis-ci.org/forgecrafted/ruby-stylus.svg?branch=master)](https://travis-ci.org/forgecrafted/ruby-stylus)
+[![Coverage Status](https://coveralls.io/repos/forgecrafted/ruby-stylus/badge.svg)](https://coveralls.io/r/forgecrafted/ruby-stylus)
+
+`stylus` is a bridge between Ruby and the [Stylus](https://github.com/stylus/stylus) library that runs on [node.js](http://nodejs.org). It has support for Rails 4 applications. (if you are working with Rails 3, check the [0-7-stable](https://github.com/forgecrafted/ruby-stylus/tree/0-7-stable) branch.)
+
+## Installation
+
+If you have a `Gemfile`:
+
+```
+gem 'stylus'
+```
+
+or install it on your system:
+
+```
+gem install stylus
+```
+
+The [ruby-stylus-source](https://github.com/forgecrafted/ruby-stylus-source) packages the Stylus source into a gem, and is installed as a dependency of this gem.  Versions of `ruby-stylus-source` follow Stylus releases and their versions.
+
+You can manually replace the Stylus code by placing another version of Stylus on `./node_modules/stylus`, and it will be used instead of the version bundled inside the gem.
+
+**REMEMBER**, you still need the `node` command available on your runtime for this gem to work. This gem is also compatible with the Heroku Cedar stack, enabling asset compilation during the deployment of your apps. You can check the [Node.js wiki](https://github.com/joyent/node/wiki/Quick-and-easy-installation) for more info.
+
+## Usage
+
+The interaction is done by the `Stylus` module. You can compile Stylus syntax to CSS, convert it back, enable plugins and tweak some other options:
+
+```ruby
+require 'stylus'
+
+# Accepts a raw string or an IO object (File, StringIO or anything that responds to 'read').
+Stylus.compile(File.new('application.styl')) # returns the compiled stylesheet.
+
+# Use the :compress option, removing most newlines from the code.
+Stylus.compile(File.read('application.styl'), compress: true)
+
+# Or use the global compress flag
+Stylus.compress = true
+Stylus.compile(File.read('application.styl'))
+
+# Convert old and boring CSS to awesome Stylus.
+Stylus.convert(File.new('file.css'))
+
+# Import plugins directly from Node.js, like nib.
+Stylus.use :nib
+
+# Enable debug info, which sends the 'linenos' and 'firebug' options to Stylus.
+# If you provide a raw content String to the `Stylus.compile` method, remember to send
+# a `:filename` option so Stylus can locate your stylesheet for proper inspection.
+Stylus.debug = true
+```
+
+### With Rails and the Asset Pipeline.
+
+Adding `stylus` to your Gemfile should let you work with `.styl` files with the Rails 3.1 Pipeline. Any asset generated with `rails generate` will be created with a `.css.styl` extension.
+
+Any `@import` directive will add the stylesheet as a sprockets dependency, so you can update external libraries and it will reflect on your assets fingerprints. Also, the Sprockets load path (usually `app/assets`, `lib/assets`, `vendor/assets` and the `assets` folder inside any other gem) will be available to your stylesheets.
+
+If the `config.assets.debug` is turned on, Stylus will emit extra comments on your stylesheets to help debugging and inspection using the `linenos` and `firebug` options. Check the [FireStylus extension for Firebug](https://github.com/stylus/stylus/blob/master/docs/firebug.md) for more info.
+
+It should be noted that in a default rails project you should also remove the sass-rails gem. This gem includes the tilt gem required by the asset pipeline so you should also add that gem back on its own.
+
+```
+# gem 'sass-rails'
+gem 'tilt'
+```
+
+For compilation of assets during deployment (e.g. for heroku) you'll also need to enable/add the rubyracer gem.
+
+```
+# See https://github.com/rails/execjs#readme for more supported runtimes
+gem 'therubyracer', platforms: :ruby
+```
+
+### `@import` and file extensions.
+  
+Stylus and Sprockets file lookups differ on the subject of handling file extensions, and that may hurt a bit.
+
+If you use Stylus `@import` to expose variables, mixins or just to concatenate code, you should use only the `.styl` extension on your imported files. If you use the `.css.styl` form (a convention from Sprockets), Stylus will treat it as a plain CSS file since it has `.css` on its name.
+
+```sass
+// imports mixins.styl
+@import 'mixins'
+```
+
+### `@import` dependency resolution
+
+Because of how sprockets handles dependency resolution for computing file changes and expiring caches, it is necessary to specify the full import path in your import statements.
+
+That is, given:
+
+```
+app/assets/stylesheets/
+app/assets/stylesheets/file.styl
+app/assets/stylesheets/some_directory/other_file.styl
+app/assets/stylesheets/some_directory/another_file.styl
+```
+
+Imports should be specified with the full path relative to `app/assets/stylesheets` regardless of where the file calling the import is. In this example we use the `app/assets` directory, but this also applies to `vendor/assets` and `lib/assets`.
+
+```ruby
+# app/assets/stylesheets/file.styl
+@import "some_directory/other_file.styl"
+
+# app/assets/stylesheets/some_directory/other_file.styl
+@import "some_directory/another_file.styl"
+```
+
+This will ensure that all changes get reflected when any of the imported
+files change. If you don't do this, sprockets will not accurately be
+able to keep track of your dependencies.
+
+### Standalone Sprockets usage
+
+If you're using Sprockets outside Rails, on Sinatra or on a plain Rack app, you can wire up Stylus inside a instance of `Sprockets::Environment` with the `Stylus.setup` method.
+
+An example of serving stylesheets from `./stylesheets` using just Sprockets and Rack.
+
+```ruby
+require 'sprockets'
+require 'stylus/sprockets'
+
+# Serve your stylesheets living on ./stylesheets
+assets = Sprockets::Environment.new
+assets.append_path('stylesheets')
+
+Stylus.setup(assets)
+
+# Run the Sprockets with Rack
+map('/assets') { run assets.index }
+```
+
+## Plugins
+
+[Stylus](https://github.com/stylus/stylus) exposes a nice API to create plugins written on [node.js](http://nodejs.org), like [nib](https://github.com/visionmedia/nib). The installation process should be the same as described above for [Stylus](https://github.com/stylus/stylus) (since they're all npm packages after all). You can hook them up on your Ruby code with `Stylus.use`:
+
+```ruby
+Stylus.use :fingerprint, literal: 'caa8c262e23268d2a7062c6217202343b84f472b'
+```
+
+Will run something like this in JavaScript:
+
+```javascript
+stylus(file).use(fingerprint({literal:'caa8c262e23268d2a7062c6217202343b84f472b'}));
+```
+
+## Questions, Bugs or Support
+
+[Drop us a line in the issues section](https://github.com/forgecrafted/ruby-stylus/issues).
+
+**Be sure to include sample code that reproduces the problem.**
+
+For more info about Stylus syntax and its features, you can check the [project repository](https://github.com/stylus/stylus), and the docs on the [GitHub page](http://stylus.github.io/stylus/).
+
+## Changelog
+
+[Available here.](https://github.com/forgecrafted/ruby-stylus/blob/master/CHANGELOG.md)
+
+## License
+
+Copyright (c) 2012-2015 Lucas Mazza; 2015 Forge Software, LLC.
+
+This is free software, and may be redistributed under the terms specified in the LICENSE file.

data/lib/rails/generators/stylus/assets/assets_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators/named_base'
+
+module Stylus
+  module Generators
+    class AssetsGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+
+      def copy_stylus
+        template 'stylesheet.css.styl', File.join('app/assets/stylesheets', class_path, "#{file_name}.css.styl")
+      end
+    end
+  end
+end

data/lib/rails/generators/stylus/assets/templates/stylesheet.css.styl

@@ -0,0 +1,3 @@
+// Place all the styles related to the matching controller here.
+// They will automatically be included in application.css.
+// You can use Stylus syntax here: http://learnboost.github.io/stylus

data/lib/rails/generators/stylus/scaffold/scaffold_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators/css/scaffold/scaffold_generator'
+
+module Stylus
+  module Generators
+    # Just inherit from the original Generator from Rails
+    # because `scaffold.css` it's just to help people to start up
+    # their Rails applications.
+    class ScaffoldGenerator < Css::Generators::ScaffoldGenerator
+    end
+  end
+end

data/lib/stylus/import_processor.rb

@@ -0,0 +1,71 @@
+# Based on the ImportProcessor from the less-rails gem, by @metaskills
+module Stylus
+  # Internal: A Tilt template that tracks down '@import' declarations
+  # and marks them as a dependency on the current asset.
+  #
+  # Example
+  #
+  #  @import 'dashboard'
+  #  # => A '//= depend_on dashboard' directive can be ommited from the stylesheet.
+  class ImportProcessor < Tilt::Template
+
+    IMPORT_SCANNER = /@import\s*['"]([^'"]+)['"]\s*/.freeze
+
+    # Internal: Tilt default interface requirement.
+    #
+    # Returns nothing.
+    def prepare
+    end
+
+    # Public: Scans the current stylesheet to track down Stylus
+    # '@import' calls as dependencies.
+    #
+    # Returns the stylesheet content, unmodified.
+    def evaluate(context, locals, &block)
+      return data unless stylus_file?(context)
+
+      depend_on(context, data)
+      data
+    end
+
+    private
+
+    # Internal: Returns true if the file being processed counts as a
+    # Stylus file (That is, it has a .styl extension).
+    def stylus_file?(context)
+      File.fnmatch('*.styl', file) || File.fnmatch('*.styl.*', file)
+    end
+
+    # Internal: Scan the stylesheet body, looking for '@import' calls to
+    # declare them as a dependency on the context using 'depend_on' method.
+    # This method will recursively scans all dependency to ensure that
+    # the current stylesheet tracks down nested dependencies.
+    def depend_on(context, data)
+      dependencies = data.scan(IMPORT_SCANNER).flatten.compact.uniq
+
+      dependencies.each do |path|
+        asset = resolve(context, path)
+
+        if asset
+          context.depend_on(asset)
+          depend_on(context, File.read(asset))
+        end
+      end
+    end
+
+    # Internal: Resolves the given 'path' with the Sprockets context, but
+    # avoids 'Sprockets::FileNotFound' exceptions since we might be importing
+    # files outside the Sprockets load path - like "nib".
+    #
+    # Returns the resolved 'Asset' or nil if it can't be found.
+    def resolve(context, path)
+      context.resolve(path, content_type: 'text/css')
+    rescue ::Sprockets::FileNotFound
+      begin
+        context.resolve(path + '/index', content_type: 'text/css')
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/stylus/railtie.rb

@@ -0,0 +1,32 @@
+require 'stylus'
+require 'stylus/sprockets'
+
+module Stylus
+  # Internal: The Railtie responsible for integrate the Stylus library with
+  # a Rails application.
+  #
+  # Some of the customizations of using Stylus alongside Rails:
+  #
+  # * The application will use the Stylus stylesheet engine;
+  # * The Sprockets instance (present at Rails.application.assets) will be configured
+  #   with the Stylus templates and the configurations defined at 'config.assets' will
+  #   affect how Stylus compile your stylesheets;
+  # * The assets load path - the folders living on app/assets/stylesheets,
+  #   lib/assets/stylesheets and vendor/assets/stylesheets on your app - will be
+  #   added to the Stylus path registry.
+  class Railtie < ::Rails::Railtie
+
+    # Internal: Set the Stylesheet engine to 'stylus', so the generator constants
+    # will be loaded from the `Stylus::Generators` namespace.
+    config.app_generators.stylesheet_engine :stylus
+
+    # Internal: Initializer block that uses the Stylus.setup utility to configure
+    # both Stylus and the Sprockets instance that lives on 'app.assets'. The entire
+    # configuration object will be passed along.
+    #
+    # Returns nothing.
+    config.assets.configure do |env|
+      Stylus.setup(env, config.assets.merge(rails: true))
+    end
+  end
+end

data/lib/stylus/runtime/compiler.js

@@ -0,0 +1,40 @@
+var stylus = require('stylus');
+
+function compile(str, options, plugins, imports, definitions) {
+  var style = stylus(str, options);
+  var output = '';
+
+  for(var name in plugins) {
+    var fn = require(name);
+    style.use(fn(plugins[name]));
+  }
+
+  imports.forEach(function(path) {
+    style.import(path);
+  })
+
+  for(var definition in definitions) {
+    obj = definitions[definition];
+    value = obj.value
+
+    if(obj.literal) {
+      value = new stylus.nodes.Literal(value);
+    }
+
+    style.define(definition, value);
+  }
+
+  style.render(function(error, css) {
+    if(error) throw error;
+    output = css;
+  })
+  return output;
+}
+
+function convert(str) {
+  return stylus.convertCSS(str);
+}
+
+function version() {
+  return stylus.version;
+}

data/lib/stylus/runtime/runner.js

@@ -0,0 +1,20 @@
+(function(program, execJS) { execJS(program) })(function() { #{source}
+}, function(program) {
+  var output, print = function(string) {
+    process.stdout.write('' + string);
+  };
+  try {
+    result = program();
+    if (typeof result == 'undefined' && result !== null) {
+      print('["ok"]');
+    } else {
+      try {
+        print(JSON.stringify(['ok', result]));
+      } catch (err) {
+        print('["err"]');
+      }
+    }
+  } catch (err) {
+    print(JSON.stringify(['err', '' + err]));
+  }
+});

data/lib/stylus/runtime.rb

@@ -0,0 +1,54 @@
+require 'execjs'
+
+module Stylus
+  # Internal: Module responsible for the ExecJS interaction. Besides handling
+  # the compilation execution, this module provide a runtime validation to ensure
+  # that the Node.JS binary is available to use.
+  module Runtime
+    # Internal: Calls a specific function on the Node.JS context.
+    #
+    # Example
+    #  exec('version', 2) # => '2'
+    #
+    # Returns The function returned value.
+    def exec(*arguments)
+      check_availability!
+      context.call(*arguments)
+    end
+
+    private
+    # Internal: Queries the runtime for it's availability and raises a 'RuntimeError'
+    # if the runtime isn't available. Otherwise, this is a noop.
+    def check_availability!
+      unless runtime.available?
+        message = 'The Node.JS runtime is not available to Stylus.'
+        message << 'Ensure that the "node" (or "nodejs") executable is present in your $PATH.'
+        raise RuntimeError, message
+      end
+    end
+
+    # Internal: Compile the Stylus compilation script into a execution context
+    # to execute functions into.
+    #
+    # Returns the compiled context.
+    def context
+      @context ||= runtime.compile(script)
+    end
+
+    # Internal: The custom compilation script body.
+    def script
+      File.read(File.expand_path('../runtime/compiler.js',__FILE__))
+    end
+
+    # Internal: Create the ExecJS external runtime with a old runner script that
+    # maintains the state of 'require', so we can use it to load modules like on
+    # any Node.JS program.
+    def runtime
+      @runtime ||= ExecJS::ExternalRuntime.new(
+        name:        'Node.js (V8)',
+        command:     ['nodejs', 'node'],
+        runner_path: File.expand_path('../runtime/runner.js', __FILE__)
+        )
+    end
+  end
+end

data/lib/stylus/sprockets.rb

@@ -0,0 +1,59 @@
+require 'stylus'
+require 'stylus/tilt/stylus'
+require 'stylus/tilt/rails'
+require 'stylus/import_processor'
+# Public: The setup logic to configure both Stylus and Sprockets on any
+# kind of application - Rails, Sinatra or Rack.
+#
+# Example
+#
+#  # mounting Sprockets as a Rack application with Stylus
+#  assets = Sprockets::Environment.new
+#  assets.append_path 'stylesheets'
+#  Stylus.setup(assets)
+#  run assets.index
+module Stylus
+  # Public: Configure a Sprockets environment with Stylus Tilt engine
+  # and the ImportProcessor. It also accept a configuration Hash to
+  # setup the load path and flags of the Stylus module.
+  #
+  # environment - A instance of Sprockets::Environment.
+  # options     - The configuration Hash (default: {})
+  #             :rails - a flag to inform that the current application is a Rails app.
+  #             :paths - An Array of paths to use the '@import' directive, defaults
+  #                      to the `paths` attribute on the environment object.
+  #             :debug - The Boolean value for the debug flag.
+  #             :compress - The Boolean value for the debug compress.
+  #
+  # Example
+  #
+  #  assets = Sprockets::Environment.new
+  #  Stylus.setup(assets, compress: settings.production?)
+  #
+  # Returns nothing.
+  def self.setup(environment, options = {})
+    paths = options[:paths] || environment.paths
+
+    Stylus.paths.concat(paths)
+
+    Stylus.debug = options.fetch(:debug, Stylus.debug)
+    Stylus.compress = options.fetch(:compress, Stylus.compress)
+    template = detect_template_hander(options)
+    environment.register_mime_type 'text/styl', extensions: ['.styl']
+    environment.register_mime_type 'text/css', extensions: ['.css']
+    environment.register_transformer 'text/styl', 'text/css', template
+  end
+
+  # Internal: Gets the desired Tilt template handler to the current configuration.
+  # If a 'rails' option is present then the Rails specific template will be
+  # returned instead of the default Stylus Tilt template.
+  #
+  # Returns a Tilt::Template children class.
+  def self.detect_template_hander(options = {})
+    if options[:rails]
+      Stylus::Rails::StylusTemplate
+    else
+      Tilt::StylusTemplate
+    end
+  end
+end

data/lib/stylus/tilt/rails.rb

@@ -0,0 +1,53 @@
+require 'stylus/tilt/stylus'
+# Public: A Tilt template to compile Stylus stylesheets with asset helpers.
+module Stylus
+  module Rails
+    class StylusTemplate < ::Tilt::StylusTemplate
+      EXCLUDED_EXTENSIONS = %w{ css js gzip json md html }
+
+      # Public: The default mime type for stylesheets.
+      self.default_mime_type = 'text/css'
+
+      # Internal: Appends stylus mixin for asset_url and asset_path support
+      def evaluate(scope, locals, &block)
+        @data = build_mixin_body(scope) + data
+        super
+      end
+
+      protected
+
+      # Internal: Builds body of a mixin
+      #
+      # Returns string representation of a mixin with asset helper functions
+      def build_mixin_body(scope)
+        @mixin_body ||= if assets_hash(scope).values.all? {|value| value != '' }
+                          <<-STYL
+asset-url(key)
+  return pair[1] if pair[0] == key for pair in #{assets_hash(scope)[:url]} ()
+asset-path(key)
+  return pair[1] if pair[0] == key for pair in #{assets_hash(scope)[:path]} ()
+                          STYL
+                        else
+                          ''
+                        end
+      end
+
+      # Internal: Construct Hash with absolute/relative paths in stylus syntax.
+      #
+      # Returns string representations of hash in Stylus syntax
+      def assets_hash(scope)
+        @assets_hash ||= scope.environment.each_logical_path.each_with_object({ :url => '', :path => '' }) do |logical_path, assets_hash|
+          extensions = EXCLUDED_EXTENSIONS.join('|')
+          unless File.extname(logical_path) =~ Regexp.new("^(\.(#{extensions})|)$")
+            path_to_asset = scope.path_to_asset(logical_path)
+            assets_hash[:url] << "('#{logical_path}' url(\"#{path_to_asset}\")) "
+            assets_hash[:path] << "('#{logical_path}' \"#{path_to_asset}\") "
+          end
+        end
+      end
+
+    end
+  end
+end
+
+Tilt.register ::Stylus::Rails::StylusTemplate, 'styl'

data/lib/stylus/tilt/stylus.rb

@@ -0,0 +1,52 @@
+require 'tilt'
+# Public: A Tilt template to compile Stylus stylesheets.
+#
+# Examples
+#
+#  template = Tilt::StylusTemplate.new { |t| File.read('app.styl') }
+#  template.render # => the compiled CSS from the app.styl file.
+#
+#  Options should assigned on the template constructor.
+#  template = Tilt::StylusTemplate.new(compress: true) { |t| File.read('app.styl') }
+#  template.render # => the compiled CSS with compression enabled.
+module Tilt
+  class StylusTemplate < Template
+
+    # Public: The default mime type for stylesheets.
+    self.default_mime_type = 'text/css'
+
+    # Internal: Checks if the Stylus module has been properly defined.
+    #
+    # Returns true if the 'Stylus' module is present.
+    def self.engine_initialized?
+      defined? ::Stylus
+    end
+
+    # Internal: Require the 'stylus' file to load the Stylus module.
+    #
+    # Returns nothing.
+    def initialize_engine
+      require_template_library 'stylus'
+    end
+
+    # Internal: Caches the filename as an option entry if it's present.
+    #
+    # Returns nothing.
+    def prepare
+      if self.file
+        options[:filename] ||= self.file
+      end
+    end
+
+    # Internal: Compile the template Stylus using this instance options.
+    # The current 'scope' and given 'locals' are ignored and the output
+    # is cached.
+    #
+    # Returns a String with the compiled stylesheet with CSS syntax.
+    def evaluate(scope, locals, &block)
+      @output ||= Stylus.compile(data, options)
+    end
+  end
+end
+
+Tilt.register Tilt::StylusTemplate, 'styl'

data/lib/stylus/tilt.rb

@@ -0,0 +1,2 @@
+# require compatibility with older versions.
+require 'stylus/tilt/stylus'

data/lib/stylus/version.rb

@@ -0,0 +1,3 @@
+module Stylus
+  VERSION = '1.0.2'
+end