sdb_dal 0.0.1

data/lib/sdb_dal/geo.rb

@@ -0,0 +1,188 @@
+module SdbDal
+
+module Geo
+
+  class Location
+  
+
+    attr_accessor :latitude
+    attr_accessor :longitude
+    
+    def initialize(lat,lon)
+      self.latitude=lat
+      self.longitude=lon
+    end
+
+    def to_address
+	if latitude==nil || longitude==nil
+		return nil
+	end      
+	address='t'
+      right=0
+      top=0
+      width=180.0
+      height=90.0
+      16.times do
+
+        if latitude>top
+          top=top+height/2.0
+          if longitude<right
+            right=right-width/2.0
+            address<<'q'
+          else
+            right=right+width/2.0
+            address << 'r'
+          end
+        else
+
+          top=top-height/2.0
+          if longitude<right
+            right=right-width/2.0
+            address<<'t'
+          else
+            right=right+width/2.0
+            address << 's'
+          end
+        end
+        width=width/2.0
+        height=height/2.0
+    #    puts "#{address} w=#{width}  h=#{height} r=#{right}  t=#{top}"
+      end
+      return address
+    end
+    def get_nearby_addresses(zoom_level)
+      address=self.to_address
+      if address.length>(zoom_level+1)
+        address=address.slice(0,zoom_level+1)        
+      end
+      
+      result=[address]
+      
+      tileWidth=360.0/(2**zoom_level)
+      tileHeight=180.0/(2**zoom_level)
+
+      other=Geo::Location.new(self.latitude+tileHeight,self.longitude+tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude+tileHeight,self.longitude)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude+tileHeight,self.longitude-tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude-tileHeight,self.longitude+tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude-tileHeight,self.longitude)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude-tileHeight,self.longitude-tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+
+      other=Geo::Location.new(self.latitude,self.longitude+tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+      other=Geo::Location.new(self.latitude,self.longitude-tileWidth)
+      result << other.to_address.slice(0,zoom_level+1)
+
+
+    end
+    def  Location.to_location(address)
+      width=90.0
+      height=45.0
+
+      index=0
+      x=0
+      y=0
+      length=address.length-1
+      length.times do
+        index+=1
+
+        puts address[index].chr
+        case address[index].chr
+
+           when 'r'
+            x+=width
+            y+=height
+           when 'q'
+            x-=width
+            y+=height
+
+           when 't'
+            x-=width
+            y-=height
+           when 's'
+            x+=width
+            y-=height
+        end
+        width/=2
+        height/=2
+      end
+        loc=Location.new
+      loc.latitude=y
+      loc.longitude=x
+      return loc
+    end
+
+    def self.deg2rad(deg)
+      (deg * Math::PI / 180)
+      end
+    
+    def self.rad2deg(rad)
+      (rad * 180 / Math::PI)
+    end
+    
+    def self.acos(rad)
+      Math.atan2(Math.sqrt(1 - rad**2), rad)
+    end
+    
+    def distance_in_miles( loc2)
+      lat2 = loc2.latitude
+      lon2 = loc2.longitude
+      theta = self.longitude - lon2
+      
+      dist = Math.sin(self.deg2rad(self.latitude)) * Math.sin(deg2rad(lat2)) + Math.cos(self.deg2rad(self.latitude)) * Math.cos(self.deg2rad(lat2)) * Math.cos(deg2rad(theta))
+      
+      dist = self.rad2deg(self.acos(dist))
+      
+      (dist * 60 * 1.1515).round #distance in miles
+    end
+    
+  end
+
+#mixin
+#locatable object must have latitude, longitude and address attributes
+  module Locatable
+    def location
+      return Geo::Location.new(latitude,longitude)
+    end
+    def get_nearby(zoom_level=7,order=nil)
+       if latitude==nil or longitude==nil 
+	return []
+	end
+	result= self.class.find_near(self.location,zoom_level,order)
+        result.delete_if{|item|item.id==id}
+        return result
+    end
+
+    def find_near(loc,zoom_level=7,order_by=nil,order=:ascending)
+        nearby= loc.get_nearby_addresses(zoom_level)
+
+        address_params=[]
+        for address in nearby
+            
+                 address_params<<StartsWithCondition.new(self.AttributeDescription(:address),address)
+       
+        end
+       orCondition=OrCondition.new(address_params)
+      
+        return find(:all,:limit => 24,:order_by => order_by,:order => order,:conditions=>[orCondition])
+      
+    end
+  end
+  module Xxx
+
+  end
+end
+end

data/lib/sdb_dal/index_description.rb

@@ -0,0 +1,29 @@
+module SdbDal
+
+class IndexDescription < DomainAttributeDescription
+    include SdbFormatter
+ attr_accessor :columns
+  
+    
+  def initialize(name,columns)
+    self.name=name
+    self.columns=columns
+    self.value_type =:string
+    self.is_primary_key=false
+  end
+  
+  def format_index_entry(attribute_descriptions,attribute_values)
+   result=""
+      columns.each do |column|
+        if column.respond_to?(:transform)
+          result << column.transform(attribute_values[column.source_column] )
+        else
+          result<<attribute_descriptions[column].format_for_sdb(attribute_values[column]).to_s
+        end
+        result<<"&"
+      end
+      result
+  end
+  
+end
+end

data/lib/sdb_dal/is_null_transform.rb

@@ -0,0 +1,16 @@
+module SdbDal
+
+class IsNullTransform
+  attr_accessor :name
+  attr_accessor :source_column 
+  def initialize(source_column )
+    self.source_column =source_column 
+    self.name = "#{name}_is_null".to_sym
+  end
+  def transform(value)
+    value.nil?.to_s
+  end
+ 
+  
+end
+end

data/lib/sdb_dal/lazy_loading_text.rb

@@ -0,0 +1,27 @@
+module SdbDal
+ 
+
+class LazyLoadingText
+  attr_reader :is_dirty
+   attr_reader :has_loaded
+  def initialize(get_clob_proc)
+    @get_clob_proc=get_clob_proc
+    @has_loaded=false
+    @is_dirty=false
+  end
+  
+  def value=(v)
+    @is_dirty=true
+    @has_loaded=true
+    @value=v
+  end
+  def value
+    if !@did_load
+        @value= @get_clob_proc.call      
+        @has_loaded=true          
+    end
+    return @value
+    
+  end
+end
+end

data/lib/sdb_dal/memory_repository.rb

@@ -0,0 +1,168 @@
+module SdbDal
+
+require File.dirname(__FILE__) +"/memory_storage.rb"
+
+class MemoryRepository
+  attr_accessor :use_cache #this here just so interface matches sdb repo
+      attr_accessor :storage
+   
+  def initialize(
+      sdb_domain= nil,
+      clob_bucket= nil,
+      aws_key_id= nil,
+      aws_secret_key= nil,
+      memcache_servers = nil ,
+      dummy=nil
+    )
+    @records={}
+    @storage=MemoryStorage.new
+  end
+  def clear_session_cache
+    
+  end
+  def clear
+     @records={}
+    @storage=MemoryStorage.new
+  end
+  def save(table_name, primary_key, attributes)
+    key=make_cache_key(table_name,primary_key);
+    record=@records[key]
+    if !record 
+      record={}
+      @records[key]=record
+        
+    end
+    
+    attributes.each do |description,value|
+      if description.is_clob
+        @storage.put("",make_clob_key(table_name,primary_key,description.name),value)
+      else
+        record[description.name]=value
+      end
+    end
+    record["metadata%table_name"]=table_name
+    record["metadata%primary_key"]=primary_key
+  end
+  def query_ids(table_name,attribute_descriptions,options)
+    primary_key=nil
+    attribute_descriptions.each do |name,desc|
+      if desc.is_primary_key
+        primary_key= name.to_sym 
+        break
+      end
+      
+    end
+    objects=query(table_name,attribute_descriptions,options)
+    result=[]
+    objects.each do | o|
+      result<<o[primary_key]
+    end
+    result
+  end
+  
+  def query(table_name,attribute_descriptions,options)
+      
+    if options[:query]
+      raise 'query not supported yet'
+    end
+    
+    result=[]
+    @records.each do |record_key,record|
+      ok=true
+      if record["metadata%table_name"]!=table_name
+        ok=false
+      else
+        if options.has_key?(:params)
+             
+          options[:params].each do |param_key,param_value|
+
+            if param_value==:NOT_NULL 
+              if record[param_key]==nil
+                ok=false
+                break
+              end
+            elsif param_value==:NULL 
+               if record[param_key]!=nil
+                ok=false
+                break
+              end         
+            elsif param_value.respond_to?(:matches?)
+
+              if !param_value.matches?(record[param_key])
+                ok=false
+                break
+              end
+            elsif !record[param_key] && !param_value
+              #ok 
+              break
+            elsif record[param_key]!=param_value
+              ok=false
+              break
+            end
+          end
+        end
+        if options.has_key?(:conditions)
+             
+          options[:conditions].each do |condition|
+
+            if !condition.matches?(record)
+              ok=false
+              break
+            end
+          end
+        end
+      end
+      if ok
+        result<<record
+      end
+          
+    end
+    
+    if options and options[:order_by]
+      result.sort! do |a,b|
+        a_value=a[options[:order_by]]
+        b_value=b[options[:order_by]]
+        if options[:order] && options[:order]!=:ascending
+          if b_value
+            b_value <=> a_value
+          else
+            -1
+          end
+        else
+          if a_value
+            a_value <=> b_value
+          else
+            -1
+          end
+        end
+      end
+    end
+    if options[:limit] and result.length>options[:limit]
+      result=result[0..options[:limit]-1]
+    end
+    return result
+  end
+  def find_one(table_name, primary_key,attribute_descriptions)#, non_clob_attribute_names, clob_attribute_names)
+    return @records[make_cache_key(table_name,primary_key)]
+  end
+  def get_clob(table_name,primary_key,clob_name)
+    return @storage.get("",make_clob_key(table_name,primary_key,clob_name))
+        
+  end
+  def destroy(table_name, primary_key)
+    key=make_cache_key(table_name,primary_key);
+    
+    if @records.has_key?(key)
+      @records.delete(key)
+    end
+  end
+  
+  private
+  def make_cache_key(table_name,primary_key)
+    return "cached_objects/#{table_name}/#{CGI.escape(primary_key.to_s)}"
+  end
+  def make_clob_key(table_name,primary_key,clob_name)
+    return "clobs/#{table_name}/#{CGI.escape(primary_key)}/#{clob_name}"
+  end
+end
+end

data/lib/sdb_dal/memory_storage.rb

@@ -0,0 +1,29 @@
+module SdbDal
+
+
+class MemoryStorage
+  
+  def initialize
+    @stuff={}
+    @attributes={}
+  end
+  def get(bucket,key)
+    return @stuff[bucket+"sdsdw555"+key]
+        
+  end
+  def delete(bucket,key)
+    @attributes.delete(bucket+"sdsdw555"+key)
+    return @stuff.delete(bucket+"sdsdw555"+key)
+        
+  end
+  def put(bucket,key,object,attributes=nil)
+    @stuff[bucket+"sdsdw555"+key]=object
+    @attributes[bucket+"sdsdw555"+key]=attributes if attributes    
+  end
+  def get_content_type(bucket,key)
+    return @attributes[bucket+"sdsdw555"+key]['Content-Type'] if @attributes.has_key?(bucket+"sdsdw555"+key)
+    return nil
+  end
+end
+
+end

data/lib/sdb_dal/or_condition.rb

@@ -0,0 +1,53 @@
+module SdbDal
+ 
+
+class OrCondition
+    attr_accessor :child_conditions
+    
+  def initialize(child_conditions=[])
+    self.child_conditions=child_conditions
+  end
+  
+  def add(child_condition)
+      self.child_conditions<<child_condition
+  end
+  
+  def matches?(domain_object)
+      
+      self.child_conditions.each do | condition|
+          if condition.respond_to?(:matches?)
+              if condition.matches?(domain_object)
+                  return true
+              end
+                   
+          end
+      end
+      return false
+  end
+  def to_sdb_query
+      first =true
+      query=""
+      count=0
+      self.child_conditions.each do | condition|
+        count=count+1
+          if ! first
+              if count>4
+                  query<< " ] union [ "
+                  count=0
+              else
+                  query<< " or "
+              end
+          end
+              first=false
+          
+          if condition.respond_to?(:to_sdb_query)
+             
+              query << condition.to_sdb_query
+          else  
+               query << condition.to_s      
+          end
+      end
+      return query
+  end
+end
+end

data/lib/sdb_dal/query_string_auth_generator.rb

@@ -0,0 +1,166 @@
+require 'base64'
+require 'cgi'
+require 'openssl'
+require 'digest/sha1'
+require 'time'
+module SdbDal
+module S3
+    # This interface mirrors the AWSAuthConnection class, but instead
+    # of performing the operations, this class simply returns a url that can
+    # be used to perform the operation with the query string authentication
+    # parameters set.
+    # PLEASE NOTE - For security reasons, it is HIGHLY RECOMMENDED to avoid
+    # using product tokens in signed urls.  Please see the README for 
+    # further details.
+  class QueryStringAuthGenerator
+    attr_accessor :calling_format
+    attr_accessor :expires
+    attr_accessor :expires_in
+    attr_reader :server
+    attr_reader :port
+
+    # by default, expire in 1 minute
+    DEFAULT_EXPIRES_IN = 60
+
+    def initialize(aws_access_key_id, aws_secret_access_key, tokens=Array.new,
+            is_secure=true, 
+                   server=DEFAULT_HOST, port=PORTS_BY_SECURITY[is_secure], 
+                   format=CallingFormat::REGULAR)
+      @aws_access_key_id = aws_access_key_id
+      @aws_secret_access_key = aws_secret_access_key
+      @protocol = is_secure ? 'https' : 'http'
+      @server = server
+      @port = port
+      @calling_format = format 
+      @tokens = tokens 
+      # by default expire
+      @expires_in = DEFAULT_EXPIRES_IN
+      
+     
+    end
+    def tokens
+        @tokens
+    end
+
+    # set the expires value to be a fixed time.  the argument can
+    # be either a Time object or else seconds since epoch.
+    def expires=(value)
+      @expires = value
+      @expires_in = nil
+    end
+
+    # set the expires value to expire at some point in the future
+    # relative to when the url is generated.  value is in seconds.
+    def expires_in=(value)
+      @expires_in = value
+      @expires = nil
+    end
+
+    def create_bucket(bucket, headers={})
+      return generate_url('PUT', bucket, '', {}, headers)
+    end
+
+    # takes options :prefix, :marker, :max_keys, and :delimiter
+    def list_bucket(bucket, options={}, headers={})
+      path_args = {}
+      options.each { |k, v|
+        path_args[k] = v.to_s
+      }
+      return generate_url('GET', bucket, '', path_args, headers)
+    end
+
+    def delete_bucket(bucket, headers={})
+      return generate_url('DELETE', bucket, '', {}, headers)
+    end
+
+    # don't really care what object data is.  it's just for conformance with the
+    # other interface.  If this doesn't work, check tcpdump to see if the client is
+    # putting a Content-Type header on the wire.
+    def put(bucket, key, object=nil, headers={})
+      object = S3Object.new(object) if not object.instance_of? S3Object
+      return generate_url('PUT', bucket, CGI::escape(key), {}, merge_meta(headers, object))
+    end
+
+    def get(bucket, key, headers={})
+      return generate_url('GET', bucket, CGI::escape(key), {}, headers)
+    end
+
+    def delete(bucket, key, headers={})
+      return generate_url('DELETE', bucket, CGI::escape(key), {}, headers)
+    end
+
+    def get_bucket_logging(bucket, headers={})
+      return generate_url('GET', bucket, '', {'logging' => nil}, headers)
+    end
+
+    def put_bucket_logging(bucket, logging_xml_doc, headers={})
+      return generate_url('PUT', bucket, '', {'logging' => nil}, headers)
+    end
+
+    def get_acl(bucket, key='', headers={})
+      return generate_url('GET', bucket, CGI::escape(key), {'acl' => nil}, headers)
+    end
+
+    def get_bucket_acl(bucket, headers={})
+      return get_acl(bucket, '', headers)
+    end
+
+    # don't really care what acl_xml_doc is.
+    # again, check the wire for Content-Type if this fails.
+    def put_acl(bucket, key, acl_xml_doc, headers={})
+      return generate_url('PUT', bucket, CGI::escape(key), {'acl' => nil}, headers)
+    end
+
+    def put_bucket_acl(bucket, acl_xml_doc, headers={})
+      return put_acl(bucket, '', acl_xml_doc, headers)
+    end
+
+    def list_all_my_buckets(headers={})
+      return generate_url('GET', '', '', {}, headers)
+    end
+
+
+    private
+    # generate a url with the appropriate query string authentication
+    # parameters set.
+    def generate_url(method, bucket="", key="", path_args={}, headers={})
+      expires = 0
+      if not @expires_in.nil?
+        expires = Time.now.to_i + @expires_in
+      elsif not @expires.nil?
+        expires = @expires
+      else
+        raise "invalid expires state"
+      end
+      if @tokens && !@tokens.empty?
+          headers[AMAZON_TOKEN_HEADER_PREFIX]=@tokens.join(',')
+          path_args[AMAZON_TOKEN_HEADER_PREFIX]=@tokens.join(',')
+      end
+      canonical_string =
+        S3::canonical_string(method, bucket, key, path_args, headers, expires)
+      encoded_canonical =
+        S3::encode(@aws_secret_access_key, canonical_string)
+      
+      url = CallingFormat.build_url_base(@protocol, @server, @port, bucket, @calling_format)
+      
+      path_args["Signature"] = encoded_canonical.to_s
+      path_args["Expires"] = expires.to_s
+      path_args["AWSAccessKeyId"] = @aws_access_key_id.to_s
+    
+      arg_string = S3.path_args_hash_to_string(path_args) 
+
+      return "#{url}/#{key}?#{arg_string}"
+    end
+
+    def merge_meta(headers, object)
+      final_headers = headers.clone
+      if not object.nil? and not object.metadata.nil?
+        object.metadata.each do |k, v|
+          final_headers[METADATA_PREFIX + k] = v
+        end
+      end
+      return final_headers
+    end
+  end
+end
+end

data/lib/sdb_dal/reference.rb

@@ -0,0 +1,28 @@
+module SdbDal
+
+
+class Reference
+    attr_accessor :target_class 
+    attr_accessor :primary_key 
+    attr_accessor :index 
+  def initialize(options={})
+      if options.has_key?(:target)
+          self.target_class=options[:target].class.name.to_sym
+          self.primary_key=options[:target].primary_key
+      end
+      self.index=-1
+      if options.has_key?(:index)
+          self.index=options[:index]
+      end
+  end
+  def targets?(item)
+      return false unless item 
+      self.target_class==item.class.name.to_sym and self.primary_key==item.primary_key
+  end
+  def get_target
+      the_class=Kernel.const_get(self.target_class)
+      the_class.find(self.primary_key)
+      
+  end
+end
+end