sunstone 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5c574fe947ca4f3c808d4b1d843ae0e2bb4ce9ea
-  data.tar.gz: a2410c511c64d0f2b7a85dbc5cbbff3b23a2f7a1
+  metadata.gz: c22d4667778ecfe53034454215950b7c93c82dac
+  data.tar.gz: fab3525c04c36627f5df0788ab9357fe5b020135
 SHA512:
-  metadata.gz: 3837b844459bdf78f20fd3562f44b6a91cb53c3fa3f4474d32bf3e7375b96400a2b39a45e907ff0fc2cf0d60730d2984606f01a13bfa7b03a01e330878d5be75
-  data.tar.gz: bf4c9c42165f389bc6e5e1475b19641a24d41ed6b7f8007fa37a549fdf6917656db7ebdcb609156b649d3c793eac053db84aa9fad2be3fabcc603430e8009d61
+  metadata.gz: 0758fa4348af24daae4be0a7217385e7e648dd8ff8790521a12411559b3b0f15892028eb6c2398b85e67546b40fc1c9c2edfa3a93d6bb2b07f920411e11cb17f
+  data.tar.gz: ef3c3385aa3502ce96e787e53b653cb8b9901fc9dcd11b756c9098e24ad3e3d2ea30abb8017913df15d6bcffc4b527d96f8185d4eb0d63415539193bbc510221

data/lib/active_record/connection_adapters/sunstone/column.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module ConnectionAdapters
+    # Sunstone-specific extensions to column definitions in a table.
+    class SunstoneColumn < Column #:nodoc:
+      attr_accessor :array
+
+      def initialize(name, cast_type, options={})
+        @primary_key = (options['primary_key'] == true)
+        @array = !!options['array']
+        super(name, options['default'], cast_type, nil, options['null'])
+      end
+      
+      def primary_key?
+        @primary_key
+      end
+      
+    end
+  end
+end

data/lib/active_record/connection_adapters/sunstone/database_statements.rb

@@ -0,0 +1,40 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sunstone
+      module DatabaseStatements
+        
+        # Converts an arel AST to a Sunstone API Request
+        def to_sar(arel, bvs)
+          if arel.respond_to?(:ast)
+            collected = visitor.accept(arel.ast, collector)
+            collected.compile(bvs)
+          else
+            arel
+          end
+        end
+              
+        # Returns an ActiveRecord::Result instance.
+        def select_all(arel, name = nil, binds = [], &block)
+          exec_query(arel, name, binds)
+        end
+        
+        def exec_query(arel, name = 'SAR', binds = [])
+          result = exec(to_sar(arel, binds), name)
+
+          if result.is_a?(Array)
+            ActiveRecord::Result.new(result[0] ? result[0].keys : [], result.map{|r| r.values})
+          else
+            # this is a count.. yea i know..
+            ActiveRecord::Result.new(['all'], [[result]], {:all => type_map.lookup('integer')})
+          end
+        end
+
+      end
+    end
+  end
+end
+
+
+
+
+

data/lib/active_record/connection_adapters/sunstone/schema_statements.rb

@@ -0,0 +1,95 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sunstone
+
+      module SchemaStatements
+
+        # Returns true if table exists.
+        # If the schema is not specified as part of +name+ then it will only find tables within
+        # the current schema search path (regardless of permissions to access tables in other schemas)
+        def table_exists?(name)
+          schema_definition[name] != nil
+        end
+
+        # Returns the list of all column definitions for a table.
+        def columns(table_name)
+          # Limit, precision, and scale are all handled by the superclass.
+          column_definitions(table_name).map do |column_name, options|
+            new_column(column_name, lookup_cast_type(options['type']), options)
+          end
+        end
+
+        # Returns the list of a table's column names, data types, and default values.
+        #
+        # Query implementation notes:
+        #  - format_type includes the column size constraint, e.g. varchar(50)
+        #  - ::regclass is a function that gives the id for a table name
+        def column_definitions(table_name) # :nodoc:
+          definition = schema_definition[table_name]
+          raise ActiveRecord::StatementInvalid, "Table \"#{table_name}\" does not exist" if definition.nil?
+
+          definition
+        end
+        
+        def schema_definition
+          exec( Arel::Table.new(:schema).project )
+        end
+    
+        def tables
+          Wankel.parse(@connection.get('/schema').body, :symbolize_keys => true).keys
+        end
+        
+        def new_column(name, cast_type, options={}) # :nodoc:
+          SunstoneColumn.new(name, cast_type, options)
+        end
+
+        # TODO: def encoding
+
+        # Returns just a table's primary key
+        def primary_key(table)
+          columns(table).find{ |c| c.primary_key? }.name
+        end
+
+        # TODO: do we need this?
+        # Maps logical Rails types to PostgreSQL-specific data types.
+        # def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+        #   case type.to_s
+        #   when 'binary'
+        #     # PostgreSQL doesn't support limits on binary (bytea) columns.
+        #     # The hard limit is 1Gb, because of a 32-bit size field, and TOAST.
+        #     case limit
+        #     when nil, 0..0x3fffffff; super(type)
+        #     else raise(ActiveRecordError, "No binary type has byte size #{limit}.")
+        #     end
+        #   when 'text'
+        #     # PostgreSQL doesn't support limits on text columns.
+        #     # The hard limit is 1Gb, according to section 8.3 in the manual.
+        #     case limit
+        #     when nil, 0..0x3fffffff; super(type)
+        #     else raise(ActiveRecordError, "The limit on text can be at most 1GB - 1byte.")
+        #     end
+        #   when 'integer'
+        #     return 'integer' unless limit
+        #
+        #     case limit
+        #       when 1, 2; 'smallint'
+        #       when 3, 4; 'integer'
+        #       when 5..8; 'bigint'
+        #       else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with precision 0 instead.")
+        #     end
+        #   when 'datetime'
+        #     return super unless precision
+        #
+        #     case precision
+        #       when 0..6; "timestamp(#{precision})"
+        #       else raise(ActiveRecordError, "No timestamp type has precision of #{precision}. The allowed range of precision is from 0 to 6")
+        #     end
+        #   else
+        #     super
+        #   end
+        # end
+
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sunstone/type/date_time.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module Sunstone
+      module Type
+        class DateTime < ActiveRecord::Type::DateTime
+          
+          def type_cast_for_database(value)
+            super(value).iso8601(3) if value
+          end
+          
+          def cast_value(string)
+            return string unless string.is_a?(::String)
+            return if string.empty?
+
+            ::DateTime.iso8601(string) || fast_string_to_time(string) || fallback_string_to_time(string)
+          end
+         
+        end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/sunstone_adapter.rb

@@ -0,0 +1,177 @@
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/statement_pool'
+
+require 'arel/visitors/sunstone'
+require 'arel/collectors/sunstone'
+
+require 'active_record/connection_adapters/sunstone/database_statements'
+require 'active_record/connection_adapters/sunstone/schema_statements'
+require 'active_record/connection_adapters/sunstone/column'
+
+require 'active_record/connection_adapters/sunstone/type/date_time'
+
+module ActiveRecord
+  module ConnectionHandling # :nodoc:
+
+    VALID_SUNSTONE_CONN_PARAMS = [:site, :host, :port, :api_key, :use_ssl]
+
+    # Establishes a connection to the database that's used by all Active Record
+    # objects
+    def sunstone_connection(config)
+      conn_params = config.symbolize_keys
+
+      conn_params.delete_if { |_, v| v.nil? }
+
+      # Map ActiveRecords param names to PGs.
+      conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
+      conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]
+      if conn_params[:site]
+        uri = URI.parse(conn_params.delete(:site))
+        conn_params[:api_key] ||= (uri.user ? CGI.unescape(uri.user) : nil)
+        conn_params[:host]    ||= uri.host
+        conn_params[:port]    ||= uri.port
+        conn_params[:use_ssl] ||= (uri.scheme == 'https')
+      end
+      
+      # Forward only valid config params to PGconn.connect.
+      conn_params.keep_if { |k, _| VALID_SUNSTONE_CONN_PARAMS.include?(k) }
+
+      # The postgres drivers don't allow the creation of an unconnected PGconn object,
+      # so just pass a nil connection object for the time being.
+      ConnectionAdapters::SunstoneAPIAdapter.new(nil, logger, conn_params, config)
+    end
+  end
+
+  module ConnectionAdapters
+    # The SunstoneAPI adapter.
+    #
+    # Options:
+    #
+    # * <tt>:host</tt> - Defaults to a Unix-domain socket in /tmp. On machines
+    #   without Unix-domain sockets, the default is to connect to localhost.
+    # * <tt>:port</tt> - Defaults to 5432.
+    # * <tt>:username</tt> - The API key to connect with
+    # * <tt>:encoding</tt> - An optional client encoding that is used in a <tt>SET client_encoding TO
+    #   <encoding></tt> call on the connection.
+    class SunstoneAPIAdapter < AbstractAdapter
+      ADAPTER_NAME = 'Sunstone'
+
+      NATIVE_DATABASE_TYPES = {
+        string:      { name: "string" },
+        number:      { name: "number" },
+        json:        { name: "json" },
+        boolean:     { name: "boolean" }
+      }
+
+      include Sunstone::DatabaseStatements
+      include Sunstone::SchemaStatements
+      
+      # Returns 'SunstoneAPI' as adapter name for identification purposes.
+      def adapter_name
+        ADAPTER_NAME
+      end
+      
+      # Adds `:array` option to the default set provided by the AbstractAdapter
+      def prepare_column_options(column, types) # :nodoc:
+        spec = super
+        spec[:array] = 'true' if column.respond_to?(:array) && column.array
+        spec
+      end
+
+      # Initializes and connects a SunstoneAPI adapter.
+      def initialize(connection, logger, connection_parameters, config)
+        super(connection, logger)
+
+        @visitor = Arel::Visitors::Sunstone.new self
+        @connection_parameters, @config = connection_parameters, config
+
+        connect
+
+        @type_map = Type::HashLookupTypeMap.new
+        initialize_type_map(type_map)
+      end
+
+      # Is this connection alive and ready for queries?
+      def active?
+        @connection.ping
+        true
+      rescue Net::HTTPExceptions
+        false
+      end
+
+      # TODO: this doesn't work yet
+      # Close then reopen the connection.
+      def reconnect!
+        super
+        @connection.reset
+        configure_connection
+      end
+
+      # TODO don't know about this yet
+      def reset!
+        configure_connection
+      end
+
+      # TODO: deal with connection.close
+      # Disconnects from the database if already connected. Otherwise, this
+      # method does nothing.
+      def disconnect!
+        super
+        @connection.close rescue nil
+      end
+
+      def native_database_types #:nodoc:
+        NATIVE_DATABASE_TYPES
+      end
+
+      def use_insert_returning?
+        true
+      end
+
+      def valid_type?(type)
+        !native_database_types[type].nil?
+      end
+
+      def update_table_definition(table_name, base) #:nodoc:
+        SunstoneAPI::Table.new(table_name, base)
+      end
+      
+      def collector
+        Arel::Collectors::Sunstone.new
+      end
+      
+      def server_config
+        Wankel.parse(@connection.get("/configuration").body)
+      end
+
+      private
+
+        def initialize_type_map(m) # :nodoc:
+          m.register_type 'boolean',    Type::Boolean.new
+          m.register_type 'string',     Type::String.new
+          m.register_type 'integer',    Type::Integer.new
+          m.register_type 'decimal',    Type::Decimal.new
+          m.register_type 'datetime',   Sunstone::Type::DateTime.new
+          m.register_type 'hash',       Type::Value.new
+        end
+
+        def exec(arel, name='SAR', binds=[])
+          # result = without_prepared_statement?(binds) ? exec_no_cache(sql, name, binds) :
+          #                                               exec_cache(sql, name, binds)
+          sar = to_sar(arel, binds)
+
+          log(sar.is_a?(String) ? sar : "#{sar.class} #{CGI.unescape(sar.path)}", name) { Wankel.parse(@connection.send_request(sar).body) }
+        end
+
+        # Connects to a Sunstone API server and sets up the adapter depending on
+        # the connected server's characteristics.
+        def connect
+          @connection = ::Sunstone::Connection.new(@connection_parameters)
+        end
+
+        def create_table_definition(name, temporary, options, as = nil) # :nodoc:
+          SunstoneAPI::TableDefinition.new native_database_types, name, temporary, options, as
+        end
+    end
+  end
+end

data/lib/arel/collectors/sunstone.rb

@@ -0,0 +1,75 @@
+module Arel
+  module Collectors
+    class Sunstone < Arel::Collectors::Bind
+      
+      attr_accessor :request_type, :table, :where, :limit, :offset, :order, :operation, :columns
+      
+      def substitute_binds hash, bvs
+        if hash.is_a?(Array)
+          hash.map { |w| substitute_binds(w, bvs) }
+        else
+          newhash = {}
+          hash.each do |k, v|
+            if Arel::Nodes::BindParam === v
+              newhash[k] = bvs.shift.last
+            elsif v.is_a?(Hash)
+              newhash[k] = substitute_binds(v, bvs)
+            else
+              newhash[k] = v
+            end
+          end
+          newhash
+        end
+      end
+      
+      def value
+        flatten_nested(where).flatten
+      end
+      
+      def flatten_nested(obj)
+        if obj.is_a?(Array)
+          obj.map { |w| flatten_nested(w) }
+        elsif obj.is_a?(Hash)
+          obj.map{ |k,v| [k, flatten_nested(v)] }.flatten
+        else
+          obj
+        end
+      end
+      
+      def compile bvs
+        path = "/#{table}"
+        
+        case operation
+        when :count, :average, :min, :max
+          path += "/#{operation}"
+        end
+        
+        get_params = {}
+        
+        if where
+          get_params[:where] = substitute_binds(where.clone, bvs)
+          if get_params[:where].size == 1
+            get_params[:where] = get_params[:where].pop
+          end
+        end
+        
+        get_params[:limit] = limit if limit
+        get_params[:offset] = offset if offset
+        get_params[:order] = order if order
+        get_params[:columns] = columns if columns
+        
+        if get_params.size > 0
+          path += '?' + get_params.to_param
+        end
+          
+        request = request_type.new(path)
+        
+        request
+      end
+      
+    end
+  end
+end
+
+
+