sublime_dsl 0.1.1

data/lib/sublime_dsl/sublime_text/command.rb

@@ -0,0 +1,157 @@
+# encoding: utf-8
+
+module SublimeDSL
+module SublimeText
+
+  ##
+  # A command.
+
+  class Command
+
+    def self.from_method_missing(sym, args)
+      method = sublime_method(sym.to_s)
+      last_word = method.split('_').last
+      case args.length
+      when 0
+      when 1
+        args = args.first.is_a?(Hash) ? args.first : { last_word => args.first }
+      when 2
+        args.last.is_a?(Hash) or
+          return new(sym, args, "invalid arguments to #{method}: #{cmd.args.inspect}")
+        args = { last_word => args.first }.merge(args.last)
+      else
+        return new(sym, args, "invalid arguments to #{method}: #{cmd.args.inspect}")
+      end
+      new(method, args)
+    end
+
+    def self.dsl_method(name)
+      if ruby_keyword_hash[name]
+        '_' << name
+      elsif name.start_with?('$')
+        '_dollar_' << name[1..-1]
+      else
+        name
+      end
+    end
+
+    def self.sublime_method(name)
+      return name unless name.start_with?('_')
+      m = name[1..-1]
+      if m.start_with?('dollar_')
+        '$' << m[7..-1]
+      elsif ruby_keyword_hash[m]
+        m
+      else
+        name
+      end
+    end
+
+    def self.ruby_keyword_hash
+      @ruby_keyword_hash ||= Hash[
+        %w(
+          alias and BEGIN begin break case class def defined? do
+          else elsif END end ensure false for if in module
+          next nil not or redo rescue retry return self super
+          then true undef unless until when while yield
+        ).map { |w| [w, true] }
+      ]
+    end
+
+    attr_reader :name, :args, :error
+
+    def initialize(name, args, error = nil)
+      @name = name
+      @args =
+        if error
+          args
+        else
+          args ? args.to_a.map { |n,v| Argument.new(n,v) } : []
+        end
+      @error = error
+    end
+
+    def to_h(command_key = 'command', args_key = 'args')
+      if args.empty?
+        { command_key => name }
+      else
+        args_hash = {}
+        args.each { |a| args_hash[a.name] = a.value }
+        { command_key => name, args_key => args_hash }
+      end
+    end
+
+    def to_dsl(statement_style = false)
+      method = Command.dsl_method(name)
+      return method if args.empty?
+      last = name.split('_').last
+      if last == args.first.name
+        arg_list = args.first.to_s(false)
+        arg_list << ', ' << args[1..-1].map(&:to_s).join(', ') if args.length > 1
+      else
+        arg_list = args.map(&:to_s).join(', ')
+      end
+      statement_style ? "#{method} #{arg_list}" : "#{method}(#{arg_list})"
+    end
+
+    alias to_s to_dsl
+
+    include Tools::ValueEquality
+
+    ##
+    # A command argument.
+
+    class Argument
+
+      attr_reader :name, :value
+
+      def initialize(name, value)
+        @name = name
+        @value = value
+      end
+
+      def to_s(hash_style = true)
+        if hash_style
+          "#{name}: #{display(value)}"
+        else
+          display(value)
+        end
+      end
+
+      include Tools::ValueEquality
+
+    private
+
+      def display(v)
+        case v
+        when String
+          v.inspect
+        when TrueClass, FalseClass, Numeric
+          v.to_s
+        when Array
+          display_array(v)
+        when Hash
+          v.inspect
+        when NilClass
+          'nil'
+        else
+          raise Error, "command argument #{name.inspect} value: #{v.inspect}"
+        end
+      end
+
+      def display_array(a)
+        if a.empty?
+          '[]'
+        elsif a.all? { |e| e.is_a?(String) && e =~ /\A(\S+)\z/ }
+          "%w(#{a.join(' ')})"
+        else
+          a.inspect
+        end
+      end
+
+    end
+
+  end
+
+end
+end

data/lib/sublime_dsl/sublime_text/command_set.rb

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+module SublimeDSL
+module SublimeText
+
+  class CommandSet
+
+    def self.import(file)
+      name = File.basename(file, File.extname(file))
+      set = new(name)
+      list = JSON[File.read(file, encoding: 'utf-8')]
+      begin
+        set.items.concat list.map { |h| Item.from_json(h) }
+      rescue => ex
+        Console.error "file: #{file}"
+        raise ex
+      end
+      set
+    end
+
+    attr_reader :name, :items
+
+    def initialize(name)
+      @name = name
+      @items = []
+    end
+
+    def to_dsl
+      dsl = "commands #{name.to_source} do\n\n"
+      items.each { |i| dsl << "  #{i.to_dsl}\n" }
+      dsl << "\nend"
+    end
+
+    def export(dir)
+      file = "#{dir}/#{name}.sublime-commands"
+      File.open(file, 'wb:utf-8') { |f| f.write to_json }
+    end
+
+    def to_json
+      "[\n" <<
+        items.map { |i| JSON.generate(i.to_h) }.join(",\n").indent(2) <<
+      "\n]"
+    end
+
+
+    class Item
+
+      def self.from_json(json_hash)
+        h = json_hash.dup
+        cap = h.delete('caption') or raise Error, "no caption: #{json_hash.inspect}"
+        cmd = h.delete('command') or raise Error, "no command: #{json_hash.inspect}"
+        args = h.delete('args')
+        h.empty? or warn "unkown keys ignored: #{h.inspect}"
+        new(cap, Command.new(cmd, args))
+      end
+
+      attr_reader :caption, :command
+
+      def initialize(caption, command)
+        @caption = caption
+        @command = command
+      end
+
+      def to_dsl
+        "item #{caption.to_source}, #{command.to_dsl}"
+      end
+
+      def to_h
+        { 'caption' => caption }.merge(command.to_h)
+      end
+
+    end
+
+
+    class DSLReader < Tools::BlankSlate
+
+      def initialize(file = nil)
+        @command_sets = []
+        @current_set = nil
+        instance_eval File.read(file, encoding: 'utf-8'), file if file
+      end
+
+      def _command_sets
+        @command_sets
+      end
+
+      def commands(name, &block)
+        @current_set and raise Error, "'commands' blocks cannot be nested"
+        @current_set = CommandSet.new(name)
+        instance_eval(&block)
+        @command_sets << @current_set
+        @current_set = nil
+      end
+
+      def item(caption, cmd)
+        @current_set or raise Error, "'item' is invalid outside of a 'commands' block"
+        cmd.error and raise Error, "item '#{caption}': #{cmd.error}"
+        @current_set.items << Item.new(caption, cmd)
+      end
+
+      def method_missing(sym, *args, &block)
+        @current_set or raise Error, "'#{sym}' is invalid outside of a 'commands' block"
+        Command.from_method_missing(sym, args)
+      end
+
+    end
+
+
+  end
+
+end
+end