Ruby on zLinux

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 wrote:

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

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,

···

On Wed, May 28, 2008 at 4:22 AM, Eric K. Dickinson <eric.dickinson@nih.gov> wrote:
--
Hassan Schroeder ------------------------ hassan.schroeder@gmail.com

Hassan Schroeder wrote:

···

On Wed, May 28, 2008 at 4:22 AM, Eric K. Dickinson > <eric.dickinson@nih.gov> 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,

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

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

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!

···

On Thu, May 29, 2008 at 11:57 PM, S.D <s.d@comcast.net> 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;
    }
  }
}

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

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

* 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.

···

On Fri, May 30, 2008 at 6:50 PM, S.D <s.d@comcast.net> 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 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

···

On Fri, May 30, 2008 at 11:50 AM, S.D <s.d@comcast.net> 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"?