sublime_dsl 0.1.1

data/lib/sublime_dsl/sublime_text/menu.rb

@@ -0,0 +1,237 @@
+# encoding: utf-8
+
+module SublimeDSL
+module SublimeText
+
+  class Menu
+
+    def self.import(file)
+      name = File.basename(file, File.extname(file))
+      set = new(name)
+      list = JSON[File.read(file, encoding: 'utf-8')]
+      set.items.concat list.map { |h| Item.from_json(h) }
+
+      set
+    end
+
+    attr_reader :name, :items
+
+    def initialize(name)
+      @name = name
+      @items = []
+    end
+
+    def to_dsl
+      dsl = "menu #{name.to_source} do\n\n"
+      items.each { |i| dsl << "#{i.to_dsl}\n" }
+      dsl << "\nend"
+    end
+
+    def write(dir)
+      file = "#{dir}/#{name}.menu.rb"
+      File.open(file, 'wb:utf-8') do |f|
+        f.puts '# encoding: utf-8'
+        f.puts "\n#{to_dsl}"
+      end
+    end
+
+    def export(dir)
+      file = "#{dir}/#{name}.sublime-menu"
+      File.open(file, 'wb:utf-8') { |f| f.write to_json }
+    end
+
+    def to_json
+      "[\n" <<
+        items.map { |i| i.to_json('  ') }.join(",\n") <<
+      "\n]"
+    end
+
+
+    class Item
+
+      def self.from_json(json_hash)
+        h = json_hash.dup
+        item = Item.new.tap do |i|
+          i.caption = h.delete('caption')
+          i.mnemonic = h.delete('mnemonic')
+          cmd = h.delete('command')
+          args = h.delete('args')
+          i.command = Command.new(cmd, args) if cmd
+          i.id = h.delete('id')
+          i.checkbox = h.delete('checkbox')
+          i.platform = h.delete('platform')
+        end
+        children = h.delete('children') || []
+        children.each do |c|
+          item.items << Item.from_json(c)
+        end
+        h.empty? or warn "unkown keys ignored: #{h.inspect}"
+
+        item
+      end
+
+      attr_accessor :command, :caption, :mnemonic, :id, :checkbox, :platform
+      attr_reader :items
+
+      def initialize()
+        @command = nil
+        @caption = nil
+        @mnemonic = nil
+        @id = nil
+        @checkbox = nil
+        @platform = nil
+        @items = []
+      end
+
+      def to_dsl(indent = '  ')
+        args = ''
+        options = []
+
+        if caption
+          cap = caption.gsub('&', '&&')
+          if mnemonic
+            if cap =~ /^(.*?)(#{mnemonic})(.*)$/i
+              args << "#{$1}&#{$2}#{$3}".to_source
+            else
+              args << cap.to_source
+              options << "mnemonic: #{mnemonic.to_source}"
+            end
+          else
+            args << cap.to_source
+          end
+        end
+
+        if command
+          args << ', ' unless args.empty?
+          args << command.to_dsl
+          options << "mnemonic: #{mnemonic.to_source}" if caption.nil? && mnemonic
+        end
+
+        options << "id: #{id.to_source}" if id
+        options << "checkbox: true" if checkbox
+        options << "platform: #{platform.to_source}" if platform
+
+        dsl = "#{indent}item #{args}"
+        unless options.empty?
+          dsl << ', ' unless args.empty?
+          dsl << options.join(', ')
+        end
+
+        unless items.empty?
+          i = indent + '  '
+          dsl << " do\n"
+          items.each do |c|
+            dsl << c.to_dsl(i) << "\n"
+          end
+          dsl << "#{indent}end"
+        end
+
+        dsl
+      end
+
+      def to_h(include_items = true)
+        h = {}
+        h['caption'] = caption if caption
+        h['mnemonic'] = mnemonic if mnemonic
+        h.merge! command.to_h if command
+        h['id'] = id if id
+        h['checkbox'] = checkbox if checkbox
+        h['platform'] = platform if platform
+        h['children'] = items.map(&:to_h) if include_items && !items.empty?
+        h
+      end
+
+      def to_json(indent)
+        return indent + JSON.generate(to_h) if items.empty?
+        json = indent + JSON.pretty_generate(to_h(false))
+        json = json[0..-3] # remove trailing "\n}"
+        json.gsub!("\n", "\n#{indent}")
+        json << %(,\n#{indent}  "children": [\n)
+        ind = indent + '    '
+        json << items.map { |i| i.to_json(ind) }.join(",\n")
+        json << "\n#{indent}  ]\n#{indent}}"
+      end
+
+    end
+
+
+    class DSLReader < Tools::BlankSlate
+
+      def initialize(file = nil)
+        @menus = []
+        @item_stack = []
+        instance_eval File.read(file, encoding: 'utf-8'), file if file
+      end
+
+      def _menus
+        @menus
+      end
+
+      def menu(name, &block)
+        @item_stack.empty? or raise Error, "menu blocks cannot be nested"
+        @item_stack.push Menu.new(name)
+        instance_eval(&block)
+        @menus << @item_stack.pop
+      end
+
+      def item(*args, &block)
+        @item_stack.empty? and raise Error, "'item' is invalid outside of a menu block"
+        item = new_item(args)
+        @item_stack.last.items << item
+        return unless block
+        @item_stack.push item
+        instance_eval(&block)
+        @item_stack.pop
+      end
+
+      def method_missing(sym, *args, &block)
+        @item_stack.empty? and raise Error, "'#{sym}' is invalid outside of a menu block"
+        Command.from_method_missing(sym, args)
+      end
+
+      def new_item(args)
+        args.empty? and raise Error, "no argument for 'item'"
+        item = Item.new
+
+        # get the caption if any
+        if args.first.is_a?(String)
+          caption = args.shift
+          caption =~ /&([^& ])/ and item.mnemonic = $1.upcase
+          item.caption = caption.gsub(/&(.)/, '\1')
+          return item if args.empty?
+        end
+
+        # get the command if any
+        cmd = args.first
+        if cmd.is_a?(Command)
+          cmd.error and raise Error, "item '#{caption}': #{cmd.error}"
+          item.command = cmd
+          args.shift
+          return item if args.empty?
+        end
+
+        # options
+        options = args.first
+        args.length == 1 && options.is_a?(Hash) or
+          raise Error, "invalid arguments for 'item': #{args.inspect}"
+
+        item.id = options.delete(:id)
+        item.checkbox = options.delete(:checkbox)
+        item.platform = options.delete(:platform)
+        mnemonic = options.delete(:mnemonic)
+        if mnemonic
+          item.mnemonic && mnemonic != item.mnemonic and
+            warn "item '#{caption}': mnemonic #{item.mnemonic} overwritten by #{mnemonic}"
+          item.mnemonic = mnemonic
+        end
+
+        item
+      end
+
+    end
+
+
+  end
+
+end
+end

data/lib/sublime_dsl/sublime_text/mouse.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+module SublimeDSL
+module SublimeText
+
+  class Mouse
+
+    def self.sublime
+      @sublime ||= create_sublime_mouse
+    end
+
+    def self.create_sublime_mouse
+      mouse = new('Sublime Text')
+      (1..9).each { |i| mouse.add_button "button#{i}" }
+      mouse.add_button "scroll_up"
+      mouse.add_button "scroll_down"
+      %w(shift ctrl alt super).each { |m| mouse.add_modifier m }
+      mouse.modifiers.concat mouse.buttons
+      mouse
+    end
+
+    attr_reader :name, :buttons, :modifiers
+
+    def initialize(name)
+      @name = name
+      @buttons = []
+      @modifiers = []
+      @clicks = []
+    end
+
+    alias to_s name
+
+    def clone(name)
+      clone = Mouse.new(name)
+      buttons.each { |b| clone.add_button b.st_name, b.name }
+      (modifiers - buttons).each { |m| clone.add_modifier m.st_name, m.name }
+      clone.modifiers.concat clone.buttons
+      clone
+    end
+
+    def button(name)
+      buttons.find { |b| b.name == name }
+    end
+
+    def modifier(name)
+      modifiers.find { |b| b.name == name }
+    end
+
+    def add_button(st_name, name = nil)
+      @buttons << Button.new(st_name, name)
+    end
+
+    def add_modifier(st_name, name = nil)
+      @modifiers << Button.new(st_name, name)
+    end
+
+    def clicks_hash
+      @clicks_hash ||= {}
+    end
+
+    def modifiers_index_hash
+      @modifiers_index_hash ||= begin
+        h = {}
+        modifiers.each_with_index { |b,i| h[b.name] = i }
+        h
+      end
+    end
+
+    def ensure_click(spec)
+      *modifier_names, button_name = spec.split('+')
+
+      button = button(button_name) or
+        raise Error, "invalid button #{button_name.inspect}"
+
+      # check & reorder the modifiers
+      unless modifier_names.empty?
+        sorted = []
+        modifier_names.each do |name|
+          i = modifiers_index_hash[name]
+          i or raise Error, "invalid modifier #{name.inspect}"
+          sorted[i] = name
+        end
+        modifier_names = sorted.compact
+      end
+
+      # if there is a registered click for this spec, return it
+      std_spec = [*modifier_names, button_name].join('+')
+      click = clicks_hash[std_spec]
+      return click if click
+
+      # can't have the button in the modifiers
+      modifier_names.include?(button_name) and
+        raise Error, "can't have the button in the modifiers: #{spec.inspect}"
+
+      # create and register the click
+      modifiers = modifier_names.map { |n| modifier(n) }
+      click = Click.new(modifiers, button)
+      clicks_hash[click.to_spec] = click
+
+      click
+    end
+
+
+    ##
+    # A mouse button or modifier.
+
+    class Button
+
+      attr_reader :st_name
+      attr_accessor :name
+
+      def initialize(st_name, name)
+        @st_name = st_name
+        @name = name || st_name
+      end
+
+    end
+
+
+    ##
+    # A mouse click: button + modifiers.
+
+    class Click
+
+      attr_reader :button, :modifiers
+
+      def initialize(modifiers, button)
+        @modifiers = modifiers
+        @button = button
+      end
+
+      def to_spec
+        [*modifiers.map(&:name), button.name].join('+')
+      end
+
+      alias to_s to_spec
+
+      def to_h
+        h = { 'button' => button.st_name }
+        h['modifiers'] = modifiers.map(&:st_name) unless modifiers.empty?
+        h
+      end
+
+    end
+
+  end
+
+end
+end

data/lib/sublime_dsl/sublime_text/mousemap.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+
+module SublimeDSL
+module SublimeText
+
+  class MouseMap
+
+    def self.import(file)
+      name = File.basename(file, File.extname(file))
+      map = new(name)
+      list = JSON[File.read(file, encoding: 'utf-8')]
+      begin
+        map.bindings.concat list.map { |h| MouseBinding.from_json(h) }
+      rescue => ex
+        puts "file: #{file}"
+        raise ex
+      end
+
+      map
+    end
+
+    attr_reader :name, :bindings
+
+    def initialize(name)
+      @name = name
+      @bindings = []
+    end
+
+    def write(dir)
+      file = "#{dir}/#{name}.mousemap.rb"
+      File.open(file, 'wb') do |f|
+        f.puts "\nmousemap #{name.to_source} do"
+        f.puts
+        bindings.each do |b|
+          begin
+            f.puts '  ' << b.to_dsl
+          rescue => ex
+            puts "file: #{file}\nbinding: #{b.click}"
+            raise ex
+          end
+        end
+        f.puts "\nend"
+      end
+    end
+
+    def export(dir)
+      file = "#{dir}/#{name}.sublime-mousemap"
+      File.open(file, 'wb:utf-8') { |f| f.write to_json }
+    end
+
+    def to_json
+      "[\n" <<
+        bindings.map { |b| JSON.generate(b.to_h) }.join(",\n").indent(2) <<
+      "\n]"
+    end
+
+
+    ##
+    # A mouse binding: a click with its command(s).
+
+    class MouseBinding
+
+      def self.from_json(json_hash)
+        h = json_hash.dup
+
+        button = h.delete('button') or raise Error, 'no button: ' << json_hash.inspect
+        modifiers = h.delete('modifiers')
+        spec = [*modifiers, button].join('+')
+        click = Mouse.sublime.ensure_click(spec)
+
+        count = h.delete('count')
+        count = count.to_i if count
+
+        press = h.delete('press_command')
+        press_command = press ? Command.new(press, h.delete('press_args')) : nil
+
+        cmd = h.delete('command')
+        command = cmd ? Command.new(cmd, h.delete('args')) : nil
+
+        h.empty? or raise Error, 'unexpected JSON keys: ' << h.inspect
+        new(click, count, press_command, command)
+
+      rescue => ex
+        warn "error with binding #{json_hash.inspect}"
+        warn ex.message
+        raise
+      end
+
+      attr_reader :click, :count, :press_command, :command
+      attr_accessor :source_file
+
+      def initialize(click, count, press_command, command)
+        @click = click
+        @count = count
+        @press_command = press_command
+        @command = command
+      end
+
+      def to_dsl
+        spec = click.to_spec
+        dsl = "click#{count} #{spec.to_source}"
+        dsl << ", down: #{press_command.to_dsl}" if press_command
+        dsl << ", up: #{command.to_dsl}" if command
+
+        dsl
+      end
+
+      def to_h
+        h = click.to_h
+        h['count'] = count if count
+        h.merge! press_command.to_h('press_command', 'press_args') if press_command
+        h.merge! command.to_h if command
+        h
+      end
+
+    end
+
+
+    class DSLReader < Tools::BlankSlate
+
+      def initialize(file = nil)
+        @mousemaps = []
+        @current_map = nil
+        @mouse = Mouse.sublime
+        instance_eval File.read(file, encoding: 'utf-8'), file if file
+      end
+
+      def _mousemaps
+        @mousemaps
+      end
+
+      def mousemap(name, &block)
+        @current_map and raise Error, "'mousemap' blocks cannot be nested"
+        @current_map = MouseMap.new(name)
+        instance_eval(&block)
+        @mousemaps << @current_map
+        @current_map = nil
+      end
+
+      def button_names(maps={})
+        # create a copy of the Sublime mouse
+        @mouse = Mouse.sublime.clone('Custom Names')
+        maps.each_pair do |name, st_name|
+          b = @mouse.modifier(st_name) or
+            raise Error, "no button nor modifier named '#{st_name}'"
+          b.name = name
+        end
+      end
+
+      def click1(spec, options={})
+        click spec, options.merge({ count: 1 })
+      end
+
+      def click2(spec, options={})
+        click spec, options.merge({ count: 2 })
+      end
+
+      def click3(spec, options={})
+        click spec, options.merge({ count: 3 })
+      end
+
+      def click(spec, options={})
+        @current_map or raise Error, "'click' is invalid outside of a 'mousemap' block"
+        click = @mouse.ensure_click(spec)
+        count = options.delete(:count)
+        press_cmd = options.delete(:down)
+        press_cmd && press_cmd.error and raise Error, "click '#{spec}':#{press_cmd.error}"
+        cmd = options.delete(:up)
+        cmd && cmd.error and raise Error, "click '#{spec}':#{cmd.error}"
+        press_cmd || cmd or
+          raise Error, "click '#{spec}': no 'up' nor 'down' command"
+        @current_map.bindings << MouseBinding.new(click, count, press_cmd, cmd)
+      end
+
+      def method_missing(sym, *args, &block)
+        @current_map or raise Error, "'#{sym}' is invalid outside of a 'mousemap' block"
+        Command.from_method_missing(sym, args)
+      end
+
+    end
+
+  end
+
+end
+end

data/lib/sublime_dsl/sublime_text/package/dsl_reader.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+module SublimeDSL
+module SublimeText
+class Package
+
+  ##
+  # 'Universal' DSL reader: reads any DSL block and updates its package.
+
+  class DSLReader
+
+    def initialize(file, package)
+      @file = file
+      @package = package
+      instance_eval File.read(file, encoding: 'utf-8'), file
+    end
+
+    def method_missing(sym, *args, &block)
+      raise DSLError, "'#{sym}' is not a valid Package DSL statement"
+    end
+
+    def theme(*args, &block)
+      r = TextMate::Theme::DSLReader.new
+      r.theme(*args, &block)
+      @package.themes.concat r._themes
+    end
+
+    def language(*args, &block)
+      r = TextMate::Grammar::DSLReader.new
+      r.language(*args, &block)
+      @package.grammars.concat r._grammars
+    end
+
+    def preferences(*args, &block)
+      r = TextMate::Preference::DSLReader.new
+      r.preferences(*args, &block)
+      @package.preferences.concat r._preferences
+    end
+
+    def snippets(*args, &block)
+      r = TextMate::Snippet::DSLReader.new
+      r.snippets(*args, &block)
+      @package.snippets.concat r._snippets
+    end
+
+    def settings(*args, &block)
+      r = SettingSet::DSLReader.new
+      r.settings(*args, &block)
+      @package.setting_sets.concat r._setting_sets
+    end
+
+    def macro(*args, &block)
+      r = Macro::DSLReader.new
+      r.macro(*args, &block)
+      @package.macros.concat r._macros
+    end
+
+    def commands(*args, &block)
+      r = CommandSet::DSLReader.new
+      r.commands(*args, &block)
+      @package.command_sets.concat r._command_sets
+    end
+
+    def menu(*args, &block)
+      r = Menu::DSLReader.new
+      r.menu(*args, &block)
+      @package.menus.concat r._menus
+    end
+
+    def mousemap(*args, &block)
+      r = MouseMap::DSLReader.new
+      r.mousemap(*args, &block)
+      @package.mousemaps.concat r._mousemaps
+    end
+
+    def keymap(*args, &block)
+      r = KeyMap::DSLReader.new
+      r._file = @file
+      r.keymap(*args, &block)
+      @package.keymaps.concat r._keymaps
+    end
+
+    def keyboard(*args, &block)
+      raise Error, "keyboards must be defined in a separate *.keyboard.rb file"
+    end
+
+  end
+
+end
+end
+end