google-ft 0.0.2

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/README.md

@@ -0,0 +1,4 @@
+google_ft
+===============
+
+Google Fusion Tables API for ruby.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/google-ft.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "google-ft"
+  s.version     = "0.0.2"
+  s.authors     = ["Jon Durbin"]
+  s.email       = ["jond@greenviewdata.com"]
+  s.homepage    = "https://github.com/gdi/google-ft"
+  s.summary     = %q{Work with Google Fusion Tables using a service account}
+  s.description = %q{Work with Google Fusion Tables using a service account}
+
+  s.rubyforge_project = "google-ft"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'rspec'
+  s.add_dependency 'bundler'
+  s.add_dependency 'google-sa-auth'
+  s.add_dependency 'json'
+end

data/lib/google-ft.rb

@@ -0,0 +1,96 @@
+require 'json'
+require 'curb-fu'
+require 'google-sa-auth'
+require 'google-ft/table'
+require 'google-ft/table/column'
+require 'google-ft/table/permission'
+
+# Quick and dirty method to symbolize keys of a hash.
+class Hash
+  def symbolize
+    self.inject({}){|item,(k,v)| item[k.to_sym] = v; item}
+  end
+end
+
+class GoogleFT
+  class << self
+    # Method to convert values into google-compatible format.
+    def to_google_ft_format(value)
+      if value.class == String
+        bytes = value.bytes.each.collect {|l| l.chr.gsub(/\\|'/) { |c| "\\#{c}" }.gsub('&', '%26').gsub("\b", '\\b').gsub("\f", '\\f').gsub("\n", '\\n').gsub("\r", '\\r').gsub("\t",'\\t')}
+        "'#{bytes.join}'"
+      elsif value.class == Array
+        "'#{value.first} #{value.last}'"
+      else
+        value.to_json
+      end
+    end
+
+    # Quick wrapper method for utilizing curb-fu.
+    def get_and_parse_response(args)        
+      response = GoogleSAAuth::Client.run(args)
+
+      # Make sure we get a 20* status.
+      unless response.status.to_s =~ /^20/
+        puts response.body.to_s
+        raise RuntimeError
+      end
+
+      # Return the symbolized hash of the response body.
+      begin
+        JSON.parse(response.body).symbolize
+      rescue
+        response.body
+      end
+    end
+  end
+
+  attr_accessor :authorization, :token
+
+  def get_auth_token(args)
+    # Make sure the token wasn't already set and hasn't yet expired.
+    @authorization = nil unless has_auth?
+
+    # (Re)create the authorization.
+    @authorization ||= GoogleSAAuth.new(args)
+
+    # Save the token.
+    @token = @authorization.token
+    @authorization
+  end
+
+  def show_tables
+    require_auth
+    GoogleFT::Table.show_tables(@authorization.token_string)
+  end
+
+  def create_table(args)
+    require_auth
+
+    # Create the table and save it.
+    args[:token] = @authorization.token_string
+    table = GoogleFT::Table.new(args)
+    table.save
+    table
+  end
+
+  def delete_table(table_id)
+    require_auth
+    GoogleFT::Table.get_table_by_id(table_id, @authorization.token_string).delete
+  end
+
+  def get_table(table_id)
+    require_auth
+    GoogleFT::Table.get_table_by_id(table_id, @authorization.token_string)
+  end
+
+private
+  def has_auth?
+    return false unless @token
+    @token.expired? ? false : true
+  end
+
+  def require_auth
+    raise RuntimeError unless has_auth?
+  end
+end

data/lib/google-ft/table.rb

@@ -0,0 +1,173 @@
+class GoogleFT
+  class Table
+    # Base URI for the fusion tables API.
+    $FT_BASE_URI = 'https://www.googleapis.com/fusiontables/v1/tables'
+
+    class << self
+      # Show a list of tables, requires the authentication token.
+      def show_tables(token)
+        args = {
+          :uri => "#{$FT_BASE_URI}",
+          :method => 'get',
+          :headers => {
+            'Authorization' => "Bearer #{token}"
+          }
+        }
+        result = GoogleFT.get_and_parse_response(args)
+        return [] if result[:items].nil?
+        result[:items].each.collect do |table|
+          table = table.symbolize
+          GoogleFT::Table.new(
+            :token => token,
+            :id => table[:tableId],
+            :name => table[:name],
+            :columns => table[:columns],
+            :description => table[:description],
+            :exportable => table[:isExportable]
+          )
+        end
+      end
+
+      # Get a table by it's ID and return a table object.
+      def get_table_by_id(table_id, token = nil)
+        args = {
+          :uri => "#{$FT_BASE_URI}/#{table_id}",
+          :method => 'get'
+        }
+
+        # Add the auth token if it was provided.
+        args[:headers] = {'Authorization' => "Bearer #{token}"} unless token.nil?
+
+        # Get and parse results.
+        result = GoogleFT.get_and_parse_response(args)
+        GoogleFT::Table.new(
+          :token => token,
+          :id => result[:tableId],
+          :name => result[:name],
+          :columns => result[:columns],
+          :description => result[:description],
+          :exportable => result[:isExportable]
+        )
+      end
+    end
+
+
+    # Accessors.
+    attr_accessor :columns, :id, :name, :description, :exportable, :token
+    attr_accessor :permissions
+
+    # Create a new table object.
+    def initialize(args = {})
+      # Clean-up args.
+      args = args.symbolize.delete_if {|k,v| ![:id, :name, :columns, :description, :exportable, :token].include?(k)}
+
+      # Create nicely formated columns.
+      self.columns = args[:columns].nil? ? [] : args[:columns].each.collect do |col|
+        name = col[:name] || col['name']
+        type = col[:type] || col['type']
+        GoogleFT::Table::Column.new(name, type)
+      end
+
+      # Set other attributes.
+      self.token = args[:token]
+      self.id = args[:id]
+      self.name = args[:name].gsub(/[^a-zA-Z0-9_\-]/, '_')
+      self.description = args[:description] || ''
+      self.exportable = args[:exportable].nil? ? false : args[:exportable]
+    end
+
+    # Delete a table.
+    def delete
+      args = {
+        :uri => "#{$FT_BASE_URI}/#{self.id}",
+        :headers => {
+          'Authorization' => "Bearer #{self.token}",
+        },
+        :data => '',
+        :method => 'delete'
+      }
+      GoogleFT.get_and_parse_response(args)
+      true
+    end
+
+    # Save this table to Google.
+    #   Used for creating or updating tables.
+    def save
+      # If ID exists, we are updating a table,
+      #  otherwise, we are creating it.
+      method = self.id.nil? ? 'post' : 'put'
+      uri = 'https://www.googleapis.com/fusiontables/v1/tables'
+      uri += "/#{self.id}" unless self.id.nil?
+      args = {
+        :uri => uri,
+        :headers => {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{self.token}"
+        },
+        :data => post_args,
+        :method => method
+      }
+      result = GoogleFT.get_and_parse_response(args)
+      self.id = result[:tableId]
+      result
+    end
+
+    # Set permissions for a table.
+    def set_permissions(permission)
+      args = {
+        :uri => "https://www.googleapis.com/drive/v2/files/#{self.id}/permissions",
+        :headers => {
+          'Content-Type' => 'application/json',
+          'Authorization' => "Bearer #{self.token}"
+        },
+        :method => 'post',
+        :data => permission.post_args
+      }
+      GoogleFT.get_and_parse_response(args)
+    end
+
+    # Return the JSON string of our table arguments.
+    #   Used for creating and updating tables.
+    def post_args
+      {
+        :name => self.name,
+        :columns => self.columns.each.collect {|col| {:name => col.name, :type => col.type}},
+        :isExportable => self.exportable,
+        :description => self.description
+      }.to_json
+    end
+
+    # Insert rows into a table.
+    def insert(rows)
+      # Get the SQL-ish statement from arg hash.
+      inserts = []
+
+      # Go through each row.
+      rows.each do |row|
+
+        # Get all of the column/value pairs.
+        columns = []
+        values = []
+        row.each do |column,value|
+          columns.push(column)
+          values.push(value)
+        end
+
+        # Add this insert line.
+        inserts.push("INSERT INTO #{self.id} (#{columns.join(',')}) VALUES (#{values.each.collect {|v| GoogleFT.to_google_ft_format(v)}.join(',')});")
+      end
+
+      # Post the insert's to Google.
+      args = {
+        :uri => 'https://www.googleapis.com/fusiontables/v1/query',
+        :headers => {
+          'Authorization' => "Bearer #{self.token}"
+        },
+        :method => 'post',
+        :data => "sql=#{inserts.join("\n")}"
+      }
+puts "SQL:\n#{inserts.join("\n")}"
+      GoogleFT.get_and_parse_response(args)
+    end
+  end
+end

data/lib/google-ft/table/column.rb

@@ -0,0 +1,16 @@
+class GoogleFT
+  class Table
+    class Column
+      attr_accessor :name, :type
+
+      def initialize(name, type = 'string')
+        # Cleanup the column name.
+        self.name = name.gsub(/[^a-zA-Z0-9_\-]/, '_')
+
+        # Store type and make sure it's valid.
+        self.type = type.upcase
+        raise ArgumentError unless ['STRING','NUMBER','DATETIME','LOCATION'].include?(self.type)
+      end
+    end
+  end
+end

data/lib/google-ft/table/permission.rb

@@ -0,0 +1,32 @@
+class GoogleFT
+  class Table
+    class Permission
+      attr_accessor :role, :type, :value, :require_link
+      def initialize(args)
+        # Clean up args and make sure we were at least supplied the required ones.
+        args = args.symbolize.delete_if {|k,v| ![:role, :type, :value, :require_link].include?(k)}
+        raise ArgumentError unless args[:role] && args[:type] 
+
+        # Set defaults.
+        args[:value] ||= 'me'
+        args[:require_link] ||= false
+
+        # Set the attributes.
+        self.role = args[:role]
+        self.type = args[:type]
+        self.value = args[:value]
+        self.require_link = args[:require_link]
+      end
+
+      def post_args
+        # JSON formatted string for this permission.
+        {
+          :role => self.role,
+          :type => self.type,
+          :value => self.value,
+          :withLink => self.require_link
+        }.to_json
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: google-ft
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Jon Durbin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: google-sa-auth
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Work with Google Fusion Tables using a service account
+email:
+- jond@greenviewdata.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- google-ft.gemspec
+- lib/google-ft.rb
+- lib/google-ft/table.rb
+- lib/google-ft/table/column.rb
+- lib/google-ft/table/permission.rb
+homepage: https://github.com/gdi/google-ft
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: google-ft
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Work with Google Fusion Tables using a service account
+test_files: []
+has_rdoc: