sunstone 0.1.0 → 1.0.0

data/lib/ext/active_record/associations/builder/has_and_belongs_to_many.rb

@@ -0,0 +1,48 @@
+module ActiveRecord::Associations::Builder
+  class HasAndBelongsToMany # :nodoc:
+
+    def through_model
+      habtm = JoinTableResolver.build lhs_model, association_name, options
+      
+      join_model = Class.new(lhs_model.base_class.superclass) {
+        class << self;
+          attr_accessor :class_resolver
+          attr_accessor :name
+          attr_accessor :table_name_resolver
+          attr_accessor :left_reflection
+          attr_accessor :right_reflection
+        end
+
+        def self.table_name
+          table_name_resolver.join_table
+        end
+
+        def self.compute_type(class_name)
+          class_resolver.compute_type class_name
+        end
+
+        def self.add_left_association(name, options)
+          belongs_to name, options
+          self.left_reflection = _reflect_on_association(name)
+        end
+
+        def self.add_right_association(name, options)
+          rhs_name = name.to_s.singularize.to_sym
+          belongs_to rhs_name, options
+          self.right_reflection = _reflect_on_association(rhs_name)
+        end
+
+      }
+
+      join_model.name                = "HABTM_#{association_name.to_s.camelize}"
+      join_model.table_name_resolver = habtm
+      join_model.class_resolver      = lhs_model
+      join_model.primary_key         = nil
+
+      join_model.add_left_association :left_side, class: lhs_model
+      join_model.add_right_association association_name, belongs_to_options(options)
+      join_model
+    end
+
+  end
+end

data/lib/ext/active_record/relation.rb

@@ -0,0 +1,26 @@
+module ActiveRecord
+  class Relation
+    def to_sql
+      @to_sql ||= begin
+                    relation   = self
+                    connection = klass.connection
+                    visitor    = connection.visitor
+                    collector  = connection.collector
+
+                    if eager_loading?
+                      find_with_associations { |rel| relation = rel }
+                    end
+
+                    arel  = relation.arel
+                    binds = (arel.bind_values + relation.bind_values).dup
+                    binds.map! { |bv| connection.quote(*bv.reverse) }
+                    collect = visitor.accept(arel.ast, collector)
+                    if collector.is_a?(Arel::Collectors::Sunstone)
+                      collect.compile(binds)
+                    else
+                      collect.substitute_binds(binds).join
+                    end
+                  end
+    end
+  end
+end

data/lib/ext/active_record/statement_cache.rb

@@ -0,0 +1,24 @@
+module ActiveRecord
+  class StatementCache
+    class PartialQuery
+      
+      def initialize collector
+        @collector = collector
+        @indexes = collector.value.find_all { |thing|
+          Arel::Nodes::BindParam === thing
+        }
+      end
+
+      def sql_for(binds, connection)
+        binds = binds.dup
+        @collector.compile(binds)
+      end
+    end
+
+    def self.partial_query(visitor, ast, collector)
+      collected = visitor.accept(ast, collector)
+      PartialQuery.new collected
+    end
+
+  end
+end

data/lib/sunstone.rb

@@ -1,361 +1,51 @@
-require 'set'
-require 'uri'
-require 'net/https'
-
 require 'wankel'
 require 'cookie_store'
-require 'connection_pool'
 
 require 'active_support'
 require 'active_support/core_ext'
 
 require 'active_model'
 
+require 'active_record'
+
+require 'sunstone/connection'
 require 'sunstone/exception'
-require 'sunstone/schema'
-require 'sunstone/model'
-require 'sunstone/parser'
+require 'ext/active_record/statement_cache'
+require 'ext/active_record/relation'
+require 'ext/active_record/associations/builder/has_and_belongs_to_many'
+
+# require 'sunstone/parser'
 
-# _Sunstone_ is a low-level API. It provides basic HTTP #get, #post, #put, and
-# #delete calls to the Sunstone Server. It can also provides basic error
-# checking of responses.
 module Sunstone
   VERSION = 0.1
-  
-  extend self
-  
-  attr_reader :site
-  
-  # Set the User-Agent of the client. Will be joined with other User-Agent info
-  attr_writer :user_agent
-  attr_accessor :api_key, :host, :port, :use_ssl
-  
-  # Sets the Protocol, API Token, and Host and Port of the API Server
-  #
-  # #!ruby
-  # Sunstone.site = "https://API_KEY@host.com"
-  def site=(url)
-    @site = url
-    uri = URI.parse(url)
-    @api_key = uri.user ? CGI.unescape(uri.user) : nil
-    @host, @port = uri.host, uri.port
-    @use_ssl = (uri.scheme == 'https')
-  end
-  
-  # Returns the User-Agent of the client. Defaults to:
-  # "sunstone-ruby/SUNSTONE_VERSION RUBY_VERSION-pPATCH_LEVEL PLATFORM"
-  def user_agent
-    [
-      @user_agent,
-      "Sunstone/#{Sunstone::VERSION}",
-      "Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}",
-      RUBY_PLATFORM
-    ].compact.join(' ')
-  end
-  
-  # Set a cookie jar to use during request sent during the 
-  def with_cookie_store(store, &block)
-    Thread.current[:sunstone_cookie_store] = store
-    yield
-  ensure
-    Thread.current[:sunstone_cookie_store] = nil
-  end
-
-  # Sends a Net::HTTPRequest to the server. The headers returned from
-  # Sunestone#headers are automatically added to the request. The appropriate
-  # error is raised if the response is not in the 200..299 range.
-  #
-  # Paramaters::
-  #
-  # * +request+ - A Net::HTTPRequest to send to the server
-  # * +body+ - Optional, a String, IO Object, or a Ruby object which is 
-  #            converted into JSON and sent as the body
-  # * +block+ - An optional block to call with the +Net::HTTPResponse+ object.
-  #
-  # Return Value::
-  #
-  #  Returns the return value of the <tt>&block</tt> if given, otherwise the
-  #  response object (a Net::HTTPResponse)
-  #
-  # Examples:
-  #
-  #  #!ruby
-  #  Sunstone.send_request(#<Net::HTTP::Get>) # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.send_request(#<Net::HTTP::Get @path="/404">) # => raises Sunstone::Exception::NotFound
-  #
-  #  # this will still raise an exception if the response_code is not valid
-  #  # and the block will not be called
-  #  Sunstone.send_request(#<Net::HTTP::Get>) do |response|
-  #    # ...
-  #  end
-  #
-  #  # The following example shows how to stream a response:
-  #  Sunstone.send_request(#<Net::HTTP::Get>) do |response|
-  #    response.read_body do |chunk|
-  #      io.write(chunk)
-  #    end
-  #  end
-  def send_request(request, body=nil, &block)
-    request_headers.each { |k, v| request[k] = v }
-    
-    if body.is_a?(IO)
-      request['Transfer-Encoding'] = 'chunked'
-      request.body_stream =  body
-    elsif body.is_a?(String)
-      request.body = body
-    elsif body
-      request.body = Wankel.encode(body)
-    end
-    
-    return_value = nil
-    with_connection do |connection|
-      connection.request(request) do |response|
-        
-        if response['X-42Floors-API-Version-Deprecated']
-          logger.warn("DEPRECATION WARNING: API v#{API_VERSION} is being phased out")
-        end
-        
-        validate_response_code(response)
-        
-        # Get the cookies
-        response.each_header do |key, value|
-          if key.downcase == 'set-cookie' && Thread.current[:sunstone_cookie_store]
-            Thread.current[:sunstone_cookie_store].set_cookie("#{site}#{request.path}", value)
-          end
-        end
-        
-        if block_given?
-          return_value =yield(response)
-        else
-          return_value =response
-        end
-      end
-    end
-    
-    return_value
-  end
-  
-  # Send a GET request to +path+ on the Sunstone Server via +Sunstone#send_request+.
-  # See +Sunstone#send_request+ for more details on how the response is handled.
-  #
-  # Paramaters::
-  #
-  # * +path+ - The +path+ on the server to GET to.
-  # * +params+ - Either a String, Hash, or Ruby Object that responds to
-  #              #to_param. Appended on the URL as query params
-  # * +block+ - An optional block to call with the +Net::HTTPResponse+ object.
-  #
-  # Return Value::
-  #
-  #  See +Sunstone#send_request+
-  #
-  # Examples:
-  #
-  #  #!ruby
-  #  Sunstone.get('/example') # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.get('/example', 'query=stuff') # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.get('/example', {:query => 'stuff'}) # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.get('/404') # => raises Sunstone::Exception::NotFound
-  #
-  #  Sunstone.get('/act') do |response|
-  #    # ...
-  #  end
-  def get(path, params='', &block)
-    params ||= ''
-    request = Net::HTTP::Get.new(path + '?' + params.to_param)
-    
-    send_request(request, nil, &block)
-  end
 
-  # Send a POST request to +path+ on the Sunstone Server via +Sunstone#send_request+.
-  # See +Sunstone#send_request+ for more details on how the response is handled.
-  #
-  # Paramaters::
-  #
-  # * +path+ - The +path+ on the server to POST to.
-  # * +body+ - Optional, See +Sunstone#send_request+.
-  # * +block+ - Optional, See +Sunstone#send_request+
-  #
-  # Return Value::
-  #
-  #  See +Sunstone#send_request+
-  #
-  # Examples:
-  #
-  #  #!ruby
-  #  Sunstone.post('/example') # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.post('/example', 'body') # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.post('/example', #<IO Object>) # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.post('/example', {:example => 'data'}) # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.post('/404') # => raises Sunstone::Exception::NotFound
-  #
-  #  Sunstone.post('/act') do |response|
-  #    # ...
-  #  end
-  def post(path, body=nil, &block)
-    request = Net::HTTP::Post.new(path)
-    
-    send_request(request, body, &block)
-  end
-  
-  # Send a PUT request to +path+ on the Sunstone Server via +Sunstone#send_request+.
-  # See +Sunstone#send_request+ for more details on how the response is handled.
-  #
-  # Paramaters::
-  #
-  # * +path+ - The +path+ on the server to POST to.
-  # * +body+ - Optional, See +Sunstone#send_request+.
-  # * +block+ - Optional, See +Sunstone#send_request+
-  #
-  # Return Value::
-  #
-  #  See +Sunstone#send_request+
-  #
-  # Examples:
-  #
-  #  #!ruby
-  #  Sunstone.put('/example') # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.put('/example', 'body') # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.put('/example', #<IO Object>) # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.put('/example', {:example => 'data'}) # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.put('/404') # => raises Sunstone::Exception::NotFound
-  #
-  #  Sunstone.put('/act') do |response|
-  #    # ...
-  #  end
-  def put(path, body=nil, *valid_response_codes, &block)
-    request = Net::HTTP::Put.new(path)
-    
-    send_request(request, body, &block)
-  end
-  
-  # Send a DELETE request to +path+ on the Sunstone Server via +Sunstone#send_request+.
-  # See +Sunstone#send_request+ for more details on how the response is handled
-  #
-  # Paramaters::
-  #
-  # * +path+ - The +path+ on the server to POST to.
-  # * +block+ - Optional, See +Sunstone#send_request+
-  #
-  # Return Value::
-  #
-  #  See +Sunstone#send_request+
-  #
-  # Examples:
-  #
-  #  #!ruby
-  #  Sunstone.delete('/example') # => #<Net::HTTP::Response>
-  #
-  #  Sunstone.delete('/404') # => raises Sunstone::Exception::NotFound
-  #
-  #  Sunstone.delete('/act') do |response|
-  #    # ...
-  #  end
-  def delete(path, &block)
-    request = Net::HTTP::Delete.new(path)
-    
-    send_request(request, nil, &block)
-  end
-  
-  # Get a connection from the connection pool and perform the block with
-  # the connection
-  def with_connection(&block)
-    connection_pool.with({}, &block)
-  end
-  
-  # Ping the Sunstone. If everything is configured and operating correctly
-  # <tt>"pong"</tt> will be returned. Otherwise and Sunstone::Exception should be
-  # thrown.
-  #
-  #  #!ruby
-  #  Sunstone.ping # => "pong"
-  #
-  #  Sunstone.ping # raises Sunstone::Exception::ServiceUnavailable if a 503 is returned
-  def ping
-    get('/ping').body
-  end
-  
-  def config
-    @config ||= Wankel.parse(get('/config').body, :symbolize_keys => true)
-  end
-  
-  private
-  
-  def request_headers
-    headers = {
-      'Content-Type'            => 'application/json',
-      'User-Agent'              => user_agent
-    }
-    
-    headers['Api-Key'] = api_key if api_key
-    
-    headers
-  end
-  
-  # Raise an Sunstone::Exception based on the response_code, unless the response_code
-  # is include in the valid_response_codes Array
-  #
-  # Paramaters::
-  #
-  # * +response+ - The Net::HTTP::Response object
-  #
-  # Return Value::
-  #
-  #  If an exception is not raised the +response+ is returned
-  #
-  # Examples:
-  #
-  #  #!ruby
-  #  Sunstone.validate_response_code(<Net::HTTP::Response @code=200>) # => <Net::HTTP::Response @code=200>
-  #
-  #  Sunstone.validate_response_code(<Net::HTTP::Response @code=404>) # => raises Sunstone::Exception::NotFound
-  #
-  #  Sunstone.validate_response_code(<Net::HTTP::Response @code=500>) # => raises Sunstone::Exception
-  def validate_response_code(response)
-    code = response.code.to_i
-    
-    if !(200..299).include?(code)
-      case code
-      when 400
-        raise Sunstone::Exception::BadRequest, response
-      when 401
-        raise Sunstone::Exception::Unauthorized, response
-      when 404
-        raise Sunstone::Exception::NotFound, response
-      when 410
-        raise Sunstone::Exception::Gone, response
-      when 422
-        raise Sunstone::Exception::ApiVersionUnsupported, response
-      when 503
-        raise Sunstone::Exception::ServiceUnavailable, response
-      when 301
-        raise Sunstone::Exception::MovedPermanently, response
-      when 300..599
-        raise Sunstone::Exception, response
-      else
-        raise Sunstone::Exception, response
-      end
-    end
-  end
-  
-  def connection_pool
-    @connection_pool ||= ConnectionPool.new(size: 5, timeout: 5) do
-      connection = Net::HTTP.new(@host, @port)
-      connection.use_ssl = @ssl
-      connection
-    end
-  end
-  
+# TODO:
+#   # Set a cookie jar to use during request sent during the
+#   def with_cookie_store(store, &block)
+#     Thread.current[:sunstone_cookie_store] = store
+#     yield
+#   ensure
+#     Thread.current[:sunstone_cookie_store] = nil
+#   end
+#
+#
+#   # Get a connection from the connection pool and perform the block with
+#   # the connection
+#   def with_connection(&block)
+#     connection_pool.with({}, &block)
+#   end
+#
+#   private
+#
+#   def request_headers
+#     headers = {
+#       'Content-Type'            => 'application/json',
+#       'User-Agent'              => user_agent
+#     }
+#
+#     headers['Api-Key'] = api_key if api_key
+#
+#     headers
+#   end
+#
 end