epuber-stylus 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e4fe8b935a89a5c33ed76565781f7ee79447753a
+  data.tar.gz: 61bdd3e96d0aa491d0bb07dd0333e89fcfa991f1
+SHA512:
+  metadata.gz: dd5c1ab079de3c7ab1ce14806520ef2c82cb91352cd20b5b6972631e10f73e4fcf9a0dd205f6a4b6b48fbfc17e8293939521b92422094e0a0d570d3c37c888fe
+  data.tar.gz: 13ada496cfb38974a8cca74302fa8d093ca25796a581c893ca6ceb4296f98dcec531d62555cedf2dafc98c46a0215fad4f452cdcbfd1ac94bdc5f7cb7e380df6

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,154 @@
+# 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.
+
+### `@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/epuber-stylus.rb

@@ -0,0 +1,174 @@
+require 'epuber-stylus/runtime'
+require 'stylus/source'
+require 'epuber-stylus/version'
+require 'epuber-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/lib/epuber-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/epuber-stylus/railtie.rb

@@ -0,0 +1,32 @@
+require 'epuber-stylus'
+require 'epuber-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