epuber-stylus 1.1.0

data/lib/epuber-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/epuber-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/epuber-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/epuber-stylus/sprockets.rb

@@ -0,0 +1,58 @@
+require 'epuber-stylus'
+require 'epuber-stylus/tilt/stylus'
+require 'epuber-stylus/tilt/rails'
+require 'epuber-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_engine('.styl', template)
+    environment.register_preprocessor('text/css', Stylus::ImportProcessor)
+  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/epuber-stylus/tilt.rb

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

data/lib/epuber-stylus/tilt/rails.rb

@@ -0,0 +1,51 @@
+require 'epuber-stylus/tilt/stylus'
+# Public: A Tilt template to compile Stylus stylesheets with asset helpers.
+module Stylus
+  module Rails
+    class StylusTemplate < ::Tilt::StylusTemplate
+
+      # 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|
+          unless File.extname(logical_path) =~ /^(\.(css|js)|)$/
+            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/epuber-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/epuber-stylus/version.rb

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

data/lib/rails/generators/epuber-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/epuber-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/epuber-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/spec/generators/assets_generator_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'rails/generators/epuber-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/epuber-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/epuber-stylus/assets/assets_generator'
+require 'rails/generators/epuber-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.rstrip
+  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