gphoto4ruby 0.1.0 → 0.1.1

data/CHANGELOG.rdoc

@@ -0,0 +1,12 @@
+== master
+
+* Added rdoc comments
+* Added saving captured image to specified folder
+* Added folders browsing
+* Added folders and files listing
+
+== 0.1.0
+
+* Initial import
+* Camera configuration (limited to radio-button and float type of items)
+* Camera capture image command

data/README.rdoc

@@ -0,0 +1,38 @@
+= GPhoto4Ruby
+
+== Summary
+
+GPhoto4Ruby is Ruby wrapping around libgphoto2 C library
+(See http://gphoto.org for more information on libgphoto2 and gphoto2).
+It maps a digital camera to Ruby object and allows operating it by
+calling object methods.
+
+  c = GPhoto2::Camera.new
+  c[:exptime] = "0.010" # you can list values with c[:exptime, :all]
+  c["f-number"] = "f/4.5"
+  c.capture
+
+== Installation
+
+* First of all you'll need the original gphoto2 C library installed. For
+  installation instructions goto http://gphoto.org.
+
+* Apparently this GitHub will not build this Gem due to "$SAFE problem".
+  So you can download it from http://rubyforge.org/projects/gphoto4ruby/
+  and install it with:
+
+    sudo gem install gphoto4ruby-version.gem
+  
+* Plug your digital camera through usb and run:
+
+    ruby example.rb
+
+== Usage
+
+See example.rb
+
+== Contact
+
+neq4 company:: http://neq4.com
+Sergey Kruk:: sergey.kruk@gmail.com
+

data/Rakefile

@@ -0,0 +1,16 @@
+require "rubygems"
+require "rake"
+require "rake/rdoctask"
+
+desc "Generate RDoc documentation for gphoto4ruby gem."
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+    rdoc.rdoc_files.include("README.rdoc", "LICENSE", "CHANGELOG.rdoc").
+            include("docs/COPYING", "docs/COPYING.LESSER").
+            include("ext/gphoto4ruby.c")
+    rdoc.main = "README.rdoc"
+    rdoc.title = "GPhoto4Ruby documentation"
+    rdoc.rdoc_dir = "docs"
+    rdoc.options << "--charset=UTF-8"
+    rdoc.options << "--webcvs=http://github.com/lonelyelk/gphoto4ruby/tree/master"
+end

data/example.rb

@@ -0,0 +1,40 @@
+require "rubygems"
+require "gphoto4ruby"
+
+ports = GPhoto2::Camera.ports
+if ports.empty?
+    # ports array can be empty if there is only one camera plugged in
+    # or there are no cameras connected to the computer
+    # assuming there is one
+    c = GPhoto2::Camera.new()
+    c.configs.each do |cfg|
+        puts cfg + " value is: " + c[cfg].to_s
+        puts "values available are: " + c[cfg, :all].inspect
+    end
+    c.capture
+    puts "files on camera: " + c.files.inspect
+    puts "some folder stuff: " + c.folder_up.subfolders.inspect
+else
+    puts ports.length.to_s + "cameras connected"
+    cams = []
+    ports.each do |port|
+        c = GPhoto2::Camera.new(port)
+        puts "camera in port: " + port
+        c.configs.each do |cfg|
+            puts cfg + " value is: " + c[cfg].to_s
+            puts "values available are: " + c[cfg, :all].inspect
+        end
+        c.capture
+        puts "files on camera: " + c.files.inspect
+        puts "some folder stuff: " + c.folder_up.subfolders.inspect
+        cams.push c
+    end
+    # to capture image with all attached cameras at a time use:
+    cams.each_index do |index|
+        if index < cams.length - 1
+            fork {cams[index].capture; exit!}
+        else
+            cams[index].capture
+        end
+    end
+end

data/ext/gphoto4ruby.c

@@ -22,18 +22,12 @@
 
 #include <stdlib.h>
 #include <stdio.h>
+#include <fcntl.h>
 #include <string.h>
 #include <gphoto2/gphoto2.h>
 #include <ruby.h>
 #include "gphoto4ruby.h"
 
-
-static VALUE rb_mGPhoto2;
-static VALUE rb_cGPhoto2Camera;
-static VALUE rb_cGPhoto2Exception;
-static VALUE rb_cGPhoto2ConfigurationError;
-static VALUE rb_cGPhoto2ProgrammerError;
-
 static void rb_raise_gp_result(int retval) {
     rb_raise(rb_cGPhoto2Exception, "LibGPhoto2 function returned: %s", gp_result_as_string(retval));
 }
@@ -208,7 +202,10 @@ static void camera_free(GPhoto2Camera *c) {
     int retval;
     retval = gp_camera_exit(c->camera, c->context);
     retval = gp_widget_free(c->config);
+    retval = gp_list_free(c->list);
+    retval = gp_file_free(c->file);
     retval = gp_camera_free(c->camera);
+    free(c->virtFolder);
     free(c->context);
     free(c);
 }
@@ -217,18 +214,40 @@ static VALUE camera_allocate(VALUE klass) {
     int retval;
     GPhoto2Camera *c;
     c = (GPhoto2Camera*) malloc(sizeof(GPhoto2Camera));
+    c->virtFolder = (char*) malloc(sizeof(char)*100);
+    strcpy(c->virtFolder, "/");//store_00010001/DCIM/100NCD80/");
+//    c->path = "/store_00010001";
     c->context = gp_context_new();
     retval = gp_camera_new(&(c->camera));
     if (retval == GP_OK) {
-        retval = gp_camera_get_config(c->camera, &(c->config), c->context);
+        retval = gp_list_new(&(c->list));
         if (retval == GP_OK) {
-            return Data_Wrap_Struct(klass, camera_mark, camera_free, c);
+            retval = gp_camera_get_config(c->camera, &(c->config), c->context);
+            if (retval == GP_OK) {
+                retval = gp_file_new(&(c->file));
+                if (retval == GP_OK) {
+                    return Data_Wrap_Struct(klass, camera_mark, camera_free, c);
+                }
+            }
         }
     }
     rb_raise_gp_result(retval);
     return Qnil;
 }
 
+/*
+ * call-seq:
+ *   GPhoto2::Camera.new(port=nil)
+ *
+ * Returns camera object. Camera should be connected at a time constructor
+ * is called. If there is more than one camera connected through usb ports,
+ * port parameter can be passed to specify which camera is addressed with
+ * object.
+ *
+ *   GPhoto2::Camera.new
+ *   GPhoto2::Capera.new(GPhoto2::Camera.ports[0])
+ *
+ */
 static VALUE camera_initialize(int argc, VALUE *argv, VALUE self) {
     switch (argc) {
         case 0:
@@ -270,6 +289,19 @@ static VALUE camera_initialize(int argc, VALUE *argv, VALUE self) {
     }
 }
 
+/*
+ * call-seq:
+ *   GPhoto2::Camera.ports          =>      array
+ *
+ * Returns an array of usb port paths with cameras. If only one camera
+ * is connected, returned array is empty.
+ *
+ *   # with one camera connected
+ *   GPhoto2::Camera.ports          #=>     []
+ *   # with two cameras connected
+ *   GPhoto2::Camera.ports          #=>     ["usb:005,004", "usb:005,006"]
+ *
+ */
 static VALUE camera_class_ports(VALUE klass) {
     int retval, i, portsTotal;
     GPPortInfoList *portInfoList;
@@ -298,15 +330,26 @@ static VALUE camera_class_ports(VALUE klass) {
     return Qnil;
 }
 
+/*
+ * call-seq:
+ *   capture                        =>      camera
+ *
+ * Sends command to camera to capture image with current configuration
+ *
+ *   c = GPhoto2::Camera.new
+ *   c.capture
+ *
+ */
 static VALUE camera_capture(VALUE self) {
     int retval;
     GPhoto2Camera *c;
 
     Data_Get_Struct(self, GPhoto2Camera, c);
 
-    retval = gp_camera_capture(c->camera, GP_CAPTURE_IMAGE, &(c->filepath), c->context);
+    retval = gp_camera_capture(c->camera, GP_CAPTURE_IMAGE, &(c->path), c->context);
     if (retval == GP_OK) {
-//        printf("captured: %s/%s\n", c->filepath.folder, c->filepath.name);
+        strcpy(c->virtFolder, c->path.folder);
+        printf("captured: %s/%s\n", c->path.folder, c->path.name);
         return self;
     } else {
         rb_raise_gp_result(retval);
@@ -314,6 +357,89 @@ static VALUE camera_capture(VALUE self) {
     }
 }
 
+/*
+ * call-seq:
+ *   capture_save(folder="")        =>      camera
+ *
+ * Sends command to camera to capture image with current configuration
+ * and saves file into specified folder with the same filename as on
+ * camera file system.
+ *
+ *   c = GPhoto2::Camera.new
+ *   c.capture_save "/home"
+ *
+ */
+static VALUE camera_capture_save(int argc, VALUE *argv, VALUE self) {
+    int retval;
+    GPhoto2Camera *c;
+    const char *fData;
+    char *fPath;
+    char fName[100];
+    unsigned long int fSize;
+    int fd;
+    
+    if (argc > 1) {
+        rb_raise(rb_eArgError, "Wrong number of arguments (%d for 0 or 1)", argc);
+        return Qnil;
+    }
+    
+    Data_Get_Struct(self, GPhoto2Camera, c);
+
+    retval = gp_camera_capture(c->camera, GP_CAPTURE_IMAGE, &(c->path), c->context);
+    if (retval == GP_OK) {
+        strcpy(c->virtFolder, c->path.folder);
+        if (retval == GP_OK) {
+            retval = gp_camera_file_get(c->camera, c->path.folder, c->path.name, GP_FILE_TYPE_NORMAL, c->file, c->context);
+            if (retval == GP_OK) {
+                retval = gp_file_get_data_and_size(c->file, &fData, &fSize);
+                if (retval == GP_OK) {
+                    if (argc == 1)  {
+                        fPath = RSTRING(argv[0])->ptr;
+                        if (strlen(fPath) == 0) {
+                            strcpy(fName, c->path.name);
+                        } else if (fPath[strlen(fPath)] == '/') {
+                            strcpy(fName, fPath);
+                            strcat(fName, c->path.name);
+                        } else {
+                            strcpy(fName, fPath);
+                            strcat(fName, "/");
+                            strcat(fName, c->path.name);
+                        }
+                    } else {
+                        strcpy(fName, c->path.name);
+                    }
+                    fd = open(fName, O_CREAT | O_WRONLY, 0644);
+                    write(fd, fData, fSize);
+                    close(fd);
+                    return self;
+                }
+            }
+        }
+    }
+    rb_raise_gp_result(retval);
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   configs                        =>      array
+ *
+ * Returns an array of adjustable camera configurations.
+ *
+ *   c = GPhoto2::Camera.new
+ *   # with Nikon DSC D80
+ *   c.configs                      #=>     ["capturetarget", "imgquality",
+ *                                           "imgsize", "whitebalance",
+ *                                           "f-number", "focallength",
+ *                                           "focusmode", "iso",
+ *                                           "exposurebiascompensation",
+ *                                           "exptime", "expprogram",
+ *                                           "capturemode", "focusmetermode",
+ *                                           "exposuremetermode", "flashmode",
+ *                                           "burstnumber", "accessmode",
+ *                                           "channel", "encryption"]
+ *
+ */
 static VALUE camera_get_configs(VALUE self) {
     GPhoto2Camera *c;
     VALUE arr = rb_ary_new();
@@ -325,6 +451,22 @@ static VALUE camera_get_configs(VALUE self) {
     return arr;
 }
 
+/*
+ * call-seq:
+ *   cam[cfg]                       =>      float or string
+ *   cam[cfg, :all]                 =>      array
+ *
+ * Returns current value of specified camera configuration. Configuration name
+ * (cfg) can be string or symbol and must be in configs method returned array.
+ * When called with directive <b>:all</b> returns an array of allowed values
+ *
+ *   c = GPhoto2::Camera.new
+ *   # with Nikon DSC D80
+ *   c["f-number"]                  #=>     "f/4.5"
+ *   c[:focallength]                #=>     10.5
+ *   c[:focusmode, :all]            #=>     ["Manual", "AF-S", "AF-C", "AF-A"]
+ *
+ */
 static VALUE camera_get_value(int argc, VALUE *argv, VALUE self) {
     int retval;
     const char *name;
@@ -398,6 +540,18 @@ static VALUE camera_get_value(int argc, VALUE *argv, VALUE self) {
     return Qnil;
 }
 
+/*
+ * call-seq:
+ *   cam[cfg] = value               =>      float or string
+ *
+ * Sets specified camera configuration to specified value if value is allowed.
+ *
+ *   c = GPhoto2::Camera.new
+ *   # with Nikon DSC D80
+ *   c["f-number"] = "f/4.5"        #=>     "f/4.5"
+ *   c[:focallength] = 10.5         #=>     10.5
+ *
+ */
 static VALUE camera_set_value(VALUE self, VALUE str, VALUE newVal) {
     int retval;
     const char *name;
@@ -443,11 +597,209 @@ static VALUE camera_set_value(VALUE self, VALUE str, VALUE newVal) {
     return Qnil;
 }
 
+/*
+ * call-seq:
+ *   folder                         =>      string
+ *
+ * Returns current camera path. When image is captured, folder changes to
+ * path where files are saved on camera.
+ *
+ *   c = GPhoto2::Camera.new
+ *   # with Nikon DSC D80
+ *   c.folder                       #=>     "/"
+ *   c.capture
+ *   c.folder                       #=>     "/store_00010001/DCIM/100NCD80"
+ *
+ */
+static VALUE camera_folder(VALUE self) {
+    GPhoto2Camera *c;
+    
+    Data_Get_Struct(self, GPhoto2Camera, c);
+    
+    return rb_str_new2(c->virtFolder);
+}
+
+/*
+ * call-seq:
+ *   subfolders                     =>      array
+ *
+ * Returns an array of subfolder names in current camera path.
+ *
+ *   c = GPhoto2::Camera.new
+ *   # with Nikon DSC D80
+ *   c.folder                       #=>     "/"
+ *   c.subfolders                   #=>     ["special", "store_00010001"]
+ *
+ */
+static VALUE camera_subfolders(VALUE self) {
+    int retval, i, count;
+    const char *name;
+    GPhoto2Camera *c;
+    VALUE arr;
+    
+    Data_Get_Struct(self, GPhoto2Camera, c);
+    
+    retval = gp_camera_folder_list_folders(c->camera, c->virtFolder, c->list, c->context);
+    if (retval == GP_OK) {
+        count = gp_list_count(c->list);
+        if (count < 0) {
+            rb_raise_gp_result(retval);
+            return Qnil;
+        }
+        arr = rb_ary_new();
+        for (i = 0; i < count; i++) {
+            retval = gp_list_get_name(c->list, i, &name);
+            if (retval == GP_OK) {
+                rb_ary_push(arr, rb_str_new2(name));
+            }
+        }
+        return arr;
+    }
+    rb_raise_gp_result(retval);
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   files                          =>      array
+ *
+ * Returns an array of file names in current camera path.
+ *
+ *   c = GPhoto2::Camera.new
+ *   # with Nikon DSC D80
+ *   c.folder                       #=>     "/"
+ *   c.files                        #=>     []
+ *   c.capture
+ *   c.files                        #=>     ["DSC_0001.JPG", "DSC_0002.JPG",
+ *                                           "DSC_0003.JPG", ... ]
+ *
+ */
+static VALUE camera_files(VALUE self) {
+    int retval, i, count;
+    const char *name;
+    GPhoto2Camera *c;
+    VALUE arr;
+    
+    Data_Get_Struct(self, GPhoto2Camera, c);
+    
+    retval = gp_filesystem_reset(c->camera->fs);
+    if (retval == GP_OK) {
+        retval = gp_camera_folder_list_files(c->camera, c->virtFolder, c->list, c->context);
+        if (retval == GP_OK) {
+            count = gp_list_count(c->list);
+            if (count < 0) {
+                rb_raise_gp_result(retval);
+                return Qnil;
+            }
+            arr = rb_ary_new();
+            for (i = 0; i < count; i++) {
+                retval = gp_list_get_name(c->list, i, &name);
+                if (retval == GP_OK) {
+                    rb_ary_push(arr, rb_str_new2(name));
+                }
+            }
+            return arr;
+        }
+    }
+    rb_raise_gp_result(retval);
+    return Qnil;
+}
+
+/*
+ * call-seq:
+ *   folder_up                      =>      camera
+ *
+ * Changes current camera path one level up.
+ *
+ *   c = GPhoto2::Camera.new
+ *   # with Nikon DSC D80
+ *   c.folder                       #=>     "/"
+ *   c.capture
+ *   c.folder                       #=>     "/store_00010001/DCIM/100NCD80"
+ *   c.folder_up
+ *   c.folder                       #=>     "/store_00010001/DCIM"
+ *   c.folder_up.folder_up          #=>     "/"
+ *
+ */
+static VALUE camera_folder_up(VALUE self) {
+    char *pch;
+    GPhoto2Camera *c;
+    
+    Data_Get_Struct(self, GPhoto2Camera, c);
+    
+    pch = strrchr(c->virtFolder, '/');
+    if ((pch - c->virtFolder) == 0) {
+        c->virtFolder[1] = '\0';
+    } else {
+        c->virtFolder[pch - c->virtFolder] = '\0';
+    }
+    
+    return self;
+}
+
+/*
+ * call-seq:
+ *   folder_down(name)              =>      camera
+ *
+ * Changes current camera path one level down into subfolder with
+ * specified name.
+ *
+ *   c = GPhoto2::Camera.new
+ *   # with Nikon DSC D80
+ *   c.folder                       #=>     "/"
+ *   c.folder_down "store_00010001"
+ *   c.folder                       #=>     "/store_00010001"
+ *   c.folder_down("DCIM").folder_down("100NCD80")
+ *   c.folder                       #=>     "/store_00010001/DCIM/100NCD80"
+ *
+ */
+static VALUE camera_folder_down(VALUE self, VALUE folder) {
+    Check_Type(folder, T_STRING);
+    int retval;
+    const char *name;
+    int index;
+    GPhoto2Camera *c;
+    
+    Data_Get_Struct(self, GPhoto2Camera, c);
+    
+    name = RSTRING(folder)->ptr;
+    retval = gp_camera_folder_list_folders(c->camera, c->virtFolder, c->list, c->context);
+    if (retval == GP_OK) {
+        retval = gp_list_find_by_name(c->list, &index, name);
+        if (retval == GP_OK) {
+            if (strlen(c->virtFolder) > 1) {
+                strcat(c->virtFolder, "/");
+            }
+            strcat(c->virtFolder, name);
+        }
+    }
+    return self;
+}
+
 void Init_gphoto4ruby() {
+    /*
+     * Module contains camera class definition and some exceptions
+     */
     rb_mGPhoto2 = rb_define_module("GPhoto2");
+    /*
+     * GPhoto2::Camera object is a Ruby wrapping aroung gphoto2 C library.
+     */
     rb_cGPhoto2Camera = rb_define_class_under(rb_mGPhoto2, "Camera", rb_cObject);
+    /*
+     * GPhoto2::Exception is raised when libgphoto2 functions from C core
+     * return any error code
+     */
     rb_cGPhoto2Exception = rb_define_class_under(rb_mGPhoto2, "Exception", rb_eStandardError);
+    /*
+     * GPhoto2::ConfigurationError is raised when trying to set configuration
+     * values that are not allowed or trying to access properties that are not
+     * supported
+     */
     rb_cGPhoto2ConfigurationError = rb_define_class_under(rb_mGPhoto2, "ConfigurationError", rb_eStandardError);
+    /*
+     * GPhoto2::ProgrammerError is never raised. :) Only when program gets
+     * where it could never get.
+     */
     rb_cGPhoto2ProgrammerError = rb_define_class_under(rb_mGPhoto2, "ProgrammerError", rb_eStandardError);
     rb_define_alloc_func(rb_cGPhoto2Camera, camera_allocate);
     rb_define_module_function(rb_cGPhoto2Camera, "ports", camera_class_ports, 0);
@@ -456,4 +808,11 @@ void Init_gphoto4ruby() {
     rb_define_method(rb_cGPhoto2Camera, "[]", camera_get_value, -1);
     rb_define_method(rb_cGPhoto2Camera, "[]=", camera_set_value, 2);
     rb_define_method(rb_cGPhoto2Camera, "capture", camera_capture, 0);
+    rb_define_method(rb_cGPhoto2Camera, "capture_save", camera_capture_save, -1);
+    rb_define_method(rb_cGPhoto2Camera, "folder", camera_folder, 0);
+    rb_define_method(rb_cGPhoto2Camera, "subfolders", camera_subfolders, 0);
+    rb_define_method(rb_cGPhoto2Camera, "files", camera_files, 0);
+    rb_define_method(rb_cGPhoto2Camera, "folder_up", camera_folder_up, 0);
+    rb_define_method(rb_cGPhoto2Camera, "folder_down", camera_folder_down, 1);
 }
+

data/ext/gphoto4ruby.h

@@ -1,7 +1,7 @@
 /**
  *
- * Copyright 2008 neq4 company
- * Author: Sergey Kruk (sergey.kruk@gmail.com)
+ * Copyright 2008 neq4 company <http://neq4.com>
+ * Author: Sergey Kruk <sergey.kruk@gmail.com>
  *
  * This file is part of GPhoto4Ruby.
  *
@@ -24,7 +24,45 @@ typedef struct {
     Camera *camera;
     CameraWidget *config;
     CameraWidget *childConfig;
-    CameraFilePath filepath;
+    CameraList *list;
+    CameraFilePath path;
+    CameraFile *file;
     GPContext *context;
+    
+    char *virtFolder;
 } GPhoto2Camera;
 
+static VALUE rb_mGPhoto2;
+static VALUE rb_cGPhoto2Camera;
+static VALUE rb_cGPhoto2Exception;
+static VALUE rb_cGPhoto2ConfigurationError;
+static VALUE rb_cGPhoto2ProgrammerError;
+
+static void rb_raise_gp_result(int retval);
+static void rb_raise_programmer_error(const char* fName);
+
+static VALUE getRadio(CameraWidget *cc);
+static VALUE listRadio(CameraWidget *cc);
+static VALUE setRadio(GPhoto2Camera *c, VALUE newVal);
+static VALUE getRange(CameraWidget *cc);
+static VALUE listRange(CameraWidget *cc);
+static VALUE setRange(GPhoto2Camera *c, VALUE newNum);
+
+static void populateWithConfigs(CameraWidget *cc, VALUE arr);
+
+static void camera_mark(GPhoto2Camera *c);
+static void camera_free(GPhoto2Camera *c);
+static VALUE camera_allocate(VALUE klass);
+
+static VALUE camera_initialize(int argc, VALUE *argv, VALUE self);
+static VALUE camera_class_ports(VALUE klass);
+static VALUE camera_capture(VALUE self);
+static VALUE camera_get_configs(VALUE self);
+static VALUE camera_get_value(int argc, VALUE *argv, VALUE self);
+static VALUE camera_set_value(VALUE self, VALUE str, VALUE newVal);
+
+static VALUE camera_folder(VALUE self);
+static VALUE camera_subfolders(VALUE self);
+static VALUE camera_files(VALUE self);
+static VALUE camera_folder_up(VALUE self);
+static VALUE camera_folder_down(VALUE self, VALUE folder);

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gphoto4ruby
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - heq4 company
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-13 00:00:00 +04:00
+date: 2008-08-15 00:00:00 +04:00
 default_executable: 
 dependencies: []
 
@@ -20,8 +20,11 @@ executables: []
 
 extensions: 
 - ext/extconf.rb
-extra_rdoc_files: []
-
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+- CHANGELOG.rdoc
+- ext/gphoto4ruby.c
 files: 
 - ext/gphoto4ruby.c
 - ext/gphoto4ruby.h
@@ -29,12 +32,20 @@ files:
 - docs/COPIYNG.LESSER
 - docs/gphoto4ruby_api_ru.txt
 - LICENSE
-- README
-has_rdoc: false
-homepage: 
+- CHANGELOG.rdoc
+- README.rdoc
+- Rakefile
+- example.rb
+has_rdoc: true
+homepage: http://github.com/lonelyelk/gphoto4ruby
 post_install_message: 
-rdoc_options: []
-
+rdoc_options: 
+- --main
+- README.rdoc
+- --charset
+- UTF-8
+- --webcvs
+- http://github.com/lonelyelk/gphoto4ruby/tree/master
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -51,10 +62,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: gphoto4ruby
 rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
-summary: GPhoto4Ruby is Ruby wrapping for libgphoto2 C library
+summary: GPhoto4Ruby is Ruby wrapping around libgphoto2 C library
 test_files: []
 

data/README

@@ -1,23 +0,0 @@
-GPhoto4Ruby
-===========
-
-
-Summary
--------
-
-
-ChangeLog
----------
-
-
-Contact
--------
-
-
-Installation
-------------
-
-
-Usage
------
-