sublime_dsl 0.1.1

data/lib/sublime_dsl/sublime_text.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require_relative 'sublime_text/command'
+require_relative 'sublime_text/command_set'
+require_relative 'sublime_text/keyboard'
+require_relative 'sublime_text/keymap'
+require_relative 'sublime_text/macro'
+require_relative 'sublime_text/menu'
+require_relative 'sublime_text/mouse'
+require_relative 'sublime_text/mousemap'
+require_relative 'sublime_text/package'
+require_relative 'sublime_text/setting_set'
+
+module SublimeDSL
+module SublimeText
+
+  # Path to the Packages directory.
+
+  def self.packages_dir
+    @packages_dir ||=
+      case Tools.os
+      when :Windows
+        ENV['APPDATA'].gsub('\\', '/') << '/Sublime Text 2/Packages'
+      when :OSX
+        "~/Library/Application Support/Sublime Text 2/Packages"
+      when :Linux
+        "~/.config/sublime-text-2/Packages"
+      else
+        raise NotImplementedError,
+          "don't know the location of Sublime Text packages on #{os}"
+      end
+  end
+
+  # Order a series of config files like ST does:
+  # - Default/* first,
+  # - then packages alphabetically,
+  # - then User/Default*,
+  # - then User/* alphabetically.
+
+  def self.order_config(files)
+    default, other = files.partition { |f| f.start_with?('Default') }
+    user, other = other.partition { |f| f.start_with?('User') }
+    user_default, user_other = user.partition { |f| f.start_with?('User/Default') }
+    default.sort + other.sort + user_default.sort + user_other.sort
+  end
+
+end
+end

data/lib/sublime_dsl/textmate/custom_base_name.rb

@@ -0,0 +1,45 @@
+module SublimeDSL
+module TextMate
+
+  ##
+  # Mix-in to define a custom file base name.
+  #
+  # The includer has a #name method.
+
+  module CustomBaseName
+
+
+    # Returns #custom_basename if defined, otherwise Tools.filename(name).
+    def basename
+      custom_basename || Tools.filename(name)
+    end
+
+    # Sets #custom_basename to +base+.
+    def basename=(base)
+      @basename = base
+    end
+
+    # Returns the custom base name, or +nil+ if none.
+    def custom_basename
+      # avoid warning on uninitialized instance variable
+      if defined?(@basename)
+        @basename
+      else
+        @basename = nil
+      end
+    end
+
+    # Returns ", file: '<basename>'" if #basename different from
+    # Tools.filename(name). Otherwise sets it to +nil+
+    def dsl_file_arg
+      if basename != Tools.filename(name)
+        ", file: #{custom_basename.to_source}"
+      else
+        ''
+      end
+    end
+
+  end
+
+end
+end

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

@@ -0,0 +1,383 @@
+# encoding: utf-8
+
+module SublimeDSL
+module TextMate
+class Grammar
+
+  class DSLReader
+
+    def initialize(file = nil)
+      @grammars = []
+      @context_stack = []
+      instance_eval File.read(file, encoding: 'utf-8'), file if file
+    end
+
+    def _grammars
+      @grammars
+    end
+
+    def _context
+      @context_stack.last
+    end
+
+    def _grammar
+      @context_stack.first
+    end
+
+    def method_missing(sym, *args, &block)
+      raise Error, "'#{sym}' is not a valid grammar DSL statement"
+    end
+
+    def language(options = {}, &block)
+      _context and raise Error, "'language' blocks cannot be nested"
+      base = options.delete(:file)
+      options.length == 0 and raise Error, 'missing name & scope'
+      name = options.keys.first
+      scope = options.delete(name)
+      options.empty? or warn "invalid options: #{options.inspect}"
+      g = Grammar.new(name, scope)
+      g.basename = base
+      @context_stack.push g
+      instance_eval(&block)
+      @context_stack.pop
+      g.complete!
+      @grammars << g
+    end
+
+    def file_types(array)
+      ensure_writer
+      _grammar.file_types = array
+    end
+
+    def first_line_match(re)
+      ensure_writer
+      _grammar.first_line_match = Tools::RegexpWannabe.new(re.source)
+    end
+
+    def folding_start_marker(re)
+      ensure_writer
+      _grammar.folding_start_marker = Tools::RegexpWannabe.new(re.source)
+    end
+
+    def folding_stop_marker(re)
+      ensure_writer
+      _grammar.folding_stop_marker = Tools::RegexpWannabe.new(re.source)
+    end
+
+    def key_equivalent(str)
+      ensure_writer
+      _grammar.key_equivalent = str
+    end
+
+    def uuid(str)
+      ensure_writer
+      _grammar.uuid = str
+    end
+
+    def bundle_uuid(str)
+      ensure_writer
+      _grammar.bundle_uuid = str
+    end
+
+    def include(name_or_module)
+      if name_or_module.is_a?(Module)
+        self.class.send :include, name_or_module
+      else
+        ensure_reader :patterns
+        _context.patterns << Include.new(name_or_module)
+      end
+    end
+
+    def fragment(name)
+      ensure_reader :fragments
+      f = Fragment.new(name.to_s)   # FIXME pas la peine de sortir des :sym pour faire du to_s!
+      _grammar.fragments << f
+      @context_stack.push f
+      yield self # block.call
+      @context_stack.pop
+    end
+
+    def rule(scope = nil)
+      ensure_reader :patterns
+      b = RuleBuilder.new(scope)
+      @context_stack.push b
+      yield self # block.call
+      @context_stack.pop
+      b.rule.complete! _grammar
+      _context.patterns << b.rule
+    end
+
+    def match(re, captures = {})
+      ensure_reader
+      _context.match re, captures
+    end
+
+    def from(re, captures = {})
+      ensure_reader
+      _context.from re, captures
+    end
+
+    def to(re, captures = {})
+      ensure_reader
+      _context.to re, captures
+    end
+
+    def both(captures)
+      ensure_reader
+      _context.both captures
+    end
+
+    def content_scope(scope)
+      ensure_writer
+      _context.content_scope = scope
+    end
+
+    def to_last(value)
+      ensure_writer
+      _context.to_last = value
+    end
+
+    def disabled(value)
+      ensure_writer
+      _context.disabled = value
+    end
+
+    def ensure_reader(method = nil)
+      name = caller[0].gsub(/.*`(.*)'$/, '\1')
+      method ||= name
+      _context.respond_to? method or raise invalid_context(name)
+    end
+
+    def ensure_writer(method = nil)
+      name = caller[0].gsub(/.*`(.*)'$/, '\1')
+      method ||= name + '='
+      _context.respond_to? method or raise invalid_context(name)
+    end
+
+    def invalid_context(name)
+      if _context
+        c = _context.class.name.split('::').last.snake_case
+        c = 'rule' if c == 'rule_builder'
+        "#{name} is invalid inside '#{c}'"
+      else
+        "#{name} is invalid outside 'language'"
+      end
+    end
+
+  end
+
+  class RuleBuilder
+
+    attr_accessor :state
+
+    def initialize(scope)
+      @state = State.new(self)
+      @state.scope = scope
+    end
+
+    def disabled=(value)
+      state.disabled = value
+    end
+
+    def match(re, captures)
+      state.match re, captures
+    end
+
+    def from(re, captures)
+      state.from re, captures
+    end
+
+    def to(re, captures)
+      state.to re, captures
+    end
+
+    def both(captures)
+      state.both captures
+    end
+
+    def content_scope=(scope)
+      state.content_scope = scope
+    end
+
+    def to_last=(value)
+      state.to_last = value
+    end
+
+    def patterns
+      state.patterns
+    end
+
+    def rule
+      state.rule
+    end
+
+    class State
+
+      attr_accessor :builder
+      attr_accessor :scope, :comment, :disabled
+
+      def initialize(builder)
+        @scope = @comment = @disabled = nil
+        @builder = builder
+        @patterns = []
+      end
+
+      def match(re, captures)
+        @patterns.empty? or raise Error, "a 'match' rule cannot contain 'include' or 'rule'"
+        s = state_for(MatchState)
+        s.match re, captures
+      end
+
+      def from(re, captures)
+        s = state_for(BeginEndState)
+        s.from re, captures
+      end
+
+      def to(re, captures)
+        s = state_for(BeginEndState)
+        s.to re, captures
+      end
+
+      def both(captures)
+        s = state_for(BeginEndState)
+        s.both captures
+      end
+
+      def content_scope=(scope)
+        s = state_for(BeginEndState)
+        s.content_scope = scope
+      end
+
+      def to_last=(value)
+        s = state_for(BeginEndState)
+        s.to_last = value
+      end
+
+      def patterns
+        @patterns
+      end
+
+      def rule
+        r = NoMatchRule.new
+        init r
+        r.patterns.concat @patterns
+        r
+      end
+
+    private
+
+      def state_for(klass)
+        s = klass.new(builder)
+        s.scope = scope
+        s.comment = comment
+        s.disabled = disabled
+        s.patterns.concat @patterns unless @patterns.empty?
+        @builder.state = s
+      end
+
+      def init(rule)
+        rule.scope = @scope
+        rule.comment = @comment
+        rule.disabled = @disabled
+      end
+
+    end
+
+    class MatchState < State
+
+      def match(re, captures)
+        @match = Match.new(Tools::RegexpWannabe.new(re.source))
+        @match.captures.merge! captures
+      end
+
+      def from(re, captures)
+        raise Error, "'from' is invalid with 'match'"
+      end
+
+      def to(re, captures)
+        raise Error, "'to' is invalid with 'match'"
+      end
+
+      def both(captures)
+        raise Error, "'both' is invalid with 'match'"
+      end
+
+      def content_scope=(scope)
+        raise Error, "'content_scope' is invalid with 'match'"
+      end
+
+      def to_last=(value)
+        raise Error, "'to_last' is invalid with 'match'"
+      end
+
+      def patterns
+        raise Error, "'patterns' is invalid with 'match'"
+      end
+
+      def rule
+        r = MatchRule.new
+        init r
+        r.match = @match
+        r
+      end
+
+    end
+
+    class BeginEndState < State
+
+      def initialize(builder)
+        super builder
+        @from = @to = nil
+        @both = {}
+        @content_scope = nil
+        @to_last = nil
+      end
+
+      def match(re, captures)
+        raise Error, "'match' is invalid with 'from' or 'to'"
+      end
+
+      def from(re, captures)
+        @from and raise Error, "'from' called twice"
+        @from = Match.new(Tools::RegexpWannabe.new(re.source))
+        @from.captures.merge! captures
+      end
+
+      def to(re, captures)
+        @to and raise Error, "'to' called twice"
+        @to = Match.new(Tools::RegexpWannabe.new(re.source, @from))
+        @to.captures.merge! captures
+      end
+
+      def both(captures)
+        @both.empty? or raise Error, "'both' already specified"
+        @both.merge! captures
+      end
+
+      def content_scope=(scope)
+        @content_scope = scope
+      end
+
+      def to_last=(value)
+        @to_last = value
+      end
+
+      def rule
+        r = BeginEndRule.new
+        init r
+        r.content_scope = @content_scope
+        r.from = @from
+        r.to = @to
+        r.to_last = @to_last
+        r.captures.merge! @both
+        r.patterns.concat @patterns
+        r
+      end
+
+    end
+
+  end
+
+end
+end
+end

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

@@ -0,0 +1,178 @@
+# encoding: utf-8
+
+module SublimeDSL
+module TextMate
+class Grammar
+
+  ##
+  # Creates the DSL for a grammar.
+
+  class DSLWriter
+
+    attr_reader :grammar
+    attr_reader :io
+
+    def initialize(grammar)
+      @grammar = grammar
+      @io = StringIO.new('', 'wb:utf-8')
+      output_grammar
+    end
+
+    def dsl
+      io.string
+    end
+
+  private
+
+    def output_grammar
+
+      args = "#{grammar.name.to_source} => #{grammar.scope.to_source}"
+      args << grammar.dsl_file_arg
+
+      # grammar start
+      io.puts "language #{args} do"
+      indent = '  '
+
+      # comment
+      output_comment grammar.comment, indent
+
+      # file types
+      if grammar.file_types && !grammar.file_types.empty?
+        if grammar.file_types.any? { |t| t =~ /\s/ }
+          array = grammar.file_types.map { |t| "'" << t << "'" }.join(', ')
+          io.puts indent + "file_types [#{array}]"
+        else
+          list = grammar.file_types.join(' ')
+          if list.length <= 80
+            io.puts indent + "file_types %w(#{list})"
+          else
+            io.puts indent + "file_types %w("
+            io.puts list.wrap.indent(indent.length + 2)
+            io.puts indent + ")"
+          end
+        end
+      else
+        io.puts indent + '# FIXME: no file types'
+      end
+
+      # regexps
+      %w(firstLineMatch foldingStartMarker foldingStopMarker).each do |att|
+        met = att.snake_case
+        re = grammar.send(met)
+        next unless re
+        io.print re.fixme_comments(indent)
+        io.puts indent + met + ' ' + re.inspect(true)
+      end
+
+      # TextMate stuff
+      %w(keyEquivalent uuid bundleUUID).each do |att|
+        met = att.snake_case
+        str = grammar.send(met)
+        next unless str
+        io.puts indent + met + ' ' + str.inspect + '  # TextMate only'
+      end
+
+      # patterns
+      io.puts
+      output_array grammar.patterns, indent
+
+      # repository
+      grammar.fragments.each { |f| output_fragment f, indent }
+
+      # grammar end
+      io.puts 'end'
+
+    end
+
+    def output_object(object, indent)
+      k = object.class.name.split('::').last.snake_case
+      send "output_#{k}", object, indent
+    end
+
+    def output_array(list, indent)
+      list.each { |o| output_object o, indent }
+    end
+
+    def output_fragment(f, indent)
+      io.puts
+      io.puts indent + '# FIXME: this fragment is never referenced' unless f.used
+      io.puts "#{indent}fragment #{f.name.to_sym.inspect} do"
+      i = indent + '  '
+      output_comment f.comment, i
+      output_array f.patterns, i
+      io.puts indent + 'end'
+    end
+
+    def output_include(inc, indent)
+      output_comment inc.comment, indent
+      io.puts indent + 'include ' + inc.fragment_name.inspect
+    end
+
+    def output_no_match_rule(rule, indent)
+      io.puts indent + '# FIXME: no "match" nor "begin/end"' unless !rule.patterns.empty? &&
+        (rule.scope && rule.scope.start_with?('meta.') || !rule.disabled.nil?)
+      output_rule_start rule, indent
+      output_array rule.patterns, indent + '  '
+      io.puts indent + 'end'
+    end
+
+    def output_match_rule(rule, indent)
+      output_rule_start rule, indent
+      output_match 'match', rule.match, indent + '  '
+      io.puts indent + 'end'
+    end
+
+    def output_begin_end_rule(rule, indent)
+      output_rule_start rule, indent
+      i = indent + '  '
+      io.puts i + 'content_scope ' + rule.content_scope.inspect if rule.content_scope
+      output_match 'from', rule.from, i
+      output_match 'to', rule.to, i
+      unless rule.captures.empty?
+        io.print i + 'both '
+        output_captures rule.captures, i + '     '
+      end
+      output_boolean 'to_last', rule.to_last, i
+      output_array rule.patterns, i
+      io.puts indent + 'end'
+    end
+
+    def output_rule_start(rule, indent)
+      io.puts indent + (rule.scope ? "rule '#{rule.scope}' do" : 'rule do')
+      indent += '  '
+      output_comment rule.comment, indent
+      output_boolean 'disabled', rule.disabled, indent
+    end
+
+    def output_match(name, match, indent)
+      io.print match.regexp.fixme_comments(indent)
+      io.print indent + name + ' ' + match.regexp.inspect(true)
+      if match.captures.empty?
+        io.puts
+      else
+        io.print ",\n" << indent + '  '
+        output_captures match.captures, indent + '  '
+      end
+    end
+
+    def output_captures(captures, indent)
+      lines = []
+      captures.each_pair do |number, scope|
+        lines << number.to_s + " => '" + scope + "'"
+      end
+      io.puts lines.join(",\n" + indent)
+    end
+
+    def output_boolean(name, value, indent)
+      io.puts indent + name + ' ' + (value.to_i == 0 ? 'false' : 'true') if value
+    end
+
+    def output_comment(text, indent)
+      text and text.each_line { |l| io.puts indent + ('# ' + l).rstrip }
+    end
+
+  end
+
+end
+end
+end