cartodb-rb-client-rails-322 0.4.3

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

@@ -0,0 +1,11 @@
+require 'forwardable'
+require 'active_support/core_ext/string'
+require 'cartodb-rb-client/cartodb/model/constants'
+require 'cartodb-rb-client/cartodb/model/geo'
+require 'cartodb-rb-client/cartodb/model/getters'
+require 'cartodb-rb-client/cartodb/model/setters'
+require 'cartodb-rb-client/cartodb/model/schema'
+require 'cartodb-rb-client/cartodb/model/persistence'
+require 'cartodb-rb-client/cartodb/model/query'
+require 'cartodb-rb-client/cartodb/model/base'
+require 'cartodb-rb-client/cartodb/model/scope'

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(:set_geometry_type) unless self.class.send(:geometry_type).present?
+        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,101 @@
+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
+
+          case geometry_column[:geometry_type].upcase
+          when 'POINT'
+            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
+
+            setup_point_geometry
+          when 'MULTIPOLYGON'
+            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] = convert_to_polygon(the_geom)
+            end
+          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?
+
+        case self.class.geometry_type
+        when 'point'
+          longitude = attributes.delete(:longitude)
+          latitude = attributes.delete(:latitude)
+
+          attributes[:the_geom] = convert_to_point(latitude, longitude) if latitude && longitude
+        when /polygon/
+          attributes[:the_geom] = convert_to_polygon(attributes[:the_geom])
+        end
+
+        attributes
+      end
+      private :prepare_geo_attributes
+
+      def convert_to_point(latitude, longitude)
+        RGEO_FACTORY.point(longitude, latitude)
+      end
+
+      def convert_to_polygon(the_geom)
+        case the_geom
+        when String
+          RGeo::GeoJSON.decode(the_geom, :json_parser => :json, :geo_factory => RGeo::Geographic.spherical_factory(:srid => 4326))
+        when Hash
+          RGeo::GeoJSON.decode(::JSON.generate(the_geom), :json_parser => :json, :geo_factory => RGeo::Geographic.spherical_factory(:srid => 4326))
+        end
+      end
+      private :convert_to_polygon
+
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+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 geometry_type
+          @geometry_type
+        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 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,121 @@
+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})
+          return if name == 'the_geom'
+
+          @columns_synchronized = false
+          @model_columns ||= []
+          column = {
+            :name => name.to_s,
+            :type =>  CARTODB_TYPES[options[:type]] || options[:type]
+          }
+          return if model_columns.include?(column)
+
+          model_columns << column
+          update_cartodb_schema
+        end
+        private :field
+
+        def set_geometry_type(geometry_type = Point)
+          self.geometry_type = case geometry_type
+                               when Class, Module
+                                 geometry_type.name.split('::').last.downcase
+                               else
+                                 geometry_type.to_s.downcase
+                               end
+        end
+        private :set_geometry_type
+
+        def update_cartodb_schema
+          table = nil
+          if cartodb_table_exists?
+            table = cartodb_table
+          else
+            table = connection.create_table table_name, geometry_type
+          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]
+
+            if column_name.eql?(GEOMETRY_COLUMN) || column_type.eql?('geometry')
+              setup_geometry_column(c)
+            else
+              self.send :define_method, column_name do
+                self.attributes[column_name.to_sym]
+              end
+
+              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