Ruby on zLinux

[Eric K. Dickinson]

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

 

[Eric K. Dickinson]

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

Am I in the right thread for this?

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

eric

 

[Hassan Schroeder]

Am I in the right thread for this?

Yes, but it's such a trivial issue --

Of course; why would you even hesitate?

Wherever `find` and `grep` turn up that string, I'd think

FWIW,

 

[Eric K. Dickinson]

Yes, but it's such a trivial issue --


Of course; why would you even hesitate?


Wherever `find` and `grep` turn up that string, I'd think

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

 

[S.D]

[Note: parts of this message were removed to make it a legal post.]

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

 

[Tobias Weber]

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.

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

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

 

[Jano Svitok]

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',
+ 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

['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 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!

 

[Jörg W Mittag]

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;
}
}
}

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

 

[Todd Benson]

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

 

[Jano Svitok]

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.