cuken 0.1.13 → 0.1.15

data/lib/cuken/api/rvm/wip.rb

@@ -0,0 +1,554 @@
+#
+# These methods have to be verified as working with RVM API - many were broken as of 1.6.5
+#
+module ::Cuken
+  module Api
+    module Rvm
+
+      class RvmrcProcessor
+
+        attr_writer :gemspecs_to_install
+
+        def initialize(path)
+          @root_path = ::File.directory?(path) ? path : File.dirname(path)
+           rvmrc_read(path)
+        end
+
+        # read the .rvmrc file contents into @rvmrc
+        def rvmrc_read(path)
+          fn = ::File.directory?(path) ? path + '/.rvmrc' : path
+          @rvmrc = ::File.new(fn).read
+          return true if @rvmrc.size > 0
+        end
+
+        # return the .rvmrc file contents
+        def rvmrc
+          @rvmrc
+        end
+
+        # return ruby name parsed from .rvmrc file contents
+        def rvmrc_ruby_name
+          extract_rubie(rvmrc)
+        end
+
+        # return gemset name parsed from .rvmrc file contents
+        def rvmrc_gemset_name
+          extract_gemset(rvmrc)
+        end
+
+        # return concatenated string of rvmrc_ruby@rvmrc_gemset
+        def rvmrc_ruby_gemset(rvmrc)
+          "#{extract_rubie(rvmrc)}@#{extract_gemset(rvmrc)}"
+        end
+
+        # return an array of .rvmrc file paths found beneath a root folder
+        def find_rvmrc_files(rvmrc_root)
+          Dir.glob(rvmrc_root + '/**' + '/.rvmrc')
+        end
+
+        # return an arry of paths containing .rvmrc files
+        def find_rvmrc_paths(rvmrc_root)
+          root = File.directory?(rvmrc_root) ?  rvmrc_root : File.dirname(rvmrc_root)
+          dirs = []
+          find_rvmrc_files(root).each do |path|
+            dirs << File.dirname(File.expand_path(path)) if File.file?(path)
+          end
+          dirs
+        end
+
+        #return an array of *.gems file paths found beneath a root folder
+        def find_gems_files(rvmrc_root)
+          Dir.glob(rvmrc_root + '/**' + '/*.gems')
+        end
+
+        # returns rubies and gemsets from .rvmrc files glob'ed below
+        # a root folder.
+        def all_rubies_gemsets(root_path=@root_path)
+          @all_rubies_gemsets = Hash.new([])
+          arry=find_rvmrc_paths(root_path)
+          arry.each do |dir|
+            Dir.glob(dir + '/*.gems').each do |fn|
+              gsn     = File.basename(fn,'.gems').to_s
+              rvmrc_read(dir + '/.rvmrc')
+              rube    = rvmrc_ruby_name
+              egsn    = rvmrc_gemset_name
+              @all_rubies_gemsets[rube] = [] unless @all_rubies_gemsets.key? rube
+              if gsn == egsn
+                @all_rubies_gemsets[rube] << {:ruby_alias => "cuken_#{rube}",:gemset_alias => "cuken_#{gsn}", :gemset_name => gsn, :gemset_path => fn}
+              end
+            end
+          end
+          @all_rubies_gemsets
+         end
+
+        # returns hash of all gemsets, per-Ruby, in all .rvmrc files beneath a root folder
+        def all_gemsets(root_path=@root_path)
+          default = Hash.new{|hsh,ky| hsh[ky] = {:ruby_alias => "cuken_#{ky}"}}
+          @all_rubies_gemsets ||= all_rubies_gemsets(root_path)
+          @all_gemsets = @all_rubies_gemsets.inject(default){|h,(k,v)| h[k]; h[k][:gemsets]=v; h }
+        end
+
+        # returns array of all rubies in all .rvmrc files beneath a root folder
+        def all_rubies(root_path=@root_path)
+          @all_rubies_gemsets ||= all_rubies_gemsets(root_path)
+          @all_rubies = @all_rubies_gemsets.keys
+        end
+
+        # yield a block in the environment of each in the installed rubies,
+        # and return current Ruby string even if the given block raises
+        def each_ruby
+          begin
+            all_rubies(@root_path).each do |rubie|
+              RVM.use(rubie)
+              yield rubie
+            end
+          rescue
+          ensure
+            RVM.reset_current!
+          end
+        end
+
+        # create gemsets parsed from all .rvmrc files beneath a root folder
+        def create_gemsets
+          each_ruby do |rubie|
+            all_gemsets(@root_path)[rubie][:gemsets].each do |hsh|
+              ::RVM.gemset.create([hsh[:gemset_name]])
+            end
+          end
+        end
+
+        # Return array of [gem_name, gem_version] to be installed into all
+        # gemsets found in .rvmrc files. Default is Bundler versio 1.0.10
+        def gemspecs_to_install
+          @gemspecs_to_install ||= [['bundler', '1.0.10']]
+        end
+
+      # Install @gemspecs_to_install contents using rubies and gemsets
+      # found in .rvmrc files.
+      def gems_install
+        create_gemsets
+        each_ruby do |rubie|
+          gemspecs_to_install.each { |spec| install_gem(rubie, spec) }
+        end
+      end
+
+      # return the options string for Ruby's `gem install...` CLI
+      def gem_install_options
+        @gem_install_options ||= ['no_ri', 'no_rdoc']
+        "--" + @gem_install_options.join(' --')
+      end
+
+      # install given gem into all ruby+gemsets parsed from .rvmrc files beneath a root folder
+      def install_gem(rubie, spec)
+        gem, version = spec
+        all_gemsets.each do |rubie, hsh|
+          hsh[:gemsets].each do |h|
+            if gem_available?(spec)
+              puts "info: Gem #{gem}-#{version} already installed in #{rvm_current_name}."
+            else
+              puts "info: Installing gem #{gem}-#{version} in #{rvm_current_name}..."
+              RVM.gemset.use(h[:gemset_alias])
+              RVM.run("rvm --create use #{h[:gemset_alias]}; gem install #{gem} -v#{version} #{gem_install_options}")
+            end
+          end
+        end
+      end
+
+      # return the parsed .rvmrc info for the current ruby
+      def current_ruby_info(rubie)
+        @all_rubies_gemsets ||= all_rubies_gemsets
+        @all_rubies_gemsets[rubie]
+      end
+
+      def rvm_path
+        pn = Pathname.new(File.expand_path(ENV['rvm_path'] || '~/.rvm'))
+        pn.exist? ? pn : raise(RuntimeError, "Could not find RVM's .rvm folder (#{pn})", caller)
+      end
+      # Does not install existing RVM rubies that are listed in the .rvmrc files
+      # raise an error if RVM's install root does not exist
+      def setup_rubies
+        rvm_loaded? ? true : raise(RuntimeError, "RVM library not loaded.", caller)
+        @all_rubies_gemsets ||= all_rubies_gemsets(@root_path)
+        @all_rubies_gemsets.keys.each do |rubie|
+          if RVM.list_strings.include?(rubie)
+            puts "info: Rubie #{rubie} already installed."
+          else
+            with_rvm_environment_vars do
+              install_rubie(rubie)
+            end
+          end
+          RVM.alias_create(current_ruby_info(rubie)[0][:ruby_alias], "#{rubie}") unless rubie == current_ruby_info(rubie)[0][:ruby_alias]
+        end
+      end
+
+        private
+          def extract_rubie(rvmrc)
+            rvmrc[/ruby_id=\"(.*)\"/, 1]
+          end
+          def extract_gemset(rvmrc)
+            rvmrc[/gemset_id=\"(.*)\"/, 1]
+          end
+          def gem_available?(spec)
+            gem, version = spec
+            RVM.ruby_eval("require 'rubygems' ; print Gem.available?('#{gem}','#{version}')").stdout == 'true'
+          end
+          def rvm_current_name
+            RVM.current.expanded_name
+          end
+
+          def rvm_loaded?
+            @rvm_setup = defined?(RVM) ? true : false
+            return(true) if @rvm_setup
+            rvm_lib_path = rvm_path + "lib" rescue return
+            $LOAD_PATH.unshift(rvm_lib_path.to_s) unless $LOAD_PATH.include?(rvm_lib_path.to_s)
+            require 'rvm'
+            @rvm_setup = defined?(RVM) ? true : false
+          end
+
+          def install_rubie(rubie)
+            std_msg = "info: Rubie #{rubie} installed."
+            err_msg  = "Failed #{rubie} install! Check RVM logs here: #{RVM.path}/log/#{rubie}"
+            puts "info: Rubie #{rubie} installation inprogress. This couldtake awhile..."
+            RVM.install(rubie, rvm_install_options) ? puts(std_msg) : abort(err_msg)
+          end
+
+          def rvm_install_options
+            { }
+          end
+
+          def with_rvm_environment_vars
+            my_vars = rvm_environment_vars
+            current_vars = my_vars.inject({}) { |cvars,kv| k,v = kv ; cvars[k]= ENV[k] ; cvars }
+            set_environment_vars(my_vars)
+            yield
+            ensure
+            set_environment_vars(current_vars)
+          end
+
+          def set_environment_vars(vars)
+            vars.each { |k,v| ENV[k] = v }
+          end
+
+          def rvm_environment_vars
+             if rvm_for_macports?
+               {'CC' => '/usr/bin/gcc-4.2',
+                'CFLAGS' => '-O2 -arch x86_64',
+                'LDFLAGS' => '-L/opt/local/lib -arch x86_64',
+                'CPPFLAGS' => '-I/opt/local/include'}
+             else
+               {}
+             end
+           end
+
+           def rvm_for_macports?
+             `uname`.strip == 'Darwin' && `which port`.present?
+           end
+
+      end # class RvmrcProcessor
+
+      module_function
+       class << self
+         attr_accessor :rvm_install_rubies, :rvm_install_gem_specs,
+           :rvm_gem_install_options
+       end
+
+      def run_simple_gemset(cmd_str, options = {} )
+        # RVM 1.6.5 is not generating rvm-legal code when given a command str so we write to a temp file
+        tmpfile = ::Tempfile.open("cuken_#{__method__.to_s}_"){ |f| f.puts(cmd_str);f }
+        tmpfile.close
+        Pathname(tmpfile).chmod(0700)
+        FileUtils.copy(tmpfile,tmpfile.path+'.bak')
+        @run_simple_gemset_result = nil
+        begin
+          case
+            when options.key?(:ruby) && options.key?(:gemset)
+              full_gemset_string = "#{options[:ruby]}@#{options[:gemset]}"
+            when options.key?(:ruby) && !options.key?(:gemset)
+              full_gemset_string = "#{options[:ruby]}@#{RVM.current.gemset.name}"
+            when !options.key?(:ruby) && options.key?(:gemset)
+              full_gemset_string = "#{RVM.current.expanded_name[/(.*)@/,1]}@#{options[:gemset]}"
+            when !options.key?(:ruby) && !options.key?(:gemset)
+              full_gemset_string = RVM.current.expanded_name
+            else
+              full_gemset_string = RVM.current.expanded_name
+          end
+          raise(::ArgumentError, "The RVM gemset #{full_gemset_string} is not present.") unless ::RVM.list_gemsets.include?(full_gemset_string)
+          ::RVM.environment(full_gemset_string) do |env|
+            if @announce_env
+              announce_or_puts("Ruby environment for #{::RVM.current.expanded_name}:")
+              announce_or_puts("#{env.info.inspect}")
+            end
+            @run_simple_gemset_result = env.ruby(tmpfile, options)
+            #sin = @run_simple_gemset_result.command
+            #sout = @run_simple_gemset_result.stdout
+            #serr = @run_simple_gemset_result.stderr
+            #estat = @run_simple_gemset_result.exit_status
+          end
+        rescue ::Exception => e
+          puts e.message
+          puts e.backtrace.join('\n')
+          raise
+        rescue ::ArgumentError => e
+          puts "Exception raised by run_simple_gemset(#{cmd_str}, #{options})"
+          puts "Script executed from #{tmpfile.to_s}:\n#{tmpfile.open.readlines}"
+          puts "Exception: #{e.message}"
+          puts e.backtrace.join('\n')
+          raise e
+        ensure
+         tmpfile.unlink
+        end
+        @run_simple_gemset_result.inspect
+      end
+
+      def rvmrc(path)
+         @rvmrc ||= RvmrcProcessor.new(path)
+      end
+
+      def rvm_current_name
+        RVM.current.expanded_name
+      end
+
+      def rvm_gem_install_options
+        @rvm_gem_install_options ||= ['no_ri', 'no_rdoc']
+        "--" + @rvm_gem_install_options.join(' --')
+      end
+
+      def rvm_install_rubies
+        @rvm_install_rubies ||= []
+      end
+
+      def rvm_install_gemspecs
+        @rvm_install_gemspecs ||= [['bundler', '1.0.10']]
+      end
+
+      def rvm_create_gemsets
+        @rvm_create_gemsets ||= []
+      end
+
+      def rvm_requested_gemset(gemset)
+        @rvm_requested_gemset = gemset
+      end
+
+      def rvm_requested_gemset
+        @rvm_requested_gemset ||='vagrant'
+      end
+      #wip
+      def rvm_path
+        pn = Pathname.new(File.expand_path(ENV['rvm_path'] || '~/.rvm'))
+        pn.exist? ? pn : raise(RuntimeError, "Could not find RVM's .rvm folder (#{pn})", caller)
+      end
+
+      def rvm_local_install?
+        rvm_path.dirname.realpath.directory?
+      end
+      # done
+      def rvm_loaded?
+        _rvm_load
+      end
+
+      def rvm_gemset_paths(root_path='/usr/src/cuken')
+        rpn = Pathname(root_path)
+        rvmrc_dirs = []
+        Dir.glob((rpn + '**' + '.rvmrc').to_s).each do |d|
+          dn = File.dirname(d)
+          rvmrc_dirs << dn if File.directory?(dn)
+        end
+        rvmrc_dirs
+      end
+
+      # done
+      def rvmrc_rubies_gemsets(root_path='/usr/src/cuken')
+        @rvmrc_rubies_gemsets = Hash.new([])
+        arry=rvm_gemset_paths(root_path)
+        arry.each do |dir|
+          Dir.glob(dir + '/*.gems').each do |fn|
+            gsn     = File.basename(fn,'.gems').to_s
+            rvmrc   = File.new(File.dirname(fn) + '/.rvmrc').read
+            rube    = rvmrc_extract_ruby(rvmrc)
+            egsn    = rvmrc_extract_gemset(rvmrc)
+            @rvmrc_rubies_gemsets[rube] = [] unless @rvmrc_rubies_gemsets.key? rube
+            @rvmrc_rubies_gemsets[rube] << gsn if gsn == egsn
+          end
+        end
+        @rvmrc_rubies_gemsets
+       end
+      # done
+      def rvmrc_rubies
+        @rvmrc_rubies ||= _rvmrc_rubies #.keys.map{ |rubie| "#{rubie}@#{rvm_requested_gemset}" }
+      end
+      #wip
+      def rvm_rubies_setup(root_path='/usr/src/cuken')
+        rvm_loaded? ? true : raise(RuntimeError, "RVM library not loaded.", caller)
+        @rvmrc_rubies_gemsets ? true : rvmrc_rubies_gemsets(root_path)
+        @rvmrc_rubies_gemsets.keys.each do |rubie|
+          if RVM.list_strings.include?(rubie)
+            puts "info: Rubie #{rubie} already installed."
+          else
+            with_rvm_environment_vars do
+              _rvm_install_rubie(rubie)
+            end
+          end
+          RVM.alias_create(rvmrc_rubies[rubie][:alias], "#{rubie}@#{rvm_requested_gemset}") unless rubie == rvmrc_rubies[rubie][:alias]
+        end
+      end
+      #done
+      def rvm_current_rubie_info
+        rvmrc_rubies[_rvm_current_rubie_name]
+      end
+
+      # Install @rvm_install_gemspecs gemspec using rubies and gemsets
+      # found in .rvmrc files.
+      # done
+      def rvmrc_gems_install(root_path)
+        @rvmrc_root_path = root_path
+        _rvmrc_create_gemsets
+        _each_rvmrc_rubie do |rubie|
+          rvm_install_gemspecs.each { |spec| _rvmrc_install_gem(rubie, spec) }
+        end
+      end
+
+      def rvmrc_gemsets_install(root_path)
+        @rvmrc_root_path = root_path
+        _each_rvmrc_rubie do |rubie|
+          rvm_install_gemspecs.each { |spec| _rvmrc_install_gem(rubie, spec) }
+        end
+      end
+
+      protected
+      #done
+      def _rvm_load
+        @rvm_setup = false
+        rvm_lib_path = rvm_path + "lib" rescue return
+        $LOAD_PATH.unshift(rvm_lib_path.to_s) unless $LOAD_PATH.include?(rvm_lib_path.to_s)
+        require 'rvm'
+        @rvm_setup = defined?(RVM) ? true : false
+      end
+      module_function :_rvm_load
+      #done
+      def _rvm_install_rubie(rubie)
+        std_msg = "info: Rubie #{rubie} installed."
+        err_msg  = "Failed #{rubie} install! Check RVM logs here: #{RVM.path}/log/#{rubie}"
+        puts "info: Rubie #{rubie} installation inprogress. This couldtake awhile..."
+        RVM.install(rubie, rvm_install_options) ? puts(std_msg) : abort(err_msg)
+      end
+      module_function :_rvm_install_rubie
+
+      #done
+      def rvmrc_extract_ruby_gemset(rvmrc)
+        "#{rvmrc_extract_ruby(rvmrc)}@#{rvmrc_extract_gemset(rvmrc)}"
+      end
+      module_function :rvmrc_extract_ruby_gemset
+      #done
+      def rvmrc_extract_ruby(rvmrc)
+        rvmrc[/ruby_id=\"(.*)\"/, 1]
+      end
+      module_function :rvmrc_extract_ruby
+      #done
+      def rvmrc_extract_gemset(rvmrc)
+        rvmrc[/gemset_id=\"(.*)\"/, 1]
+      end
+      module_function :rvmrc_extract_gemset
+      #done
+      def _rvmrc_rubies
+        default = Hash.new{|hsh,ky| hsh[ky] = {:alias => "cuken-#{ky}"}}
+        @rvmrc_rubies_gemsets ||= rvmrc_rubies_gemsets(@rvmrc_root_path)
+        @rvmrc_rubies = @rvmrc_rubies_gemsets.keys.inject(default){|h,(k,v)| h[k]; h }
+      end
+      module_function :_rvmrc_rubies
+      #done
+      def _rvmrc_gemsets
+        default = Hash.new{|hsh,ky| hsh[ky] = {:alias => "cuken-#{ky}"}}
+        @rvmrc_rubies_gemsets ||= rvmrc_rubies_gemsets(@rvmrc_root_path)
+        @rvmrc_gemsets = @rvmrc_rubies_gemsets.inject(default){|h,(k,v)| h[k]; h[k][:gemsets]=v; h }
+      end
+      module_function :_rvmrc_gemsets
+      # done
+      def _each_rvmrc_rubie
+        _rvmrc_rubies.each do |ary|
+          RVM.use(ary[0])
+          yield ary[0]
+        end
+      ensure
+        RVM.reset_current!
+      end
+      module_function :_each_rvmrc_rubie
+      # done
+      def _rvmrc_create_gemsets
+        _rvmrc_gemsets.each do |hsh|
+          RVM.use hsh[0]
+          hsh[1][:gemsets].each do |gmst|
+            # TODO: Post refactor
+            #RVM.gemset.create([gmst])
+          end
+        end
+      end
+      module_function :_rvmrc_create_gemsets
+      #done
+      def _rvmrc_install_gem(rubie, spec)
+        gem, version = spec
+        _rvmrc_gemsets.each do |hsh|
+          rubie = hsh[0]
+          hsh[1][:gemsets].each do |gmst|
+            if RVM.gemset.instance_of? ::RVM::Environment::GemsetWrapper
+              #RVM.gemset.create([gmst])
+              RVM.gemset.use(gmst)
+              if _rvm_gem_available?(spec)
+                puts "info: Gem #{gem}-#{version} already installed in #{rvm_current_name}."
+              else
+                puts "info: Installing gem #{gem}-#{version} in #{rvm_current_name}..."
+                RVM.run("rvm --create use #{rubie}@#{gmst}; gem install #{gem} -v#{version} #{rvm_gem_install_options}")
+              end
+            end
+          end
+        end
+      end
+      module_function :_rvmrc_install_gem
+
+      # done
+      def set_environment_vars(vars)
+        vars.each { |k,v| ENV[k] = v }
+      end
+      module_function :set_environment_vars
+      #done
+      def with_rvm_environment_vars
+        my_vars = rvm_environment_vars
+        puts my_vars
+        current_vars = my_vars.inject({}) { |cvars,kv| k,v = kv ; cvars[k]= ENV[k] ; cvars }
+        puts current_vars
+        set_environment_vars(my_vars)
+        yield
+        ensure
+        set_environment_vars(current_vars)
+      end
+      module_function :with_rvm_environment_vars
+      #done
+      def rvm_environment_vars
+         if rvm_for_macports?
+           {'CC' => '/usr/bin/gcc-4.2',
+            'CFLAGS' => '-O2 -arch x86_64',
+            'LDFLAGS' => '-L/opt/local/lib -arch x86_64',
+            'CPPFLAGS' => '-I/opt/local/include'}
+         else
+           {}
+         end
+       end
+       module_function :rvm_environment_vars
+       #done
+       def rvm_for_macports?
+         `uname`.strip == 'Darwin' && `which port`.present?
+       end
+       module_function :rvm_for_macports?
+       # done
+       def rvm_install_options
+         { }
+       end
+       module_function :rvm_install_options
+      #done
+      def _rvm_gem_available?(spec)
+        gem, version = spec
+        RVM.ruby_eval("require 'rubygems' ; print Gem.available?('#{gem}','#{version}')").stdout == 'true'
+      end
+      module_function :_rvm_gem_available?
+    end
+  end
+end