simply_stored 0.1.4

data/lib/simply_stored/simpledb/attributes.rb

@@ -0,0 +1,173 @@
+module SimplyStored
+  module SimpleDB
+    module Attributes
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    
+      module ClassMethods
+        # generates an accessor for a simple attribute
+        def simpledb_string(*attributes)
+          attributes.each do |attr|
+            # getter
+            define_method attr.to_s do
+              self[attr.to_s].try(:first) || @_partitioned_attributes.try(:[], attr.to_s)
+            end
+      
+            # setter
+            define_method "#{attr}=" do |val|
+              self[attr.to_s] = val
+            end
+      
+            add_attribute_definition_to_attribute_list(attr)
+            add_attribute_definition_to_partition_list(attr)
+          end
+        end
+  
+        def simpledb_array(*attributes)
+          attributes.each do |attr|
+            # getter
+            define_method attr.to_s do
+              self[attr.to_s] = [] unless self[attr.to_s]
+              self[attr.to_s]
+            end
+      
+            # setter
+            define_method "#{attr}=" do |val|
+              self[attr.to_s] = [val].flatten
+            end
+      
+            add_attribute_definition_to_attribute_list(attr)
+          end
+        end
+  
+        def simpledb_timestamp(*attributes)
+          attributes.each do |attr|
+            # getter
+            define_method attr.to_s do
+              if self[attr.to_s]
+                cached = instance_variable_get("@#{attr}")
+                if cached
+                  return cached
+                else
+                  val = Time.parse(self[attr.to_s].first + "+0000").utc # UTC
+                  instance_variable_set("@#{attr}", val)
+                  return val
+                end
+              else
+                nil
+              end
+            end
+      
+            # setter
+            define_method "#{attr}=" do |val|
+              instance_variable_set("@#{attr}", val)
+              self[attr.to_s] = val.strftime("%Y%m%d%H%M%S")
+            end
+      
+            add_attribute_definition_to_attribute_list(attr)
+          end
+        end
+  
+        def simpledb_integer(*attributes)
+          attributes.each do |attr|
+            # getter
+            define_method attr.to_s do
+              if self[attr.to_s]
+                cached = instance_variable_get("@#{attr}")
+                if cached
+                  return cached
+                else
+                  val = self[attr.to_s].first.sub(/\A0+/, '').to_i
+                  instance_variable_set("@#{attr}", val)
+                  return val
+                end
+              else
+                nil
+              end
+            end
+      
+            # setter
+            define_method "#{attr}=" do |val|
+              instance_variable_set("@#{attr}", val)
+              self[attr.to_s] = sprintf("%016d", val.to_i)
+            end
+      
+            add_attribute_definition_to_attribute_list(attr)
+          end
+        end
+  
+        def add_attribute_definition_to_attribute_list(attr)
+          @_defined_attributes ||= []
+          @_defined_attributes << attr.to_s
+        end
+
+        def add_attribute_definition_to_partition_list(attr)
+          @_partitioned_attributes ||= []
+          @_partitioned_attributes << attr.to_s
+        end
+      
+        def attr_protected(*args)
+          @_protected_attributes ||= []
+          @_protected_attributes += args.to_a
+        end
+      
+        def attr_accessible(*args)
+          @_accessible_attributes ||= []
+          @_accessible_attributes += args.to_a
+        end
+      
+      end
+    
+      def attributes=(attr)
+        attr = _remove_protected_attributes(attr)
+        super(attr)
+      end
+    
+      def _remove_protected_attributes(attrs)
+        return {} if attrs.blank?
+        attrs = attrs.dup.stringify_keys
+        (self.class.instance_variable_get(:@_protected_attributes) || []).map(&:to_s).each do |protected_attribute|
+          attrs.delete(protected_attribute)
+        end
+      
+        accessible_attributes = (self.class.instance_variable_get(:@_accessible_attributes) || []).map(&:to_s)
+
+        if accessible_attributes.present?
+          attrs.each do |attr_key, attr_value|
+            attrs.delete(attr_key) unless accessible_attributes.include?(attr_key)
+          end
+        end
+      
+        attrs
+      end
+    
+      def partition_string_attributes
+        (self.class.instance_variable_get(:@_partitioned_attributes) || []).each do |attr|
+          next if self[attr].nil?
+          value = self[attr].first
+          if value.present? && value.size > 1024
+            0.upto(value.size / 1024) do |i|
+              self["#{attr.to_s}_#{i}"] = value[(1024 * i)..(1024 * (i + 1) - 1)]
+            end
+            @_partitioned_attributes ||= {}
+            @_partitioned_attributes[attr] = self[attr]
+            send("#{attr}=", [])
+          end
+        end
+      end
+
+      def restore_partitioned_attributes
+        (self.class.instance_variable_get(:@_partitioned_attributes) || []).each do |attr|
+          if (partitions = attributes.select{|key, value| key.match(/^#{attr}_([0-9]+)$/)}).any?
+            unpartitioned_value = ""
+            partitions.sort_by{|key, value| key.match(/^#{attr}_([0-9]+)$/); $1}.each do |partition|
+              unpartitioned_value << partition.last.first
+            end
+            self[attr] = unpartitioned_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simply_stored/simpledb/storag.rb

@@ -0,0 +1,85 @@
+module SimplyStore
+  module Storage
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.class_eval do
+        cattr_accessor :_s3_options
+      end
+    end
+    
+    def s3_connection
+      @_s3_connection ||= RightAws::S3.new(AWS_CONFIG[:aws_access_key_id], AWS_CONFIG[:aws_secret_access_key], :multi_thread => true)
+    end
+    
+    def s3_bucket(name)
+      if !@_s3_bucket
+        @_s3_bucket = s3_connection.bucket(_s3_options[name][:bucket])
+        @_s3_bucket = s3_connection.bucket(_s3_options[name][:bucket], true, 'private') if @_s3_bucket.nil? # create it if it didn't exist, do not do it the first time as the ACL get modified
+      end
+      @_s3_bucket
+    rescue Exception => e
+      raise ArgumentError, "Could not access/create S3 bucket '#{name}': #{e} #{e.backtrace.join("\n")}"
+    end
+    
+    def save
+      if ret = super
+        save_attachments
+      end
+      ret
+    end
+    
+    def save_attachments
+      if @_attachments
+        @_attachments.each do |name, attachment|
+          if attachment[:dirty]
+            value = attachment[:value].is_a?(String) ? attachment[:value] : attachment[:value].to_json
+            s3_bucket(name).put(s3_attachment_key(name), value, {}, _s3_options[name][:permissions])
+            attachment[:dirty] = false
+          end
+        end
+      end
+    end
+    
+    def s3_attachment_key(name)
+      "#{self.class.name.tableize}/#{name}/#{id}"
+    end
+    
+    module ClassMethods
+      def has_s3_attachment(name, options = {})
+        name = name.to_sym
+        raise ArgumentError, "No bucket name specified for attachment #{name}" if options[:bucket].blank?
+        options.update(:permissions => 'private', :ssl => true)
+        self._s3_options ||= {}
+        self._s3_options[name] = options
+        
+        define_attachment_accessors(name)
+        attr_reader :_attachments
+      end
+      
+      def define_attachment_accessors(name)
+        define_method(name) do
+          unless @_attachments and @_attachments[name]
+            @_attachments = {name => {}}
+            @_attachments[name][:value] = s3_bucket(name).get(s3_attachment_key(name))
+          end
+          @_attachments[name][:value]
+        end
+        
+        define_method("#{name}=") do |value|
+          @_attachments ||= {}
+          @_attachments[name] ||= {}
+          @_attachments[name].update(:value => value, :dirty => true)
+          value
+        end
+        
+        define_method("#{name}_url") do
+          if _s3_options[name][:permissions] == 'private'
+            RightAws::S3Generator.new(AWS_CONFIG[:aws_access_key_id], AWS_CONFIG[:aws_secret_access_key], :multi_thread => true).bucket(_s3_options[name][:bucket]).get(s3_attachment_key(name), 5.minutes)
+          else
+            "http://#{_s3_options[name][:bucket].to_s}.s3.amazonaws.com/#{s3_attachment_key(name)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simply_stored/simpledb/validations.rb

@@ -0,0 +1,88 @@
+module SimplyStored
+  module SimpleDB
+    module Validations
+      def validate
+        # abstract - implement in subclass and add checks that add to errors with add_error
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+    
+      module ClassMethods
+        def require_attributes(*attributes)
+          @_required_attributes ||= []
+          attributes.each do |attr|
+            @_required_attributes << attr.to_s
+          end
+        end
+  
+        def require_inclusion_of(attr, valid_set, options = {})
+          options = {
+            :allow_blank => false
+          }.update(options)
+          @_required_inclusions ||= {}
+          @_required_inclusions[attr.to_s] = [valid_set, options]
+        end
+  
+        def require_format_of(attr, valid_regex, options = {})
+          options = {
+            :allow_blank => false
+          }.update(options)
+          @_required_formats ||= {}
+          @_required_formats[attr.to_s] = [valid_regex, options]
+        end
+      end
+    
+      def ensure_formats
+        list_of_format_checks = self.class.instance_variable_get("@_required_formats") || {}
+        list_of_format_checks.each do |attr, check_options|
+          valid_regex, options = check_options
+          add_error(attr, 'is of invalid format') unless valid_regex.match(self.send(attr)) || (self.send(attr).blank? && options[:allow_blank])
+        end
+      end
+  
+      def ensure_inclusions
+        list_of_inclusion_checks = self.class.instance_variable_get("@_required_inclusions") || {}
+        list_of_inclusion_checks.each do |attr, check_options|
+          valid_set, options = check_options
+          if self.send(attr) && self.send(attr).is_a?(Array)
+            self.send(attr).all? do |item|
+              add_error(attr, 'is not included in the valid set') unless (valid_set.include?(item) rescue false) || (self.send(attr).blank? && options[:allow_blank])
+            end
+          else
+            add_error(attr, 'is not included in the valid set') unless (valid_set.include?(self.send(attr)) rescue false) || (self.send(attr).blank? && options[:allow_blank])
+          end
+        end
+      end
+
+      def add_error(attr, desc)
+        errors << [attr, desc]
+      end
+  
+      def clear_errors
+        @errors = []
+      end
+  
+      def ensure_no_foreign_attributes
+        not_allowed_attributes = self.attributes.keys.sort - (self.class.instance_variable_get("@_defined_attributes") || [])
+        not_allowed_attributes = not_allowed_attributes.delete_if{|attr| attr.to_s == 'id'} # the ID is an implicit attribute
+        not_allowed_attributes.each do |attr|
+          add_error(attr, 'is unknown and should not be set')
+        end
+      end
+  
+      def ensure_required_attributes_present
+        list_of_required_attributes = self.class.instance_variable_get("@_required_attributes") || []
+        list_of_required_attributes.all? do |attr| 
+          if self.send(attr).blank?
+            add_error(attr, 'is missing')
+            false
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simply_stored/simpledb.rb

@@ -0,0 +1,212 @@
+require File.expand_path(File.dirname(__FILE__) + '/../simply_stored')
+
+require 'sdb/right_sdb_interface'
+require 'sdb/active_sdb'
+require "simply_stored/simpledb/attributes"
+require "simply_stored/simpledb/associations"
+require "simply_stored/simpledb/validations"
+
+module SimplyStored
+  class Simple < RightAws::ActiveSdb::Base
+    def self.aws_access_key
+      @_aws_access_key
+    end
+    
+    def self.aws_secret_access_key
+      @_aws_secret_access_key
+    end
+
+    def self.aws_access_key=(aws_access_key)
+      @_aws_access_key = aws_access_key
+    end
+    
+    def self.aws_secret_access_key=(aws_secret_access_key)
+      @_aws_secret_access_key = aws_secret_access_key
+    end
+    
+    include SimplyStored::SimpleDB::Associations
+    include SimplyStored::SimpleDB::Attributes
+    include SimplyStored::SimpleDB::Validations
+    extend SimplyStored::Storage::ClassMethods
+  
+    alias :active_sdb_save :save
+    alias :active_sdb_delete :delete
+    alias :active_sdb_save_attributes :save_attributes
+  
+    def initialize(attrs={})
+      attrs = _remove_protected_attributes(attrs) || {}
+      super(attrs)
+    end
+  
+    def save(run_validations = true)
+      run_validations ? save_with_validations : save_without_validations
+    end
+  
+    def reload
+      super
+      restore_partitioned_attributes
+      self
+    end
+  
+    def save_with_validations
+      new_record = new_record? # save status as it changes during saving
+      before_create if new_record && respond_to?(:before_create)
+      before_save if respond_to?(:before_save)
+      if valid?
+        set_timestamps
+        partition_string_attributes
+        sdb_operation(:save)
+        clear_errors
+        after_create if new_record && respond_to?(:after_create)
+        after_save if respond_to?(:after_save)
+        true
+      else
+        false
+      end
+    end
+  
+    def save_without_validations
+      new_record = new_record? # save status as it changes during saving
+      before_create if new_record && respond_to?(:before_create)
+      before_save if respond_to?(:before_save)
+      set_timestamps
+      sdb_operation(:save)
+      clear_errors
+      after_create if new_record && respond_to?(:after_create)
+      after_save if respond_to?(:after_save)
+      true
+    end
+  
+    def delete
+      before_delete if respond_to?(:before_delete)
+      sdb_operation(:delete)
+      after_delete if respond_to?(:after_delete)
+      clear_dependents_after_delete
+      nil
+    end
+  
+    def valid?
+      clear_errors
+      before_validation if respond_to?(:before_validation)
+      ensure_no_foreign_attributes
+      ensure_required_attributes_present
+      ensure_inclusions
+      ensure_formats
+      validate
+      errors.empty?
+    end
+  
+    def errors
+      @errors ||= []
+    end
+  
+    def self.domain
+      unless @domain
+        if defined? ActiveSupport::CoreExtensions::String::Inflections
+          @domain = name.tableize.gsub('/','__').gsub('::','__')
+        else
+          @domain = name.downcase.gsub('/','__').gsub('::','__')
+        end
+      end
+      @domain
+    end
+  
+    def self.foreign_key
+      self.name.underscore.gsub('/','__').gsub('::','__') + "_id"
+    end
+  
+    def self.find(*args)
+      retries = 0
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      options.update(:auto_load => true)
+      args << options
+      begin
+        super(*args)
+      rescue Rightscale::AwsError => e
+        if (Rightscale::AwsError.system_error?(e) or e.message.match(/^RequestThrottled/)) and retries < 2
+          retries += 1
+          sleep retries * 0.5
+          retry
+        else
+          raise Error.new("Couldn't find item with #{args.inspect}: #{e}")
+        end
+      rescue RightAws::ActiveSdb::ActiveSdbError => e
+        if e.message.match(/Couldn't find #{name} with ID/)
+          if retries < 2
+            retries += 1
+            sleep retries * 0.5
+            retry
+          else
+            raise RecordNotFound, e.message
+          end
+        else
+          raise
+        end
+      end
+    end
+  
+    def self.all(options = {})
+      find(:all, options)
+    end
+  
+    def self.first(options = {})
+      find(:first, options)
+    end
+  
+    def update_attributes(*args)
+      # HACK in order to update attributes to nil
+      # thank you ActiveSDB
+      if (attrs = args.first).is_a?(Hash)
+        attrs.each do |k,v|
+          attrs[k] = [nil] if v.blank?
+        end
+      end
+    
+      sdb_operation(:save_attributes, *args)
+    end
+  
+    def to_param
+      id
+    end
+  
+    # set several attrbiutes at once with a given hash
+    # in contrast to ActiveSDB#attributes= it doesn't nil the other attributes
+    def set_attributes(attrs)
+      attrs = _remove_protected_attributes(attrs)
+    
+      attrs.each do |k,v|
+        self[k] = v
+      end
+    end
+  
+  protected
+
+    def self.generate_id
+      UUIDTools::UUID.random_create().to_s
+    end
+
+    def sdb_operation(operation, *args)
+      retries = 0
+      begin
+        send("active_sdb_#{operation}", *args)
+      rescue Rightscale::AwsError => e
+        if (Rightscale::AwsError.system_error?(e) or e.message.match(/^RequestThrottled/)) and retries < 2
+          retries += 1
+          sleep retries * 0.5
+          retry
+        else
+          raise Error.new("Couldn't #{operation} item of type #{self.class.name}#{id.nil? ? "" : " (with id: #{id})"}: #{e} #{e.backtrace.join("\n")}")
+        end
+      end
+    end
+  
+    def set_timestamps
+      self.updated_at = Time.now.utc if self.respond_to?(:updated_at=)
+      self.created_at = Time.now.utc if self.respond_to?(:created_at=) && self.new_record?
+    end
+  
+    def self.get_class_from_name(klass_name)
+      klass_name.to_s.gsub('__','/').gsub('__','::').classify.constantize
+    end
+  end
+end

data/lib/simply_stored/storage.rb

@@ -0,0 +1,93 @@
+module SimplyStored
+  module Storage
+    module InstanceMethods
+      def _s3_options
+        self.class._s3_options
+      end
+      
+      def s3_connection(name)
+        @_s3_connection ||= RightAws::S3.new(_s3_options[name][:access_key], _s3_options[name][:secret_access_key], :multi_thread => true)
+      end
+    
+      def s3_bucket(name)
+        if !@_s3_bucket
+          @_s3_bucket = s3_connection(name).bucket(_s3_options[name][:bucket])
+          @_s3_bucket = s3_connection(name).bucket(_s3_options[name][:bucket], true, 'private') if @_s3_bucket.nil?
+        end
+        @_s3_bucket
+      rescue Exception => e
+        raise ArgumentError, "Could not access/create S3 bucket '#{name}': #{e} #{e.backtrace.join("\n")}"
+      end
+    
+      def save(validate = true)
+        if ret = super(validate)
+          save_attachments
+        end
+        ret
+      end
+    
+      def save_attachments
+        if @_s3_attachments
+          @_s3_attachments.each do |name, attachment|
+            if attachment[:dirty]
+              value = attachment[:value].is_a?(String) ? attachment[:value] : attachment[:value].to_json
+              s3_bucket(name).put(s3_attachment_key(name), value, {}, _s3_options[name][:permissions])
+              attachment[:dirty] = false
+            end
+          end
+        end
+      end
+    
+      def s3_attachment_key(name)
+        "#{self.class.name.tableize}/#{name}/#{id}"
+      end
+    end
+    
+    module ClassMethods
+      def has_s3_attachment(name, options = {})
+        require 'awsbase/right_awsbase'
+        require 's3/right_s3'
+        require 's3/right_s3_interface'
+        
+        self.class.instance_eval do
+          attr_accessor :_s3_options
+        end
+        
+        name = name.to_sym
+        raise ArgumentError, "No bucket name specified for attachment #{name}" if options[:bucket].blank?
+        options.update(:permissions => 'private', :ssl => true)
+        self._s3_options ||= {}
+        self._s3_options[name] = options
+        
+        define_attachment_accessors(name)
+        attr_reader :_s3_attachments
+        include InstanceMethods
+      end
+      
+      def define_attachment_accessors(name)
+        define_method(name) do
+          unless @_s3_attachments and @_s3_attachments[name]
+            @_s3_attachments = {name => {}}
+            @_s3_attachments[name][:value] = s3_bucket(name).get(s3_attachment_key(name))
+          end
+          @_s3_attachments[name][:value]
+        end
+        
+        define_method("#{name}=") do |value|
+          @_s3_attachments ||= {}
+          @_s3_attachments[name] ||= {}
+          @_s3_attachments[name].update(:value => value, :dirty => true)
+          value
+        end
+        
+        define_method("#{name}_url") do
+          if _s3_options[name][:permissions] == 'private'
+            RightAws::S3Generator.new(_s3_options[name][:access_key], _s3_options[name][:secret_access_key], :multi_thread => true).bucket(_s3_options[name][:bucket]).get(s3_attachment_key(name), 5.minutes)
+          else
+            "http://#{_s3_options[name][:bucket].to_s}.s3.amazonaws.com/#{s3_attachment_key(name)}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/simply_stored.rb

@@ -0,0 +1,9 @@
+$:<<(File.expand_path(File.dirname(__FILE__) + "/lib"))
+require File.expand_path(File.dirname(__FILE__) + '/simply_stored/instance_methods')
+require File.expand_path(File.dirname(__FILE__) + '/simply_stored/storage')
+require File.expand_path(File.dirname(__FILE__) + '/simply_stored/class_methods_base')
+
+module SimplyStored
+  class Error < RuntimeError; end
+  class RecordNotFound < RuntimeError; end
+end

data/test/custom_views_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/test_helper')
+require File.expand_path(File.dirname(__FILE__) + '/fixtures/couch')
+
+class CustomViewUser
+  include SimplyStored::Couch
+  
+  property :tags
+  view :by_tags, :type => SimplyStored::Couch::Views::ArrayPropertyViewSpec, :key => :tags
+end
+
+class CustomViewsTest < Test::Unit::TestCase
+  
+  context "Custom couch views" do
+    setup do
+      CouchPotato::Config.database_name = 'simply_stored_test'
+      recreate_db
+    end
+    
+    context "With array views" do
+      should "find objects with one match of the array" do
+        CustomViewUser.create(:tags => ["agile", "cool", "extreme"])
+        CustomViewUser.create(:tags => ["agile"])
+        assert_equal 2, CustomViewUser.find_all_by_tags("agile").size
+      end
+      
+      should "find the object when the property is not an array" do
+        CustomViewUser.create(:tags => "agile")
+        assert_equal 1, CustomViewUser.find_all_by_tags("agile").size
+        
+      end
+    end
+  end
+end