simply_stored 0.3.9 → 0.5.0

data/lib/simply_stored/simpledb/attributes.rb

@@ -1,173 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,216 +0,0 @@
-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('__','/').classify.constantize
-    end
-  
-    def self.formalize_class_name(name)
-      name.to_s.gsub('__','/').gsub('__','::').classify
-    end
-  end
-end

data/test/fixtures/simpledb/item.rb

@@ -1,11 +0,0 @@
-class Item < SimplyStored::Simple
-  simpledb_string :foo_attribute, :item_daddy_id
-  simpledb_array :bar_attribute_array
-  simpledb_timestamp :updated_at, :created_at
-  simpledb_integer :integer_field
-  
-  require_inclusion_of :foo_attribute, ['a', 'b', 'c']
-  require_inclusion_of :bar_attribute_array, ['goog', 'boob']
-  
-  belongs_to :item_daddy
-end

data/test/fixtures/simpledb/item_daddy.rb

@@ -1,8 +0,0 @@
-class ItemDaddy < SimplyStored::Simple
-  simpledb_string :name, 'namespace__foo_id'
-  require_attributes :name
-  
-  has_one :item
-  has_many :items
-  
-end

data/test/fixtures/simpledb/log_item.rb

@@ -1,3 +0,0 @@
-class LogItem < SimplyStored::Simple
-  has_s3_attachment :log_data, :bucket => "bucket-for-monsieur", :access_key => 'abcdef', :secret_access_key => 'secret!'
-end

data/test/fixtures/simpledb/namespace_bar.rb

@@ -1,5 +0,0 @@
-module Namespace
-  class Bar < SimplyStored::Simple
-    has_many :foos
-  end
-end

data/test/fixtures/simpledb/namespace_foo.rb

@@ -1,7 +0,0 @@
-module Namespace
-  class Foo < SimplyStored::Simple
-    has_many :item_daddys
-    belongs_to :namespace__bar
-    simpledb_string :namespace__bar_id
-  end
-end

data/test/fixtures/simpledb/protected_item.rb

@@ -1,3 +0,0 @@
-class ProtectedItem < SimplyStored::Simple
-  simpledb_string :a, :b, :c
-end