cartodb-rb-client 0.1.8

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

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/model/base.rb

@@ -0,0 +1,20 @@
+module CartoDB
+  module Model
+    class Base
+      include CartoDB::Model::Getters
+      include CartoDB::Model::Setters
+      include CartoDB::Model::Geo
+      include CartoDB::Model::Schema
+      include CartoDB::Model::Persistence
+      include CartoDB::Model::Query
+      include RGeo::Feature
+
+      def initialize(attributes = {})
+        self.class.cartodb_table = nil
+        self.class.send(:field, :the_geom, :type => Point)
+        self.attributes = attributes
+        self.class.send(:update_cartodb_schema) unless schema_synchronized?
+      end
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/model/constants.rb

@@ -0,0 +1,30 @@
+module CartoDB
+  module Model
+    module Constants
+      include RGeo::Feature
+
+      CARTODB_TYPES = {
+        String     => 'text',
+        Integer    => 'numeric',
+        Numeric    => 'numeric',
+        Date       => 'date',
+        DateTime   => 'date',
+        TrueClass  => 'boolean',
+        FalseClass => 'boolean',
+        Point      => 'geometry'
+      }.freeze
+
+      INVALID_COLUMNS = [
+        :cartodb_id,
+        :id
+      ].freeze
+
+      GEOMETRY_COLUMN = 'the_geom'.freeze
+
+      RGEO_FACTORY = ::RGeo::Geographic.simple_mercator_factory(:srid => 4326)
+
+      DEFAULT_ROWS_PER_PAGE = 10.freeze
+
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/model/defaults.rb

@@ -0,0 +1,15 @@
+module CartoDB
+  module Model
+    module Defaults
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+      end
+
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/model/geo.rb

@@ -0,0 +1,73 @@
+module CartoDB
+  module Model
+    module Geo
+      include CartoDB::Model::Constants
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        include CartoDB::Model::Constants
+
+        def setup_geometry_column(geometry_column)
+          return if geometry_column[:geometry_type].nil?
+
+          geometry_name = geometry_column[:name].to_sym
+
+          self.send :define_method, :the_geom do
+            self.attributes[geometry_name]
+          end
+
+          self.send :define_method, :the_geom= do |the_geom|
+            self.attributes[geometry_name] = the_geom
+          end
+
+          case geometry_column[:geometry_type].upcase
+          when 'POINT'
+            setup_point_geometry
+          end
+        end
+        private :setup_geometry_column
+
+        def setup_point_geometry
+          self.send :define_method, :latitude do
+            self.the_geom ? self.the_geom.y : nil
+          end
+          self.send :define_method, :longitude do
+            self.the_geom ? self.the_geom.x : nil
+          end
+
+          self.send :define_method, :latitude= do |latitude|
+            @latitude = latitude
+            if @latitude && @longitude
+              self.the_geom = RGEO_FACTORY.point(@longitude, @latitude)
+            end
+          end
+          self.send :define_method, :longitude= do |longitude|
+            @longitude = longitude
+            if @latitude && @longitude
+              self.the_geom = RGEO_FACTORY.point(@longitude, @latitude)
+            end
+          end
+
+        end
+        private :setup_point_geometry
+
+      end
+
+      def prepare_geo_attributes(attributes)
+        return if attributes.nil?
+        longitude = attributes.delete(:longitude)
+        latitude = attributes.delete(:latitude)
+        if latitude && longitude
+          attributes[:the_geom] = RGEO_FACTORY.point(longitude, latitude)
+        end
+
+        attributes
+      end
+      private :prepare_geo_attributes
+
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/model/getters.rb

@@ -0,0 +1,79 @@
+module CartoDB
+  module Model
+    module Getters
+      attr_reader :table, :attributes
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def connection
+          CartoDB::Connection
+        end
+
+        def table_name
+          @table_name ||= self.name.tableize
+        end
+
+        def cartodb_table
+          @cartodb_table = begin
+            connection.table table_name
+          rescue CartoDB::Client::Error
+            nil
+          end
+        end
+
+        def columns
+          update_cartodb_schema unless schema_synchronized?
+          @columns
+        end
+
+        def data_columns
+          columns.reject{|c| %w(cartodb_id created_at updated_at).include?(c[:name])}.compact
+        end
+
+        def model_columns
+          @model_columns || []
+        end
+        private :model_columns
+
+      end
+
+      def connection
+        self.class.connection
+      end
+
+      def table_name
+        self.class.table_name
+      end
+
+      def cartodb_table
+        self.class.cartodb_table
+      end
+
+      # def method_missing(name, *args, &block)
+      #   if args.empty? && block.nil? && column_names.include?(name.to_s)
+      #     attributes[name]
+      #   else
+      #     super
+      #   end
+      # end
+
+      def columns
+        self.class.columns
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def column_names
+        columns.map{|column| column[:name]}
+      end
+      private :column_names
+
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/model/persistence.rb

@@ -0,0 +1,69 @@
+module CartoDB
+  module Model
+    module Persistence
+      include CartoDB::Model::Constants
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def create(attributes = {})
+          model = self.new attributes
+          model.save
+          model
+        end
+
+      end
+
+      def save
+        if new_record?
+          create_row
+        else
+          update_row
+        end
+      end
+
+      def destroy
+        unless new_record?
+          delete_row
+        end
+      end
+
+      def new_record?
+        cartodb_id.nil? || cartodb_id <= 0
+      end
+
+      def create_row
+        inserted_record = connection.insert_row table_name, attributes_for_insert
+        self.cartodb_id = inserted_record.id
+      end
+      private :create_row
+
+      def update_row
+        connection.update_row table_name, cartodb_id, attributes_for_update
+      end
+      private :update_row
+
+      def delete_row
+        connection.delete_row table_name, cartodb_id
+      end
+      private :delete_row
+
+      def attributes_for_insert
+        # only the columns defined in the model are allowed to be inserted
+        row = attributes.symbolize_keys.reject{|key,value| INVALID_COLUMNS.include?(key) || !column_names.include?(key.to_s) }
+        row
+      end
+      private :attributes_for_insert
+
+      def attributes_for_update
+        row = attributes.reject{|key,value| !column_names.include?(key.to_s) }
+        row
+      end
+      private :attributes_for_update
+
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/model/query.rb

@@ -0,0 +1,66 @@
+module CartoDB
+  module Model
+    module Query
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        def select(*fields)
+          scope = Scope.new(self)
+          scope.select(fields)
+        end
+
+        def all
+          scope = Scope.new(self)
+          scope.all
+        end
+
+        def where(attributes = nil, *rest)
+          scope = Scope.new(self)
+          scope.where(attributes, rest)
+        end
+
+        def find(id)
+          where(id)
+        end
+
+        def count
+          begin
+            results = connection.query "SELECT COUNT(CARTODB_ID) FROM #{table_name}"
+            results.rows.first[:count].try(:to_i)
+          rescue Exception => e
+            0
+          end
+        end
+
+        def page(page_number)
+          scope = Scope.new(self)
+          scope.page(page_number)
+        end
+
+        def per_page(ammount)
+          scope = Scope.new(self)
+          scope.page(page_number)
+        end
+
+        def order(order_clause)
+          scope = Scope.new(self)
+          scope.order(order_clause)
+        end
+
+      end
+
+      def count
+        self.class.count
+      end
+
+      def count=(ammount)
+        self.class.count= ammount
+      end
+
+    end
+  end
+end

data/lib/cartodb-rb-client/cartodb/model/schema.rb

@@ -0,0 +1,111 @@
+module CartoDB
+  module Model
+    module Schema
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        include CartoDB::Model::Constants
+
+        def schema_synchronized?
+          cartodb_table && @columns_synchronized
+        end
+
+        def cartodb_table_exists?
+          begin
+            cartodb_table && cartodb_table.name.eql?(table_name)
+          rescue CartoDB::Client::Error => e
+            e.status_code != 404
+          end
+        end
+
+        def field(name, options = {:type => String})
+          @columns_synchronized = false
+          @model_columns ||= []
+          column = {
+            :name => name.to_s,
+            :type =>  CARTODB_TYPES[options[:type]] || options[:type]
+          }
+          column[:geometry_type] = options[:type].name.split('::').last.downcase if column[:type].eql?('geometry')
+          return if model_columns.include?(column)
+
+          model_columns << column
+          update_cartodb_schema
+        end
+        private :field
+
+        def update_cartodb_schema
+          table = nil
+          if cartodb_table_exists?
+            table = cartodb_table
+          else
+            table = connection.create_table table_name, model_columns
+          end
+
+          read_metadata table
+          create_missing_columns
+          create_column_accessors
+          @columns_synchronized = true
+        end
+        private :update_cartodb_schema
+
+        def read_metadata(table)
+          extract_columns table
+        end
+        private :read_metadata
+
+        def extract_columns(table)
+          @columns = table.schema.map{|c| c[0].eql?('the_geom') ? {:name => c[0], :type => c[1], :geometry_type => c[3]} : {:name => c[0], :type => c[1]}}
+        end
+        private :extract_columns
+
+        def create_missing_columns
+          table_column_names = @columns.map{|c| c[:name]}
+          missing_columns = model_columns.reject{|c| table_column_names.include?(c[:name])}
+          return unless missing_columns && missing_columns.any?
+
+          missing_columns.each do |column|
+            connection.add_column table_name, column[:name], column[:type]
+          end
+
+          self.cartodb_table = nil
+          read_metadata self.cartodb_table
+        end
+        private :create_missing_columns
+
+        def create_column_accessors
+          @columns.each do |c|
+            column_name = c[:name]
+            column_type = c[:type]
+            setup_geometry_column(c) and next if column_name.eql?(GEOMETRY_COLUMN) || column_type.eql?('geometry')
+
+            # unless self.methods.include?(column_name)
+              self.send :define_method, column_name do
+                self.attributes[column_name.to_sym]
+              end
+            # end
+
+            # unless self.methods.include?("#{column_name}=")
+              self.send :define_method, "#{column_name}=" do |value|
+                self.attributes[column_name.to_sym] = value
+              end
+            # end
+          end
+        end
+        private :create_column_accessors
+
+      end
+
+      def schema_synchronized?
+        self.class.schema_synchronized? && cartodb_table_exists?
+      end
+
+      def cartodb_table_exists?
+        self.class.cartodb_table_exists?
+      end
+
+    end
+  end
+end