sublime_dsl 0.1.1

data/lib/sublime_dsl/textmate/grammar/plist_reader.rb

@@ -0,0 +1,163 @@
+# encoding: utf-8
+
+module SublimeDSL
+module TextMate
+class Grammar
+
+  ##
+  # Creates a Grammar from a PList.
+
+  class PListReader
+
+    attr_reader :grammar
+
+    def initialize(file)
+      @grammar = Grammar.new(nil, nil)
+      read_plist PList.import(file)
+      @grammar.basename = File.basename(file, File.extname(file))
+      @grammar.complete!
+    end
+
+  private
+
+    def read_plist(root)
+
+      grammar.name = root.delete('name')
+      grammar.scope = root.delete('scopeName')
+
+      root.each_pair do |key, value|
+        case key
+        when 'comment'
+          grammar.comment = cleanup(value)
+        when 'fileTypes'
+          grammar.file_types = value  # an array of strings
+        when *%w(foldingStartMarker foldingStopMarker firstLineMatch)
+          grammar.send key.snake_case + '=', regexp(value)
+        when *%w(keyEquivalent bundleUUID uuid)
+          grammar.send key.snake_case + '=', value
+        when 'patterns'
+          grammar.patterns = patterns(value, grammar)  # an array
+        when 'repository'
+          value.each_pair do |name, content|
+            f = Fragment.new(name)
+            f.patterns = scan(content, f)
+            f.patterns = [f.patterns] unless f.patterns.is_a? Array
+            grammar.fragments << f
+          end
+        when 'injections'
+          warn "grammar #{grammar}: #{key.inspect} is not supported"
+        else
+          warn "unknown key in grammar #{grammar}: #{key.inspect}"
+        end
+      end
+
+    end
+
+    def patterns(list, parent)
+      list.map { |v| scan v, parent }.flatten
+    end
+
+    def scan(value, parent)
+      value.is_a?(Hash) or raise Error, "expected a Hash: #{value.inspect}"
+      hash = value.dup
+      comment = cleanup(hash.delete('comment'))
+
+      if (inc = hash['include'])
+        hash.length == 1 or raise Error, "include: too many keys: #{value.inspect}"
+        inc = Include.new(inc)
+        inc.comment = comment
+        return inc
+      end
+
+      # do not create a rule that just contains patterns: return the patterns instead
+      if hash.length == 1 && hash['patterns']
+        if comment
+          parent.comment and raise Error, 'comment conflict'
+          parent.comment = comment
+        end
+        return patterns(hash['patterns'], parent)
+      end
+
+      if (match = hash.delete('match'))
+        rule = MatchRule.new
+        caps = hash.delete('captures')
+        if hash['beginCaptures']
+          caps and raise Error, "both 'beginCaptures' and 'captures': " << value.inspect
+          warn "grammar '#{grammar}': 'beginCaptures' understood as 'captures'" \
+               " in 'match' rule: " << value.inspect
+          caps = hash.delete('beginCaptures')
+        end
+        rule.match = create_match(match, caps)
+      elsif hash['begin'] || hash['end']
+        rule = BeginEndRule.new
+        rule.content_scope = hash.delete('contentName')
+        bcap = hash.delete('beginCaptures')
+        ecap = hash.delete('endCaptures')
+        caps = hash.delete('captures')
+        assign_captures rule, caps if caps
+        beg_re = hash.delete('begin')
+        unless beg_re
+          warn "no 'begin' for rule with 'end' in grammar #{grammar}"
+          beg_re = ''
+        end
+        end_re = hash.delete('end')
+        unless end_re
+          warn "no 'end' for rule with 'begin' in grammar #{grammar}"
+          end_re = ''
+        end
+        rule.from = create_match(beg_re, bcap)
+        rule.to = create_match(end_re, ecap, rule.from.regexp)
+        rule.to_last = hash.delete('applyEndPatternLast')
+      else
+        warn "grammar #{grammar}: no 'begin' nor 'match': " << hash.inspect
+        rule = NoMatchRule.new
+      end
+
+      rule.scope = hash.delete('name')
+      rule.comment = comment
+      rule.disabled = hash.delete('disabled')
+      rule.patterns = patterns(hash.delete('patterns'), rule) if hash['patterns']
+      hash.length == 0 or warn "invalid rule keys in grammar #{grammar}: #{hash.inspect}"
+
+      rule.complete!(grammar)
+
+      rule
+    end
+
+    def create_match(re, captures, backref = nil)
+      m = Match.new(regexp(re, backref))
+      assign_captures m, captures if captures
+      m
+    end
+
+    # Assign the PList +captures+ to +object+ (a Match or a BeginEndRule).
+    def assign_captures(object, captures)
+      # get the captures, making sure the keys are in ascending order
+      cap = []
+      captures.each_pair do |k,v|
+        name = v['name']
+        if name.nil?
+          warn "invalid capture in grammar #{grammar}: #{v.inspect}"
+          next
+        elsif v.length > 1
+          warn "extra capture ignored in grammar #{grammar}: #{v.inspect}"
+        end
+        cap[k.to_i] = name unless name.empty?
+      end
+      cap.each_with_index { |name, index| object.captures[index] = name if name }
+    end
+
+    # Replaces tabs by 2 spaces & dedents.
+    def cleanup(text)
+      text && text.gsub("\t", '  ').dedent
+    end
+
+    def regexp(str, backref = nil)
+      Tools::RegexpWannabe.new(str, backref)
+    end
+
+  end
+
+end
+end
+end

data/lib/sublime_dsl/textmate/grammar/plist_writer.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+
+module SublimeDSL
+module TextMate
+class Grammar
+
+  ##
+  # Creates the PList for a grammar.
+
+  class PListWriter
+
+    attr_reader :grammar
+    attr_reader :root
+
+    def initialize(grammar)
+      @grammar = grammar
+      @root = {}
+      convert_grammar
+    end
+
+    def export(file)
+      PList.export(root, file)
+    end
+
+  private
+
+    def convert_grammar
+
+      root['name'] = grammar.name
+      root['scopeName'] = grammar.scope
+
+      %w(fileTypes firstLineMatch foldingStartMarker foldingStopMarker keyEquivalent uuid bundleUUID).each do |att|
+        root[att] = convert_object(grammar.send(att.snake_case))
+      end
+
+      root['patterns'] = convert_array(grammar.patterns)
+
+      frags = {}
+      grammar.fragments.each { |f| frags[f.name] = convert_fragment(f) }
+      root['repository'] = frags
+
+      cleanup_hash root
+
+    end
+
+    def convert_object(object)
+      k = object.class.name.split('::').last.snake_case
+      send "convert_#{k}", object
+    end
+
+    def convert_array(list)
+      list.map { |o| convert_object o }
+    end
+
+    def convert_fragment(f)
+      unless f.used
+        warn "grammar '#{grammar.name}': fragment '#{f.name}' never used, not output"
+        return nil
+      end
+      a = convert_array(f.patterns)
+      a.length > 1 ? { 'patterns' => a } : a.first
+    end
+
+    def convert_include(inc)
+      { 'include' => inc.fragment_name }
+    end
+
+    def convert_no_match_rule(rule)
+      return nil if rule.empty?
+      h = convert_rule_start(rule)
+      h['patterns'] = convert_array(rule.patterns)
+      h
+    end
+
+    def convert_match_rule(rule)
+      h = convert_rule_start(rule)
+      h.merge! convert_match(rule.match, 'match', 'captures')
+    end
+
+    def convert_begin_end_rule(rule)
+      h = convert_rule_start(rule)
+      h['contentName'] = rule.content_scope
+      h.merge! convert_match(rule.from, 'begin', 'beginCaptures')
+      h.merge! convert_match(rule.to, 'end', 'endCaptures')
+      h.merge! convert_captures('captures', rule.captures)
+      h['applyEndPatternLast'] = convert_object(rule.to_last)
+      h['patterns'] = convert_array(rule.patterns)
+      h
+    end
+
+    def convert_rule_start(rule)
+      { 'name' => rule.scope, 'disabled' => convert_object(rule.disabled) }
+    end
+
+    def convert_match(match, regexp_key, captures_key)
+      { regexp_key => convert_regexp_wannabe(match.regexp) }
+        .merge convert_captures(captures_key, match.captures)
+    end
+
+    def convert_regexp_wannabe(re)
+      re.to_s
+    end
+
+    def convert_captures(captures_key, captures)
+      h = {}
+      return h if captures.empty?
+      captures.each_pair do |number, scope|
+        h[number.to_s] = { 'name' => scope }
+      end
+      { captures_key => h }
+    end
+
+    def convert_string(v); v; end;
+    def convert_nil_class(v); v; end
+    def convert_true_class(v); 1; end
+    def convert_false_class(v); 0; end
+
+    def cleanup_object(o)
+      case o
+      when Array; cleanup_array o
+      when Hash; cleanup_hash o
+      end
+    end
+
+    def cleanup_array(list)
+      list.each { |o| cleanup_object o }
+      list.reject! { |o| empty(o) }
+    end
+
+    def cleanup_hash(h)
+      h.keys.each do |key|
+        value = h[key]
+        cleanup_object value
+        if empty(value)
+          # HACK: an empty 'begin' or 'end' matches anything (used by C & Tcl grammars)
+          if key != 'end' && key != 'begin'
+            h.delete key
+          else
+            h[key] = ''
+          end
+        end
+      end
+    end
+
+    def empty(o)
+      o.nil? || o.respond_to?(:empty?) && o.empty?
+    end
+
+  end
+
+end
+end
+end

data/lib/sublime_dsl/textmate/grammar.rb

@@ -0,0 +1,252 @@
+# encoding: utf-8
+
+require_relative 'grammar/plist_reader'
+require_relative 'grammar/dsl_writer'
+require_relative 'grammar/dsl_reader'
+require_relative 'grammar/plist_writer'
+
+module SublimeDSL
+module TextMate
+
+  ##
+  # A language grammar.
+
+  class Grammar
+
+    # Create from a PList file.
+    def self.import(file)
+      PListReader.new(file).grammar
+    end
+
+    include CustomBaseName
+
+    attr_accessor :name
+    attr_accessor :scope
+    attr_accessor :file_types
+    attr_accessor :comment
+    attr_accessor :first_line_match
+    attr_accessor :folding_start_marker
+    attr_accessor :folding_stop_marker
+
+    # TextMate only
+    attr_accessor :key_equivalent
+    attr_accessor :uuid
+    attr_accessor :bundle_uuid
+
+    # content
+    attr_accessor :patterns
+    attr_accessor :fragments
+
+    def initialize(name, scope)
+
+      @name = name
+      @scope = scope
+
+      @file_types = nil
+      @first_line_match = nil
+      @folding_start = nil
+      @folding_stop = nil
+
+      @key_equivalent = nil
+      @uuid = nil
+
+      @patterns = []
+      @fragments = []
+
+    end
+
+    alias to_s name
+
+    def complete!
+      @repos = fragments.keyed_by(&:name)
+      resolve_includes self
+      fragments.each { |f| resolve_includes f }
+    end
+
+    def resolve_includes(parent)
+      parent.patterns.each do |o|
+        if o.respond_to? :patterns
+          resolve_includes o
+        elsif o.is_a?(Include) && o.fragment_name.start_with?('#')
+          name = o.fragment_name[1..-1]
+          o.fragment = @repos[name]
+          if o.fragment
+            o.fragment.used = true
+          else
+            warn "grammar #{self.name}: no such fragment: #{o.fragment_name.inspect}"
+          end
+        end
+      end
+    end
+
+    def write(dir)
+      file = "#{dir}/#{basename}.tmLanguage.rb"
+      File.open(file, 'wb:utf-8') do |f|
+        f.puts '# encoding: utf-8'
+        f.puts "\n" << DSLWriter.new(self).dsl
+      end
+    end
+
+    def export(dir)
+      file = "#{dir}/#{basename}.tmLanguage"
+      PListWriter.new(self).export(file)
+    end
+
+    ##
+    # A repository item.
+
+    class Fragment
+      attr_reader :name
+      attr_accessor :comment
+      attr_accessor :patterns
+      attr_accessor :used
+      def initialize(name)
+        @name = name
+        @comment = nil
+        @patterns = []
+        @used = nil
+      end
+    end
+
+    ##
+    # An included fragment.
+
+    class Include
+      attr_reader :fragment_name
+      attr_accessor :fragment
+      attr_accessor :comment
+      def initialize(fragment_name)
+        @fragment_name = fragment_name
+      end
+    end
+
+    ##
+    # An abstract rule.
+
+    class Rule
+      attr_accessor :scope
+      attr_accessor :comment
+      attr_accessor :disabled
+      def complete!(grammar) end
+    end
+
+    ##
+    # A 'match' rule.
+
+    class MatchRule < Rule
+      attr_accessor :match  # Match object
+    end
+
+    ##
+    # A 'begin/end' rule.
+
+    class BeginEndRule < Rule
+
+      attr_accessor :content_scope
+      attr_accessor :from   # Match object
+      attr_accessor :to     # Match object
+      attr_accessor :to_last
+      attr_reader   :captures   # common captures, a hash { number => scope }
+      attr_accessor :patterns
+
+      def initialize
+        @patterns = []
+        @captures = {}
+      end
+
+      def complete!(grammar)
+        captures.each_pair do |index, scope|
+          fscope = from.captures[index]
+          tscope = to.captures[index]
+          if fscope
+            if tscope == fscope
+              if fscope == scope
+                # from scope == to scope == common scope => just keep common
+                from.captures.delete(index)
+                to.captures.delete(index)
+              else
+                # from scope == to scope != common scope => set common = from/to
+                warn "grammar #{grammar}: 'both' capture #{index} => #{scope.inspect} replaced by 'from/to' capture #{index} => #{fscope.inspect}"
+                captures[index] = fscope
+                from.captures.delete index
+                to.captures.delete index
+              end
+            elsif tscope.nil?
+              if fscope == scope
+                # from scope == common scope, no 'to' scope => just keep common
+                from.captures.delete(index)
+              else
+                # from scope != common scope, no 'to' scope => common become 'to'
+                warn "grammar #{grammar}: 'both' capture #{index} => #{scope.inspect} moved to 'to' ('from' has #{index} => #{fscope.inspect})"
+                add_capture captures.delete(index), index, to.captures
+              end
+            else
+              # from scope != to scope => ignore common
+              warn "grammar #{grammar}: 'both' capture #{index} => #{scope.inspect} ignored: 'from' and 'to' already given"
+              captures.delete(index)
+            end
+          elsif tscope.nil?
+            # both fscope & tscope nil: ok
+          else
+            if tscope == scope
+              # to scope == common scope, no 'from' scope => just keep common
+              to.captures.delete(index)
+            else
+              # to scope != common scope, no 'from' scope => common become 'from'
+              warn "grammar #{grammar}: 'both' capture #{index} => #{scope.inspect} moved to 'from' ('to' has #{index} => #{tscope.inspect})"
+              add_capture captures.delete(index), index, from.captures
+            end
+          end
+        end
+        if !from.captures.empty? && from.captures == to.captures
+          captures.merge! from.captures
+          from.captures.clear
+          to.captures.clear
+        end
+      end
+
+      def add_capture(scope, index, captures)
+        captures[index] = scope
+        h = {}
+        captures.keys.sort.each do |i|
+          h[i] = captures[i]
+        end
+        captures.clear
+        captures.merge! h
+      end
+
+    end
+
+    ##
+    # A rule without 'match' nor 'begin'
+
+    class NoMatchRule < Rule
+
+      attr_accessor :patterns
+
+      def initialize
+        @patterns = []
+      end
+
+      def empty?
+        scope.nil? && patterns.empty?
+      end
+
+    end
+
+    ##
+    # A regexp with its captures.
+
+    class Match
+      attr_reader :regexp
+      attr_reader :captures   # hash { number => scope }
+      def initialize(regexp)
+        @regexp = regexp
+        @captures = {}
+      end
+    end
+
+  end
+
+end
+end

data/lib/sublime_dsl/textmate/plist.rb

@@ -0,0 +1,141 @@
+# encoding: utf-8
+
+module SublimeDSL
+module TextMate
+
+  ##
+  # Tools to read and write hashes in PList format.
+
+  module PList
+
+    class << self
+
+      # Returns a Hash read from +file+. See ::load.
+      def import(file)
+        File.open(file, 'r:utf-8') { |f| load(f) }
+      end
+
+      # Writes the Hash +hash+ to +file+ in PList format.
+      def export(hash, file)
+        File.open(file, 'wb:utf-8') { |f| f.write dump(hash) }
+      end
+
+      # Returns a Hash corresponding to the root +dict+ of the PList.
+      def load(string_or_io)
+        doc = Tools::XML.load(string_or_io)
+        # Document name="document" children = [
+        #   DTD
+        #   Element name="plist" children = [
+        #     Element name="dict" children = [
+        #       Element name="key" children = [ Text "author" ]
+        #       Element name="string" children = [ Text "Z comme Zorglub" ]
+        #       Element name = "key"  children = [ Text "name" ]
+        #       Element name = "string" children = [ Text "Zorgléoptère" ]
+        #       ...
+        #     ]
+        #   ]
+        # ]
+        root_node = doc.children.last.children.first
+        load_node(root_node)
+      end
+
+      # Returns a String containing the PList XML for +hash+.
+      def dump(hash)
+        <<-XML.dedent << dump_hash(hash, '') << '</plist>'
+          <?xml version="1.0" encoding="UTF-8"?>
+          <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+          <plist version="1.0">
+        XML
+      end
+
+    private
+
+      def load_node(node)
+        if node.comment?
+          # warn 'plist: comment node ignored'
+          return nil
+        end
+        case node.name
+        when 'dict'
+          load_dict(node)
+        when 'string'
+          node.text
+        when 'integer'
+          node.text.to_i
+        when 'array'
+          node.children.map { |n| load_node n }.compact
+        when 'true'
+          true
+        when 'false'
+          false
+        else
+          raise Error, "unexpected: #{node.name.inspect}"
+        end
+      end
+
+      def load_dict(node)
+        h = {}
+        # comments, list = node.children.partition(&:comment?)
+        # warn 'plist: comment node(s) ignored in dict' unless comments.empty?
+        list = node.children.reject(&:comment?)
+        n = list.length / 2
+        (0...n).each do |i|
+          i = i * 2
+          k = list[i]
+          v = list[i+1]
+          k.name == 'key' or raise Error, "expected 'key': #{k.name.inspect}"
+          v = load_node(v)
+          v.nil? and raise Error, "comment as value for key '#{k.text}'"
+          h[k.text] = v
+        end
+        h
+      end
+
+      def dump_object(object, indent)
+        case object
+        when String;      dump_string(object, indent)
+        when Fixnum;      dump_fixnum(object, indent)
+        when Hash;        dump_hash(object, indent)
+        when Array;       dump_array(object, indent)
+        when TrueClass;   "#{indent}<true/>\n"
+        when FalseClass;  "#{indent}<false/>\n"
+        else; raise Error, "unexpected type: #{object.class.name}"
+        end
+      end
+
+      def dump_string(str, indent)
+        "#{indent}<string>" << h(str) << "</string>\n"
+      end
+
+      def dump_fixnum(num, indent)
+        "#{indent}<integer>#{num}</integer>\n"
+      end
+
+      def dump_hash(hash, indent)
+        return "#{indent}<dict/>\n" if hash.empty?
+        result = "#{indent}<dict>\n"
+        i = indent + "\t"
+        hash.keys.sort.each do |key|
+          result << "#{i}<key>#{key}</key>\n" << dump_object(hash[key], i)
+        end
+        result << "#{indent}</dict>\n"
+      end
+
+      def dump_array(array, indent)
+        return "#{indent}<array/>\n" if array.empty?
+        result = "#{indent}<array>\n"
+        i = indent + "\t"
+        array.each { |o| result << dump_object(o, i) }
+        result << "#{indent}</array>\n"
+      end
+
+      def h(text)
+        text.html_escape(false)
+      end
+
+    end
+
+  end
+
+end
+end