bitgirder-platform 0.1.7

data/lib/bitgirder/irb.rb

@@ -0,0 +1,35 @@
+require 'bitgirder/core'
+
+require 'irb'
+
+module BitGirder
+module Irb
+
+    STATE = {}
+
+    def Irb.run( opts )
+        
+        STATE[ :init_eval ] = opts[ :init_eval ]
+        IRB.start( __FILE__ )
+    end
+
+end
+end
+
+module IRB
+
+    class Irb
+        
+        BG_EVAL_INPUT_ORIG = instance_method( :eval_input )
+ 
+        def eval_input( *argv )
+            
+            if ( script = BitGirder::Irb::STATE[ :init_eval ] )
+                @context.evaluate( script, 1 )
+            end
+
+            BG_EVAL_INPUT_ORIG.bind( self ).call( *argv )
+        end
+    end
+
+end

data/lib/bitgirder/mysql.rb

@@ -0,0 +1,60 @@
+require 'bitgirder/core'
+
+module BitGirder
+module MySql
+
+    # Although the 3p Mysql module won't conflict with this module (cases differ
+    # on the 'S' in 'sql') we nevertheless reference the external module via
+    # this local instance variable to help avoid typo-related errors
+    require 'mysql'
+    @@mysql = Mysql # The 3p library we're working on top of
+
+    extend BitGirder::Core::BitGirderMethods
+
+    def self.connect_from_hash( h )
+
+        flattened = h.values_at( :host, :user, :password, :db, :port, :socket )
+        flattened << ( h[ :flag ] || 0 )
+
+        @@mysql.connect( *flattened )
+    end 
+    
+    def self.connect( *argv )
+        
+        case argv.size
+            
+            when 0 then raise "Need connect args"
+
+            when 1
+                case argv[ 0 ]
+                    when Hash then connect_from_hash( argv[ 0 ] )
+                    else @@mysql.connect( *argv ) # assume passthrough args
+                end
+
+            else raise ArgumentError, "Unexpected argv: #{argv}"
+        end
+    end
+
+    def self.open( *argv )
+ 
+        mysql = connect( *argv )
+
+        begin
+            yield( mysql )
+        ensure
+            mysql.close
+        end
+    end
+
+    def self.flush_privileges( db )
+        
+        not_nil( db, :db )
+        db.query( "flush privileges" )
+    end
+
+    def self.quote( str )
+        @@mysql.quote( str )
+    end
+
+end
+end

data/lib/bitgirder/ops/java.rb

@@ -0,0 +1,117 @@
+require 'bitgirder/core'
+require 'bitgirder/io'
+
+module BitGirder
+module Ops
+module Java
+
+include BitGirder::Core
+
+module JavaEnvironments
+
+    extend BitGirder::Core::BitGirderMethods
+
+    ENV_JAVA_HOME = "JAVA_HOME"
+
+    def get_java_home
+
+        if res = ENV[ ENV_JAVA_HOME ]
+            if File.exist?( res )
+                res
+            else
+                raise 
+                    "Location specified in #{ENV_JAVA_HOME} doesn't exist: " +
+                    res
+            end
+        else
+            if jv = Io.which( "java" )
+                File.dirname( File.dirname( jv ) )
+            else
+                raise "#{ENV_JAVA_HOME} is not set and no 'java' found on path"
+            end
+        end
+    end
+
+    module_function :get_java_home
+end
+
+class JavaEnvironment < BitGirderClass
+
+    include BitGirder::Io
+    
+    bg_attr :java_home, :validation => :file_exists
+
+    public
+    def jcmd( cmd )
+        
+        not_nil( cmd, :cmd )
+        file_exists( "#@java_home/bin/#{cmd}" )
+    end
+
+    public
+    def as_classpath( val )
+        
+        if val.respond_to?( :join )
+            val.join( ":" )
+        else
+            val.to_s
+        end
+    end
+
+    def self.get_default
+        self.new( :java_home => JavaEnvironments.get_java_home )
+    end
+end
+
+class JavaRunner < BitGirderClass
+
+    bg_attr :java_env
+    bg_attr :command
+    bg_attr :classpath, :default => proc { [] }
+    bg_attr :jvm_args, :default => proc { [] }
+    bg_attr :sys_props, :default => proc { {} }
+    bg_attr :argv, :validation => :not_empty
+    bg_attr :proc_env, :default => proc { {} }
+    bg_attr :proc_opts, :default => proc { {} }
+
+    private
+    def create_jv_argv
+        
+        res = []
+ 
+        unless @classpath.empty?
+            res << "-classpath" << @java_env.as_classpath( @classpath )
+        end
+
+        res += @jvm_args
+        @sys_props.each_pair { |k, v| res << "-D#{k}=#{v}" }
+        res += argv
+
+        res.map { |v| v.to_s }
+    end
+
+    public
+    def process_builder
+
+        BitGirder::Io::UnixProcessBuilder.new(
+            :cmd => @java_env.jcmd( @command ),
+            :argv => create_jv_argv,
+            :env => @proc_env,
+            :opts => @proc_opts
+        )
+    end
+ 
+    def self.create_application_runner( opts )
+
+        not_nil( opts, :opts )
+
+        argv = [ has_key( opts, :main ) ]
+        argv += ( opts[ :argv ] || [] )
+
+        JavaRunner.new( opts.merge( :command => "java", :argv => argv ) )
+    end
+end
+
+end
+end
+end

data/lib/bitgirder/ops/ruby.rb

@@ -0,0 +1,235 @@
+require 'bitgirder/core'
+require 'bitgirder/io'
+
+module BitGirder
+module Ops
+module Ruby
+
+module RubyEnvVarNames
+    ENV_GEM_HOME = "GEM_HOME"
+    ENV_RUBYLIB = "RUBYLIB"
+    ENV_PATH = "PATH"
+end
+
+module RubyIncludes
+
+    extend BitGirder::Core::BitGirderMethods
+
+    extend BitGirder::Io
+        
+    # clean up adjacent slashes and other things that can be unsightly and in
+    # some cases cause more serious problems
+    def self.clean_include_dir_names( dirs )
+        
+        dirs.map { |dir| dir.gsub( %r{/+}, "/" ) }.
+             map { |dir| dir.sub( %r{/$}, "" ) }
+    end
+ 
+    def self.get_single_dir( dir, pat )
+
+        res = 
+            Dir.chdir( dir ) do |dir|
+                Dir.glob( "*" ).
+                    select { |f| File.directory?( f ) }.
+                    grep( pat )
+            end
+ 
+        case res.size
+
+            when 0 then nil
+            when 1 then res[ 0 ]
+            else raise "Multiple directories in #{dir} match #{pat}"
+        end
+    end
+ 
+    def self.expect_single_dir( dir, pat )
+
+        self.get_single_dir( dir, pat ) or
+            raise "Couldn't find entry in #{dir} matching #{pat}"
+    end
+
+    def self.infer_version_str( lib_dir )
+        self.expect_single_dir( lib_dir, /^\d+(?:\.\d+)*$/ )
+    end
+
+    def self.get_arch_dir( dir )
+
+        self.get_single_dir( 
+            dir, /^(?:i\d86|x86_64).*(?:darwin|linux|solaris)/ )
+    end
+
+    def self.get_ruby_include_dirs( opts )
+
+        ruby_home = has_key( opts, :ruby_home )
+        lib_dir = file_exists( "#{ruby_home}/lib/ruby" )
+
+        ver = opts[ :version ] || self.infer_version_str( lib_dir )
+
+        res = [ "", "site_ruby", "vendor_ruby" ].inject( [] ) do |res, dir|
+            
+            dir = file_exists( "#{lib_dir}/#{dir}/#{ver}" )
+            res << dir
+
+            if arch_dir = self.get_arch_dir( dir )
+                res << "#{dir}/#{arch_dir}"
+            end
+
+            res
+        end
+
+        self.clean_include_dir_names( res )
+    end
+
+    def self.as_include_argv( incl_dirs )
+        incl_dirs.map { |dir| [ "-I", dir ] }.flatten
+    end
+end
+
+class RubyContext < BitGirderClass
+
+    require 'set'
+
+    bg_attr :id
+    bg_attr :gem_home, validation: :file_exists
+    bg_attr :ruby_home, validation: :file_exists
+    bg_attr :ruby_flavor, required: false
+    bg_attr :env, default: {}
+
+    def rcmd( cmd, alts = true )
+        
+        not_nil( cmd, :cmd )
+
+        cmds = [ cmd ]
+        cmds << "j#{cmd}" if alts
+
+        bin_dirs = [ @gem_home, @ruby_home ].map { |dir| "#{dir}/bin" }
+        files = bin_dirs.map { |bd| cmds.map { |cmd| "#{bd}/#{cmd}" } }.flatten
+        
+        files.find { |f| File.exist?( f ) } or
+            raise "No #{cmd} in #{bin_dirs.join( " or " )}"
+    end
+
+    def prepend_path_ruby_home
+        "#@gem_home/bin:#@ruby_home/bin:#{ENV[ ENV_PATH ]}"
+    end
+
+    def get_ruby_include_dirs
+
+        if @ruby_flavor == "jruby"
+            []
+        else
+            RubyIncludes.get_ruby_include_dirs( ruby_home: @ruby_home )
+        end
+    end
+
+    def get_env_var_rubylib
+        
+        res = get_ruby_include_dirs.join( ":" )
+
+        if prev = ENV[ ENV_RUBYLIB ]
+            res << ":#{prev}"
+        end
+
+        res
+    end
+
+    def proc_builder_opts( cmd = nil )
+        
+        opts = { opts: {}, argv: [] }
+
+        opts[ :env ] = @env.merge( 
+            ENV_GEM_HOME => @gem_home,
+            ENV_PATH => prepend_path_ruby_home,
+        )
+
+        opts[ :cmd ] = rcmd( cmd ) if cmd
+
+        opts
+    end
+
+    def self.read_env_in( s )
+        
+        ( s[ :env ] || [] ).inject( {} ) do |env, pair|
+            
+            nm, val = pair[ 0 ], pair[ 1 ]
+
+            if env.key?( nm )
+                raise "Multiple definitions of env var #{nm}"
+            else
+                env[ nm ] = val
+            end
+
+            env
+        end
+    end
+
+    def self.from_mingle_struct( s )
+        
+        self.new(
+            id: s.expect_string( :id ),
+            ruby_home: s.expect_string( :ruby_home ),
+            gem_home: s.expect_string( :gem_home ),
+            ruby_flavor: s.get_string( :ruby_flavor ),
+            env: read_env_in( s )
+        )
+    end
+end
+
+class RubyEnv < BitGirderClass
+
+    bg_attr :rubies
+    bg_attr :default_id, required: false # name of default ruby
+
+    def initialize( *argv )
+        
+        super( *argv )
+
+        if @default_id
+            unless @rubies.key?( @default_id )
+                raise "Default id #@default_id not a defined ruby"
+            end
+        end
+    end
+
+    def get_context( id = nil )
+        
+        if id 
+            @rubies[ id ] or raise "No ruby context with id: #{id}"
+        else
+            if @default_id
+                @rubies[ @default_id ] or 
+                    raise "Default context #@default_id not set (!?)"
+            else
+                raise "No default ruby context set"
+            end
+        end
+    end
+
+    def self.read_rubies_in( s )
+        
+        ( s[ :rubies ] || [] ).inject( {} ) do |res, mg_ctx|
+            
+            ctx = RubyContext.from_mingle_struct( mg_ctx )
+
+            if res.key?( ctx.id )
+                raise "Env has multiple ruby contexts with id: #{ctx.id}"
+            else
+                res[ ctx.id ] = ctx
+            end
+
+            res
+        end
+    end
+
+    def self.from_mingle_struct( s )
+        
+        self.new( 
+            rubies: self.read_rubies_in( s ),
+            default_id: s.get_string( :default_ruby ),
+        )
+    end
+end
+
+end
+end
+end

data/lib/bitgirder/testing.rb

@@ -0,0 +1,152 @@
+require 'bitgirder/core'
+
+module BitGirder
+module Testing
+
+ENV_TEST_DATA_PATH = "TEST_DATA_PATH"
+
+def self.find_test_data( name )
+    
+    ( ENV[ ENV_TEST_DATA_PATH ] || "" ).split( ":" ).
+        map { |path| "#{path}/#{name}" }.
+        find { |f| File.exists?( f ) } or
+        raise "No #{name} found on path $#{ENV_TEST_DATA_PATH}"
+end
+
+class AssertionFailure < StandardError; end
+
+module BeforePhase; end
+module TestPhase; end
+module AfterPhase; end
+
+module AssertMethods
+
+    include BitGirder::Core::BitGirderMethods
+
+    def fail_test( msg = nil )
+        
+        msg = msg.call if msg.is_a?( Proc )
+        raise AssertionFailure.new( msg )
+    end
+
+    def assert( passed, msg = nil )
+        fail_test( msg ) unless passed
+    end
+
+    def assert_false( val, *argv )
+        assert( ! val, *argv )
+    end
+
+    def assert_equal( expct, actual, msg = nil )
+        
+        unless expct == actual
+            fail_test( msg || "expct != actual (#{expct} != #{actual})" )
+        end
+    end
+
+    def assert_equal_meth( expct_obj, actual_obj, meth, msg = nil )
+        
+        not_nil( meth, :meth )
+        assert_equal( expct_obj.send( meth ), actual_obj.send( meth ), msg )
+    end
+
+    def assert_equal_i( expct, actual, msg = nil )
+        assert_equal_meth( expct, actual, :to_i, msg )
+    end
+
+    def assert_equal_s( expct, actual, msg = nil )
+        assert_equal_meth( expct, actual, :to_s, msg )
+    end
+
+    def assert_nil( val, msg = nil )
+        assert( val == nil, msg ||= "Expected nil but got #{val}" )
+    end
+
+    def assert_match( pat, str, msg = nil )
+
+        msg ||= lambda { "#{str.inspect} does not match #{pat}" }
+        assert( pat.match( str ), msg )
+    end
+
+    def get_expect_raised_pat( excpts )
+            
+        case excpts[ 0 ]
+            when String then Regexp.new( /^#{Regexp.quote( excpts.shift )}$/ )
+            when Regexp then excpts.shift
+            else nil
+        end
+    end
+
+    def assert_raised( *excpts )
+        
+        res = nil
+
+        pat = get_expect_raised_pat( excpts )
+
+        begin
+            yield
+        rescue *excpts => e; # got an expected exception
+            res = e
+        rescue Exception => e
+            raise e
+        end
+
+        if pat && res
+            pat.match( res.message ) or 
+                raise "Message #{res.message.inspect} does not match #{pat}"
+        end
+
+#        res or raise "No expected exception raised"
+        res or fail_test( "Expected raise of one of #{excpts.inspect}" )
+    end
+end
+
+#def assert_raise( *argv, &blk ); assert_raised( *argv, &blk ); end
+
+# May also have a base class TestClass for classes that want it
+module TestClassMixin
+    include AssertMethods
+end
+
+class AbstractPhaseClass < BitGirder::Core::BitGirderClass
+
+    include AssertMethods
+
+    bg_abstract :start_impl
+
+    public
+    def start_invocation( ctx )
+
+        @ctx = ctx
+        start_impl
+    end
+
+    private
+    def inst_set( fld, val )
+
+        not_nil( fld, :fld )
+        @ctx.inst.instance_variable_set( :"@#{fld}", val )
+    end
+
+    private
+    def inst_get( fld )
+
+        not_nil( fld, :fld )
+        @ctx.inst.instance_variable_get( :"@#{fld}" )
+    end
+end
+
+class TestHolder < BitGirder::Core::BitGirderClass
+
+    def self.inherited( by )
+        by.send( :include, TestClassMixin )
+    end
+end
+
+class TestRunClass < AbstractPhaseClass
+    include TestClassMixin
+    include TestPhase
+end
+
+end
+end

data/lib/doc-gen17.rb

@@ -0,0 +1,14 @@
+
+# Autogenerated docs on 2012-11-21 11:47:21 -0800
+#
+
+# This code is only included for rdoc purposes and would not normally get
+# required. Even so, in case of overzealous scripts which might auto-require
+# this file, we enclose the entire body of this file in a guard that will
+# prevent it from being interpreted in an actual run
+#
+if false
+
+
+end # 'if false...' block
+