gem-exefy 1.2.0-universal-mingw32

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.rdoc

@@ -0,0 +1,18 @@
+=== 1.2.0 / 2012-09-11
+
+* Enhancements
+
+  * Added support for x64 Ruby versions (https://github.com/bosko/gem-exefy/issues/12)
+
+=== 1.1.0 / 2012-08-15
+
+* Enhancements
+
+  * Dropped support for Ruby versions less than 1.9.2 (@luislavena)
+
+=== 1.0.0 / 2012-06-25
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,11 @@
+.autotest
+History.rdoc
+Manifest.txt
+README.rdoc
+Rakefile
+lib/rubygems/commands/exefy_command.rb
+lib/rubygems_plugin.rb
+lib/exefy.rb
+lib/exefy/version.rb
+templates/gem_exe.c
+templates/gem_exe.rc.erb

data/README.rdoc

@@ -0,0 +1,115 @@
+= gem-exefy
+
+code :: http://github.com/bosko/gem-exefy
+bugs :: http://github.com/bosko/gem-exefy/issues
+
+== DESCRIPTION:
+
+GemExefy is RubyGems plugin aimed to replace batch files (.bat) with
+executables with the same name. This gem will work only on
+RubyInstaller Ruby installation and it requires RubyInstaller DevKit.
+
+Reason for such replaceming batch files with executable stubs is
+twofold. When execution of batch file is interrupted with Ctrl-C key
+combination, user is faced with the confusing question
+
+"Terminate batch job (Y/N)?"
+
+which is avoided after replacement.
+
+Second reason is appearance of processes in Task manager (or Process
+Explorer). In the case of batch files all processes are visible as
+ruby.exe. In order to distinguish between them, program arguments must
+be examined. In addition, having one process name makes it hard to
+define firewall rules. Having executable versions instead of batch
+files will facilitate process identification in task list as well as
+defining firewall rules. Moreover it makes it possible to create
+selective firewall rules for different Ruby gems. Installing Ruby
+applications as Windows services should be also much easer when
+executable stub is used instead of batch file.
+
+=== How does it work?
+
+If GemExefy is installed prior to other gems installation it will
+automatically install executable stub instead of each batch file that
+is normally created during gem installation. GemExefy enables
+replacement for existing gems too. Either all or one by one gem can be
+processed. Finally GemExefy can revert all changes and return all
+batch files instead of executable stubs if needed.
+
+== FEATURES/PROBLEMS:
+
+* No known problems at the moment
+
+== SYNOPSIS:
+
+Exefying single gem:
+
+  C:\> gem exefy <gem_name>
+
+Exefying all installed gems on the system:
+
+  C:\> gem exefy --all
+
+Reverting batch file for single gem:
+
+  C:\> gem exefy <gem_name> --revert
+
+Reverting batch files for all previously processed gems:
+
+  C:\> gem exefy --all --revert
+
+== REQUIREMENTS:
+
+* RubyInstaller Ruby version
+* RubyInstaller's DevKit
+
+== INSTALL:
+
+* gem install gem-exefy
+
+== DEVELOPERS:
+
+After checking out the source, run:
+
+  $ rake newb
+
+This task will install any missing dependencies, run the tests/specs,
+and generate the RDoc.
+
+GemExefy searches following directories for batch files
+
+- Gem.bindir
+- Gem.path
+
+Since Gem::path array contains directories pointing to the top level
+directory and executables are saved in the Gem#bindir folder, GemExefy
+concatenates directory from Gem.path with value of Gem#bindir (bin
+directory defined in the target Gem) and name from Gem#executables
+array with .bat extension. If such file is found it is replaced with
+corresponding executable file with same name and .exe extension.
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2012 Boško Ivanišević
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,29 @@
+# coding: utf-8
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/exefy/version'
+
+Hoe.spec 'gem-exefy' do
+  developer('Boško Ivanišević', 'bosko.ivanisevic@gmail.com')
+
+  self.urls = {"GitHub repository" => "http://github.com/bosko/gem-exefy"}
+  self.readme_file = 'README.rdoc'
+  self.history_file = 'History.rdoc'
+  self.extra_rdoc_files = FileList['*.rdoc']
+  self.require_rubygems_version(">= 1.8.0")
+  self.version = Exefy::VERSION
+  spec_extras[:platform] = Gem::Platform.new("universal-mingw32")
+  spec_extras[:required_ruby_version] = ">= 1.9.3"
+  self.post_install_message = %Q{**************************************************
+*                                                *
+*  Thank you for installing #{self.name}-#{self.version}!     *
+*                                                *
+*  This gem will work only on RubyInstaller      *
+*  versions of Ruby with installed DevKit.       *
+*                                                *
+**************************************************}
+end
+
+# vim: syntax=ruby

data/lib/exefy.rb

@@ -0,0 +1,187 @@
+module Exefy
+  require 'rubygems'
+  require 'rubygems/user_interaction'
+  require 'tmpdir'
+  require 'rbconfig'
+  require 'erb'
+  require 'exefy/version'
+
+  def self.process_existing_gem(gem, revert)
+    generator = GeneratorFromBatch.new(gem)
+    revert ? generator.revert_gem : generator.exefy_gem
+  end
+
+  def self.process_gem_install(target_path)
+    generator = Generator.new(target_path)
+    generator.exefy_gem
+  end
+
+  def self.executable
+    return @executable if defined?(@executable)
+
+    gem_root     = File.expand_path("../..", __FILE__)
+    ruby_version = RbConfig::CONFIG["ruby_version"]
+
+    @executable = File.join(gem_root, "data", ruby_version, "gemstub.exe")
+  end
+
+  def self.devkit_needed?
+    !File.executable?(Exefy.executable)
+  end
+
+  class Generator
+    include Gem::UserInteraction
+
+    def initialize(target_path)
+      @exe_target = target_path
+    end
+
+    def exefy_gem
+      process
+    end
+
+    def process
+      install_executable_stub(@exe_target)
+    end
+
+    def install_executable_stub(target)
+      unless File.executable?(Exefy.executable)
+        generate_executable
+      end
+
+      log_message "Creating executable as '#{File.basename(target)}'"
+      FileUtils.install Exefy.executable, target
+    end
+
+    def generate_executable
+      log_message "Generating executable '#{Exefy.executable}'..."
+
+      gem_root = File.expand_path("../..", __FILE__)
+      template = File.join(gem_root, "templates", "gem_exe.c")
+      res_template = File.join(gem_root, "templates", "gem_exe.rc.erb")
+
+      Dir.mktmpdir do |build_dir|
+        base = File.basename(template)
+        res_base = File.basename(res_template)
+
+        obj  = File.join(build_dir, base.gsub(".c", ".o"))
+        res_src = File.join(build_dir, res_base.gsub(".erb", ""))
+        res_obj = File.join(build_dir, res_base.gsub(".erb", ".o"))
+        exe  = File.join(build_dir, base.gsub(".c", ".exe"))
+
+        compile(template, obj)
+        compile_resources(res_template, res_src, res_obj)
+        link([obj, res_obj].join(" "), exe)
+
+        # verify target directory first exists
+        FileUtils.mkdir_p File.dirname(Exefy.executable)
+
+        FileUtils.install exe, Exefy.executable
+      end
+    end
+
+    def compile(source, target)
+      cflags = RbConfig::CONFIG["CFLAGS"]
+      cppflags = RbConfig::CONFIG["CPPFLAGS"]
+
+      hdr_dir = RbConfig::CONFIG["rubyhdrdir"] || RbConfig::CONFIG["includedir"]
+      arch_dir = RbConfig::CONFIG["arch"]
+
+      include_dirs = "-I#{hdr_dir}/#{arch_dir} -I#{hdr_dir}"
+
+      cc = ENV.fetch("CC", RbConfig::CONFIG["CC"])
+
+      system "#{cc} -c #{source} -o #{target} #{cflags} #{cppflags} #{include_dirs}"
+    end
+
+    def compile_resources(template, source, target)
+      binary_version = VERSION.gsub('.', ',') + ",0"
+      File.open source, "w" do |file|
+        erb = ERB.new File.read(template)
+        file.puts erb.result(binding)
+      end
+
+      system "windres #{source} -o #{target}"
+    end
+
+    def link(objs, target)
+      libruby_dir = RbConfig::CONFIG["libdir"]
+      libruby = RbConfig::CONFIG["LIBRUBYARG"]
+
+      libs = RbConfig::CONFIG["LIBS"]
+      libs_dir = "-L#{libruby_dir} #{libruby} #{libs}"
+
+      cc = ENV.fetch("CC", RbConfig::CONFIG["CC"])
+      system "#{cc} #{objs} -o #{target} #{libs_dir}"
+      system "strip #{target}"
+    end
+
+    def log_message(message)
+      say message if Gem.configuration.really_verbose
+    end
+  end
+
+  class GeneratorFromBatch < Generator
+    def initialize(gem)
+      @gem = gem
+    end
+
+    def exefy_gem
+      batch_files(@gem).each do |list|
+        process(list)
+      end
+    end
+
+    def revert_gem
+      require "rubygems/installer"
+
+      return if @gem.executables.nil? or @gem.executables.empty?
+
+      # Instantiate Gem::Installer object with no additional options
+      # WARNING!!! at the moment RubyGems do not handle additional
+      # install options correctly (--install-dir or --bindir). Once
+      # gem is installed in non-default location it becomes unusable.
+      # We cannot get path to its .bat files nor path where it is
+      # installed (https://github.com/rubygems/rubygems/issues/342).
+      # Therefore we will, for now, process gems as they are always
+      # installed in default locations.
+      @gem.executables.each do |filename|
+        filename.untaint
+        exe_file = File.join(Gem.bindir, "#{filename}.exe")
+        if File.exist? exe_file
+          Gem::Installer.new(@gem).generate_windows_script(filename, Gem.bindir)
+          if File.exist? exe_file.gsub(".exe", ".bat")
+            log_message "Removing #{exe_file}"
+            File.unlink exe_file
+          else
+            log_message "Reverting batch file failed. Executable file will remain in bin directory."
+          end
+        end
+      end
+    end
+
+    def process(batch_files)
+      batch_files.each do |bf|
+        target = bf.gsub(".bat", ".exe")
+        install_executable_stub(target)
+
+        log_message "Removing batch file '#{File.basename(bf)}'"
+        File.unlink bf
+      end
+    end
+
+    def batch_files(gem)
+      bf = {}
+      test_paths = Gem.path.map {|gp| File.join(gp, gem.bindir)}.
+        unshift(Gem.bindir).uniq
+
+      gem.executables.each do |executable|
+        test_paths.map {|tp| File.join(tp, "#{executable}.bat")}.each do |bat|
+          bf[executable] = [] unless bf[executable]
+          bf[executable] << bat if File.exist?(bat)
+        end
+      end
+      bf.values
+    end
+  end
+end

data/lib/exefy/version.rb

@@ -0,0 +1,3 @@
+module Exefy
+  VERSION = "1.2.0"
+end

data/lib/rubygems/commands/exefy_command.rb

@@ -0,0 +1,70 @@
+require "rubygems/command"
+
+module Gem
+  module Commands
+    class ExefyCommand < Gem::Command
+      def initialize
+        super 'exefy', "Replaces a Gem's batch script with a Windows executable"
+
+        add_option('--all', 'Replaces batch files with executable file',
+               'for all installed gems') do |value, options|
+          options[:process_all_gems] = value
+        end
+
+        add_option('--revert', 'Restores batch files for given gem',
+               'or all gems if --all option is used') do |value, options|
+          options[:revert] = value
+        end
+      end
+
+      def arguments
+        "GEMNAME       name of gem to exefy (unless --all)"
+      end
+
+      def usage # :nodoc:
+        "#{program_name} [GEMNAME]"
+      end
+
+      def description # :nodoc:
+        <<-EOS
+The exefy command replaces the default gem batch(.bat) script runner with
+a Windows executable(.exe) stub. Exefy also includes hooks that will
+automatically do this for all new Gem installs and will remove the
+executable with a Gem uninstall.
+
+Requires a RubyInstaller Ruby installation and the RubyInstaller DevKit.
+        EOS
+      end
+
+      def execute
+        unless RUBY_PLATFORM =~ /mingw/
+          say "This command can be executed only on RubyInstaller Windows OS installation"
+          return
+        end
+
+        begin
+          require "exefy"
+          require "devkit" if !options[:revert] && Exefy.devkit_needed?
+        rescue ::LoadError => load_error
+          say "You must have DevKit installed in order to exefy gems"
+          return
+        end
+
+        gem_specs = if options[:process_all_gems] then
+                      Gem::Specification
+                    else
+                      begin
+                        gem_name = get_one_gem_name
+                        Gem::Specification.find_all_by_name(gem_name)
+                      rescue Gem::LoadError => e
+                        say "Cannot exefy. Gem #{name} not found"
+                      end
+                    end
+
+        gem_specs.each do |gem_spec|
+          Exefy.process_existing_gem(gem_spec, options[:revert])
+        end
+      end
+    end
+  end
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,86 @@
+require "rubygems/command_manager"
+
+Gem::CommandManager.instance.register_command :exefy
+
+Gem.pre_install do |installer|
+  class << installer
+    def generate_exe_file(filename, bindir)
+      if RUBY_PLATFORM =~ /mingw/
+        begin
+          require "exefy"
+          require "devkit" if Exefy.devkit_needed?
+
+          exe_name = filename + ".exe"
+          exe_path = File.join bindir, File.basename(exe_name)
+          Exefy.process_gem_install(exe_path)
+
+          say "Installed #{exe_path} executable" if Gem.configuration.really_verbose
+        rescue LoadError
+          puts "You must have DevKit installed in order to exefy gems"
+          generate_batch_file(filename, bindir)
+        end
+      else
+        generate_batch_file(filename, bindir)
+      end
+    end
+
+    alias_method :generate_batch_file, :generate_windows_script
+    alias_method :generate_windows_script, :generate_exe_file
+  end
+end
+
+Gem.pre_uninstall do |uninstaller|
+  class << uninstaller
+    def remove_executables_and_exe_file(spec)
+      return if spec.nil? or spec.executables.empty?
+
+      list = Gem::Specification.find_all { |s|
+        s.name == spec.name && s.version != spec.version
+      }
+
+      executables = spec.executables.clone
+
+      list.each do |s|
+        s.executables.each do |exe_name|
+          executables.delete exe_name
+        end
+      end
+
+      return if executables.empty?
+
+      executables = executables.map { |exec| formatted_program_filename exec }
+
+      remove = if @force_executables.nil? then
+                 ask_yes_no("Remove executables:\n" \
+                            "\t#{executables.join ', '}\n\n" \
+                            "in addition to the gem?",
+                            true)
+               else
+                 @force_executables
+               end
+
+      unless remove then
+        say "Executables and scripts will remain installed."
+      else
+        bin_dir = @bin_dir || Gem.bindir(spec.base_dir)
+
+        raise Gem::FilePermissionError, bin_dir unless File.writable? bin_dir
+
+        executables.each do |exe_name|
+          say "Removing #{exe_name}"
+
+          exe_file = File.join bin_dir, exe_name
+
+          FileUtils.rm_f exe_file
+          batch_file = "#{exe_file}.bat"
+          FileUtils.rm_f batch_file if File.exist?(batch_file)
+          generic_exe = "#{exe_file}.exe"
+          FileUtils.rm_f generic_exe if File.exist?(generic_exe)
+        end
+      end
+    end
+
+    alias_method :remove_executables_orig, :remove_executables
+    alias_method :remove_executables, :remove_executables_and_exe_file
+  end
+end

data/templates/gem_exe.c

@@ -0,0 +1,87 @@
+#include "ruby.h"
+#include <stdlib.h>
+
+#ifdef HAVE_LOCALE_H
+#include <locale.h>
+#endif
+
+#ifndef MAXPATHLEN
+# define MAXPATHLEN 1024
+#endif
+
+void
+dump_args(int argc, char **argv)
+{
+  int i;
+  printf("Number of arguments: %d\n", argc);
+
+  for (i = 0; i < argc; ++i)
+    printf("Argument %d: %s\n", i, argv[i]);
+
+  printf("=================\n");
+}
+
+int
+main(int argc, char **argv)
+{
+  int i;
+  int myargc;
+  char** myargv;
+  char script_path[MAXPATHLEN];
+  char* dump_val;
+  DWORD attr;
+
+#ifdef HAVE_LOCALE_H
+  setlocale(LC_CTYPE, "");
+#endif
+
+  dump_val = getenv("EXEFY_DUMP");
+
+  if (GetModuleFileName(NULL, script_path, MAXPATHLEN)) {
+    for (i = strlen(script_path) - 1; i >= 0; --i) {
+      if (*(script_path + i) == '.') {
+        *(script_path + i) = '\0';
+        break;
+      }
+    }
+
+    attr = GetFileAttributes(script_path);
+    if (attr == INVALID_FILE_ATTRIBUTES) {
+      printf("Script %s is missing!", script_path);
+      return -1;
+    }
+    // Let Ruby initialize program arguments
+    ruby_sysinit(&argc, &argv);
+
+    // Change arguments by inserting path to script file
+    // as second argument (first argument is always executable
+    // name) and copying arguments from command line after it.
+    myargc = argc + 1;
+    myargv = (char**)xmalloc(sizeof(char*) * (myargc + 1));
+    if (NULL != myargv) {
+      memset(myargv, 0, sizeof(char*) * (myargc + 1));
+      *myargv = *argv;
+      *(myargv + 1) = &script_path[0];
+
+      for (i = 1; i < argc; ++i) {
+         *(myargv + i + 1) = *(argv + i);
+      }
+
+      if (NULL != dump_val) {
+        dump_args(myargc, myargv);
+      }
+
+      {
+        RUBY_INIT_STACK;
+        ruby_init();
+        return ruby_run_node(ruby_options(myargc, myargv));
+      }
+    }
+    else {
+      printf("Not enough memory to continue. Exiting...");
+    }
+  }
+
+  // Return an error when nothing works
+  return -1;
+}

data/templates/gem_exe.rc.erb

@@ -0,0 +1,40 @@
+//#include "resource.h"
+#include <winver.h>
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION <%= binary_version %>
+ PRODUCTVERSION <%= binary_version %>
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS VOS_NT
+ FILETYPE VFT_APP
+ FILESUBTYPE VFT2_UNKNOWN
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "040904b0"
+        BEGIN
+            VALUE "FileDescription", "Gem Executable Stub is built for <%= RUBY_DESCRIPTION %>"
+            VALUE "Comments", "Stub is built for <%= RUBY_DESCRIPTION %> version."
+            VALUE "FileVersion", "<%= VERSION %>"
+            VALUE "InternalName", "Gem ExeStub"
+            VALUE "LegalCopyright", "Copyright (C) 2012 Bosko Ivanisevic"
+            VALUE "OriginalFilename", "gemstub.exe"
+            VALUE "ProductName", "Gem Exefy"
+            VALUE "ProductVersion", "<%= VERSION %>"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x409, 1200
+    END
+END

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification
+name: gem-exefy
+version: !ruby/object:Gem::Version
+  version: 1.2.0
+  prerelease: 
+platform: universal-mingw32
+authors:
+- Boško Ivanišević
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: ! 'GemExefy is RubyGems plugin aimed to replace batch files (.bat) with
+
+  executables with the same name. This gem will work only on
+
+  RubyInstaller Ruby installation and it requires RubyInstaller DevKit.
+
+
+  Reason for such replaceming batch files with executable stubs is
+
+  twofold. When execution of batch file is interrupted with Ctrl-C key
+
+  combination, user is faced with the confusing question
+
+
+  "Terminate batch job (Y/N)?"
+
+
+  which is avoided after replacement.
+
+
+  Second reason is appearance of processes in Task manager (or Process
+
+  Explorer). In the case of batch files all processes are visible as
+
+  ruby.exe. In order to distinguish between them, program arguments must
+
+  be examined. In addition, having one process name makes it hard to
+
+  define firewall rules. Having executable versions instead of batch
+
+  files will facilitate process identification in task list as well as
+
+  defining firewall rules. Moreover it makes it possible to create
+
+  selective firewall rules for different Ruby gems. Installing Ruby
+
+  applications as Windows services should be also much easer when
+
+  executable stub is used instead of batch file.'
+email:
+- bosko.ivanisevic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- History.rdoc
+- Manifest.txt
+- README.rdoc
+files:
+- .autotest
+- History.rdoc
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/rubygems/commands/exefy_command.rb
+- lib/rubygems_plugin.rb
+- lib/exefy.rb
+- lib/exefy/version.rb
+- templates/gem_exe.c
+- templates/gem_exe.rc.erb
+homepage: http://github.com/bosko/gem-exefy
+licenses: []
+post_install_message: ! '**************************************************
+
+  *                                                *
+
+  *  Thank you for installing gem-exefy-1.2.0!     *
+
+  *                                                *
+
+  *  This gem will work only on RubyInstaller      *
+
+  *  versions of Ruby with installed DevKit.       *
+
+  *                                                *
+
+  **************************************************'
+rdoc_options:
+- --main
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.0
+requirements: []
+rubyforge_project: gem-exefy
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: GemExefy is RubyGems plugin aimed to replace batch files (.bat) with executables
+  with the same name
+test_files: []