software_smithy 1.1 → 1.6

data/lib/smithy/file_operations.rb

@@ -43,6 +43,9 @@ module Smithy
   def notice_exist(file)
     puts "exists ".rjust(12).color(:blue).bright + file
   end
+  def notice_using(file)
+    puts "using ".rjust(12).color(:blue).bright + file
+  end
   def notice_link(file1, file2)
     puts "link ".rjust(12).bright + file1 + " -> " + file2
   end
@@ -83,7 +86,7 @@ module Smithy
         begin
           FileUtils.send method, nil, new_group, f, options
         rescue
-          raise "Could not set group \"#{new_group}\" on \"#{f}\""
+          # raise "Could not set group \"#{new_group}\" on \"#{f}\""
         end
       end
 
@@ -96,7 +99,7 @@ module Smithy
         else
           command = "chmod g+w #{f}"
           unless options[:noop]
-            # Check to see if it's already group writeable
+            # Check to see if it's already group writable
             # convert the integer to a string in base 8
             mode = File.stat(f).mode.to_s(8)
             # check the group bit, convert back to integer
@@ -134,7 +137,7 @@ module Smithy
         installed = false
 
         force = options.try(:[],:force)
-        force = Smithy::Config.global.try(:[], :"force")
+        force = Smithy::Config.global.try(:[], :"force") unless force
         options.reject!{|k,v| k==:force}
 
         if File.exists?(dest) && !force
@@ -143,8 +146,8 @@ module Smithy
             installed = true
           else
             notice_conflict dest
-            overwrite = nil
-            while overwrite.nil? do
+            overwrite = "unknown"
+            while overwrite == "unknown" do
               prompt = Readline.readline(" "*FILE_NOTICE_COLUMNS+"Overwrite? (enter \"h\" for help) [ynsdh] ")
               case prompt.downcase
               when "y"
@@ -208,6 +211,7 @@ module Smithy
       end
 
       def render_erb(args = {})
+        args[:options] = {} unless args[:options]
         options = {:noop => false, :verbose => false}
         options.merge!(args[:options])
         erb_filename  = args[:erb]
@@ -219,7 +223,10 @@ module Smithy
           rendered_file = "#{File.dirname(dest)}/.#{File.basename(dest)}_#{Time.now.to_i}"
         end
 
-        erb = ERB.new(File.read(erb_filename), nil, "<>")
+        erb_string = args[:erb_string]
+        erb_string = File.read(erb_filename) if erb_string.blank?
+
+        erb = ERB.new(erb_string, nil, "<>")
         File.open(rendered_file, "w+") do |f|
           f.write erb.result(args[:binding])
         end

data/lib/smithy/formula.rb

@@ -0,0 +1,203 @@
+module Smithy
+  class Formula
+    attr_accessor :formula_file, :name, :build_name, :prefix, :package, :module_setup
+
+    def self.formula_name
+      self.to_s.underscore.split("/").last.gsub /_formula$/, ""
+    end
+    def formula_name
+      self.class.formula_name
+    end
+
+    def initialize(passed_package = nil)
+      @formula_file = __FILE__
+      raise "no install method implemented" unless self.respond_to?(:install)
+      raise "homepage must be specified" if homepage.blank?
+      raise "url must be specified" if url.blank?
+      if passed_package
+        set_package(passed_package)
+      else
+        # guess name and build_name
+        @name = self.formula_name
+        @build_name = operating_system
+        initialize_modules
+      end
+    end
+
+    # setup module environment by purging and loading only what's needed
+    def initialize_modules
+      @modules = nil # re-evaluate modules block
+      @module_commands = nil # re-evaluate module_commands block
+      @module_setup = ""
+      raise "please specify modules OR modules_command, not both" if modules.present? && module_commands.present?
+      if ENV["MODULESHOME"]
+        @modulecmd = "modulecmd sh"
+        @modulecmd = "#{ENV["MODULESHOME"]}/bin/modulecmd sh" if File.exists?("#{ENV["MODULESHOME"]}/bin/modulecmd")
+        if modules.present?
+          @module_setup << `#{@module_setup} #{@modulecmd} purge 2>/dev/null` << " "
+          raise "modules must return a list of strings" unless modules.is_a? Array
+          @module_setup << `#{@module_setup} #{@modulecmd} load #{modules.join(" ")}` << " "
+        elsif module_commands.present?
+          module_commands.each do |command|
+            @module_setup << `#{@module_setup} #{@modulecmd} #{command}` << " "
+          end
+        end
+      end
+    end
+
+    def set_package(p)
+      @package    = p
+      @name       = p.name
+      @version    = p.version
+      @build_name = p.build_name
+      @prefix     = p.prefix
+      initialize_modules
+    end
+
+    # DSL Methods
+    %w{ homepage url md5 sha1 sha2 sha256 modules module_commands depends_on modulefile }.each do |attr|
+      class_eval %Q{
+        def self.#{attr}(value = nil, &block)
+          @#{attr} = block_given? ? block : value unless @#{attr}
+          @#{attr}
+        end
+        def #{attr}
+          @#{attr} = self.class.#{attr}.is_a?(Proc) ? instance_eval(&self.class.#{attr}) : self.class.#{attr} unless @#{attr}
+          @#{attr}
+        end
+      }
+    end
+
+    # DLS Version Method, can set a version or guess based on the filename
+    def self.version(value = nil)
+      unless @version
+        if value
+          @version = value
+        else
+          @version = url_filename_version_number(url) if url.present?
+        end
+      end
+      @version
+    end
+
+    def version
+      @version = self.class.version unless @version
+      @version
+    end
+
+    # DLS Version Method, can set a version or guess based on the filename
+    def self.disable_group_writable(value = true)
+      @disable_group_writable = true
+      @disable_group_writable
+    end
+
+    def group_writable?
+      ! self.class.instance_variables.include?(:@disable_group_writable)
+    end
+
+    def run_install
+      check_dependencies if depends_on
+      install
+      notice_success "SUCCESS #{@prefix}"
+      return true
+    end
+
+    def create_modulefile
+      return false if modulefile.blank?
+      notice "Creating Modulefile for #{package.prefix}"
+      m = ModuleFile.new :package => package
+      FileUtils.mkdir_p(File.dirname(m.module_file))
+      FileOperations.render_erb(:erb_string => modulefile, :binding => m.get_binding, :destination => m.module_file)
+      FileOperations.make_group_writable(m.module_file)
+      FileOperations.set_group(m.module_file, package.group)
+      return true
+    end
+
+    def module_list
+      if ENV['MODULESHOME']
+        notice "module list"
+        Kernel.system @module_setup + "#{@modulecmd} list 2>&1"
+      end
+    end
+
+    def module_is_available?(mod)
+      return false unless @modulecmd
+
+      if `#{@modulecmd} avail #{mod} 2>&1` =~ /#{mod}/
+        true
+      else
+        false
+      end
+    end
+
+    def module_environment_variable(mod, var)
+      module_display = `#{@modulecmd} display #{mod} 2>&1`
+      if module_display =~ /(\S+)\s+#{var}\s+(.*)$/
+        return $2
+      else
+        return ""
+      end
+    end
+
+    def fail_command
+      $stdout.flush
+      $stderr.flush
+      raise <<-EOF.strip_heredoc
+        The last command exited with status: #{$?.exitstatus}
+          Formula: #{formula_file}
+          Build Directory: #{@package.source_directory}
+      EOF
+    end
+
+    def patch(content, *args)
+      patch_file_name = "patch.diff"
+      File.open(patch_file_name, "w+") do |f|
+        f.write(content)
+      end
+      args << "-p1" if args.empty?
+      patch_command = "patch #{args.join(' ')} <#{patch_file_name}"
+      notice patch_command
+      Kernel.system patch_command
+      fail_command if $?.exitstatus != 0
+    end
+
+    def system(*args)
+      notice args.join(' ')
+      if args.first == :nomodules
+        args.shift
+        Kernel.system args.join(' ')
+      else
+        Kernel.system @module_setup + args.join(' ')
+      end
+      fail_command if $?.exitstatus != 0
+    end
+
+    def check_dependencies
+      @depends_on = [depends_on] if depends_on.is_a? String
+      missing_packages = []
+      notice "Searching for dependencies"
+      depends_on.each do |package|
+        name, version, build = package.split('/')
+        path = Package.all(:name => name, :version => version, :build => build).first
+        if path
+          notice_using(path)
+          p = Package.new(:path => path)
+          new_name = p.name.underscore
+          class_eval %Q{
+            def #{new_name}
+              @#{new_name} = Package.new(:path => "#{path}") if @#{new_name}.nil?
+              @#{new_name}
+            end
+          }
+        else
+          missing_packages << package
+          #TODO build package instead?
+        end
+      end
+      unless missing_packages.empty?
+        raise "#{self.class} depends on: #{missing_packages.join(" ")}"
+      end
+    end
+
+  end #class Formula
+end #module Smithy

data/lib/smithy/formula_command.rb

@@ -0,0 +1,198 @@
+module Smithy
+  # This class acts as a controller for formula subcommands
+  class FormulaCommand
+    # Return formula directories in order of precedence
+    # 1. formula directories specified on the command line
+    # 2. formulas located in ~/.smithy/formulas/
+    # 3. smithy's built in formulas
+    def self.formula_directories
+      unless @formula_directories
+        @formula_directories = [ File.join(ENV["HOME"], ".smithy/formulas") ]
+        if Smithy::Config.global[:"formula-directories"]
+          Smithy::Config.global[:"formula-directories"].reverse.each do |dir|
+            @formula_directories << dir
+          end
+        end
+        @formula_directories << File.join(@@smithy_bin_root, "formulas")
+      end
+      @formula_directories
+    end
+
+    # Prepend a directory to the formula file paths
+    def self.prepend_formula_directory(dir)
+      @formula_directories.unshift(dir)
+      @formula_directories
+    end
+
+    # Returns an array containing the full paths
+    # to each file name in order of precedence
+    def self.formula_files
+      unless @formula_files
+        @formula_files = []
+        formula_directories.each do |dir|
+          @formula_files += Dir.glob(File.join(File.expand_path(dir),"*.rb")).sort
+        end
+      end
+      @formula_files
+    end
+
+    # Format the full file paths to display only the name
+    def self.formula_names
+      @formula_names = formula_files.collect{|f| File.basename(f,"_formula.rb")}.uniq unless @formula_names
+      @formula_names
+    end
+
+    # Return the file path of a single formula file
+    def self.formula_file_path(name)
+      formula_files.select{|f| f =~ /\/#{name}_formula.rb/}.first
+    end
+
+    # Return the file contents of a formula
+    def self.formula_contents(name)
+      raise "unkown formula '#{name}'" unless formula_file_path(name).present? && File.exists?(formula_file_path(name))
+      File.read(formula_file_path(name))
+    end
+
+    def self.initialize_directories(options)
+      prepend_formula_directory(options[:d]) if options[:d]
+    end
+
+    def self.which_command(options,args)
+      initialize_directories(options)
+      formula_name = args.first.split("/").first
+      puts formula_file_path(formula_name)
+    end
+
+    def self.display_command(options,args)
+      initialize_directories(options)
+      formula_name = args.first.split("/").first
+      puts formula_contents(formula_name)
+    end
+
+    def self.list_command(options,args)
+      initialize_directories(options)
+      puts formula_names
+    end
+
+    # construct a new fomula object given a formula name or full name/version/build
+    def self.build_formula(package, formula_name = nil)
+      name, version, build = package.split("/")
+      formula_name = name if formula_name.blank?
+      raise "unknown formula #{formula_name}" unless formula_names.include?(formula_name)
+
+      require formula_file_path(formula_name)
+      f = "#{formula_name.underscore.camelize}Formula".constantize.new
+      # Set the actual formula file path, otherwise it's just formula.rb
+      f.formula_file = formula_file_path(formula_name)
+
+      version = f.version      if version.blank?
+      build = operating_system if build.blank?
+      p = Package.new :path => [name, version, build].join("/"), :group_writable => f.group_writable?
+      f.set_package(p) if p.valid?
+
+      return f
+    end
+
+    def self.install_command(options,args)
+      initialize_directories(options)
+
+      packages = args.dup
+      raise "You must supply at least one package to install" if packages.empty?
+
+      packages.each do |package|
+        f = build_formula(package, options[:"formula-name"])
+        f.package.create(:formula => true)
+
+        formula_prefix_contents = Dir["#{f.prefix}/*"]
+        unless formula_prefix_contents.empty?
+          # overwrite = "unknown"
+          # while overwrite == "unknown" do
+          #   notice_conflict f.package.prefix
+          #   prompt = Readline.readline(" "*FILE_NOTICE_COLUMNS+"Is not empty, delete contents? (enter \"h\" for help) [ynhq] ")
+          #   case prompt.downcase
+          #   when "y"
+          #     overwrite = true
+          #   when "n"
+          #     overwrite = false
+          #   when "h"
+          #     indent = " "*FILE_NOTICE_COLUMNS
+          #     puts indent+"y - yes, delete existing install"
+          #     puts indent+"n - no, do not overwrite"
+          #     puts indent+"h - help, show this help"
+          #     puts indent+"q - exit now"
+          #   when "q"
+          #     raise "Abort new formula install"
+          #   end
+          # end
+          # if overwrite
+          if options[:clean]
+            notice "cleaning #{f.prefix}"
+            formula_prefix_contents.each do |f|
+              FileUtils.rm_rf(f)
+            end
+          end
+          # end
+        end
+
+        if f.url.eql?("none")
+          Dir.chdir File.join(f.package.prefix)
+        else
+          d = DownloadCache.new(f, options[:"formula-name"]).get
+          raise "Download failure" unless d
+          # f.package.extract(:archive => d, :overwrite => true)
+          f.package.extract(:archive => d)
+          Dir.chdir File.join(f.package.prefix, "source")
+        end
+
+        if f.run_install
+          f.package.create_valid_build_file
+          f.package.set_file_permissions_recursive
+
+          if f.modulefile.present?
+            f.create_modulefile
+          elsif options[:"modulefile"]
+            ModuleFile.new(:package => f.package).create
+          end
+        end
+      end #packages.each
+    end
+
+    def self.new_command(options,args)
+      @formula_name     = options[:name]
+      @formula_name     = url_filename_basename(args.first) unless options[:name]
+      @formula_name     = @formula_name.camelize
+      @formula_url      = args.first
+      @formula_homepage = options[:homepage]
+      @formula_homepage = "#{URI(@formula_url).scheme}://#{URI(@formula_url).host}/" unless options[:homepage]
+
+      destination = File.join(ENV["HOME"], ".smithy/formulas")
+      destination = Smithy::Config.global[:"formula-directories"].first if Smithy::Config.global[:"formula-directories"]
+      FileUtils::mkdir_p(destination)
+
+      destination = File.join(destination, "#{@formula_name.underscore}_formula.rb")
+      FileOperations.render_erb :binding => binding,
+        :erb         => File.join(@@smithy_bin_root, "etc/templates/formula.rb.erb"),
+        :destination => destination
+      if Smithy::Config.global[:"file-group-name"]
+        FileOperations.set_group(destination, Smithy::Config.global[:"file-group-name"])
+        FileOperations.make_group_writable(destination)
+      end
+    end
+
+    def self.create_module_command(options,args)
+      packages = args.dup
+      raise "You must supply at least one package to install" if packages.empty?
+
+      packages.each do |package|
+        f = build_formula(package, options[:"formula-name"])
+        if f.modulefile.present?
+          f.create_modulefile
+        else
+          ModuleFile.new(:package => f.package).create
+        end
+      end
+    end
+
+  end #FormulaCommand
+
+end