compass-sass37 1.1.0

data/lib/compass/exec/project_options_parser.rb

@@ -0,0 +1,74 @@
+module Compass::Exec::ProjectOptionsParser
+  def set_options(opts)
+    super
+    set_project_options(opts)
+  end
+  def set_dir_or_path(type, dir)
+    if Pathname.new(dir).absolute?
+      self.options[:"#{type}_path"] = dir.tr('\\','/')
+    else
+      self.options[:"#{type}_dir"] = dir.tr('\\','/')
+    end
+  end
+
+  def set_project_options(opts)
+    opts.on('-c', '--config CONFIG_FILE', 'Specify the location of the configuration file explicitly.') do |configuration_file|
+      self.options[:configuration_file] = configuration_file
+    end
+
+    opts.on('--app APP', 'Tell compass what kind of application it is integrating with. E.g. rails') do |project_type|
+      self.options[:project_type] = project_type.to_sym
+    end
+
+    opts.on('--app-dir PATH', 'The base directory for your application.') do |project_path|
+      self.options[:project_path] = project_path
+    end
+
+    opts.on('--sass-dir SRC_DIR', "The source directory where you keep your sass stylesheets.") do |sass_dir|
+      set_dir_or_path(:sass, sass_dir)
+    end
+
+    opts.on('--css-dir CSS_DIR', "The target directory where you keep your css stylesheets.") do |css_dir|
+      set_dir_or_path(:css, css_dir)
+    end
+
+    opts.on('--images-dir IMAGES_DIR', "The directory where you keep your images.") do |images_dir|
+      set_dir_or_path(:images, images_dir)
+    end
+
+    opts.on('--javascripts-dir JS_DIR', "The directory where you keep your javascripts.") do |javascripts_dir|
+      set_dir_or_path(:javascripts, javascripts_dir)
+    end
+
+    opts.on('--fonts-dir FONTS_DIR', "The directory where you keep your fonts.") do |fonts_dir|
+      set_dir_or_path(:fonts, fonts_dir)
+    end
+
+    opts.on('-e ENV', '--environment ENV', [:development, :production], 'Use sensible defaults for your current environment.',
+            '  One of: development (default), production') do |env|
+      self.options[:environment] = env
+    end
+
+    opts.on('-s STYLE', '--output-style STYLE', [:nested, :expanded, :compact, :compressed], 'Select a CSS output mode.',
+            '  One of: nested, expanded, compact, compressed') do |style|
+      self.options[:output_style] = style
+    end
+
+    opts.on('--relative-assets', :NONE, 'Make compass asset helpers generate relative urls to assets.') do
+      self.options[:relative_assets] = true
+    end
+
+    opts.on('--no-line-comments', :NONE, 'Disable line comments.') do
+      self.options[:line_comments] = false
+    end
+
+    opts.on('--http-path HTTP_PATH', 'Set this to the root of your project when deployed') do |http_path|
+      self.options[:http_path] = http_path
+    end
+
+    opts.on('--generated-images-path GENERATED_IMAGES_PATH', 'The path where you generate your images') do |generated_images_path|
+      self.options[:generated_images_path] = generated_images_path
+    end
+  end
+
+end

data/lib/compass/exec/sub_command_ui.rb

@@ -0,0 +1,51 @@
+require 'compass/exec/global_options_parser'
+require 'compass/exec/project_options_parser'
+
+module Compass::Exec
+  class SubCommandUI
+
+    attr_accessor :args
+
+    def initialize(args)
+      self.args = args
+    end
+
+    def run!
+      begin
+        return perform!
+      rescue Exception => e
+        raise e if e.is_a? SystemExit
+        if e.is_a?(::Compass::Error) || e.is_a?(OptionParser::ParseError)
+          $stderr.puts e.message
+        else
+          ::Compass::Exec::Helpers.report_error(e, @options || {})
+        end
+        return 1
+      end
+    end
+    
+    protected
+    
+    def perform!
+      $command = args.shift
+      command_class = Compass::Commands[$command]
+      unless command_class
+        args.unshift($command)
+        $command = "help"
+        command_class = Compass::Commands::Default
+      end
+      @options = if command_class.respond_to?("parse_#{$command}!")
+        command_class.send("parse_#{$command}!", args)
+      else
+        command_class.parse!(args)
+      end
+      cmd = command_class.new(Dir.getwd, @options)
+      cmd.execute
+      cmd.successful? ? 0 : 1
+    rescue OptionParser::ParseError => e
+      puts "Error: #{e.message}"
+      puts command_class.usage if command_class.respond_to?(:usage)
+    end
+    
+  end
+end

data/lib/compass/exec.rb

@@ -0,0 +1,23 @@
+require 'compass/dependencies'
+require 'optparse'
+require 'compass/logger'
+require 'compass/errors'
+require 'compass/actions'
+require 'compass/installers'
+require 'compass/commands'
+require 'rbconfig'
+require 'pathname'
+begin
+  require 'win32console' if RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+rescue LoadError
+  $boring = true
+end
+
+module Compass::Exec
+end
+
+%w(helpers sub_command_ui
+   global_options_parser project_options_parser
+   command_option_parser).each do |lib|
+  require "compass/exec/#{lib}"
+end

data/lib/compass/generated_version.rb

@@ -0,0 +1,4 @@
+module Compass
+  # This file intentionall does nothing.
+  # The compass build scripts put the release VERSION constant here.
+end

data/lib/compass/installers/bare_installer.rb

@@ -0,0 +1,58 @@
+module Compass
+  module Installers
+
+    class BareInstaller < Base
+      def completed_configuration
+        nil
+      end
+
+      def init
+        directory targetize("")
+        directory targetize(Compass.configuration.sass_dir)
+      end
+
+      def prepare
+      end
+
+      def install
+        config_file ||= targetize('config.rb')
+        write_file config_file, config_contents
+      end
+
+      def config_contents
+        project_path, Compass.configuration.project_path = Compass.configuration.project_path, nil
+        Compass.configuration.serialize
+      ensure
+        Compass.configuration.project_path = project_path
+      end
+
+      def finalize(options = {})
+        puts <<-NEXTSTEPS
+
+*********************************************************************
+Congratulations! Your compass project has been created.
+
+You may now add sass stylesheets to the #{Compass.configuration.sass_dir} subdirectory of your project.
+
+Sass files beginning with an underscore are called partials and won't be
+compiled to CSS, but they can be imported into other sass stylesheets.
+
+You can configure your project by editing the config.rb configuration file.
+
+You must compile your sass stylesheets into CSS when they change.
+This can be done in one of the following ways:
+  1. To compile on demand:
+     compass compile [path/to/project]
+  2. To monitor your project for changes and automatically recompile:
+     compass watch [path/to/project]
+
+More Resources:
+  * Website: http://compass-style.org/
+  * Sass: http://sass-lang.com
+  * Community: http://groups.google.com/group/compass-users/
+NEXTSTEPS
+      end
+
+    end
+  end
+end

data/lib/compass/installers/base.rb

@@ -0,0 +1,187 @@
+module Compass
+  module Installers
+
+    class Base
+
+      include Actions
+
+      attr_accessor :template_path, :target_path, :working_path
+      attr_accessor :options
+
+      def initialize(template_path, target_path, options = {})
+        @template_path = template_path
+        @target_path = target_path
+        @working_path = Dir.getwd
+        @options = options
+        self.logger = options[:logger]
+      end
+
+      [:css_dir, :sass_dir, :images_dir, :javascripts_dir, :http_stylesheets_path, :fonts_dir, :preferred_syntax].each do |dir|
+        define_method dir do
+          Compass.configuration.send(dir)
+        end
+        define_method "#{dir}_without_default" do
+          Compass.configuration.send("#{dir}_without_default")
+        end
+      end
+
+      # Runs the installer.
+      # Every installer must conform to the installation strategy of prepare, install, and then finalize.
+      # A default implementation is provided for each step.
+      def run(run_options = {})
+        prepare unless run_options[:skip_preparation]
+        install unless options[:prepare]
+        finalize(options.merge(run_options)) unless options[:prepare] || run_options[:skip_finalization]
+      end
+
+      # The default prepare method -- it is a no-op.
+      # Generally you would create required directories, etc.
+      def prepare
+      end
+
+      # The install method override this to install
+      def install
+        raise "Not Yet Implemented"
+      end
+
+      # The default finalize method -- it is a no-op.
+      # This could print out a message or something.
+      def finalize(options = {})
+      end
+
+      def compilation_required?
+        false
+      end
+
+      def pattern_name_as_dir
+        "#{options[:pattern_name]}/" if options[:pattern_name]
+      end
+
+      def self.installer(type, installer_opts = {}, &locator)
+        locator ||= lambda{|to| to}
+        loc_method = "install_location_for_#{type}".to_sym
+        define_method("simple_#{loc_method}", locator)
+        define_method(loc_method) do |to, options|
+          if options[:like] && options[:like] != type
+            send("install_location_for_#{options[:like]}", to, options)
+          else
+            send("simple_#{loc_method}", to)
+          end
+        end
+        define_method "install_#{type}" do |from, to, options|
+          from = templatize(from)
+          to = targetize(send(loc_method, to, options))
+          is_binary = installer_opts[:binary] || options[:binary]
+          if is_binary
+            copy from, to, nil, is_binary
+          else
+            contents = File.new(from).read
+            if options.delete(:erb)
+              ctx = TemplateContext.ctx(:to => to, :options => options)
+              contents = process_erb(contents, ctx)
+            end
+            write_file to, contents
+          end
+        end
+      end
+
+      installer :stylesheet do |to|
+        "#{sass_dir}/#{pattern_name_as_dir}#{to}"
+      end
+
+      def install_stylesheet(from, to, options)
+        from = templatize(from)
+        to = targetize(install_location_for_stylesheet(to, options))
+        contents = File.new(from).read
+        if options.delete(:erb)
+          ctx = TemplateContext.ctx(:to => to, :options => options)
+          contents = process_erb(contents, ctx)
+        end
+        if preferred_syntax.to_s != from[-4..-1]
+          # logger.record :convert, basename(from)
+          tree = Sass::Engine.new(contents, Compass.sass_engine_options.merge(:syntax => from[-4..-1].intern)).to_tree
+          contents = tree.send("to_#{preferred_syntax}")
+          to[-4..-1] = preferred_syntax.to_s
+        end
+        write_file to, contents
+      end
+
+      installer :css do |to|
+        "#{css_dir}/#{to}"
+      end
+
+      installer :image, :binary => true do |to|
+        "#{images_dir}/#{to}"
+      end
+
+      installer :javascript do |to|
+        "#{javascripts_dir}/#{to}"
+      end
+
+      installer :font do |to|
+        "#{fonts_dir}/#{to}"
+      end
+
+      installer :file do |to|
+        "#{pattern_name_as_dir}#{to}"
+      end
+
+      installer :html do |to|
+        "#{pattern_name_as_dir}#{to}"
+      end
+
+      def install_directory(from, to, options)
+        d = if within = options[:within]
+          if respond_to?(within)
+            targetize("#{send(within)}/#{to}")
+          else
+            raise Compass::Error, "Unrecognized location: #{within}"
+          end
+        else
+          targetize(to)
+        end
+        directory d
+      end
+
+      alias install_html_without_haml install_html
+      def install_html(from, to, options)
+        if to =~ /\.haml$/
+          require 'haml'
+          to = to[0..-(".haml".length+1)]
+          if respond_to?(:install_location_for_html)
+            to = install_location_for_html(to, options)
+          end
+          contents = File.read(templatize(from))
+          if options.delete(:erb)
+            ctx = TemplateContext.ctx(:to => to, :options => options)
+            contents = process_erb(contents, ctx)
+          end
+          Compass.configure_sass_plugin!
+          html = Haml::Engine.new(contents, :filename => templatize(from)).render
+          write_file(targetize(to), html, options)
+        else
+          install_html_without_haml(from, to, options)
+        end
+      end
+
+      # returns an absolute path given a path relative to the current installation target.
+      # Paths can use unix style "/" and will be corrected for the current platform.
+      def targetize(path)
+        strip_trailing_separator File.join(target_path, separate(path))
+      end
+
+      # returns an absolute path given a path relative to the current template.
+      # Paths can use unix style "/" and will be corrected for the current platform.
+      def templatize(path)
+        strip_trailing_separator File.join(template_path, separate(path))
+      end
+
+      # Emits an HTML fragment that can be used to link to the compiled css files
+      def stylesheet_links
+        ""
+      end
+    end
+  end
+end
+require 'compass/installers/bare_installer'
+require 'compass/installers/manifest_installer'

data/lib/compass/installers/manifest.rb

@@ -0,0 +1,161 @@
+module Compass
+  module Installers
+
+    class Manifest
+      include Enumerable
+
+      # A Manifest entry
+      class Entry < Struct.new(:type, :from, :options)
+        def to
+          options[:to] || from
+        end
+      end
+
+      attr_reader :options
+      def initialize(manifest_file = nil, options = {})
+        @entries = []
+        @options = options
+        @generate_config = true
+        @compile_after_generation = true
+        parse(manifest_file) if manifest_file
+      end
+
+      def self.known_extensions
+        @known_extensions ||= {}
+      end
+
+      def self.plural_types
+        @plural_types ||= {}
+      end
+
+      def self.type(t, options = {})
+        Array(options[:extensions]).each do |ext|
+          self.known_extensions[ext] = t
+        end
+        self.plural_types[options[:plural]] = t if options[:plural]
+        eval <<-END
+          def #{t}(from, options = {})
+             @entries << Entry.new(:#{t}, from, options)
+          end
+          def has_#{t}?
+            @entries.detect {|e| e.type == :#{t}}
+          end
+          def each_#{t}
+            @entries.select {|e| e.type == :#{t}}.each {|e| yield e}
+          end
+        END
+      end
+
+      type :stylesheet, :plural => :stylesheets, :extensions => %w(scss sass)
+      type :image,      :plural => :images,      :extensions => %w(png gif jpg jpeg tiff gif)
+      type :javascript, :plural => :javascripts, :extensions => %w(js)
+      type :font,       :plural => :fonts,       :extensions => %w(eot otf woff ttf)
+      type :html,       :plural => :html,        :extensions => %w(html haml)
+      type :file,       :plural => :files
+      type :directory,  :plural => :directories
+
+      def discover(type)
+        type = self.class.plural_types[type] || type
+        dir = File.dirname(@manifest_file)
+        Dir.glob("#{dir}/**/*").each do |file|
+          next if /manifest\.rb/ =~ file
+          short_name = file[(dir.length+1)..-1]
+          options = {}
+          ext = if File.extname(short_name) == ".erb"
+            options[:erb] = true
+            File.extname(short_name[0..-5])
+          else
+            File.extname(short_name)
+          end[1..-1]
+          file_type = self.class.known_extensions[ext]
+          file_type = :file if file_type.nil?
+          file_type = :directory if File.directory?(file)
+          if type == :all || type == file_type
+            send(file_type, short_name, options)
+          end
+        end
+      end
+
+      def help(value = nil)
+        if value
+          @help = value
+        else
+          @help
+        end
+      end
+
+      attr_reader :welcome_message_options
+
+      def welcome_message(value = nil, options = {})
+        if value
+          @welcome_message = value
+          @welcome_message_options = options
+        else
+          @welcome_message
+        end
+      end
+
+      def welcome_message_options
+        @welcome_message_options || {}
+      end
+
+      def description(value = nil)
+        if value
+          @description = value
+        else
+          @description
+        end
+      end
+
+      # Enumerates over the manifest files
+      def each
+        @entries.each {|e| yield e}
+      end
+
+      def generate_config?
+        @generate_config
+      end
+
+      def compile?
+        @compile_after_generation
+      end
+
+      protected
+
+      def no_configuration_file!
+        @generate_config = false
+      end
+
+      def skip_compilation!
+        @compile_after_generation = false
+      end
+
+      def with_manifest(manifest_file)
+        @manifest_file = manifest_file
+        yield
+      ensure
+        @manifest_file = nil
+      end
+
+      # parses a manifest file which is a ruby script
+      # evaluated in a Manifest instance context
+      def parse(manifest_file)
+        with_manifest(manifest_file) do
+          if File.exist?(manifest_file)
+            open(manifest_file) do |f| 
+              eval(f.read, instance_binding, manifest_file)
+            end 
+          else
+              eval("discover :all", instance_binding, manifest_file)
+          end 
+        end 
+      end 
+
+
+      def instance_binding
+        binding
+      end
+    end
+
+  end
+end

data/lib/compass/installers/manifest_installer.rb

@@ -0,0 +1,61 @@
+module Compass
+  module Installers
+
+    class ManifestInstaller < Base
+
+      attr_accessor :manifest
+
+      def initialize(template_path, target_path, options = {})
+        super
+        @manifest = Manifest.new(manifest_file, options) if template_path
+      end
+
+      def manifest_file
+        @manifest_file ||= File.join(template_path, "manifest.rb")
+      end
+
+      # Initializes the project to work with compass
+      def init
+        dirs = manifest.map do |entry|
+          unless entry.type == :directory
+            loc = send("install_location_for_#{entry.type}", entry.to, entry.options)
+            File.dirname(loc)
+          end
+        end.compact
+
+        if manifest.has_stylesheet?
+          dirs << sass_dir
+          dirs << css_dir
+        end
+
+        dirs.uniq.sort.each do |dir|
+          directory targetize(dir)
+        end
+      end
+
+      # The default install method. Calls install_<type> methods in the order specified by the manifest.
+      def install
+        manifest.each do |entry|
+          send("install_#{entry.type}", entry.from, entry.to, entry.options)
+        end
+      end
+
+      def stylesheet_links
+        html = "<head>\n"
+        manifest.each_stylesheet do |stylesheet|
+          # Skip partials.
+          next if File.basename(stylesheet.from)[0..0] == "_"
+          media = if stylesheet.options[:media]
+            %Q{ media="#{stylesheet.options[:media]}"}
+          end
+          ss_line = %Q{  <link href="#{http_stylesheets_path}/#{stylesheet.to.sub(/\.s[ac]ss$/,'.css')}"#{media} rel="stylesheet" type="text/css" />}
+          if stylesheet.options[:condition]
+            ss_line = "  <!--[if #{stylesheet.options[:condition]}]>\n    #{ss_line}\n  <![endif]-->"
+          end
+          html << ss_line + "\n"
+        end
+        html << "</head>"
+      end
+    end
+  end
+end

data/lib/compass/installers/template_context.rb

@@ -0,0 +1,44 @@
+module Compass
+  module Installers
+    class TemplateContext
+
+      def self.ctx(*arguments)
+        new(*arguments).send(:get_binding)
+      end
+
+      def initialize(template, locals = {})
+        @template = template
+        @locals = locals
+      end
+
+      def http_stylesheets_path
+        config.http_stylesheets_path ||
+        config.default_for(:http_stylesheets_path) ||
+        config.http_root_relative(config.css_dir)
+      end
+
+      Compass::Configuration::ATTRIBUTES.each do |attribute|
+        unless instance_methods.include?(attribute.to_s)
+          define_method attribute do
+            config.send(attribute) || config.default_for(attribute)
+          end
+        end
+      end
+
+      def config
+        Compass.configuration
+      end
+
+      alias configuration config
+
+      protected
+
+      def get_binding
+        @locals.each do |k, v|
+          eval("#{k} = v")
+        end
+        binding
+      end
+    end
+  end
+end

data/lib/compass/installers.rb

@@ -0,0 +1,3 @@
+%w(manifest template_context base manifest_installer bare_installer).each do |f|
+  require "compass/installers/#{f}"
+end