lesstidy 0.0.1.pre

data/lib/lesstidy/grammar/less_syntax.rb

@@ -0,0 +1,30 @@
+class Treetop::Runtime::SyntaxNode
+  def cascade(env)
+    elements.each { |e| e.build env if e.respond_to? :build }  if elements.is_a? Array
+    env
+  end
+
+  def build(env)
+    cascade env
+  end
+end
+
+class Treetop::Runtime::CompiledParser
+  def failure_message
+    o = lambda {|i, *args| i }
+    return nil unless (tf = terminal_failures) && tf.size > 0
+    msg = "on line #{failure_line}: expected " + (
+      tf.size == 1 ?
+        o[tf[0].expected_string, :yellow] :
+        "one of #{o[tf.map {|f| f.expected_string }.uniq * ' ', :yellow]}"
+    )
+    f = input[failure_index]
+    got = case f
+      when "\n" then o['\n',  :cyan]
+      when nil  then o["EOF", :cyan]
+      when ' '  then o["white-space", :cyan]
+      else           o[f.chr, :yellow]
+    end
+    msg += " got #{got}" # after:\n\n#{input[index...failure_index]}\n"
+  end
+end

data/lib/lesstidy/nodes.rb

@@ -0,0 +1,107 @@
+module Lesstidy
+  module Nodes
+    class Node
+      include Lesstidy::Renderer
+
+      attr_reader :elements
+      attr_accessor :parent
+
+      def initialize(*a)
+        @elements = []
+        @parent = nil
+      end
+
+      def <<(element)
+        @elements << element
+        element.parent = self
+      end
+
+      def depth
+        @parent.nil? ? 0 : (@parent.depth+1)
+      end
+
+      def inspect
+        out = ""
+        out << "\n" + (". " * (1+depth)) + self.inspect_s
+        @elements.each { |e| out << e.inspect }
+        out
+      end
+
+      def inspect_s
+        "<#{self.class.to_s}>"
+      end
+    end
+
+    class Document < Node
+      def inspect_s
+        "[document]"
+      end
+    end
+
+    class Ruleset < Node
+      def initialize( *args )
+        super
+      end
+
+      def inspect_s
+        "[ruleset]"
+      end
+    end
+
+    class Comment < Node
+      attr_reader :comment
+
+      def initialize(content)
+        super
+        @comment = content
+      end
+
+      def inspect_s
+        "/* #{@comment} */"
+      end
+    end
+
+    class Selector < Node
+      attr_reader :selector
+
+      def initialize(selector)
+        super
+        @selector = selector
+      end
+
+      def inspect_s
+        "[S] #{@selector}"
+      end
+    end
+
+    class Rule < Node
+      attr_reader :property
+      attr_reader :value
+
+      def initialize( property, value )
+        super
+        @property = property
+        @value = value
+      end
+      
+      def inspect_s
+        "[R]    #{@property}: #{value}"
+      end
+    end
+
+    class Mixin < Node
+      attr_reader :selector
+      attr_reader :params
+
+      def initialize(selector, params = nil)
+        super
+        @selector = selector
+        @params = params
+      end
+
+      def inspect_s
+        "[M]    #{@selector}%s" % [(params ? "(#{params})" : '')]
+      end
+    end
+  end
+end

data/lib/lesstidy/preset.rb

@@ -0,0 +1,4 @@
+module Lesstidy
+  class Preset
+  end
+end

data/lib/lesstidy/renderer.rb

@@ -0,0 +1,147 @@
+require 'ostruct'
+
+module Lesstidy
+  module Renderer
+    # args = new Args(*args)
+    # args.context
+    class Args < OpenStruct
+      def new(*args)
+        super args.inject({}) { |a, i| a.merge! i }
+      end
+    end
+
+    def to_css(*args)
+      # Try to delegate to `(classname)_to_css` (eg, rule_to_css).
+      klass = /([a-zA-Z_]+)$/.match(self.class.to_s)[1]
+      css_method = "#{klass}_to_css".downcase.to_sym
+      if respond_to? css_method
+        send css_method, *args
+      else
+        ''
+      end
+    end
+
+    protected
+    def document_to_css(style = Style.new, *args)
+      @elements.inject('') do |a, element|
+        a << element.to_css(style, :context => :document); a
+      end
+    end
+
+    def comment_to_css(style, *args)
+      args = Args.new *args
+      args.depth ||= 0
+
+      if args.context == :document
+        style.document_comment % ["/* #{@comment} */"]
+
+      elsif args.context == :ruleset
+        indent  = ' ' * (args.depth * style.subrule_indent)
+        comment = "/* #{@comment} */" 
+        "#{indent}#{comment}\n"
+      end
+    end
+
+    def ruleset_to_css(style, *args)
+      args = Args.new *args
+      args.depth ||= 0
+
+      selectors = @elements.select { |e| e.is_a? Nodes::Selector }
+      items     = @elements.select { |e| e.is_a? Nodes::Mixin or e.is_a? Nodes::Rule }
+      rnc       = @elements.select { |e| e.is_a? Nodes::Ruleset or e.is_a? Nodes::Comment }
+
+      # Start: selectors
+      r = ''
+      r << selectors_to_css(selectors, style, args)
+
+      # Items (properties, mixins, etc)
+      indent = r.split("\n")[-1].size
+      r << items_to_css(items, indent, style, args)
+
+      # Subrules and Comments (rnc)
+      r << rules_and_comments_to_css(rnc, style, args)
+
+      # Close brace
+      indent = args.depth * style.subrule_indent # Number of spaces
+      r << (' ' * indent)  if /\n$/.match(r)
+      r << style.close_brace
+    end
+
+    def rule_to_css(style, *args)
+      # TODO: Property width
+      @property + style.colon + @value
+    end
+
+    def mixin_to_css(style, *args)
+      if @params
+        "%s(%s)" % [@selector, @params]
+      else
+        @selector
+      end
+    end
+
+    def selector_to_css(style, *args)
+      @selector.strip.squeeze(' ')
+    end
+
+    # Gets the rendered string for a given set of Selectors
+    # Delegate method of ruleset_to_css
+    def selectors_to_css(sels, style, args)
+      indent        = args.depth * style.subrule_indent # Number of spaces
+      indent_str    = ' ' * indent
+      selector_strs = sels.map { |sel| sel.to_css(style) }
+
+      r = CUtil::String.new
+      r.replace    selector_strs.join(style.comma)
+      r.prepend!   indent_str
+      r.wrap!      :width     => style.selector_width,
+                   :pad       => true,
+                   :no_rewrap => (!style.selector_wrap),
+                   :indent    => indent  unless style.selector_width.nil?
+      r.append!    style.open_brace
+      r.to_s
+    end
+
+    # Gets the rendered string for a given set of Mixins and Rules (what's inside {}'s)
+    # Delegate method of ruleset_to_css
+    def items_to_css(items, indent, style, args)
+      items_css = items.map { |item| item.to_css(style) + style.semicolon }
+
+      indent_value = style.property_indent
+
+      if style.selector_width.nil? # Not column mode?
+        indent_value += style.subrule_indent * (args.depth)
+      else
+        indent_value += style.selector_width
+      end
+
+      r = CUtil::String.new
+      r.replace  items_css.join('')
+      r.wrap!    :width        => style.wrap_width,
+                 :indent       => indent_value, 
+                 :first_indent => indent  unless style.wrap_width.nil?
+      r.gsub!    /^/, ' ' * indent_value  if style.wrap_width.nil? and /\{.*\n.*$/.match(style.open_brace)
+      r.to_s
+    end
+
+    # Gets the rendered string for a given set of Rules and Comments
+    # Delegate method of ruleset_to_css
+    def rules_and_comments_to_css(items, style, args)
+      r = ''
+      if items.size > 0
+        item_strs = items.map do |item|
+          item.to_css(style,
+                      :context => :ruleset,
+                      :depth   => (args.depth + 1))
+        end
+        r << style.subrule_before
+        r << item_strs.join('')
+      end
+
+      # Remove trailing \n's
+      r.gsub! /\n+$/, "\n"
+      r
+    end
+
+  end
+end

data/lib/lesstidy/style.rb

@@ -0,0 +1,32 @@
+require 'ostruct'
+
+module Lesstidy
+  class Style < OpenStruct
+    def initialize(args = {})
+     super defaults.merge(StyleParser.load_options(args))
+    end
+    
+    def verify
+      # wrap_width > selector_width
+      # /\s*{\s/.match open_brace
+    end
+
+  protected
+    def defaults
+      { :wrap_width      => nil,    # nil for no wrap
+        :selector_width  => nil,    # nil for no columning
+        :open_brace      => " {\n",
+        :close_brace     => "}\n\n",
+        :document_comment => "\n%s\n",
+        :semicolon       => ";\n",   # Add NLs after if needed
+        :property_width  => nil,
+        :colon           => ": ",   # Add spaces if needed
+        :comma           => ", ",   # Spaces if needed
+        :subrule_indent  => 2,      # Indentation of sub rules
+        :subrule_before  => "\n",   # Separators of subrules
+        :property_indent => 2,      # How much to indent properties on their next line (will take selector width into account)
+        :selector_wrap   => false,  # Wrap long selectors?
+      }
+    end
+  end
+end

data/lib/lesstidy/style_parser.rb

@@ -0,0 +1,117 @@
+module Lesstidy
+  class StyleParser
+    class << self
+      def preset_path(*args)
+        @preset_path ||= File.expand_path(File.join(File.dirname(__FILE__), %w[.. .. data presets]))
+        File.join(@preset_path, *args)
+      end
+
+      def load_preset(preset_name = '')
+        return {}  if preset_name == 'default'
+
+        preset_file = File.join(preset_path, preset_name)
+
+        raise PresetNotFoundError, preset_file unless File.exists?(preset_file)
+        preset_data = File.open(preset_file) { |f| f.read.split("\n") }
+
+        load_options preset_data
+      end
+
+      def presets
+        ['default'] + Dir[preset_path '**'].map { |file| File.basename(file) }
+      end
+
+      # Returns the defaults
+      def defaults
+        dir = Dir.pwd
+        while true do
+          fname = File.join(dir, '.lesstidyopts')
+
+          return File.open(fname) { |f| f.read.split("\n").reject(&:empty?) } \
+             if File.exists?(fname)
+
+          _dir = File.expand_path(File.join(dir, '..'))
+          return []  if dir == _dir
+          dir = _dir
+        end
+      end
+
+      # Input: array of options, or hash, or string?
+      # Output: hash to be fed into Style.new
+      def load_options(args)
+        opts = {}
+
+        if args.is_a? Array
+          parser = OptionParser.new { |o| parse(o, opts) }
+          parser.parse args
+        end
+
+        opts = opts.merge args  if args.is_a? Hash
+        opts = load_preset(args)  if args.is_a? String
+        opts = load_preset(opts[:preset]).merge(opts)  unless opts[:preset].nil?
+        opts
+      end
+
+      def parse(o, opt)
+        o.separator ""
+        o.separator "Style options:"
+        o.on('-p', '--preset', '=PRESET', "preset name to load") do |v|
+          opt[:preset] = v
+        end
+
+        o.on('--no-wrap', "disables wrapping") do
+          opt[:wrap_width] = nil
+        end
+
+        o.on('--wrap-width', '=N', "wrap width (overrides --no-wrap)") do |n|
+          opt[:wrap_width] = n.to_i
+        end
+
+        o.on('--property-width', '=N', "width of properties (NOT implemented)") do |n|
+          opt[:property_width] = n.to_i
+        end
+
+        o.on('--property-indent', '=N', "number of spaces to indent properties with") do |n|
+          opt[:property_indent] = n.to_i
+        end
+
+        # Yeh, no-sel-wrap and sel-width are NOT mutex... ambiguous :|
+        o.on('--no-selector-wrap', 'disables wrapping of long selectors (LessCSS compatibility)') do
+          opt[:selector_wrap] = false
+        end
+
+        o.on('--selector-wrap', 'enables wrapping of long selectors') do
+          opt[:selector_wrap] = true
+        end
+
+        o.on('--no-selector-column', 'disables selector column mode') do |n|
+          opt[:selector_width] = nil
+        end
+
+        o.on('--selector-width', '=N', 'selector column mode; width of selectors before wrapping') do |n|
+          opt[:selector_width] = n.to_i
+        end
+
+        o.on('--subrule-indent', '=N', 'number of spaces to indent a subrule with') do |n|
+          opt[:subrule_indent] = n.to_i
+        end
+
+        o.on('--open-brace-spaces', '=FORMAT', '') do |fmt|
+          opt[:open_brace] = fmt.tr('sn', " \n").gsub('|', '{')
+        end
+
+        o.on('--close-brace-spaces', '=FORMAT', '') do |fmt|
+          opt[:close_brace] = fmt.tr('sn', " \n").gsub('|', '}')
+        end
+
+        o.on('--semicolon-spaces', '=FORMAT', '') do |fmt|
+          opt[:semicolon] = fmt.tr('sn', " \n").gsub('|', ';')
+        end
+
+        o.on('--colon-spaces', '=FORMAT', '') do |fmt|
+          opt[:colon] = fmt.tr('sn', " \n").gsub('|', ':')
+        end
+      end
+    end
+  end
+end

data/test/d.rb

@@ -0,0 +1,31 @@
+require "../lib/lesstidy"
+
+def t( a )
+  CSSParser.new.parse a
+end
+
+def try( a )
+  style = Lesstidy::Style.new
+
+  p = CSSParser.new.parse a
+  puts (p.nil? ? '[FAIL]' : '[ OK ]') + " #{a}"
+  
+  if p.respond_to? :build
+    node = p.build
+    puts node.inspect
+    puts node.to_css style
+  end
+  
+  puts ""
+end
+
+#try ""
+#try "div { color: red; }"
+#try "div{color:red;}"
+#try "div,div { color: red; }"
+#try "div,div { .lol(); color: red; }"
+#try "div,div { color: red; font-weight: bold; }"
+#try "div,div { color: red; font-weight: bold; a { color: red; } }"
+#try "#menu a,div { color: red; font-weight: bold; } #menu ul li > div, td, tr, #menu a:hover div #lol yes yes .something span.clear-fix, table { text-align: center; .black; font-weight: bold; border: solid 2px #882828; cursor: default; background-repeat: no-repeat; } a:hover { .corner(5px); background: url(foo.png); span { font-weight: bold; } span, a:hover, a:active, a:hover span, a:active span { text-decoration: underline; strong em { color: blue; } } }"
+try File.open('fixtures/test-2.control.css') { |f| f.read }
+