sublime_dsl 0.1.1

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

@@ -0,0 +1,138 @@
+# encoding: utf-8
+
+module SublimeDSL
+module SublimeText
+class Package
+
+  ##
+  # An export operation with its options.
+
+  class Exporter
+
+    attr_reader :package
+    attr_accessor :root, :backup, :cleanup
+
+    def initialize(package = nil)
+      @package = package
+      @root = SublimeText.packages_dir
+      @backup = :always
+      @cleanup = false
+    end
+
+    def export(package = nil)
+      @package = package if package
+      validate
+      perform_backup
+      Console.info "exporting package to #{dir}"
+      Dir.mktmpdir('sublime_dsl_') do |tmpdir|
+        tmpdir = tmpdir.encode('utf-8') # for ruby 2.0
+        export_package tmpdir
+        copy_package tmpdir, dir
+      end
+    end
+
+    def dir
+      "#{root}/#{@package.name}"
+    end
+
+    def keyboard=(name)
+      @keyboard_name = name
+    end
+
+    def validate
+      File.directory?(root) or raise OptionError, "no such directory: #{root}"
+      @backup = backup.to_sym
+      unless [:never, :always, :once].include?(backup)
+        warn "invalid backup option #{backup.inspect}, 'always' assumed"
+        @backup = :always
+      end
+    end
+
+    def perform_backup
+      # no backup needed if not asked or no file to backup
+      return unless backup != :never && Dir["#{dir}/*"].length > 0
+      # don't do it if only one backup is requested, and there is already one
+      name = Tools.filename(package.name)
+      return if backup == :once && Dir["#{root}/#{name}.*.zip"].length > 0
+      # backup
+      time_stamp = Tools.filename(Time.now.strftime("%Y-%m-%d %H:%M:%S"))
+      backup_file = "#{root}/#{name}.#{time_stamp}.zip"
+      Tools.zip dir, backup_file
+      Console.info "#{dir} backed up as #{backup_file}"
+    end
+
+    def export_package(dir)
+      p = package
+      p.themes.each { |t| t.export dir }
+      p.grammars.each { |g| g.export dir }
+      p.preferences.each { |pr| pr.export dir }
+      p.snippets.each { |s| s.export dir }
+      p.setting_sets.each { |s| s.export dir }
+      p.macros.each { |m| m.export dir }
+      p.command_sets.each { |c| c.export dir }
+      p.menus.each { |m| m.export dir }
+      p.mousemaps.each { |m| m.export dir }
+      p.keymaps.each { |k| k.export dir }
+      p.other_files.each { |f| copy_file f, dir }
+    end
+
+    def copy_package(from, to)
+
+      # remember the files originally there
+      if File.directory?(to)
+        old_files = Dir["#{to}/**/*"]
+      else
+        Dir.mkdir to
+        old_files = []
+      end
+
+      # copy from the temporary directory
+      new_files = []
+      Dir["#{from}/**/*"].each do |fromfile|
+        tofile = fromfile.dup
+        tofile[from] = to
+        new_files << tofile
+        if File.directory?(fromfile)
+          Dir.mkdir tofile unless File.directory?(tofile)
+        else
+          FileUtils.cp fromfile, tofile
+        end
+      end
+
+      return unless cleanup
+
+      # on Windows, do not delete files that had just case changes
+      if Tools.os == :Windows
+        old_files = old_files.map(&:downcase)
+        new_files = new_files.map(&:downcase)
+      end
+
+      # delete files/directories that disappeared
+      (old_files - new_files).each do |f|
+        next unless File.exist?(f)  # removing directories also remove files
+        if File.directory?(f)
+          FileUtils.rm_r [f]
+        else
+          FileUtils.rm f
+        end
+      end
+
+    end
+
+    def copy_file(infile, outdir)
+      if File.directory?(infile)
+        outpath = "#{outdir}/#{File.basename(infile)}"
+        Dir.mkdir outpath unless File.directory?(outpath)
+        Dir["#{infile}/*"].each { |f| copy_file f, outpath }
+      else
+        # Console.progress ...
+        FileUtils.cp infile, outdir
+      end
+    end
+
+  end
+
+
+end
+end
+end

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

@@ -0,0 +1,127 @@
+# encoding: utf-8
+
+module SublimeDSL
+module SublimeText
+class Package
+
+  ##
+  # An import operation with its options.
+
+  class Importer
+
+    attr_reader :package_name
+    attr_accessor :root, :alt_root, :include, :exclude
+
+    def initialize(name)
+      @package_name = name
+      @root = SublimeText.packages_dir
+      @alt_root = nil
+      @include = nil
+      @exclude = '*.cache;*.pyc'
+    end
+
+    def dir
+      "#{root}/#{package_name}"
+    end
+
+    def package
+      @package ||= import
+    end
+
+  private
+
+    def validate
+      File.directory?(dir) or raise OptionError, "no such directory: #{dir}"
+      alt_root.nil? || File.directory?(alt_root) or
+        raise OptionError, "no such directory: #{alt_root}"
+    end
+
+    def files
+      @files ||= begin
+        files = Dir["#{dir}/*"]
+
+        if self.include
+          specs = self.include.split(';')
+          files.select! do |f|
+            f = File.basename(f)
+            specs.any? { |s| File.fnmatch(s, f) }
+          end
+        end
+
+        if self.exclude
+          specs = self.exclude.split(';')
+          files.reject! do |f|
+            f = File.basename(f)
+            specs.any? { |s| File.fnmatch(s, f) }
+          end
+        end
+
+        files
+      end
+    end
+
+    def import
+      validate
+
+      if files.empty?
+        Console.info "#{dir}: nothing to import"
+        return nil
+      end
+
+      Console.info "importing package from #{dir}"
+      package = Package.new(package_name)
+      files.each.with_index(1) do |file, index|
+        file = selected_file(file)
+        Console.progress index, files.length, file
+        begin
+          case File.extname(file).downcase
+          when '.tmtheme'
+            package.themes << TextMate::Theme.import(file)
+          when '.tmlanguage'
+            package.grammars << TextMate::Grammar.import(file)
+          when '.tmpreferences'
+            package.preferences << TextMate::Preference.import(file)
+          when '.tmsnippet', '.sublime-snippet'
+            package.snippets << TextMate::Snippet.import(file)
+          when '.sublime-settings'
+            package.setting_sets << SettingSet.import(file)
+          when '.sublime-macro'
+            package.macros << Macro.import(file)
+          when '.sublime-commands'
+            package.command_sets << CommandSet.import(file)
+          when '.sublime-menu'
+            package.menus << Menu.import(file)
+          when '.sublime-mousemap'
+            package.mousemaps << MouseMap.import(file)
+          when '.sublime-keymap'
+            package.keymaps << KeyMap.import(file)
+
+          when '.sublime-build'
+            # not worth it
+            package.other_files << file
+          when '.sublime-completions'
+            # only HTML & PHP, not surviving in ST 3
+            package.other_files << file
+          else
+            package.other_files << file
+          end
+        rescue => ex
+          Console.error "error when importing #{file}:"
+          raise ex
+        end
+      end
+
+      package
+    end
+
+    def selected_file(file)
+      return file unless alt_root
+      alt_file = file.sub(root, alt_root)
+      File.exist?(alt_file) ? alt_file : file
+    end
+
+  end
+
+end
+end
+end

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

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+module SublimeDSL
+module SublimeText
+class Package
+
+  ##
+  # A DSL read operation with its options.
+
+  class Reader
+
+    attr_reader :package_name
+    attr_accessor :root, :alt_root, :include, :exclude
+
+    def initialize(name)
+      @package_name = name
+      @root = '.'
+      @alt_root = nil
+      @include = nil
+      @exclude = '*.keyboard.rb'
+    end
+
+    def dir
+      "#{root}/#{package_name}"
+    end
+
+    def package
+      @package ||= read
+    end
+
+  private
+
+    def validate
+      File.directory?(dir) or raise OptionError, "no such directory: #{dir}"
+      alt_root.nil? || File.directory?(alt_root) or
+        raise OptionError, "no such directory: #{alt_root}"
+    end
+
+    def files
+      @files ||= begin
+        files = Dir["#{dir}/*"]
+
+        if self.include
+          specs = self.include.split(';')
+          files.select! do |f|
+            f = File.basename(f)
+            specs.any? { |s| File.fnmatch(s, f) }
+          end
+        end
+
+        if self.exclude
+          specs = self.exclude.split(';')
+          files.reject! do |f|
+            f = File.basename(f)
+            specs.any? { |s| File.fnmatch(s, f) }
+          end
+        end
+
+        files
+      end
+    end
+
+    def read
+      validate
+
+      if files.empty?
+        Console.info "#{dir}: nothing to read"
+        return nil
+      end
+
+      Console.info "processing DSL files in #{dir}"
+      package = Package.new(package_name)
+
+      files.each.with_index(1) do |file, index|
+        file = selected_file(file)
+        Console.progress index, files.length, file
+        begin
+          if File.basename(file) =~ /\.rb$/
+            DSLReader.new file, package
+          else
+            package.other_files << file
+          end
+        rescue => ex
+          Console.error "error when reading #{file}:"
+          raise ex
+        end
+      end
+
+      package
+    end
+
+    def selected_file(file)
+      return file unless alt_root
+      alt_file = file.sub(root, alt_root)
+      File.exist?(alt_file) ? alt_file : file
+    end
+
+  end
+
+end
+end
+end

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

@@ -0,0 +1,112 @@
+# encoding: utf-8
+
+module SublimeDSL
+module SublimeText
+class Package
+
+  ##
+  # A DSL writing operation with its options.
+
+  class Writer
+
+    attr_reader :package
+    attr_accessor :root, :backup, :copy_other_files
+
+    def initialize(package = nil)
+      @package = package
+      @root = '.'
+      @backup = :once
+      @copy_other_files = true
+      @keyboard_name = nil
+    end
+
+    def write(package = nil)
+      @package = package if package
+      validate
+      perform_backup
+      FileUtils.rm_r Dir["#{dir}/*"] if File.directory?(dir)
+      Console.info "writing package DSL to #{dir}"
+      write_package
+    end
+
+    def dir
+      "#{root}/#{@package.name}"
+    end
+
+    def keyboard=(name)
+      @keyboard_name = name
+    end
+
+    def keyboard
+      @keyboard ||=
+        if @keyboard_name.nil? || @keyboard_name == Keyboard.sublime.name
+          Keyboard.sublime
+        else
+          Keyboard.get(@keyboard_name, root)
+        end
+    end
+
+    def validate
+      File.directory?(root) or raise OptionError, "no such directory: #{root}"
+      @backup = backup.to_sym
+      unless [:never, :always, :once].include?(backup)
+        warn "invalid backup option #{backup.inspect}, 'always' assumed"
+        @backup = :always
+      end
+      keyboard
+    end
+
+    def perform_backup
+      # no backup needed if not asked or no file to backup
+      return unless backup != :never && Dir["#{dir}/*"].length > 0
+      # don't do it if only one backup is requested, and there is already one
+      name = Tools.filename(package.name)
+      return if backup == :once && Dir["#{root}/#{name}.*.zip"].length > 0
+      # backup
+      time_stamp = Tools.filename(Time.now.strftime("%Y-%m-%d %H:%M:%S"))
+      backup_file = "#{root}/#{name}.#{time_stamp}.zip"
+      Tools.zip dir, backup_file
+      Console.info "#{dir} backed up as #{backup_file}"
+    end
+
+    def write_package
+      Dir.mkdir dir unless File.directory?(dir)
+      p = package
+      p.themes.each { |t| t.write dir }
+      p.grammars.each { |g| g.write dir }
+      write_all p.preferences, "#{dir}/preferences.rb"
+      TextMate::Snippet::DSLWriter.new(p.snippets).write "#{dir}/snippets.rb"
+      write_all p.setting_sets, "#{dir}/settings.rb"
+      write_all p.macros.sort_by(&:name), "#{dir}/macros.rb"
+      write_all p.command_sets, "#{dir}/commands.rb"
+      p.menus.each { |m| m.write dir }
+      p.mousemaps.each { |m| m.write dir }
+      p.keymaps.each { |k| k.for_keyboard(keyboard).write dir }
+      return unless copy_other_files
+      p.other_files.each { |f| copy_file f, dir }
+    end
+
+    def copy_file(infile, outdir)
+      if File.directory?(infile)
+        outpath = "#{outdir}/#{File.basename(infile)}"
+        Dir.mkdir outpath unless File.directory?(outpath)
+        Dir["#{infile}/*"].each { |f| copy_file f, outpath }
+      else
+        # Console.progress ...
+        FileUtils.cp infile, outdir
+      end
+    end
+
+    def write_all(collection, file)
+      return if collection.empty?
+      File.open(file, 'wb:utf-8') do |f|
+        f.puts '# encoding: utf-8'
+        collection.each { |e| f.puts "\n#{e.to_dsl}" }
+      end
+    end
+
+  end
+
+end
+end
+end

data/lib/sublime_dsl/sublime_text/package.rb

@@ -0,0 +1,96 @@
+# encoding: utf-8
+
+require_relative 'package/importer'
+require_relative 'package/writer'
+require_relative 'package/reader'
+require_relative 'package/exporter'
+require_relative 'package/dsl_reader'
+
+module SublimeDSL
+module SublimeText
+
+  class Package
+
+    # Create a new Package from a Sublime Text 'Packages' subdirectory.
+    #
+    # The options can be any Importer option.
+
+    def self.import(name, options = {})
+      importer = Importer.new(name)
+      process_options importer, options
+
+      importer.package
+    end
+
+    # Create a new Package from a DSL directory.
+    #
+    # The options can be any Reader option.
+
+    def self.read(name, options = {})
+      reader = Reader.new(name)
+      process_options reader, options
+
+      reader.package
+    end
+
+    def self.process_options(object, options)
+      options.each_pair do |k,v|
+        m = "#{k}="
+        raise OptionError, "invalid option '#{k}'" unless object.respond_to? m
+        object.send m, v
+      end
+    end
+
+    attr_reader :name
+
+    attr_reader :themes
+    attr_reader :grammars
+    attr_reader :preferences
+    attr_reader :snippets
+    attr_reader :setting_sets
+    attr_reader :macros
+    attr_reader :command_sets
+    attr_reader :menus
+    attr_reader :mousemaps
+    attr_reader :keymaps
+
+    attr_reader :other_files
+
+    def initialize(name)
+      @name = name
+      @themes = []
+      @grammars = []
+      @preferences = []
+      @snippets = []
+      @setting_sets = []
+      @macros = []
+      @command_sets = []
+      @menus = []
+      @mousemaps = []
+      @keymaps = []
+
+      @other_files = []
+    end
+
+    # Writes the package to DSL files.
+    # The options can be any Writer option.
+
+    def write(options = {})
+      writer = Writer.new(self)
+      self.class.process_options writer, options
+      writer.write
+    end
+
+    # Exports the package.
+    # The options can be any Exporter option.
+
+    def export(options = {})
+      exporter = Exporter.new(self)
+      self.class.process_options exporter, options
+      exporter.export
+    end
+
+  end
+
+end
+end

data/lib/sublime_dsl/sublime_text/setting_set.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+module SublimeDSL
+module SublimeText
+
+  class SettingSet
+
+    def self.import(file)
+      name = File.basename(file, File.extname(file))
+      set = new(name)
+      json = File.read(file, encoding: 'utf-8')
+      h = json.empty? ? {} : JSON[json]
+      begin
+        h.each_pair { |key, value| set.settings << Setting.new(key, value) }
+      rescue => ex
+        puts "file: #{file}"
+        raise ex
+      end
+
+      set
+    end
+
+    attr_reader :name, :settings
+
+    def initialize(name)
+      @name = name
+      @settings = []
+    end
+
+    def to_dsl
+      dsl = "settings #{name.to_source} do\n"
+      dsl << "\n" unless settings.empty?
+      settings.each { |s| dsl << "  #{s.to_dsl}\n" }
+      dsl << "\nend"
+    end
+
+    def export(dir)
+      file = "#{dir}/#{name}.sublime-settings"
+      File.open(file, 'wb:utf-8') { |f| f.write to_json }
+    end
+
+    def to_json
+      h = Hash[settings.map { |s| [s.key, s.value] }]
+      JSON.pretty_generate(h)
+    end
+
+    class Setting
+
+      attr_reader :key, :value
+
+      def initialize(key, value)
+        @key = key
+        @value = value
+      end
+
+      def to_dsl
+        "#{key} #{display(value)}"
+      end
+
+    private
+
+      def display(v)
+        case v
+        when String
+          v.to_source
+        when TrueClass, FalseClass, Numeric
+          v.to_s
+        when Array
+          display_array(v)
+        when Hash
+          v.empty? ? 'Hash.new' : v.inspect[1..-2] # remove braces
+        when NilClass
+          'nil'
+        else
+          raise Error, "value: #{v.inspect} for #{name.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
+
+    class DSLReader < Tools::BlankSlate
+
+      def initialize(file = nil)
+        @setting_sets = []
+        @current_set = nil
+        instance_eval File.read(file, encoding: 'utf-8'), file if file
+      end
+
+      def _setting_sets
+        @setting_sets
+      end
+
+      def method_missing(sym, *args, &block)
+        @current_set or raise Error, "'#{sym}' is invalid outside of a 'settings' block"
+        args.empty? and raise Error, "no value for setting '#{sym}'"
+        args.length > 1 and raise Error, "more than one value for setting '#{sym}'"
+        @current_set.settings << Setting.new(sym.to_s, args.first)
+      end
+
+      def settings(name, &block)
+        @current_set and raise Error, "'settings' blocks cannot be nested"
+        @current_set = SettingSet.new(name)
+        instance_eval(&block)
+        @setting_sets << @current_set
+        @current_set = nil
+      end
+
+    end
+
+  end
+
+end
+end