releasy 0.2.0rc1

data/lib/releasy/builders/windows_folder_from_ruby_dist.rb

@@ -0,0 +1,150 @@
+require "releasy/builders/windows_builder"
+require "releasy/mixins/has_gemspecs"
+
+module Releasy
+  module Builders
+    # Wraps up an application for Windows when not on Windows, based on a RubyInstaller distribution and installing Windows binary gems.
+    #
+    # The resulting package will be much larger than a Windows package created on Windows, since it will include
+    # the whole Ruby distribution, not just files that are needed.
+    #
+    # Limitations:
+    #   * Does not DLLs loaded from the system, which will have to be included manually if any are required by the application and no universally available in Windows installations.
+    #   * Unless a gem is in pure Ruby or available as a pre-compiled binary gem, it won't work!
+    class WindowsFolderFromRubyDist < WindowsBuilder
+      include Mixins::HasGemspecs
+
+      TYPE = :windows_folder_from_ruby_dist
+      DEFAULT_FOLDER_SUFFIX = "WIN32"
+
+      # Files that are required for Tcl/Tk, but which are unlikely to be used in many applications.
+      TCL_TK_FILES = %w[bin/tcl*-ri.dll bin/tk*-ri.dll
+                         lib/tcltk
+                         lib/ruby/tk*.rb
+                         lib/ruby/1.*/tk* lib/ruby/1.*/tcl*
+                         lib/ruby/1.*/i386-mingw32/tk* lib/ruby/1.*/i386-mingw32/tcl*
+                       ]
+
+      # Encoding files that are required, even if we don't need most of them if we select to {#exclude_encoding}.
+      REQUIRED_ENCODING_FILES = %w[encdb.so iso_8859_1.so utf_16le.so trans/single_byte.so trans/transdb.so trans/utf_16_32.so]
+
+      Builders.register self
+
+      # @return [String] Path to windows distribution archive that has been manually downloaded from http://rubyinstaller.org/downloads/ (e.g. "rubies/ruby-1.9.2-p290-i386-mingw32.7z").
+      attr_accessor :ruby_dist
+
+      # Remove TCL/TK from package, which can save a significant amount of space if the application does not require them.
+      # This is over 6MB uncompressed, which is a saving of 1.6MB when compressed with 7z format (LZMA).
+      # @return [Project] self
+      def exclude_tcl_tk; @exclude_tcl_tk = true; self; end
+
+      def valid_for_platform?; not Releasy.win_platform?; end
+
+      protected
+      # FOLDER containing EXE, Ruby + source.
+      def generate_tasks
+        raise ConfigError, "#ruby_dist not set" unless ruby_dist
+        raise ConfigError, "#ruby_dist not valid: #{ruby_dist}" unless File.exist?(ruby_dist) and File.extname(ruby_dist) == ".7z"
+
+        directory project.output_path
+
+        file folder => project.files + [ruby_dist] do
+          build
+        end
+
+        desc "Build source/exe folder #{project.version} from wrapper"
+        task "build:windows:folder_from_ruby_dist" => folder
+      end
+
+      protected
+      def build
+        Rake::FileUtilsExt.verbose project.verbose?
+
+        copy_ruby_distribution
+        delete_excluded_files
+
+        copy_files_relative project.files, File.join(folder, 'src')
+
+        create_link_files folder
+        project.exposed_files.each {|file| cp file, folder }
+
+        create_executable
+
+        # Copy gems.
+        destination = File.join(folder, 'vendor')
+        downloaded_binary_gems = install_binary_gems destination
+        copy_gems vendored_gem_names(downloaded_binary_gems), destination
+      end
+
+      protected
+      def delete_excluded_files
+        # Remove TCL/TK dlls, lib folder and source.
+        rm_r Dir[*(TCL_TK_FILES.map {|f| File.join(folder, f) })].uniq.sort if @exclude_tcl_tk
+
+        # Remove Encoding files on Ruby 1.9
+        if encoding_excluded? and ruby_dist =~ /1\.9\.\d/
+          encoding_files = Dir[File.join folder, "lib/ruby/1.9.1/i386-mingw32/enc/**/*.so"]
+          required_encoding_files = REQUIRED_ENCODING_FILES.map {|f| File.join folder, "lib/ruby/1.9.1/i386-mingw32/enc", f }
+          rm_r encoding_files - required_encoding_files
+        end
+      end
+
+      protected
+      def setup
+        @exclude_tcl_tk = false
+        @ruby_dist = nil
+        super
+      end
+
+      protected
+      def executable_name; "#{project.underscored_name}.exe"; end
+
+      protected
+      def copy_ruby_distribution
+        archive_name = File.basename(ruby_dist).chomp(File.extname(ruby_dist))
+        exec %[7z x "#{ruby_dist}" -o"#{File.dirname folder}"]
+        mv File.join(File.dirname(folder), archive_name), folder
+        rm_r File.join(folder, "share")
+        rm_r File.join(folder, "include") if File.exists? File.join(folder, "include")
+        unused_exe = effective_executable_type == :windows ? "ruby.exe" : "rubyw.exe"
+        rm File.join(folder, "bin", unused_exe)
+      end
+
+      protected
+      def create_executable
+        maker = Releasy::WindowsWrapperMaker.new
+        maker.build_executable("#{folder}/#{executable_name}", "src/#{project.executable}",
+                               :windows => (effective_executable_type == :windows))
+      end
+
+      protected
+      def install_binary_gems(destination)
+        puts "Checking gems to see if any are binary" if project.verbose?
+        binary_gems = []
+        gemspecs.reject {|s| false }.each do |spec|
+          puts "Checking gem #{spec.name} #{spec.version} to see if there is a Windows binary version" if project.verbose?
+          # Find out what versions are available and if the required version is available as a windows binary, download and install that.
+          versions = %x[gem list "#{spec.name}" --remote --all --prerelease]
+          if versions =~ /#{spec.name} \(([^\)]*)\)/m
+            version_string = $1
+            platforms = version_string.split(/,\s*/).find {|s| s =~ /^#{spec.version}/ }.split(/\s+/)
+            windows_platform = platforms.find {|p| p =~ /mingw|mswin/ }
+            raise "Gem #{spec.name} is binary, but #{spec.version} does not have a published binary" if version_string =~ /mingw|mswin/ and not windows_platform
+
+            if windows_platform
+              puts "Installing Windows version of binary gem #{spec.name} #{spec.version}"
+              # If we have a bundle file specified, then gem will _only_ install the version specified by it and not the one we request.
+              bundle_gemfile = ENV['BUNDLE_GEMFILE']
+              ENV['BUNDLE_GEMFILE'] = ''
+              exec %[gem install "#{spec.name}" --remote --no-rdoc --no-ri --force --ignore-dependencies --platform "#{windows_platform}" --version "#{spec.version}" --install-dir "#{destination}"]
+              ENV['BUNDLE_GEMFILE'] = bundle_gemfile
+              binary_gems << spec.name
+            end
+          end
+        end
+
+        binary_gems
+      end
+    end
+  end
+end

data/lib/releasy/builders/windows_installer.rb

@@ -0,0 +1,117 @@
+require "releasy/builders/ocra_builder"
+
+module Releasy
+  module Builders
+    # Builds a win32 installer for the application.
+    class WindowsInstaller < OcraBuilder
+      TYPE = :windows_installer
+      INSTALLER_SCRIPT = "windows_installer.iss"
+      DEFAULT_FOLDER_SUFFIX = "WIN32_INSTALLER"
+
+      Builders.register self
+
+      # @return [String] Optional start-menu grouping of the application when installed (if name == "app" and installer_group == "frog", then it will get put into 'frog/app' in the start menu).
+      attr_accessor :start_menu_group
+
+      # @return [String] File name of readme file - End user will have the option to view this after the Windows installer has installed, recommended to be .txt, .rtf or .html.
+      attr_accessor :readme
+      # @return [String] Filename of license file - Must be .txt or .rtf file, which will be shown to user who will be requested to accept it (Windows installer only).
+      attr_accessor :license
+
+      protected
+      # Regular windows installer, but some users consider them evil.
+      def generate_tasks
+        directory folder
+
+        file folder => project.files do
+          Rake::FileUtilsExt.verbose project.verbose?
+
+          create_link_files folder
+          project.exposed_files.each {|file| cp file, folder }
+
+          create_installer installer_name, :links => true
+
+          rm temp_installer_script
+        end
+
+        desc "Build installer #{project.version} [Innosetup]"
+        task "build:windows:installer" => folder
+      end
+
+      protected
+      def setup
+        super
+        @start_menu_group = nil
+        @readme = nil
+        @license = nil
+      end
+
+      protected
+      def temp_installer_script; "#{project.output_path}/#{INSTALLER_SCRIPT}"; end
+      def installer_name; "#{folder}/#{project.underscored_name}_setup.exe"; end
+
+      protected
+      def create_installer(file, options = {})
+        generate_installer_script file, options
+        exec %[#{ocra_command} --chdir-first --no-lzma --innosetup "#{temp_installer_script}"]
+      end
+
+      # Generate innosetup script to build installer.
+      protected
+      def generate_installer_script(output_file, options = {})
+        installer_links = options[:links]
+
+        File.open(temp_installer_script, "w") do |file|
+          file.write <<END
+[Setup]
+AppName=#{project.name}
+AppVersion=#{project.version}
+DefaultDirName={pf}\\#{project.name.gsub(/[^\w\s]/, '')}
+OutputDir=#{File.dirname output_file}
+OutputBaseFilename=#{File.basename(output_file).chomp(File.extname(output_file))}
+UninstallDisplayIcon={app}\\#{project.underscored_name}.exe
+END
+
+          if installer_links
+            if start_menu_group
+              file.puts "DefaultGroupName=#{start_menu_group}\\#{project.name}"
+            else
+              file.puts "DefaultGroupName=#{project.name}"
+            end
+
+            file.puts "LicenseFile=#{license}" if license # User must accept license.
+            file.puts "SetupIconFile=#{icon}" if icon
+            file.puts
+
+            file.puts "[Files]"
+
+            file.puts %[Source: "#{license}"; DestDir: "{app}"] if license
+            file.puts %[Source: "#{readme}";  DestDir: "{app}"; Flags: isreadme] if readme
+
+            dir = File.dirname(output_file).tr("/", "\\")
+            project.send(:links).each_value do |title|
+              file.puts %[Source: "#{dir}\\#{title}.url"; DestDir: "{app}"]
+            end
+          end
+
+          file.write <<END
+
+[Run]
+Filename: "{app}\\#{project.underscored_name}.exe"; Description: "Launch"; Flags: postinstall nowait skipifsilent unchecked
+
+[Icons]
+Name: "{group}\\#{project.name}"; Filename: "{app}\\#{project.underscored_name}.exe"
+Name: "{group}\\Uninstall #{project.name}"; Filename: "{uninstallexe}"
+Name: "{commondesktop}\\#{project.name}"; Filename: "{app}\\#{project.underscored_name}.exe"; Tasks: desktopicon
+
+[Tasks]
+Name: desktopicon; Description: "Create a &desktop icon"; GroupDescription: "Additional icons:";
+Name: desktopicon\\common; Description: "For all users"; GroupDescription: "Additional icons:"; Flags: exclusive
+Name: desktopicon\\user; Description: "For the current user only"; GroupDescription: "Additional icons:"; Flags: exclusive unchecked
+Name: quicklaunchicon; Description: "Create a &Quick Launch icon"; GroupDescription: "Additional icons:"; Flags: unchecked
+END
+        end
+      end
+    end
+  end
+end

data/lib/releasy/builders/windows_standalone.rb

@@ -0,0 +1,37 @@
+require "releasy/builders/ocra_builder"
+
+module Releasy
+  module Builders
+    # Creates a completely standalone Windows executable.
+    #
+    # @note Startup of the executable created by this build takes a couple of seconds longer than running from the other windows builds, as the files are extracted into a temporary directory each time it is run. It is recommended to build with _:windows_folder_ or _:windows_installer_ instead of this, unless you really need to distribute the application as a single file.
+    class WindowsStandalone < OcraBuilder
+      TYPE = :windows_standalone
+      DEFAULT_FOLDER_SUFFIX = "WIN32_EXE"
+
+      Builders.register self
+
+      protected
+      # Self-extracting standalone executable.
+      def generate_tasks
+        directory folder
+
+        file folder => project.files do
+          Rake::FileUtilsExt.verbose project.verbose?
+
+          project.exposed_files.each {|file| cp file, folder }
+
+          create_link_files folder
+
+          exec %[#{ocra_command} --output "#{folder}/#{executable_name}"]
+        end
+
+        desc "Build standalone exe #{project.version} [Ocra]"
+        task "build:windows:standalone" => folder
+      end
+
+      protected
+      def executable_name; "#{project.underscored_name}.exe"; end
+    end
+  end
+end

data/lib/releasy/cli.rb

@@ -0,0 +1,12 @@
+require 'cri'
+
+Releasy::Cli = Cri::Command.new_basic_root.modify do
+  name        'releasy'
+  usage       'releasy [options] [command] [options]'
+  summary     'helper for using the Releasy gem'
+  description 'Helper for using the Releasy gem to release packages'
+end
+
+Dir[File.expand_path("../cli/*.rb", __FILE__)].each do |file|
+  require file.chomp(File.extname(file))
+end

data/lib/releasy/cli/install_sfx.rb

@@ -0,0 +1,66 @@
+require 'cri'
+require "releasy/archivers/exe"
+
+command = 'install-sfx'
+sfx_file = Releasy::Archivers::Exe::SFX_NAME
+sfx_path = Releasy::Archivers::Exe::SFX_FILE
+
+Releasy::Cli.define_command do
+  name        command
+  usage       "#{command} [options]"
+  aliases
+  summary     "copy #{sfx_file} to 7z assets folder"
+  description "copy #{sfx_file} to 7z assets folder, after 7z has been installed (required only when not on a Windows system). Warning: This command will likely require 'sudo' to be able to write the file"
+
+  flag   :h, :help,    'show help for this command' do |value, cmd|
+    puts cmd.help
+    exit 0
+  end
+
+  option :t, :output,  "specify directory to copy to (default is to try to find it automatically)", :argument => :required
+
+  run do |options, args, cmd|
+    if Gem.win_platform?
+      puts "#{command}: only required when not on a Windows platform, since #{sfx_file} is included in the Windows version of 7z"
+      exit 0
+    end
+
+    exe_location = `which 7z`.strip
+
+    if exe_location.empty?
+      puts "#{command}: 7z (p7zip) not installed; install it before trying to use this command"
+      exit 0
+    end
+
+    assets_location = if options[:output]
+                        options[:output]
+                      elsif exe_location =~ %r[bin/7z$]
+                        exe_location.sub %r[bin/7z$], "lib/p7zip"
+                      else
+                        nil
+                      end
+
+    destination_file = File.join(assets_location, sfx_file)
+    if File.exists? destination_file
+      puts "#{command}: #{destination_file} already exists; no need to install it again"
+      exit 0
+    else
+      begin
+        FileUtils.cp sfx_path, assets_location, :verbose => true
+        puts "#{sfx_file} copied to #{assets_location}"
+      rescue Errno::ENOENT, Errno::EACCES
+
+        if ENV["USER"] != "root"
+          command = %[sudo cp "#{sfx_path}" "#{assets_location}"]
+          puts "Copy failed, trying again as super-user:\n#{command}"
+          exec command
+          if File.exists? destination_file
+            puts "#{sfx_file} copied to #{assets_location}"
+          else
+            puts "Failed copy as super-user :("
+          end
+        end
+      end
+    end
+  end
+end

data/lib/releasy/dsl_wrapper.rb

@@ -0,0 +1,71 @@
+module Releasy
+  # Wraps an object and redirects public methods to it, to allow for a terse, block-based API.
+  #
+  # * Safer alternative to running Object#instance_eval directly, since protected/private methods and instance variables are not exposed.
+  # * Less wordy than a system which operates like Object#tap (`object.tap {|o| o.fish = 5; o.run }`)
+  #
+  # A method call, #meth called on the wrapper will try to call #meth or #meth= on the owner, as appropriate.
+  #
+  # @example
+  #     # To create a DSL block for a given object.
+  #     class Cheese
+  #       attr_accessor :value
+  #       attr_accessor :list
+  #       def initialize; @value = 0; @list = []; end
+  #       def invert; @list.reverse!; end
+  #     end
+  #
+  #     object = Cheese.new
+  #     Releasy::DSLWrapper.wrap object do
+  #       list [1, 2, 3]      # Calls object.list = [1, 2, 3]
+  #       list << 4           # Calls object.list << 4
+  #       value 5             # Calls object.value = 5
+  #       value list.size     # Calls object.value = object.list.size
+  #       invert              # Calls object.invert
+  #     end
+  #
+  class DSLWrapper
+    # @return [Object] Object that the DSLWrapper object is redirecting to.
+    attr_reader :owner
+
+    class << self
+      # Synonym for .new.
+      alias_method :wrap, :new
+    end
+
+    # If passed a block, the DSLWrapper will #instance_eval it automatically.
+    #
+    # @param owner [Object] Object to redirect the public methods of.
+    def initialize(owner, &block)
+      @owner = owner
+
+      metaclass = class << self; self; end
+
+      (@owner.public_methods - Object.public_instance_methods).each do |target_method|
+        redirection_method = target_method.to_s.chomp('=').to_sym
+
+        metaclass.class_eval do
+          define_method redirection_method do |*args, &inner_block|
+            if @owner.respond_to? "#{redirection_method}=" and (args.any? or not @owner.respond_to? redirection_method)
+              # Has a setter and we are passing argument(s) or if we haven't got a corresponding getter.
+              @owner.send "#{redirection_method}=", *args, &inner_block
+            elsif @owner.respond_to? redirection_method
+              # We have a getter or general method
+              @owner.send redirection_method, *args, &inner_block
+            else
+              # Should never reach here, but let's be paranoid.
+              raise NoMethodError, "#{owner} does not have a public method, ##{redirection_method}"
+            end
+          end
+        end
+      end
+
+      instance_eval &block if block_given?
+    end
+
+    private
+    def method_missing(meth, *args, &block)
+      raise NoMethodError, "#{owner} does not have either public method, ##{meth} or ##{meth}="
+    end
+  end
+end