compass 0.13.alpha.12 → 1.0.0.alpha.13

data/lib/compass/configuration/inheritance.rb

@@ -1,304 +0,0 @@
-module Compass
-  module Configuration
-    # The inheritance module makes it easy for configuration data to inherit from
-    # other instances of configuration data. This makes it easier for external code to layer
-    # bits of configuration from various sources.
-    module Inheritance
-
-      def self.included(base)
-        # inherited_data stores configuration data that this configuration object will
-        # inherit if not provided explicitly.
-        base.send :attr_accessor, :inherited_data, :set_attributes, :top_level
-
-        base.send(:include, InstanceMethods)
-        base.extend(ClassMethods)
-      end
-
-      module ClassMethods
-        def inherited_writer(*attributes)
-          attributes.each do |attribute|
-            line = __LINE__ + 1
-            class_eval %Q{
-              def #{attribute}=(value)                        # def css_dir=(value)
-                @set_attributes ||= {}                        #   @set_attributes ||= {}
-                @set_attributes[#{attribute.inspect}] = true  #   @set_attributes[:css_dir] = true
-                @#{attribute} = value                         #   @css_dir = value
-              end                                             # end
-
-              def unset_#{attribute}!                         # def unset_css_dir!
-                unset!(#{attribute.inspect})                  #   unset!(:css_dir)
-              end                                             # end
-
-              def #{attribute}_set?                           # def css_dir_set?
-                set?(#{attribute.inspect})                    #   set?(:css_dir)
-              end                                             # end
-            }, __FILE__, line
-          end
-        end
-
-        # Defines the default reader to be an inherited_reader that will look at the inherited_data for its
-        # value when not set. The inherited reader calls to a raw reader that acts like a normal attribute
-        # reader but prefixes the attribute name with "raw_".
-        def inherited_reader(*attributes)
-          attributes.each do |attribute|
-            line = __LINE__ + 1
-            class_eval %Q{
-              def raw_#{attribute}                         # def raw_css_dir
-                @#{attribute}                              #   @css_dir
-              end                                          # end
-              def #{attribute}_without_default             # def css_dir_without_default
-                read_without_default(#{attribute.inspect}) #  read_without_default(:css_dir)
-              end                                          # end
-              def #{attribute}                             # def css_dir
-                read(#{attribute.inspect})                 #  read(:css_dir)
-              end                                          # end
-            }, __FILE__, line
-          end
-        end
-
-        def inherited_accessor(*attributes)
-          inherited_reader(*attributes)
-          inherited_writer(*attributes)
-        end
-
-        class ArrayProxy
-          def initialize(data, attr)
-            @data, @attr = data, attr
-          end
-          def to_ary
-            @data.send(:"read_inherited_#{@attr}_array")
-          end
-          def to_a
-            to_ary
-          end
-          def <<(v)
-            @data.send(:"add_to_#{@attr}", v)
-          end
-          def >>(v)
-            @data.send(:"remove_from_#{@attr}", v)
-          end
-          def serialize_to_config(prop)
-            if v = @data.raw(prop)
-              "#{prop} = #{v.inspect}"
-            else
-              s = ""
-              if added = @data.instance_variable_get("@added_to_#{@attr}")
-                added.each do |a|
-                  s << "#{prop} << #{a.inspect}\n"
-                end
-              end
-              if removed = @data.instance_variable_get("@removed_from_#{@attr}")
-                removed.each do |r|
-                  s << "#{prop} >> #{r.inspect}\n"
-                end
-              end
-              if s[-1..-1] == "\n"
-                s[0..-2]
-              else
-                s
-              end
-            end
-          end
-          def method_missing(m, *args, &block)
-            a = to_ary
-            if a.respond_to?(m)
-              a.send(m,*args, &block)
-            else
-              super
-            end
-          end
-        end
-
-        def inherited_array(*attributes)
-          inherited_reader(*attributes)
-          inherited_writer(*attributes)
-          attributes.each do |attr|
-            line = __LINE__ + 1
-            class_eval %Q{
-              def #{attr}                                          # def sprite_load_paths
-                ArrayProxy.new(self, #{attr.inspect})              #   ArrayProxy.new(self, :sprite_load_paths)
-              end                                                  # end
-              def #{attr}=(value)                                  # def sprite_load_paths=(value)
-                @set_attributes ||= {}                             #   @set_attributes ||= {}
-                @set_attributes[#{attr.inspect}] = true            #   @set_attributes[:sprite_load_paths] = true
-                @#{attr} = Array(value)                            #   @sprite_load_paths = Array(value)
-                @added_to_#{attr} = []                             #   @added_to_sprite_load_paths = []
-                @removed_from_#{attr} = []                         #   @removed_from_sprite_load_paths = []
-              end                                                  # end
-              def read_inherited_#{attr}_array                     # def read_inherited_sprite_load_paths_array
-                if #{attr}_set?                                    #  if sprite_load_paths_set?
-                  @#{attr}                                         #    Array(@#{attr})
-                else                                               #  else
-                  value = if inherited_data                        #    value = Array(read(:sprite_load_paths))
-                    Array(inherited_data.#{attr})
-                  else
-                    Array(read(#{attr.inspect}))
-                  end
-                  value -= Array(@removed_from_#{attr})            #    value -= Array(@removed_from_sprite_load_paths)
-                  Array(@added_to_#{attr}) + value                 #    Array(@added_to_sprite_load_paths) + value
-                end                                                #  end
-              end                                                  # end
-              def add_to_#{attr}(v)                                # def add_to_sprite_load_paths(v)
-                if #{attr}_set?                                    #   if sprite_load_paths_set?
-                  raw_#{attr} << v                                 #     raw_sprite_load_paths << v
-                else                                               #   else
-                  (@added_to_#{attr} ||= []) << v                  #     (@added_to_sprite_load_paths ||= []) << v
-                end                                                #   end
-              end                                                  # end
-              def remove_from_#{attr}(v)                           # def remove_from_sprite_load_paths(v)
-                if #{attr}_set?                                    #   if sprite_load_paths_set?
-                  raw_#{attr}.reject!{|e| e == v}                  #     raw_sprite_load_path.reject!{|e| e == v}s
-                else                                               #   else
-                  (@removed_from_#{attr} ||= []) << v              #     (@removed_from_sprite_load_paths ||= []) << v
-                end                                                #   end
-              end                                                  # end
-            }, __FILE__, line
-          end
-        end
-
-        def chained_method(method)
-          line = __LINE__ + 1
-          class_eval %Q{
-            alias_method :_chained_#{method}, method
-            def #{method}(*args, &block)
-              _chained_#{method}(*args, &block)
-              if inherited_data
-                inherited_data.#{method}(*args, &block)
-              end
-            end
-          }, __FILE__, line
-        end
-
-        
-      end
-
-      module InstanceMethods
-
-        def on_top!
-          self.set_top_level(self)
-        end
-
-        def set_top_level(new_top)
-          self.top_level = new_top
-          if self.inherited_data.respond_to?(:set_top_level)
-            self.inherited_data.set_top_level(new_top)
-          end
-        end
-
-
-        def inherit_from!(data)
-          if self.inherited_data
-            self.inherited_data.inherit_from!(data)
-          else
-            self.inherited_data = data
-          end
-          self
-        end
-
-        def reset_inheritance!
-          self.inherited_data = nil
-        end
-
-        def with_defaults(data)
-          inherit_from!(data)
-          yield
-          reset_inheritance!
-        end
-
-        def unset!(attribute)
-          @set_attributes ||= {}
-          send("#{attribute}=", nil)
-          @set_attributes.delete(attribute)
-          nil
-        end
-
-        def set?(attribute)
-          @set_attributes ||= {}
-          @set_attributes[attribute]
-        end
-
-        def any_attributes_set?
-          @set_attributes && @set_attributes.size > 0
-        end
-
-        def default_for(attribute)
-          method = "default_#{attribute}".to_sym
-          if respond_to?(method)
-            send(method)
-          end
-        end
-
-        # Read an explicitly set value that is either inherited or set on this instance
-        def read_without_default(attribute)
-          if set?(attribute)
-            send("raw_#{attribute}")
-          elsif inherited_data.nil?
-            nil
-          elsif inherited_data.respond_to?("#{attribute}_without_default")
-            inherited_data.send("#{attribute}_without_default")
-          elsif inherited_data.respond_to?(attribute)
-            inherited_data.send(attribute)
-          end
-        end
-
-        # Reads the raw value that was set on this object.
-        # you generally should call raw_<attribute>() instead.
-        def raw(attribute)
-          instance_variable_get("@#{attribute}")
-        end
-
-        # Read a value that is either inherited or set on this instance, if we get to the bottom-most configuration instance,
-        # we ask for the default starting at the top level.
-        def read(attribute)
-          if !(v = send("#{attribute}_without_default")).nil?
-            v
-          else
-            top_level.default_for(attribute)
-          end
-        end
-
-        def method_missing(meth, *args, &block)
-          if inherited_data
-            inherited_data.send(meth, *args, &block)
-          else
-            raise NoMethodError, meth.to_s
-          end
-        end
-
-        def respond_to?(meth)
-          if super
-            true
-          elsif inherited_data
-            inherited_data.respond_to?(meth)
-          else
-            false
-          end
-        end
-
-        def chain
-          instances = [self]
-          instances << instances.last.inherited_data while instances.last.inherited_data
-          instances
-        end
-
-        def debug
-          normalized_attrs = {}
-          ATTRIBUTES.each do |prop|
-            values = []
-            chain.each do |instance|
-              values << {
-                :raw => (instance.send("raw_#{prop}") rescue nil),
-                :value => (instance.send("#{prop}_without_default") rescue nil),
-                :default => (instance.send("default_#{prop}") rescue nil),
-                :resolved => instance.send(prop)
-              }
-            end
-            normalized_attrs[prop] = values
-          end
-          normalized_attrs
-        end
-
-      end
-    end
-  end
-end

data/lib/compass/configuration/paths.rb

@@ -1,19 +0,0 @@
-module Compass::Configuration::Paths
-
-  TRAILING_SEPARATOR = %r{.(/|#{Regexp.escape(File::SEPARATOR)})$}
-
-  def strip_trailing_separator(*attributes)
-    attributes.each do |attr|
-      alias_method "#{attr}_with_trailing_separator".to_sym, attr
-      class_eval %Q{
-        def #{attr}                                # def css_dir
-          path = #{attr}_with_trailing_separator   #   path = css_dir_with_trailing_separator
-          if path.to_s =~ TRAILING_SEPARATOR       #   if path =~ TRAILING_SEPARATOR
-            path = path[0..-($1.length+1)]         #     path = path[0..-($1.length+1)]
-          end                                      #   end
-          path                                     #   path
-        end                                        # end
-      }
-    end
-  end
-end

data/lib/compass/exec/switch_ui.rb

@@ -1,179 +0,0 @@
-require 'compass/exec/global_options_parser'
-require 'compass/exec/project_options_parser'
-
-module Compass::Exec
-  class SwitchUI
-    include GlobalOptionsParser
-    include ProjectOptionsParser
-    attr_accessor :args, :options, :opts
-
-    def initialize(args)
-      self.args = args
-      self.options = {}
-      parse!
-    end
-
-    def run!
-      begin
-        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
-      return 0
-    end
-    
-    protected
-    
-    def perform!
-      if options[:command]
-        do_command(options[:command])
-      else
-        puts self.opts
-      end
-    end
-    
-    def parse!
-      self.opts = OptionParser.new(&method(:set_opts))
-      self.opts.parse!(self.args)    
-      if self.args.size > 0
-        self.options[:project_name] = trim_trailing_separator(self.args.shift)
-      end
-      self.options[:command] ||= self.options[:project_name] ? :create_project : :update_project
-      self.options[:framework] ||= :compass
-    end
-
-    def trim_trailing_separator(path)
-      path[-1..-1] == File::SEPARATOR ? path[0..-2] : path
-    end
-
-    def set_opts(opts)
-      opts.banner = <<END
-Usage: compass [options] [project]
-
-Description:
-The compass command line tool will help you create and manage the stylesheets for your project.
-
-To get started on a stand-alone project based on blueprint:
-
-  compass -f blueprint my_compass_project
-
-When you change any sass files, you must recompile your project using --update or --watch.
-END
-      opts.separator ''
-      opts.separator 'Mode Options(only specify one):'
-
-      opts.on('-i', '--install', :NONE, "Create a new compass project.",
-                                        "  The default mode when a project is provided.") do
-        self.options[:command] = :create_project
-      end
-
-      opts.on('-u', '--update', :NONE, 'Update the current project.',
-                                       '  This is the default when no project is provided.') do
-        self.options[:command] = :update_project
-      end
-
-      opts.on('-w', '--watch', :NONE, 'Monitor the current project for changes and update') do
-        self.options[:command] = :watch_project
-        self.options[:quiet] = true
-      end
-
-      opts.on('-p', '--pattern PATTERN', 'Stamp out a pattern into the current project.',
-                                         '  Must be used with -f.') do |pattern|
-        self.options[:command] = :stamp_pattern
-        self.options[:pattern] = pattern
-      end
-
-      opts.on('-h', '--help') do
-        self.options[:command] = :help
-        self.options[:help_command] = :help
-      end
-
-      opts.on('--write-configuration', "Write the current configuration to the configuration file.") do
-        self.options[:command] = :write_configuration
-      end
-
-      opts.on('--list-frameworks', "List compass frameworks available to use.") do
-        self.options[:command] = :list_frameworks
-      end
-
-      opts.on('--validate', :NONE, 'Validate your project\'s compiled css. Requires Java.') do
-        self.options[:command] = :validate_project
-      end
-
-      opts.on('--grid-img [DIMENSIONS]', 'Generate a background image to test grid alignment.',
-                                         '  Dimension is given as <column_width>+<gutter_width>x<height>.',
-                                         '  Defaults to 30+10x20. Height is optional.') do |dimensions|
-        self.options[:grid_dimensions] = dimensions || "30+10"
-        self.options[:command] = :generate_grid_background
-      end
-
-      opts.separator ''
-      opts.separator 'Install/Pattern Options:'
-
-      opts.on('-f FRAMEWORK', '--framework FRAMEWORK', 'Use the specified framework. Only one may be specified.') do |framework|
-        self.options[:framework] = framework
-      end
-
-      opts.on('-n', '--pattern-name NAME', 'The name to use when stamping a pattern.',
-                                           '  Must be used in combination with -p.') do |name|
-        self.options[:pattern_name] = name
-      end
-
-      opts.on("-x", "--syntax SYNTAX", [:sass, :scss], "Specify the syntax to use when generating stylesheets.", "One of sass or scss. Defaults to scss.") do |syntax|
-        self.options[:preferred_syntax] = syntax
-      end
-
-      opts.on('--rails', "Sets the app type to a rails project (same as --app rails).") do
-        self.options[:project_type] = :rails
-      end
-
-      opts.on('--app APP_TYPE', 'Specify the kind of application to integrate with.') do |project_type|
-        self.options[:project_type] = project_type.to_sym
-      end
-
-      opts.separator ''
-      opts.separator 'Configuration Options:'
-
-      set_project_options(opts)
-
-      opts.separator ''
-      opts.separator 'General Options:'
-
-      set_global_options(opts)
-
-      opts.on('--imports', :NONE, 'Emit an imports suitable for passing to the sass command-line.',
-                                  '  Example: sass `compass --imports`',
-                                  '  Note: Compass\'s Sass extensions will not be available.') do
-        print ::Compass::Frameworks::ALL.map{|f| "-I #{f.stylesheets_directory}"}.join(' ')
-        exit
-      end
-
-      opts.on('--install-dir', :NONE, 'Emit the location where compass is installed.') do
-        puts ::Compass.base_directory
-        exit
-      end
-
-      opts.on_tail("-v", "--version", "Print version") do
-        self.options[:command] = :print_version
-      end
-
-      opts.on('--boring', :NONE, 'Turn off colorized output.') do
-        self.options[:color_output] = false
-      end
-
-    end
-    
-    def do_command(command)
-      command_class_name = command.to_s.split(/_/).map{|p| p.capitalize}.join('')
-      command_class = eval("::Compass::Commands::#{command_class_name}")
-      command_class.new(Dir.getwd, options).execute
-    end
-
-  end
-end