armada 0.1.0

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Sam Aarons
+ 
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+ 
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,10 @@
+# coding: UTF-8
+
+require "rake"
+require "spec/rake/spectask"
+
+desc "Run all tests"
+Spec::Rake::SpecTask.new("test") do |t|
+  t.spec_opts = ["--color"]
+  t.pattern = "test/**/*_spec.rb"
+end

data/lib/armada/attribute_methods.rb

@@ -0,0 +1,76 @@
+# coding: UTF-8
+
+module Armada
+  module AttributeMethods
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+    
+    included do
+      attr_reader :attributes
+      class_attribute :columns
+      self.columns = [:id]
+      ["", "="].each { |x| attribute_method_suffix(x) }
+    end
+    
+    module ClassMethods
+      def add_columns(*cols)
+        self.columns = (self.columns + cols.map(&:to_sym)).uniq
+      end
+      alias :add_column :add_columns
+      
+      def remove_columns(*cols)
+        self.columns = (self.columns - cols.map(&:to_sym).delete_if { |x| x == :id })
+      end
+      alias :remove_column :remove_columns
+      
+      def define_attribute_methods
+        super(self.columns)
+      end
+    end
+    
+    def write_attribute(attribute_name, value)
+      attribute_name = attribute_name.to_s
+      if !persisted? || attribute_name != "id"
+        @attributes[attribute_name] = value
+      else
+        @attributes["id"]
+      end
+    end
+    
+    def read_attribute(attribute_name)
+      @attributes[attribute_name]
+    end
+    
+    def attributes=(attributes)
+      attributes.each_pair { |k, v| send("#{k}=",v) }
+      @attributes
+    end
+    
+    def method_missing(method_id, *args, &block)
+      if !self.class.attribute_methods_generated?
+        self.class.define_attribute_methods
+        method_name = method_id.to_s
+        guard_private_attribute_method!(method_name, args)
+        send(method_id, *args, &block)
+      else
+        super
+      end
+    end
+ 
+    def respond_to?(*args)
+      self.class.define_attribute_methods
+      super
+    end
+    
+    private
+    def attribute=(attribute_name, value)
+      write_attribute(attribute_name, value)
+    end
+    
+    def attribute(attribute_name)
+      read_attribute(attribute_name)
+    end
+    alias :read_attribute_for_validation :attribute
+    
+  end
+end

data/lib/armada/callbacks.rb

@@ -0,0 +1,77 @@
+# coding: UTF-8
+
+module Armada
+  module Callbacks
+    extend ActiveSupport::Concern
+    
+    CALLBACKS = [
+      :before_validation, :after_validation,
+      :before_save,       :after_save,       :around_save,
+      :before_create,     :after_create,     :around_create,
+      :before_update,     :after_update,     :around_update,
+      :before_destroy,    :after_destroy,    :around_destroy
+    ]
+    
+    included do
+      %w(create_or_update valid? create update destroy).each do |method|
+        alias_method_chain method, :callbacks
+      end
+      extend ActiveModel::Callbacks
+      define_callbacks :validation, :terminator => "result == false", :scope => [:kind, :name]
+      define_model_callbacks :save, :create, :update, :destroy
+    end
+    
+    module ClassMethods
+      def before_validation(*args, &block)
+        options = args.last
+        if options.is_a?(Hash) && options[:on]
+          options[:if] = Array(options[:if])
+          options[:if] << "@_on_validate == :#{options[:on]}"
+        end
+        set_callback(:validation, :before, *args, &block)
+      end
+ 
+      def after_validation(*args, &block)
+        options = args.extract_options!
+        options[:prepend] = true
+        options[:if] = Array(options[:if])
+        options[:if] << "!halted && value != false"
+        options[:if] << "@_on_validate == :#{options[:on]}" if options[:on]
+        set_callback(:validation, :after, *(args << options), &block)
+      end
+    end
+    
+    def valid_with_callbacks?
+      @_on_validate = new_record? ? :create : :update
+      _run_validation_callbacks do
+        valid_without_callbacks?
+      end
+    end
+ 
+    def destroy_with_callbacks
+      _run_destroy_callbacks do
+        destroy_without_callbacks
+      end
+    end
+    
+    private
+    def create_or_update_with_callbacks
+      _run_save_callbacks do
+        create_or_update_without_callbacks
+      end
+    end
+ 
+    def create_with_callbacks
+      _run_create_callbacks do
+        create_without_callbacks
+      end
+    end
+ 
+    def update_with_callbacks(*args)
+      _run_update_callbacks do
+        update_without_callbacks(*args)
+      end
+    end
+    
+  end
+end

data/lib/armada/connection.rb

@@ -0,0 +1,54 @@
+# coding: UTF-8
+
+module Armada
+  mattr_reader :connection
+  
+  class Connection
+    def initialize(host, port, password)
+      @host     = host
+      @port     = port
+      @password = password
+      connect
+    end
+    
+    def connect
+      begin
+        @socket = TCPSocket.new(@host, @port)
+        @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+        query(["auth", @password]) if @password
+      rescue
+        raise Armada::ConnectionError, "could not connect"
+      end
+    end
+    
+    def query(q)
+      request = ActiveSupport::JSON.encode(q)
+      @socket.write(request << "\r\n")
+      status, value = ActiveSupport::JSON.decode(@socket.gets)
+      status == 0 ? value : raise(Armada::ServerError.new(request),value)
+    end  
+  end
+  
+  def self.setup!(spec = {})
+    return @@connection if @@connection
+    config = { address: "127.0.0.1", port: 3400 }.merge!(spec)
+    @@connection = Connection.new(config[:address], config[:port], config[:password])
+  end
+  
+  def self.compact!
+    query_if_connection("compact")
+  end
+  
+  def self.list_collections
+    query_if_connection("list-collections")
+  end
+  
+  def self.explain(query)
+    query_if_connection("explain", query)
+  end
+  
+  private
+  def self.query_if_connection(*query)
+    @@connection && @@connection.query(query)
+  end
+end

data/lib/armada/database_methods.rb

@@ -0,0 +1,32 @@
+# coding: UTF-8
+
+module Armada
+  module DatabaseMethods
+    extend ActiveSupport::Concern
+    
+    included do
+      singleton_class.alias_method_chain :inherited, :collection_name
+    end
+    
+    module ClassMethods
+      def collection_name(name = nil)
+        name ? (@collection_name = name) : @collection_name
+      end
+      
+      private
+      def instantiate(attributes)
+        record = self.allocate
+        record.instance_variable_set(:@attributes, attributes.with_indifferent_access)
+        record.instance_variable_set(:@new_record, false)
+        record
+      end
+      
+      def inherited_with_collection_name(subclass)
+        subclass.collection_name(subclass.model_name.plural)
+        inherited_without_collection_name(subclass)
+      end
+
+    end
+    
+  end
+end

data/lib/armada/dirty.rb

@@ -0,0 +1,35 @@
+# coding: UTF-8
+
+module Armada
+  module Dirty
+    extend ActiveSupport::Concern
+    include ActiveModel::Dirty
+    
+    included do
+      [:create_or_update, :write_attribute].each do |method|
+        alias_method_chain method, :dirty
+      end
+    end
+    
+    private
+    def write_attribute_with_dirty(attribute_name, value)
+      send("#{attribute_name}_will_change!") if persisted?
+      write_attribute_without_dirty(attribute_name, value)
+    end
+    
+    def create_or_update_with_dirty
+      if status = create_or_update_without_dirty
+        @previously_changed = changes
+        changed_attributes.clear
+      else
+        changed.each { |attribute_name| send("reset_#{attribute_name}!") } if persisted?
+      end
+      status
+    end
+    
+    def serializable_changes
+      changed.inject({}) { |h, a| h[a] = @attributes[a]; h }
+    end
+    
+  end
+end

data/lib/armada/errors.rb

@@ -0,0 +1,19 @@
+# coding: UTF-8
+
+module Armada
+  class ServerError < StandardError
+    attr_reader :query
+    def initialize(query)
+      @query = query
+    end
+  end
+  
+  class ConnectionError < StandardError
+  end
+  
+  class RecordNotFound < StandardError
+  end
+  
+  class RecordNotSaved < StandardError
+  end
+end

data/lib/armada/finder_methods.rb

@@ -0,0 +1,43 @@
+# coding: UTF-8
+
+module Armada
+  module FinderMethods
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      
+      def find(*args)
+        find_from_ids(args)
+      end
+      
+      private
+      def find_from_ids(ids)
+        expects_array = ids.first.kind_of?(Array)
+        return ids.first if expects_array && ids.first.empty?
+ 
+        ids = ids.flatten.compact.uniq
+ 
+        case ids.size
+          when 0
+            raise(Armada::RecordNotFound)
+          when 1
+            result = find_one(ids.first)
+            expects_array ? [ result ] : result
+          else
+            find_some(ids)
+        end
+      end
+      
+      def find_one(id)
+        result = self.where(:id => id).limit(1).first
+        result.blank? ? raise(Armada::RecordNotFound) : result
+      end
+      
+      def find_some(ids)
+        results = self.where(:id => ids).all
+        results.size == ids.size ? results : raise(Armada::RecordNotFound)
+      end
+      
+    end 
+  end
+end

data/lib/armada/model.rb

@@ -0,0 +1,92 @@
+# coding: UTF-8
+
+module Armada
+  class Model
+    include Armada::Validations
+    extend  ActiveModel::Naming
+    include Armada::FinderMethods
+    include ActiveModel::Observing
+    include Armada::DatabaseMethods
+    include Armada::RelationMethods
+    include ActiveModel::Conversion
+    extend  ActiveModel::Translation
+    include Armada::AttributeMethods
+    include ActiveModel::Validations
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::Xml
+    include ActiveModel::Serializers::JSON
+    
+    def initialize(attributes = {})
+      @attributes = {}.with_indifferent_access
+      @new_record = true
+      self.attributes = attributes
+    end
+
+    def new_record?
+      @new_record || false
+    end
+    
+    def destroy
+      @destroyed = (persisted? && relation.delete == 1)
+    end
+    
+    def destroyed?
+      @destroyed || false
+    end
+    
+    def persisted?
+      !(new_record? || destroyed?)
+    end
+    
+    def save
+      create_or_update
+    end
+    
+    def save!
+      save || raise(Armada::RecordNotSaved)
+    end
+    
+    def ==(other)
+      klass = self.class
+      case other
+        when klass then klass.collection_name == other.class.collection_name && self.attributes == other.attributes
+        else false
+      end
+    end
+    
+    protected
+    def generate_unique_id
+      self.id ||= rand(36**26).to_s(36)[0..24]
+    end
+    
+    private
+    def create_or_update
+      (valid? && !destroyed?) && (new_record? ? create : update)
+    end
+    
+    def create
+      if status = (relation.insert(@attributes) == 1)
+        @new_record = false
+      end
+      status
+    end
+    
+    def update
+      changed? && relation.update(serializable_changes) == 1
+    end
+    
+    def relation
+      @relation ||= Armada::Relation.new(self.class).where(:id => self.id)
+    end
+    
+  end
+end
+
+Armada::Model.class_eval do
+  include Armada::Dirty
+  include Armada::Callbacks
+  include Armada::Timestamp
+  
+  validates :id, :presence => true
+  before_validation :generate_unique_id, :on => :create
+end

data/lib/armada/observer.rb

@@ -0,0 +1,34 @@
+# coding: UTF-8
+
+module Armada
+  class Observer < ActiveModel::Observer
+    class_attribute :observed_methods
+    self.observed_methods = []
+
+    def initialize
+      super
+      observed_subclasses.each { |klass| add_observer!(klass) }
+    end
+
+    def self.method_added(method)
+      self.observed_methods += [method] if Armada::Callbacks::CALLBACKS.include?(method.to_sym)
+    end
+
+    protected
+      def observed_subclasses
+        observed_classes.sum([]) { |klass| klass.send(:subclasses) }
+      end
+
+      def add_observer!(klass)
+        super
+        
+        self.class.observed_methods.each do |method|
+          callback = :"_notify_observers_for_#{method}"
+          if (klass.instance_methods & [callback, callback.to_s]).empty?
+            klass.class_eval "def #{callback}; notify_observers(:#{method}); end"
+            klass.send(method, callback)
+          end
+        end
+      end
+  end
+end

data/lib/armada/relation.rb

@@ -0,0 +1,262 @@
+# coding: UTF-8
+
+module Armada
+  module RelationMethods
+    extend ActiveSupport::Concern
+    
+    module ClassMethods
+      RELATION_METHODS = %w(all)
+      QUERY_OPTIONS    = %w(where offset order limit only distinct)
+      QUERY_METHODS    = %w(insert select delete count multi_read multi_write checked_write create_index drop_index list_indexes)
+      
+      def relation
+        @_class_relation ||= Armada::Relation.new(self)
+      end
+      
+      delegate(*(QUERY_METHODS + QUERY_OPTIONS + RELATION_METHODS), :to => :relation)
+      
+    end
+    
+  end
+  
+  class Relation
+    FIND_OPTIONS_KEYS = %w(where offset order limit only distinct)
+    
+    # undefine :select to avoid bugs/confusion with Kernel.select
+    # ...true story
+    undef_method :select
+    
+    def initialize(superclass)
+      @superclass = superclass
+      @join = "and"
+    end
+    
+    def where(conditions)
+      where = []
+      conditions.each_pair do |attribute, value|
+        if value.is_a?(Hash)
+           value.each_pair do |operator, val|
+             where << [operator, attribute, build_condition_value(val)]
+           end
+        else
+          where << build_condition(attribute, value)  
+        end
+      end
+      where = where.size > 1 ? where.unshift("and") : where.first
+      
+      join, old_where = [@join, @where]
+      
+      new_where = if option_defined?(:where)
+        if join == old_where.first && old_where.first == where.first
+          old_where.concat(where.from(1))
+        elsif join == old_where.first && !is_conjunction?(where.first)
+          old_where << where
+        elsif join == where.first && is_conjunction?(old_where.first)
+          old_where.tap { |w| w[-1] = ([join] << w.last).concat(where.from(1)) }
+        elsif join == where.first && !is_conjunction?(old_where.first)
+          where.insert(1,old_where)
+        elsif join == "and" && old_where.first == "or" && !is_conjunction?(where.first) && !is_conjunction?(old_where.last.first)
+          old_where.tap { |w| w[-1] = [join] << w.last << where }
+        elsif join == "and" && old_where.first == "or" && !is_conjunction?(where.first) && is_conjunction?(old_where.last.first)
+          old_where.tap { |w| w[-1] << where }
+        else
+          [join] << old_where << where
+        end
+      else
+        where
+      end
+      self.dup.tap do |r|
+        r.set_option(:where, new_where)
+        r.set_option(:join, "and")
+      end
+    end
+    
+    def or
+      raise(ArgumentError, "Missing 'where' condition") unless option_defined?(:where)
+      self.dup.tap { |r| r.set_option(:join, "or") }
+    end
+    
+    def offset(value)
+      self.dup.tap { |r| r.set_option(:offset, value) }
+    end
+    
+    def limit(value)
+      self.dup.tap { |r| r.set_option(:limit, value) }
+    end
+    
+    def order(*attributes)
+      options = attributes.extract_options!
+      
+      attributes.flatten!
+      attributes.map! do |attribute|
+        attribute.is_a?(Array) ? attribute : [attribute, :asc]
+      end
+      
+      order = attributes.concat(options.to_a).tap do |order|
+        order.flatten! if order.size == 1
+      end
+      
+      old_order = @order
+      
+      new_order = if option_defined?(:order)
+        old_order = [old_order] unless old_order.first.is_a?(Array)
+        order.first.is_a?(Array) ? old_order.concat(order) : old_order << order
+      else
+        order
+      end
+      
+      self.dup.tap { |r| r.set_option(:order, new_order) }
+    end
+    
+    def only(*attributes)
+      attributes.flatten!
+      only = if option_defined?(:only)
+        Array.wrap(@only).concat(attributes)
+      else
+        attributes.size == 1 ? attributes.first : attributes
+      end
+      
+      self.dup.tap { |r| r.set_option(:only, only) }
+    end
+    
+    def distinct
+      self.dup.tap { |r| r.set_option(:distinct, true) }
+    end
+    
+    def to_query(method = nil, *args, &block)
+      method ? send("generate_#{method}_query", *args, &block) : find_options
+    end
+    
+    def all
+      results = self.select
+      return results if option_defined?(:only) || @superclass.is_a?(String)
+      results.map { |record| @superclass.send(:instantiate, record) }
+    end
+    delegate :first, :last, :to => :all
+    
+    def set_option(option, value)
+      instance_variable_set("@#{option}", value)
+    end
+    
+    def get_option(option)
+      instance_variable_get("@#{option}")
+    end
+    
+    private
+    
+    def method_missing(method, *args, &block)
+      method = method.to_s
+      if %w(create_index drop_index).include?(method)
+        singleton_class.send(:define_method, method) do
+          raise(ArgumentError, "Missing 'order' condition") unless option_defined?(:order)
+          query(to_query(method, @order)) == 1
+        end.call
+      elsif %w(delete count update insert select checked_write multi_read multi_write list_indexes).include?(method)
+        singleton_class.send(:define_method, method) do |*args, &block|
+          query(to_query(method, *args, &block))
+        end.call(*args, &block)
+      else
+        super
+      end
+    end
+    
+    def generate_list_indexes_query
+      ["list-indexes", collection_name]
+    end
+    
+    def generate_create_index_query(order)
+      ["create-index", collection_name, order]
+    end
+    
+    def generate_drop_index_query(order)
+      ["drop-index", collection_name, order]
+    end
+    
+    def generate_multi_read_query(read_queries = [], &block)
+      yield read_queries if block_given?
+      ["multi-read", read_queries]
+    end
+    
+    def generate_multi_write_query(queries = [], &block)
+      yield queries if block_given?
+      ["multi-write", queries]
+    end
+    
+    def generate_checked_write_query(read_query, expected_result, write_query)
+      ["checked-write", read_query, expected_result, write_query]
+    end
+    
+    def generate_delete_query
+      ["delete", collection_name].tap do |q|
+        q << find_options if find_options?
+      end
+    end
+    
+    def generate_update_query(changes)
+      ["update", collection_name, changes, find_options]
+    end
+    
+    def generate_insert_query(records)
+      ["insert", collection_name].tap do |q|
+        q << (records.size == 1 ? records.first : records)
+      end
+    end
+    
+    def generate_count_query
+      ["count", collection_name].tap do |q|
+        q << find_options if find_options?
+      end
+    end
+    
+    def generate_select_query
+      ["select", collection_name].tap do |q|
+        q << find_options if find_options?
+      end
+    end
+    
+    def is_conjunction?(value)
+      %w(and or).include?(value)
+    end
+    
+    def option_defined?(option)
+      instance_variable_defined?("@#{option}")
+    end
+    
+    def find_options?
+      FIND_OPTIONS_KEYS.any? { |x| option_defined?(x) }
+    end
+    
+    def find_options
+      FIND_OPTIONS_KEYS.dup.inject({}) do |h1, x|
+        option_defined?(x) ? h1.tap { |h2| h2[x.to_sym] = instance_variable_get("@#{x}") } : h1
+      end
+    end
+    
+    def collection_name
+      @collection_name ||= @superclass.is_a?(String) ? @superclass : @superclass.collection_name
+    end
+    
+    def query(args)
+      Armada.connection.query(args)
+    end
+    
+    def build_condition(attribute, value)
+      operator = case value
+        when Array then "in"
+        when Range then value.exclude_end? ? ">=<" : ">=<="
+        else "="
+      end
+      [operator, attribute, build_condition_value(value)]
+    end
+    
+    def build_condition_value(value)
+      case value
+        when Range           then [value.first, value.last]
+        when Time, DateTime  then value.to_i
+        else value
+      end
+    end
+    
+    
+  end
+end

data/lib/armada/timestamp.rb

@@ -0,0 +1,58 @@
+# coding: UTF-8
+
+module Armada
+  module Timestamp
+    extend ActiveSupport::Concern
+ 
+    included do
+      alias_method_chain :create, :timestamps
+      alias_method_chain :update, :timestamps
+ 
+      class_attribute :record_timestamps
+      self.record_timestamps = true
+    end
+    
+    def touch(attribute = nil)
+      current_time = current_time_from_current_timezone
+ 
+      if attribute
+        write_attribute(attribute, current_time)
+      else
+        write_attribute('updated_at', current_time) if respond_to?(:updated_at)
+        write_attribute('updated_on', current_time) if respond_to?(:updated_on)
+      end
+ 
+      save!
+    end
+ 
+    private
+    def create_with_timestamps
+      if self.class.record_timestamps?
+        current_time = current_time_from_current_timezone
+    
+        write_attribute('created_at', current_time) if respond_to?(:created_at) && created_at.nil?
+        write_attribute('created_on', current_time) if respond_to?(:created_on) && created_on.nil?
+        
+        write_attribute('updated_at', current_time) if respond_to?(:updated_at) && updated_at.nil?
+        write_attribute('updated_on', current_time) if respond_to?(:updated_on) && updated_on.nil?
+      end
+    
+      create_without_timestamps
+    end
+    
+    def update_with_timestamps(*args)
+      if self.class.record_timestamps? && changed?
+        current_time = current_time_from_current_timezone
+    
+        write_attribute('updated_at', current_time) if respond_to?(:updated_at)
+        write_attribute('updated_on', current_time) if respond_to?(:updated_on)
+      end
+    
+      update_without_timestamps(*args)
+    end
+    
+    def current_time_from_current_timezone
+      Time.zone.now.to_i
+    end
+  end
+end

data/lib/armada/validations.rb

@@ -0,0 +1,41 @@
+# coding: UTF-8
+
+module Armada
+  module Validations
+    extend ActiveSupport::Concern
+    
+    class UniquenessValidator < ActiveModel::EachValidator
+      
+      def validate_each(record, attribute, value)
+        relation = record.class.where(attribute => value)
+        
+        Array.wrap(options[:scope]).each do |scope_attribute|
+          relation = relation.where(scope_attribute => record.attributes[scope_attribute])
+        end
+        
+        relation = relation.where(:id => {"!=" => record.id}) if record.persisted?
+        
+        return if relation.count == 0
+        record.errors.add(attribute, :taken, :default => options[:message], :value => value)
+      end
+      
+    end
+  end
+  
+  module ClassMethods
+    # Configuration options:
+    # * <tt>:message</tt> - Specifies a custom error message (default is: "has already been taken").
+    # * <tt>:scope</tt> - One or more columns by which to limit the scope of the uniqueness constraint.
+    # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute is +nil+ (default is +false+).
+    # * <tt>:allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is +false+).
+    # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
+    # occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
+    # method, proc or string should return or evaluate to a true or false value.
+    # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
+    # not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
+    # method, proc or string should return or evaluate to a true or false value.
+    def validates_uniqueness_of(*attr_names)
+      validates_with UniquenessValidator, _merge_attributes(attr_names)
+    end
+  end
+end

data/lib/armada.rb

@@ -0,0 +1,27 @@
+# coding: UTF-8
+
+require 'yajl'
+require 'socket'
+
+require 'active_model'
+require 'active_support/core_ext/array/access'
+require 'active_support/core_ext/array/uniq_by'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/module/aliasing'
+require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/module/attribute_accessors'
+
+require 'armada/dirty'
+require 'armada/errors'
+require 'armada/relation'
+require 'armada/callbacks'
+require 'armada/observer'
+require 'armada/timestamp'
+require 'armada/connection'
+require 'armada/validations'
+require 'armada/finder_methods'
+require 'armada/database_methods'
+require 'armada/attribute_methods'
+
+require 'armada/model'

data/test/armada_finder_methods_spec.rb

@@ -0,0 +1,20 @@
+# coding: UTF-8
+
+require File.join(File.dirname(__FILE__),'spec_helper.rb')
+ 
+describe Bank, :type => :model do
+  it "has a collection name" do
+    Bank.collection_name.should == "banks"
+  end
+  
+  it "will find banks" do
+    Bank.find(@bac.id).should == @bac
+    Bank.find([@bac.id]).should == [@bac]
+    Bank.find(@wfc.id, @c.id).should == [@wfc, @c]
+    Bank.find(@wfc.id, @c.id, @bac.id).should == [@wfc, @c, @bac]
+  end
+  
+  it "will raise an error when it does not find a bank" do
+    lambda { Bank.find("481516") }.should raise_error Armada::RecordNotFound
+  end
+end

data/test/armada_model_spec.rb

@@ -0,0 +1,95 @@
+# coding: UTF-8
+
+require File.join(File.dirname(__FILE__),'spec_helper.rb')
+ 
+describe "A bank instance" do
+  before do
+    Bank.delete
+    @bank = Bank.new(:name => "Wells Fargo", :rank => 4)
+  end
+  
+  after do
+    Bank.delete
+  end
+  
+  it "has read accessors" do
+    @bank.name.should == "Wells Fargo"
+    @bank.attributes[:name].should == "Wells Fargo"
+  end
+  
+  it "has write accessors" do
+    @bank.name = "Citigroup"
+    @bank.name.should == "Citigroup"
+    @bank.attributes[:name].should == "Citigroup"
+  end
+  
+  it "is comparable to other banks" do
+    @bank.should == Bank.new(:name => "Wells Fargo", :rank => 4)
+  end
+  
+  context "that is unsaved" do
+    it "is new" do
+      @bank.new_record?.should be_true
+    end
+    
+    it "is not persisted" do
+      @bank.persisted?.should be_false
+    end
+    
+    it "can not be destroyed" do
+      @bank.destroy.should be_false
+    end
+  end
+  
+  context "that is valid" do
+    it "will save" do
+      @bank.save.should be_true
+    end
+    
+    it "will save!" do
+      lambda { @bank.save! }.should be_true
+    end
+  end
+  
+  context "that is invalid" do
+    before do
+      @bank.rank = 5
+    end
+    
+    it "will not save" do
+      @bank.save.should be_false
+    end
+    
+    it "will not save!" do
+      lambda { @bank.save! }.should raise_error Armada::RecordNotSaved
+    end
+  end
+  
+  context "that is saved" do
+    before do
+      @bank.save
+    end
+    
+    it "is persisted" do
+      @bank.persisted?.should be_true
+    end
+    
+    it "can be destroyed" do
+      @bank.destroy.should be_true
+      @bank.destroyed?.should be_true
+    end
+    
+    it "can be changed" do
+      @bank.name = "Citigroup"
+      @bank.rank = 2
+      @bank.save.should be_true
+    end
+    
+    it "will retain previous value after a failed update" do
+      @bank.rank = 5
+      @bank.save.should be_false
+      @bank.rank.should == 4
+    end
+    
+  end
+end

data/test/armada_relation_spec.rb

@@ -0,0 +1,112 @@
+# coding: UTF-8
+
+require File.join(File.dirname(__FILE__),'spec_helper.rb')
+
+describe Armada::Relation, :type => :model do
+  
+  it "will find all banks" do
+    Bank.all.should =~ [@bac, @c, @wfc]
+  end
+  
+  it "will implement select correctly" do
+    Bank.select.should =~ [@bac, @c, @wfc].map { |x| x.attributes }
+    Bank.where(:rank => 4).select.should == [@wfc.attributes]
+  end
+  
+  it "will implement delete correctly" do
+    Bank.where(:rank => 4).delete.should == 1
+    Bank.delete.should == 2
+  end
+  
+  it "will implement count correctly" do
+    Bank.count.should == 3
+    Bank.where(:rank => 4).count.should == 1
+  end
+  
+  it "will implement where correctly" do
+    Bank.where(:rank => 4).all.should == [@wfc]
+    Bank.where(:rank => 1..2).all.should =~ [@bac, @c]
+  end
+  
+  it "will implement order correctly" do
+    Bank.order(:rank).all.should == [@bac, @c, @wfc]
+    Bank.order(:rank => :asc).all.should  == [@bac, @c, @wfc]
+    Bank.order(:rank => :desc).all.should == [@wfc, @c, @bac]
+  end
+  
+  it "will implement limit correctly" do
+    Bank.order(:rank => :desc).limit(1).all.should == [@wfc]
+  end
+  
+  it "will implement offset correctly" do
+    Bank.order(:rank => :desc).offset(1).all.should == [@c, @bac]
+  end
+  
+  it "will implement only correctly" do
+    Bank.order(:rank => :desc).only(:rank).all.should == [4,2,1]
+    Bank.order(:rank => :desc).only(:rank, :name).all.should == [[4,"Wells Fargo"],[2,"Citigroup"],[1,"Bank of America"]]
+  end
+  
+  it "will implement to_query correctly for #where" do
+    Bank.where(:rank => 4).to_query.should == {where:["=", :rank, 4]}
+    
+    Bank.where(:rank => 4, :name => "Wells Fargo").to_query.should       == {where:["and",["=", :rank, 4],["=", :name, "Wells Fargo"]]}
+    Bank.where(:rank => 4).where(:name => "Wells Fargo").to_query.should == {where:["and",["=", :rank, 4],["=", :name, "Wells Fargo"]]}
+    
+    Bank.where(:rank => 4).where(:name => "Wells Fargo").where(:id => 1).to_query.should == {where:["and",["=", :rank, 4],["=", :name, "Wells Fargo"],["=", :id, 1]]}
+    Bank.where(:rank => 4, :name => "Wells Fargo").where(:id => 1).to_query.should       == {where:["and",["=", :rank, 4],["=", :name, "Wells Fargo"],["=", :id, 1]]}
+    Bank.where(:rank => 4).where(:name => "Wells Fargo", :id => 1).to_query.should       == {where:["and",["=", :rank, 4],["=", :name, "Wells Fargo"],["=", :id, 1]]}
+    
+    Bank.where(:rank => 4, :name => "Wells Fargo").where(:id => 1, :created_at => {">" => 1}).to_query.should == {where:["and",["=", :rank, 4],["=", :name, "Wells Fargo"],["=", :id, 1],[">", :created_at, 1]]}
+  end
+  
+  it "will implement to_query correctly for #where with \"or\" boolean matching" do
+    Bank.where(:name => "Wells Fargo").or.where(:rank => 1).to_query.should == {where:["or",["=", :name, "Wells Fargo"],["=", :rank, 1]]}
+    Bank.where(:name => "Citigroup").or.where(:rank => 1).or.where(:rank => 4).to_query.should == {where:["or", ["=", :name, "Citigroup"], ["=", :rank, 1], ["=", :rank, 4]]}
+    
+    Bank.where(:rank => 1).or.where(:rank => 4, :name => "Wells Fargo").to_query.should       == {where:["or",["=", :rank, 1], ["and", ["=", :rank, 4], ["=", :name, "Wells Fargo"]]]}
+    Bank.where(:rank => 1).or.where(:rank => 4).where(:name => "Wells Fargo").to_query.should == {where:["or",["=", :rank, 1], ["and", ["=", :rank, 4], ["=", :name, "Wells Fargo"]]]}
+    
+    Bank.where(:name => "Wells Fargo", :rank => 4).or.where(:rank => 1).to_query.should == {where:["or",["and", ["=", :name, "Wells Fargo"], ["=", :rank, 4]],["=", :rank, 1]]}
+    
+    Bank.where(:name => "Wells Fargo", :rank => 4).or.where(:name => "Bank of America", :rank => 1).to_query.should       == {where:["or",["and", ["=", :name, "Wells Fargo"], ["=", :rank, 4]],["and", ["=", :name, "Bank of America"], ["=", :rank, 1]]]}
+    Bank.where(:name => "Wells Fargo", :rank => 4).or.where(:name => "Bank of America").where(:rank => 1).to_query.should == {where:["or",["and", ["=", :name, "Wells Fargo"], ["=", :rank, 4]],["and", ["=", :name, "Bank of America"], ["=", :rank, 1]]]}
+    
+    Bank.where(:name => "Wells Fargo", :rank => 4).or.where(:name => "Bank of America").where(:rank => {"=" => 1, "!=" => 4}).to_query.should       == {where:["or",["and", ["=", :name, "Wells Fargo"], ["=", :rank, 4]],["and", ["=", :name, "Bank of America"], ["=", :rank, 1], ["!=", :rank, 4]]]}
+    Bank.where(:name => "Wells Fargo", :rank => 4).or.where(:name => "Bank of America", :rank => 1).where(:rank => {"!=" => 4}).to_query.should     == {where:["or",["and", ["=", :name, "Wells Fargo"], ["=", :rank, 4]],["and", ["=", :name, "Bank of America"], ["=", :rank, 1], ["!=", :rank, 4]]]}
+    Bank.where(:name => "Wells Fargo").where(:rank => 4).or.where(:name => "Bank of America").where(:rank => {"=" => 1, "!=" => 4}).to_query.should == {where:["or",["and", ["=", :name, "Wells Fargo"], ["=", :rank, 4]],["and", ["=", :name, "Bank of America"], ["=", :rank, 1], ["!=", :rank, 4]]]}
+  end
+  
+  it "will implement to_query correctly for #order" do
+    Bank.order(:rank).to_query.should == {order:[:rank, :asc]}
+    
+    Bank.order(:rank, :name => :desc).to_query.should       == {order:[[:rank, :asc], [:name, :desc]]}
+    Bank.order(:rank).order(:name => :desc).to_query.should == {order:[[:rank, :asc], [:name, :desc]]}
+    
+    Bank.order(:rank, :id, :name => :desc).to_query.should       == {order:[[:rank, :asc], [:id, :asc], [:name, :desc]]}
+    Bank.order(:rank, :id).order(:name => :desc).to_query.should == {order:[[:rank, :asc], [:id, :asc], [:name, :desc]]}
+    Bank.order(:rank).order(:id, :name => :desc).to_query.should == {order:[[:rank, :asc], [:id, :asc], [:name, :desc]]}
+    
+    Bank.order(:rank, :id).order(:name, :created_at).to_query.should == {order:[[:rank, :asc], [:id, :asc], [:name, :asc], [:created_at, :asc]]}
+  end
+  
+  it "will implement to_query correctly for #limit" do
+    Bank.limit(1).to_query.should == {limit: 1}
+  end
+  
+  it "will implement to_query correctly for #offset" do
+    Bank.offset(1).to_query.should == {offset: 1}
+  end
+  
+  it "will implement to_query correctly for #only" do
+    Bank.only(:rank).to_query.should   == {only: :rank}
+    
+    Bank.only(:rank, :name).to_query.should          == {only: [:rank, :name]}
+    Bank.only(:rank).only(:name).to_query.should     == {only: [:rank, :name]}
+    
+    Bank.only(:id).only(:rank, :name).to_query.should == {only: [:id, :rank, :name]}
+    Bank.only(:id, :rank).only(:name).to_query.should == {only: [:id, :rank, :name]}
+    
+    Bank.only(:id, :rank).only(:name, :created_at).to_query.should == {only: [:id, :rank, :name, :created_at]}
+  end
+end

data/test/armada_validations_spec.rb

@@ -0,0 +1,15 @@
+# coding: UTF-8
+
+require File.join(File.dirname(__FILE__),'spec_helper.rb')
+
+describe Armada::Validations, :type => :model do
+  it "should validate uniqueness of rank" do
+    @wfc.rank = 2
+    @wfc.save.should be_false
+  end
+  
+  it "should not allow new records to intervene" do
+    @jpm = Bank.new(:name => "JPMorgan Chase", :rank => 2, :price => 42.59, :public => true)
+    @jpm.save.should be_false
+  end
+end

data/test/spec_helper.rb

@@ -0,0 +1,31 @@
+# coding: UTF-8
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require "pp"
+require "spec"
+require "armada"
+
+Time.zone = "UTC"
+
+Armada.setup!
+
+class Bank < Armada::Model
+  add_columns :name, :created_at, :updated_at, :rank, :price, :public
+  validates :rank, :inclusion => {:in => 1..4}, :uniqueness => true
+end
+
+Spec::Runner.configure do |config|
+  config.before(:each, :type => :model) do
+    Bank.delete
+    
+    @bac = Bank.new(:name => "Bank of America", :rank => 1, :price => 16.24, :public => true)
+    @c   = Bank.new(:name => "Citigroup",       :rank => 2, :price =>  3.56, :public => true)
+    @wfc = Bank.new(:name => "Wells Fargo",     :rank => 4, :price => 28.89, :public => true)
+    
+    [@bac, @c, @wfc].each { |x| x.save }
+  end
+  config.after(:each, :type => :model) do
+    Bank.delete
+  end
+end

metadata

@@ -0,0 +1,129 @@
+--- !ruby/object:Gem::Specification 
+name: armada
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Sam Aarons
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 7
+        - 4
+        version: 0.7.4
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activemodel
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        - beta3
+        version: 3.0.0.beta3
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id003
+description: Armada makes it simple and easy to combine ActiveModel and FleetDB together
+email: 
+- samaarons@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/armada/attribute_methods.rb
+- lib/armada/callbacks.rb
+- lib/armada/connection.rb
+- lib/armada/database_methods.rb
+- lib/armada/dirty.rb
+- lib/armada/errors.rb
+- lib/armada/finder_methods.rb
+- lib/armada/model.rb
+- lib/armada/observer.rb
+- lib/armada/relation.rb
+- lib/armada/timestamp.rb
+- lib/armada/validations.rb
+- lib/armada.rb
+- test/armada_finder_methods_spec.rb
+- test/armada_model_spec.rb
+- test/armada_relation_spec.rb
+- test/armada_validations_spec.rb
+- test/spec_helper.rb
+- LICENSE
+- Rakefile
+- README.md
+has_rdoc: true
+homepage: http://github.com/saarons/armada
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      - 1
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 6
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: armada
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: An ActiveModel interface to FleetDB
+test_files: []
+