Ruby on zLinux

Ruby
1

We are trying to install the MySQL gem on RH51
running under zVM.

Install MySQL gem as follows:
gem install mysql – --with-mysql-config=/usr/lib/mysql/mysql_config

It errors out with

cat /mysql-2.5.1/mkmf.log | less

cc1: error: unrecognized command line option “-mesa-mzarch”

There appears to be a space missing between the -mesa and
-mzarch.

Can I add the space? and if so where?

thank you

eric

2

Eric K. Dickinson wrote:

Am I in the right thread for this?

Should there be another group/ML that
where I should post this?

eric

3

On Wed, May 28, 2008 at 4:22 AM, Eric K. Dickinson
[email protected] wrote:

Am I in the right thread for this?

Yes, but it’s such a trivial issue –

cc1: error: unrecognized command line option “-mesa-mzarch”

There appears to be a space missing between the -mesa and
-mzarch.

Can I add the space?

Of course; why would you even hesitate?

and if so where?

Wherever find and grep turn up that string, I’d think :slight_smile:

FWIW,

4

Hassan S. wrote:

-mzarch.

Can I add the space?

Of course; why would you even hesitate?

and if so where?

Wherever find and grep turn up that string, I’d think :slight_smile:

FWIW,

I have been looking for it with find and grep.

I have not been able to find where the line is
assembled from.

I will not hesitate once I find it.

Thank you

eric

5

In the following PHP function, both ‘types’ and ‘groups’ are associative
arrays. I’m trying to rewrite this function in Ruby, using Hashes and I
haven’t yet got it right. If someone with some insight into PHP and Ruby
could give it a look and see where my current code might be incorrect, I
'd appreciate any pointers that might correct the results. The PHP
function is working; the Ruby version is not (yet) working. TIA for any
tips, criticism and suggestions that you can submit.

– Steve

The original PHP function:
$this->types = array(
‘aac’ => ‘audio/x-aac’,
‘ai’ => ‘application/postscript’,
‘aif’ => ‘audio/x-aiff’,
‘aiff’ => ‘audio/x-aiff’,
‘asf’ => ‘video/x-ms-asf’,
‘asx’ => ‘video/x-ms-asx’,
‘avi’ => ‘video/avi’
);

$groups[‘office’] =
array(‘csv’,‘doc’,‘dot’,‘pdf’,‘pot’,‘pps’,‘ppt’,‘rtf’,‘txt’,‘xls’);
$groups[‘image’] =
array(‘ai’,‘bmp’,‘dxf’,‘eps’,‘gif’,‘ico’,‘jpg’,‘jpe’,‘jpeg’,‘pdf’,‘png’,‘ps’,‘swf’,‘tif’,‘tiff’,‘wmf’);
$groups[‘compressed’] =
array(‘bin’,‘bz’,‘bz2’,‘gz’,‘sit’,‘tar’,‘tgz’,‘z’,‘zip’);
$groups[‘video’] =
array(‘asf’,‘asx’,‘avi’,‘mov’,‘mpg’,‘mpeg’,‘mp4’,‘qt’,‘ra’,‘ram’,‘swf’,‘wmv’);
$groups[‘audio’] = array(‘mp3’,‘m4a’,‘ra’,‘ram’,‘wav’,‘wma’);
$groups[‘web’] =
array(‘css’,‘gif’,‘ico’,‘jpg’,‘jpeg’,‘js’,‘htm’,‘html’,‘pdf’,‘php’,‘phps’,‘png’,‘shtml’,‘sql’);
$groups[‘media’] =
array(‘mp3’,‘jpg’,‘mpg’,‘mpeg’,‘vob’,‘avi’,‘wma’,‘wmv’,‘bmp’,‘jpeg’,‘aac’,‘wav’);

/*

  • Return array of mime types
  • @param string/bool $group_type
  • @return array
    */
    public function getTypes($group_type=false) {
    if(!$group_type) {
    return $this->types;
    }
    else {
    if(array_key_exists($group_type,$this->groups)) {
    foreach($this->types as $key => $mt) {
    if(in_array($key,$this->groups[$group_type])) {
    $types[$key] = $mt;
    }
    }
    return $types;
    }
    else {
    return false;
    }
    }
    }

The current Ruby translated function:
types = { ‘aac’ => ‘audio/x-aac’,
‘ai’ => ‘application/postscript’,
‘aif’ => ‘audio/x-aiff’,
‘aiff’ => ‘audio/x-aiff’,
‘asf’ => ‘video/x-ms-asf’,
‘asx’ => ‘video/x-ms-asx’,
‘avi’ => ‘video/avi’
}
groups = {‘office’ =>
[‘csv’,‘doc’,‘dot’,‘pdf’,‘pot’,‘pps’,‘ppt’,‘rtf’,‘txt’,‘xls’],
‘image’ =>
[‘ai’,‘bmp’,‘dxf’,‘eps’,‘gif’,‘ico’,‘jpg’,‘jpe’,‘jpeg’,‘pdf’,‘png’,‘ps’,‘swf’,‘tif’,‘tiff’,‘wmf’],
‘compressed’ =>
[‘bin’,‘bz’,‘bz2’,‘gz’,‘sit’,‘tar’,‘tgz’,‘z’,‘zip’],
‘video’ =>
[‘asf’,‘asx’,‘avi’,‘mov’,‘mpg’,‘mpeg’,‘mp4’,‘qt’,‘ra’,‘ram’,‘swf’,‘wmv’],
‘audio’ => [‘mp3’,‘m4a’,‘ra’,‘ram’,‘wav’,‘wma’],
‘web’ =>
[‘css’,‘gif’,‘ico’,‘jpg’,‘jpeg’,‘js’,‘htm’,‘html’,‘pdf’,‘php’,‘phps’,‘png’,‘shtml’,‘sql’],
‘media’ =>
[‘mp3’,‘jpg’,‘mpg’,‘mpeg’,‘vob’,‘avi’,‘wma’,‘wmv’,‘bmp’,‘jpeg’,‘aac’,‘wav’]
}
#---------------------------------

Return array of mime types

#---------------------------------
def getTypes(grp_type)
res_types=Hash.new
if(!grp_type) then
@types
else
if(groups.has_key?(grp_type)) then
types.each do |k,v|
if(groups[grp_type].has_value?(v)) then
res_types[k]=v
end
end
else
res_types=false
end
end
res_types
end

6

On Thu, May 29, 2008 at 11:57 PM, S.D [email protected] wrote:

The original PHP function:
$groups[‘office’] =
$groups[‘media’] =
return $this->types;
else {
return false;
}
}
}

The current Ruby translated function:

  • types = { ‘aac’ => ‘audio/x-aac’,
  • TYPES = { ‘aac’ => ‘audio/x-aac’, # if it won’t change, make it a
    constant
         'ai'    => 'application/postscript',
         'aif'   => 'audio/x-aiff',
         'aiff'  => 'audio/x-aiff',
         'asf'   => 'video/x-ms-asf',
         'asx'   => 'video/x-ms-asx',
         'avi'   => 'video/avi'
  }
  • groups = {‘office’ =>
  • GROUPS = {‘office’ => # the same

[‘mp3’,‘jpg’,‘mpg’,‘mpeg’,‘vob’,‘avi’,‘wma’,‘wmv’,‘bmp’,‘jpeg’,‘aac’,‘wav’]
}
#---------------------------------

Return array of mime types

#---------------------------------
def get_types(group_type = nil) # in ruby lowercase_and_underscores
are used for methods and variables by convention
return TYPES unless group_type # == if !group_type == if
group_type.nil?
return false unless GROUPS.has_key?(group_type) # no need to write
‘then’ or parentheses
GROUPS[group_type].inject({}) {|types, ext| types[ext] =
TYPES[ext] ; TYPES }
end

or replace the last line with

Hash[*GROUPS[group_type].collect {|ext| ext, types[ext]}.flatten] #
alternative 2

or

def …
case group_type
when nil, false
TYPES
when *GROUP.keys
GROUPS[group_type].inject({}) {|types, ext| types[ext] =
TYPES[ext] ; TYPES }
else
false
end
end

WARNING: not tested code, might contain bugs!

7

S.D wrote:

The original PHP function:
[…]
}
return $types;
}
else {
return false;
}
}
}

Hi Steve!

This is my take. I shuffled things around a bit, e.g. using constants
instead of variables, but you’ll figure it out …

def types group = nil
return TYPES unless group
return nil unless GROUPS.include? group
Hash[*TYPES.select {|suffix, mime_type| GROUPS[group].include?
suffix}.flatten]
end

HTH,
jwm

8

In article [email protected], “S.D” [email protected]
wrote:

def getTypes(grp_type)
res_types=Hash.new
if(!grp_type) then

Only FalseClass and NilClass are false in Ruby, so if it can be an empty
string you need to check that differently

 @types

Since the if/end is not the last expression in the function this will
never be returned as a value. Use explicit return.

end
res_types
end

You might be better off rewriting from scratch than translating from
PHP. You could start by documenting what the functions do :wink:

9
Jörg W Mittag wrote: 
S.D wrote:
  
In the following PHP function, both 'types' and 
'groups' are associative
arrays. I'm trying to rewrite this function in Ruby, using Hashes and I
haven't yet got it right. If someone with some insight into PHP and Ruby
could give it a look and see where my current code might be incorrect, I
'd appreciate any pointers that might correct the results. The PHP
function is working; the Ruby version is not (yet) working. TIA for any
tips, criticism and suggestions that you can submit.

– Steve


The original PHP function:


[...]
  
public function getTypes($group_type=false) {
  if(!$group_type) {
    return $this->types;
  }
  else {
    if(array_key_exists($group_type,$this->groups)) {
      foreach($this->types as $key => $mt) {
        if(in_array($key,$this->groups[$group_type])) {
          $types[$key] = $mt;
        }
      }
      return $types;
    }
    else {
      return false;
    }
  }
}

</pre>


  
Hi Steve!

This is my take. I shuffled things around a bit, e.g. using constants

instead of variables, but you’ll figure it out …


def types group = nil

return TYPES unless group

return nil unless GROUPS.include? group

Hash[*TYPES.select {|suffix, mime_type| GROUPS[group].include?

suffix}.flatten]

end


HTH,

jwm
Hi Joerg,

Great example! I don't quite understand the pointer(*) notation you are using in ruby. How would "Hash[*TYPES.select" differ from "Hash[TYPES.select"?
Is one a pointer to the Hash and the other the Hash itself? I thought Ruby did not have pointers. When I remove the '*', I get the following error in irb:

ArgumentError: odd number of arguments for Hash

Can you tell me what the '*' before the TYPES in your example changes the reference to TYPES?

Also, I understand that you've converted TYPES and GROUPS to global Hashes, but the same notation should work if these globals were embedded in a class.

Assuming class members @types is a hash of mime types => mime descriptions and @groups is a hash of group type names => [array of file extensions]

My final result, that appears to work as the PHP function did, is this:

def getTypes(group_type=nil)
  return @types unless group_type
  return nil unless @groups.include? group_type
  Hash[*@types.select {|suffix_name,mime_type| @groups[group_type].include? suffix}.flatten]
end

Thanks for your great help.

-- Steve

P.S. - Do you have any spare cycles to take on some Ruby consulting work?
10

On Fri, May 30, 2008 at 11:50 AM, S.D [email protected] wrote:

Great example! I don’t quite understand the pointer(*) notation you are
using in ruby. How would “Hash[*TYPES.select” differ from
“Hash[TYPES.select”?

  • is not pointer notation here. One way to think about it is that it
    takes an Enumerable object and turns it into a list of individual
    objects, ala…

[1, 2, 3] #one thing

…becomes…

1, 2, 3 #three things

hth,
Todd

11

I’ve had some luck with installing the mysql binary from source
[instead of the gem]
but that obviously wouldn’t fix the root of the problem you’re
describing.
-R

12

On Fri, May 30, 2008 at 6:50 PM, S.D [email protected] wrote:

Great example! I don’t quite understand the pointer(*) notation you are
using in ruby. How would “Hash[*TYPES.select” differ from
“Hash[TYPES.select”?
Is one a pointer to the Hash and the other the Hash itself? I thought Ruby
did not have pointers.

  • is not a pointer, it is so-called splat operator (google: ruby
    splat). It “expands” arrays.
    When you call f(*array) and array is [1,2,3] it has the same effect as
    calling f(1,2,3).
    Another useful pattern is:

COLORS = [‘red’, ‘green’, ‘blue’]
DAYS = [‘monday’, sunday’]

case word
when *COLORS
puts “#{word} is a Color!”
when *DAYS
puts “#{word} is a Day!”
end

For better explanation see google.

13

I’m sorry. I thought this is where one would
go to report a bug?

Any idea where I would report this?

eric

14

Roger P. wrote:

I’ve had some luck with installing the mysql binary from source
[instead of the gem]
but that obviously wouldn’t fix the root of the problem you’re describing.
-R

Thank you for the reply. There seems to be a bug in
ruby on zLinux. This is not easy to chase down.

eric

15

Eric K. Dickinson wrote:

Roger P. wrote:

I’ve had some luck with installing the mysql binary from source
[instead of the gem]
but that obviously wouldn’t fix the root of the problem you’re
describing.
-R

Thank you for the reply. There seems to be a bug in
ruby on zLinux. This is not easy to chase down.

If you have access to Java on that machine, you may be able to run
JRuby. It would also support all the same JDBC drivers for database
access that other platforms support.

  • Charlie