cartodb-rb-client-rails-322 0.4.3

data/lib/cartodb-rb-client/cartodb/client/connection/postgres.rb

@@ -0,0 +1,255 @@
+module CartoDB
+  module Client
+    module Connection
+      class PostgreSQL
+        include CartoDB::Helpers::SqlHelper
+
+        DATA_TYPES_TRANSLATION_TABLE = {
+          'int4'      => 'number',
+          'numeric'   => 'number',
+          'text'      => 'string',
+          'varchar'   => 'string',
+          'date'      => 'date',
+          'timestamp' => 'date',
+          'bool'      => 'boolean',
+          'geometry'  => 'geometry'
+        }
+
+        def initialize(connection_settings)
+          @pg = connect_to_postgres(connection_settings)
+        end
+
+        def connect_to_postgres(settings)
+          pg_connection = PGconn.open(
+            :host     => settings['host'],
+            :port     => settings['port'],
+            :user     => settings['user'],
+            :password => settings['password'],
+            :dbname   => settings['database']
+          )
+          pg_connection.set_notice_processor{|message| nil}
+          pg_connection
+        end
+        private :connect_to_postgres
+
+        def create_table(table_name = nil, schema_or_file = nil, the_geom_type = 'Point')
+          schema = schema_or_file if schema_or_file && schema_or_file.is_a?(Array)
+          file   = schema_or_file if schema_or_file && schema_or_file.is_a?(File)
+
+          params = {:name => table_name}
+          params[:file] = file if file
+
+          table_name = table_name.sanitize
+
+          if schema.nil? || schema.empty?
+            schema = []
+            schema << {:name => 'name',        :type => 'text'} if schema.select{|c| c[:name].eql?('name')}.empty?
+            schema << {:name => 'description', :type => 'text'} if schema.select{|c| c[:name].eql?('description')}.empty?
+            create_the_geom = "SELECT AddGeometryColumn('public', '#{table_name}', 'the_geom', 4326, 'POINT', 2)"
+          end
+
+          schema << {:name => 'cartodb_id',  :type => 'serial',    :extra => 'NOT NULL'}                                                                 if schema.select{|c| c[:name].eql?('cartodb_id')}.empty?
+          schema << {:name => 'created_at',  :type => 'timestamp', :extra => 'without time zone DEFAULT current_timestamp::timestamp without time zone'} if schema.select{|c| c[:name].eql?('created_at')}.empty?
+          schema << {:name => 'updated_at',  :type => 'timestamp', :extra => 'without time zone DEFAULT current_timestamp::timestamp without time zone'} if schema.select{|c| c[:name].eql?('updated_at')}.empty?
+          if schema.any? && schema.select{|c| c[:name].downcase.match(/geo/)}.any?
+            the_geom_field = schema.select{|c| c[:name].downcase.match(/geo/)}.first
+            create_the_geom = "SELECT AddGeometryColumn('public', '#{table_name}', 'the_geom', 4326, '#{the_geom_field[:geometry_type].upcase}', 2)"
+            schema.reject!{|c| c[:name].downcase.match(/geo/)}
+          end
+
+          @pg.query(<<-SQL
+            CREATE TABLE #{table_name}
+            (
+              #{schema.map{|s| "#{s[:name]} #{s[:type]} #{s[:extra]}"}.join(', ')}
+            )
+            WITH (
+              OIDS=FALSE
+            );
+            ALTER TABLE #{table_name} OWNER TO #{@pg.user};
+          SQL
+          )
+
+          @pg.query(create_the_geom) if create_the_geom
+
+          table table_name
+        end
+
+        def add_column(table_name, column_name, column_type)
+          @pg.query(<<-SQL
+            ALTER TABLE #{table_name} ADD COLUMN #{column_name} #{column_type};
+          SQL
+          )
+        end
+
+        def drop_column(table_name, column_name)
+          @pg.query(<<-SQL
+            ALTER TABLE #{table_name} DROP COLUMN #{column_name};
+          SQL
+          )
+        end
+
+        def change_column(table_name, old_column_name, new_column_name, column_type)
+          add_column table_name, new_column_name, column_type
+          @pg.query(<<-SQL
+            UPDATE #{table_name} SET #{new_column_name}=cast(#{old_column_name} as #{column_type})
+          SQL
+          )
+          drop_column table_name, old_column_name
+        end
+
+        def tables
+          pg_result = @pg.query(<<-SQL
+            SELECT columns.table_name, columns.column_name, columns.udt_name as data_type
+            FROM information_schema.tables tables
+            INNER JOIN information_schema.columns columns ON columns.table_name = tables.table_name
+            WHERE tables.table_schema = 'public' AND tables.table_name not IN ('spatial_ref_sys', 'geometry_columns', 'geography_columns')
+          SQL
+          )
+
+          result = CartoDB::Types::Metadata.new
+          tables = {}
+          pg_result.each do |column|
+            tables[column['table_name']] = CartoDB::Types::Metadata.from_hash({:name => column['table_name'], :schema => []}) unless tables[column['table_name']]
+            tables[column['table_name']].schema << %W(#{column['column_name']} #{CartoDB::Client::Connection::PostgreSQL::DATA_TYPES_TRANSLATION_TABLE[column['data_type']]})
+          end
+
+          result.total_entries = tables.to_a.length
+          result.tables = tables.to_a.map(&:last)
+          result
+        end
+
+        def table(table_name)
+          pg_result = @pg.query(<<-SQL
+            SELECT columns.table_name, columns.column_name, columns.udt_name as data_type, geo_cols.type as geometry_type
+            FROM information_schema.tables tables
+            INNER JOIN information_schema.columns columns ON columns.table_name = tables.table_name
+            LEFT OUTER JOIN public.geometry_columns geo_cols ON geo_cols.f_table_schema = columns.table_schema AND geo_cols.f_table_name = columns.table_name AND geo_cols.f_geometry_column = columns.column_name
+            WHERE tables.table_schema = 'public' AND tables.table_name not IN ('spatial_ref_sys', 'geometry_columns', 'geography_columns') AND tables.table_name ilike '#{table_name}'
+          SQL
+          )
+
+          if pg_result.to_a.empty?
+            non_existing_table = @pg.query(<<-SQL
+              SELECT tables.table_name
+              FROM information_schema.tables tables
+              WHERE tables.table_schema = 'public' AND tables.table_name not IN ('spatial_ref_sys', 'geometry_columns', 'geography_columns') AND tables.table_name ilike '#{table_name}'
+            SQL
+            )
+            raise CartoDB::Client::Error.new if non_existing_table.to_a.empty?
+          end
+
+          table_result = nil
+          pg_result.each do |column|
+            table_result = CartoDB::Types::Metadata.from_hash({:name => column['table_name'], :schema => []}) unless table_result
+            table_result.schema << %W(#{column['column_name']} #{CartoDB::Client::Connection::PostgreSQL::DATA_TYPES_TRANSLATION_TABLE[column['data_type']]})
+            table_result.schema.last << CartoDB::Client::Connection::PostgreSQL::DATA_TYPES_TRANSLATION_TABLE[column['data_type']]  if column['geometry_type']
+            table_result.schema.last << column['geometry_type'].downcase if column['geometry_type']
+          end
+          table_result
+        end
+
+        def drop_table(table_name)
+          @pg.query(<<-SQL
+            DROP TABLE #{table_name}
+          SQL
+          )
+        end
+
+        def row(table_name, row_id)
+          results = query(<<-SQL
+            SELECT #{table_name}.cartodb_id as id, #{table_name}.*
+            FROM #{table_name}
+            WHERE cartodb_id = #{row_id};
+          SQL
+          )
+
+          results.rows.first
+        end
+
+        def insert_row(table_name, row)
+          row = prepare_data(row)
+
+          results = query(<<-SQL
+            INSERT INTO #{table_name}
+            (#{row.keys.join(',')})
+            VALUES (#{row.values.join(',')});
+
+            SELECT #{table_name}.cartodb_id as id, #{table_name}.*
+            FROM #{table_name}
+            WHERE cartodb_id = currval('public.#{table_name}_cartodb_id_seq');
+          SQL
+          )
+
+          results.rows.first
+        end
+
+        def update_row(table_name, row_id, row)
+          row = prepare_data(row)
+
+          results = query(<<-SQL
+            UPDATE #{table_name}
+            SET (#{row.keys.join(',')})
+            = (#{row.values.join(',')})
+            WHERE cartodb_id = #{row_id};
+            SELECT #{table_name}.cartodb_id as id, #{table_name}.*
+            FROM #{table_name}
+            WHERE cartodb_id = currval('public.#{table_name}_cartodb_id_seq');
+          SQL
+          )
+
+          results.rows.first
+        end
+
+        def delete_row(table_name, row_id)
+          @pg.query(<<-SQL
+            DELETE FROM #{table_name}
+            WHERE cartodb_id = #{row_id}
+          SQL
+          )
+        end
+
+        def records(table_name, options = {})
+          sql = <<-SQL
+            SELECT #{table_name}.cartodb_id AS id, #{table_name}.*
+            FROM #{table_name}
+          SQL
+
+          results = query(sql, options)
+
+          results[:name] = table_name
+          results
+        end
+
+        def query(sql, options = {})
+          sql = sql.strip if sql
+
+          if sql.include?('*')
+            table_name = sql.match(/select(.*)\s((\w+\.)?\*)(.*)from\s+(\w*)[^;]*;?/im)[5]
+            schema = table(table_name).schema if table_name
+
+            sql.gsub!(/^select(.*)\s((\w+\.)?\*)(.*)from/im) do |matches|
+              %Q{SELECT #{$1.strip} #{schema.map{|c| "#{$3}#{c[0]}"}.join(', ')} #{$4.strip} FROM}
+            end
+          end
+
+          crono = Time.now
+          begin
+            result = @pg.query(<<-SQL
+              #{sql}
+            SQL
+            )
+          rescue PGError => e
+            raise CartoDB::Client::Error.new(nil, nil, nil, e.message)
+          end
+
+          CartoDB::Types::Metadata.from_hash({
+            :time => Time.now - crono,
+            :total_rows => result.cmd_tuples,
+            :rows       => result.map{|row| CartoDB::Types::Metadata.from_hash(row)}
+          })
+        end
+
+      end
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/client/error.rb

@@ -0,0 +1,68 @@
+module CartoDB
+  module Client
+    class Error < Exception
+      attr_accessor :status_code
+
+      HTTP_MESSAGES = {
+                        401 => 'Unauthorized request',
+                        404 => 'Not found',
+                        500 => 'Server error'
+                      }
+
+      def initialize(uri = nil, method = nil, http_response = nil, error_message = nil)
+        @uri            = uri
+        @method         = method
+        @error_messages = ['undefined CartoDB error']
+        @status_code    = 400
+        @error_messages = [uri] if method == nil && http_response == nil && error_message == nil
+        @error_messages = [error_message] if error_message
+
+        if http_response
+          @status_code = http_response.code
+          @error_messages = custom_error(http_response) || standard_error
+          @body = http_response.body
+        end
+
+      end
+
+      def to_s
+        message = <<-EOF
+          #{http_error_message_header}
+          #{format_error_messages}
+          #{@body}
+        EOF
+        message.strip
+      end
+
+      def http_error_message_header
+        if @method && @uri
+          %{There were errors running the #{@method.to_s.upcase} request "#{@uri}":}
+        end
+      end
+      private :http_error_message_header
+
+      def custom_error(http_response)
+        json = Utils.parse_json(http_response)
+        json[:error] if json
+      end
+
+      def standard_error
+        "#{status_code} - #{HTTP_MESSAGES[status_code.to_i]}"
+      end
+      private :standard_error
+
+      def format_error_messages
+        return '' unless @error_messages
+        if @error_messages.is_a?(String)
+          @error_messages
+        elsif @error_messages.is_a?(Array) && @error_messages.count == 1
+          @error_messages.first
+        else
+          @error_messages.map{|e| "- #{e}"}.join("\n")
+        end
+      end
+      private :format_error_messages
+
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/client/utils.rb

@@ -0,0 +1,20 @@
+module CartoDB
+  module Client
+    module Utils
+
+      def self.parse_json(response)
+        json = nil
+
+        unless response.nil? || response.body.nil? || response.body.strip == ''
+          begin
+            json = ::JSON.parse(response.body, :object_class => CartoDB::Types::Metadata, :symbolize_names => true)
+          rescue JSON::ParserError => e
+            json = CartoDB::Types::Metadata.new
+          end
+        end
+        json
+      end
+
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/helpers.rb

@@ -0,0 +1 @@
+require 'cartodb-rb-client/cartodb/helpers/sql_helper'

data/lib/cartodb-rb-client/cartodb/helpers/sql_helper.rb

@@ -0,0 +1,36 @@
+module CartoDB
+  module Helpers
+    module SqlHelper
+      require 'time'
+
+      def prepare_data(hash)
+        hash.each do |key, value|
+          hash[key] = format_value(key, value)
+        end
+        hash
+      end
+
+      def format_value(key, value)
+        case value
+        when ::String
+          #value = value.gsub(/\\/, '\&\&').gsub(/'/, "''")
+          if key.match(/geo/)
+            "#{value}"
+          else
+            "'#{value.gsub(/\\/, '\&\&').gsub(/'/, "''")}'"
+          end
+        when ::Date, ::DateTime, ::Time
+          "'#{value.to_time.utc}'"
+        when RGeo::Feature::Geometry
+          "'#{RGeo::WKRep::WKBGenerator.new(:type_format => :ewkb, :emit_ewkb_srid => true, :hex_format => true).generate(value)}'"
+        when NilClass
+          'NULL'
+        else
+          value
+        end
+      end
+      private :format_value
+
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/init.rb

@@ -0,0 +1,30 @@
+module CartoDB
+ class Init
+
+    class << self
+
+      def start(cartodb_settings = nil)
+        if cartodb_settings.blank?
+          config_path = Rails.root.join('config/cartodb_config.yml')
+          cartodb_settings = YAML.load_file(config_path)[Rails.env.to_s] if File.exists?(config_path)
+        end
+
+        return if cartodb_settings.blank?
+
+        if CartoDB.const_defined?('Settings')
+          CartoDB::Settings.merge!(cartodb_settings)
+        else
+          CartoDB.const_set('Settings', cartodb_settings)
+        end
+
+        CartoDB.const_set('Connection', CartoDB::Client::Connection::Base.new) unless CartoDB.const_defined?('Connection')
+
+
+      end
+
+    end
+
+  end
+end
+
+

data/lib/cartodb-rb-client/cartodb/libs.rb

@@ -0,0 +1,2 @@
+require 'cartodb-rb-client/cartodb/libs/string'
+require 'cartodb-rb-client/cartodb/libs/object'

data/lib/cartodb-rb-client/cartodb/libs/object.rb

@@ -0,0 +1,15 @@
+  # coding: UTF-8
+class Object
+  def needsQuotes?
+    return false unless self
+
+    case self
+    when ::String
+      true
+    when ::Date, ::DateTime, ::Time
+      true
+    else
+      false
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/libs/string.rb

@@ -0,0 +1,116 @@
+  # coding: UTF-8
+
+class String
+  def self.random(length=10)
+  ('a'..'z').sort_by {rand}[0,length].join
+  end
+
+  def normalize
+    str = self.downcase
+    return '' if str.blank?
+    n = str.force_encoding("UTF-8")
+    n.gsub!(/[àáâãäåāă]/,   'a')
+    n.gsub!(/æ/,            'ae')
+    n.gsub!(/[ďđ]/,          'd')
+    n.gsub!(/[çćčĉċ]/,       'c')
+    n.gsub!(/[èéêëēęěĕė]/,   'e')
+    n.gsub!(/ƒ/,             'f')
+    n.gsub!(/[ĝğġģ]/,        'g')
+    n.gsub!(/[ĥħ]/,          'h')
+    n.gsub!(/[ììíîïīĩĭ]/,    'i')
+    n.gsub!(/[įıijĵ]/,        'j')
+    n.gsub!(/[ķĸ]/,          'k')
+    n.gsub!(/[łľĺļŀ]/,       'l')
+    n.gsub!(/[ñńňņʼnŋ]/,      'n')
+    n.gsub!(/[òóôõöøōőŏŏ]/,  'o')
+    n.gsub!(/œ/,            'oe')
+    n.gsub!(/ą/,             'q')
+    n.gsub!(/[ŕřŗ]/,         'r')
+    n.gsub!(/[śšşŝș]/,       's')
+    n.gsub!(/[ťţŧț]/,        't')
+    n.gsub!(/[ùúûüūůűŭũų]/,  'u')
+    n.gsub!(/ŵ/,             'w')
+    n.gsub!(/[ýÿŷ]/,         'y')
+    n.gsub!(/[žżź]/,         'z')
+    n.gsub!(/[ÀÁÂÃÄÅĀĂ]/i,    'A')
+    n.gsub!(/Æ/i,            'AE')
+    n.gsub!(/[ĎĐ]/i,          'D')
+    n.gsub!(/[ÇĆČĈĊ]/i,       'C')
+    n.gsub!(/[ÈÉÊËĒĘĚĔĖ]/i,   'E')
+    n.gsub!(/Ƒ/i,             'F')
+    n.gsub!(/[ĜĞĠĢ]/i,        'G')
+    n.gsub!(/[ĤĦ]/i,          'H')
+    n.gsub!(/[ÌÌÍÎÏĪĨĬ]/i,    'I')
+    n.gsub!(/[IJĴ]/i,          'J')
+    n.gsub!(/[Ķĸ]/i,          'J')
+    n.gsub!(/[ŁĽĹĻĿ]/i,       'L')
+    n.gsub!(/[ÑŃŇŅʼnŊ]/i,      'M')
+    n.gsub!(/[ÒÓÔÕÖØŌŐŎŎ]/i,  'N')
+    n.gsub!(/Œ/i,            'OE')
+    n.gsub!(/Ą/i,             'Q')
+    n.gsub!(/[ŔŘŖ]/i,         'R')
+    n.gsub!(/[ŚŠŞŜȘ]/i,       'S')
+    n.gsub!(/[ŤŢŦȚ]/i,        'T')
+    n.gsub!(/[ÙÚÛÜŪŮŰŬŨŲ]/i,  'U')
+    n.gsub!(/Ŵ/i,             'W')
+    n.gsub!(/[ÝŸŶ]/i,         'Y')
+    n.gsub!(/[ŽŻŹ]/i,         'Z')
+    n
+  end
+
+  def sanitize
+   return if self.blank?
+   self.gsub(/<[^>]+>/m,'').normalize.downcase.gsub(/&.+?;/,'-').
+        gsub(/[^a-z0-9 _-]/,'-').strip.gsub(/\s+/,'-').gsub(/-+/,'-').
+        gsub(/-/,' ').strip.gsub(/ /,'-').gsub(/-/,'_')
+  end
+
+  def strip_tags
+    self.gsub(/<[^>]+>/m,'').strip
+  end
+
+  def convert_to_db_type
+    if CartoDB::TYPES.keys.include?(self.downcase)
+      if self.downcase == "number"
+        "double precision"
+      else
+        CartoDB::TYPES[self.downcase].first
+      end
+    else
+      self.downcase
+    end
+  end
+
+  # {"integer"=>:number, "real"=>:number, "varchar"=>:string, "text"=>:string, "timestamp"=>:date, "boolean"=>:boolean}
+  def convert_to_cartodb_type
+    inverse_types = CartoDB::TYPES.invert.inject({}){ |h, e| e.first.each{ |k| h[k] = e.last }; h}
+    if inverse_types.keys.include?(self.downcase)
+      inverse_types[self.downcase]
+    else
+      inverse_types.keys.select{ |t| !t.is_a?(String) }.each do |re|
+        if self.downcase.match(re)
+          return inverse_types[re]
+        end
+      end
+      self.downcase
+    end
+  end
+
+  def sanitize_sql
+    self.gsub(/\\/, '\&\&').gsub(/'/, "''")
+  end
+
+  def host
+    self.split('/')[2]
+  end
+
+  def sanitize_column_name
+    temporal_name = self.sanitize
+    if temporal_name !~ /^[a-zA-Z_]/ || CartoDB::POSTGRESQL_RESERVED_WORDS.include?(self.upcase)
+      return '_' + temporal_name
+    else
+      temporal_name
+    end
+  end
+
+end