ricordami 0.0.1

data/spec/acceptance/query_model_spec.rb

@@ -0,0 +1,93 @@
+require "acceptance_helper"
+require "ricordami/can_be_queried"
+
+class Singer
+  include Ricordami::Model
+  include Ricordami::CanBeQueried
+
+  attribute :username
+  attribute :email
+  attribute :first_name
+  attribute :last_name
+  attribute :deceased, :default => "false", :indexed => :value
+
+  index :unique => :username, :get_by => true
+end
+
+feature "Query model" do
+  def create_12_singers
+    [
+      ["Serge", "Gainsbourg"], ["Alain", "Bashung"], ["Benjamin", "Biolay"],
+      ["Charles", "Aznavour"], ["Yves", "Montand", true], ["Nino", "Ferrer", true],
+      ["Johnny", "Hallyday"], ["David", "Guetta"], ["Bruno", "Benabar"],
+      ["Alain", "Souchon"], ["Jacques", "Dutronc"], ["Georges", "Brasens"]
+    ].each do |first, last, deceased|
+      Singer.create(:username => (first + last[0..0]).downcase, :first_name => first,
+                    :last_name => last, :email => "#{first.downcase}@#{last.downcase}.fr",
+                    :deceased => deceased ? "true" : "false").should be_persisted
+    end
+  end
+
+  scenario "retrieve models" do
+    Singer.create(:username => "lucien", :email => "serge@gainsbourg.com",
+                   :first_name => "Serge", :last_name => "Gainsbourg")
+    Singer.get_by_username("lucien").id.should == "1"
+
+    Singer.create(:username => "bashung", :email => "alain@bashung.com",
+                   :first_name => "Alain", :last_name => "Bashung")
+    Singer.get_by_username("bashung").id.should == "2"
+
+    Singer.create(:username => "ben", :email => "benjamin@biolay.com",
+                   :first_name => "Benjamin", :last_name => "Biolay")
+    Singer.get_by_username("ben").id.should == "3"
+
+    Singer.count.should == 3
+    Singer["1"].email.should == "serge@gainsbourg.com"
+
+    Singer.get_by_username("bashung").first_name.should == "Alain"
+  end
+
+  scenario "finding models using basic queries" do
+    Singer.create(:username => "ben", :email => "benjamin@biolay.com",
+                  :first_name => "Benjamin", :last_name => "Biolay", :deceased => "false")
+    Singer.create(:username => "lucien", :email => "serge@gainsbourg.com",
+                  :first_name => "Serge", :last_name => "Gainsbourg", :deceased => "true")
+    Singer.create(:username => "bashung", :email => "alain@bashung.com",
+                  :first_name => "Alain", :last_name => "Bashung", :deceased => "true")
+
+    deceased = Singer.and(:deceased => "true").all
+    deceased.map(&:username).should =~ %w(lucien bashung)
+    q = Singer.where(:deceased => "true")
+    q.sort(:first_name, :asc_alpha).first.email.should == "alain@bashung.com"
+    q.sort(:first_name, :desc_alpha).last.email.should == "alain@bashung.com"
+    Singer.not(:deceased => true).map(&:username).should == ["ben"]
+    first = Singer.first.username
+    last = Singer.last.username
+    rand = Singer.rand.username
+    first.should_not == last
+    Singer.all.map(&:username).should include(first)
+    Singer.all.map(&:username).should include(last)
+    Singer.all.map(&:username).should include(rand)
+  end
+
+  scenario "paginate list of models" do
+    create_12_singers
+
+    Singer.paginate(:page => 1, :per_page => 5).should have(5).singers
+    Singer.paginate(:page => 2, :per_page => 5).should have(5).singers
+    Singer.paginate(:page => 3, :per_page => 5).should have(2).singers
+    Singer.paginate(:page => 4, :per_page => 5).should have(0).singers
+
+    page1 = Singer.sort(:last_name, :asc_alpha).paginate(:page => 1, :per_page => 5)
+    page1.map(&:last_name).should == ["Aznavour", "Bashung", "Benabar", "Biolay", "Brasens"]
+    page3 = Singer.sort(:last_name, :asc_alpha).paginate(:page => 3, :per_page => 5)
+    page3.map(&:last_name).should == ["Montand", "Souchon"]
+  end
+
+  scenario "query using #and, #any and #not filters" do
+    Singer.index :value => :first_name
+    create_12_singers
+
+    Singer.where(:first_name => "Alain").all.map(&:last_name).should =~ %w(Bashung Souchon)
+  end
+end

data/spec/acceptance_helper.rb

@@ -0,0 +1,2 @@
+require File.expand_path("../spec_helper", __FILE__)
+require "steak"

data/spec/ricordami/attribute_spec.rb

@@ -0,0 +1,113 @@
+require "spec_helper"
+
+describe Ricordami::Attribute do
+    subject { Ricordami::Attribute }
+
+  describe "an instance" do
+    it "has a name" do
+      attribute = subject.new(:singer)
+      attribute.name.should == :singer
+    end
+
+    it "accepts a string for its name" do
+      attribute = subject.new("string")
+      attribute.name.should == :string
+    end
+
+    it "accepts also a symbol for its name" do
+      attribute = subject.new(:string)
+      attribute.name.should == :string
+    end
+
+    it "has an option :default for a default value" do
+      attribute = subject.new(:georges, :default => "jungle")
+      attribute.default_value.should == "jungle"
+    end
+
+    it "doesn't have a default value if :default is not specified" do
+      subject.new(:no_defaults).default_value.should be_nil
+    end
+
+    it "allows to use a block as a default value for dynamic values" do
+      i = 0
+      attribute = subject.new(:sequence, :default => Proc.new { i += 1 })
+      attribute.default_value.should == 1
+      attribute.default_value.should == 2
+      attribute.default_value.should == 3
+    end
+
+    it "retuns if a default value is set with #default_value?" do
+      subject.new(:blah, :default => "1").default_value?.should be_true
+      without = subject.new(:foo).default_value?.should be_false
+    end
+
+    it "has an option :read_only when the attribute value can only be set once" do
+      attribute = subject.new(:georges, :read_only => true)
+      attribute.should be_read_only
+    end
+
+    it "its value can be set more than once when :read_only is not set" do
+      subject.new(:not_read_only).should_not be_read_only
+    end
+
+    it "has an option :indexed to index the attribute as unique" do
+      attribute = subject.new(:georges, :indexed => :unique)
+      attribute.indexed.should == :unique
+    end
+
+    it "has an option :indexed to index the attribute by value" do
+      attribute = subject.new(:georges, :indexed => :value)
+      attribute.indexed.should == :value
+    end
+
+    it "raises an error if :indexed is not :unique or :value" do
+      lambda {
+        subject.new(:georges, :indexed => :blah)
+      }.should raise_error(Ricordami::InvalidIndexDefinition)
+      lambda {
+        subject.new(:georges)
+      }.should_not raise_error
+    end
+
+    it "its value can be used for queries when :indexed is not set" do
+      subject.new(:not_indexed).should_not be_indexed
+    end
+
+    it "has an option :initial for an initial value set when saved the first time" do
+      attribute = subject.new(:id, :initial => "123")
+      attribute.initial_value.should == "123"
+    end
+
+    it "doesn't have an initial value if :initial is not specified" do
+      subject.new(:no_initials).initial_value.should be_nil
+    end
+
+    it "allows to use a block as an initial value for dynamic values" do
+      i = 1
+      attribute = subject.new(:id, :initial => Proc.new { i *= 2 })
+      attribute.initial_value.should == 2
+      attribute.initial_value.should == 4
+      attribute.initial_value.should == 8
+    end
+
+    it "retuns if an initial value is set with #initial_value?" do
+      subject.new(:id, :initial => "1").initial_value?.should be_true
+      without = subject.new(:foo).initial_value?.should be_false
+    end
+
+    it "can spefify the attribute type with :type option" do
+      attribute = subject.new(:id, :type => :integer)
+      attribute.type.should == :integer
+    end
+
+    it "has a default type :string if not specified" do
+      subject.new(:name).type.should == :string
+    end
+
+    it "returns the converter method with #converter" do
+      subject.new(:name, :type => :string).converter.should == :to_s
+      subject.new(:name, :type => :integer).converter.should == :to_i
+      subject.new(:name, :type => :float).converter.should == :to_f
+    end
+  end
+end

data/spec/ricordami/can_be_queried_spec.rb

@@ -0,0 +1,254 @@
+require "spec_helper"
+require "ricordami/can_be_queried"
+
+describe Ricordami::CanBeQueried do
+  uses_constants("Customer")
+
+  before(:each) do
+    Customer.send(:include, Ricordami::CanBeQueried)
+    Customer.attribute :country, :indexed => :value
+    Customer.attribute :sex,     :indexed => :value
+    Customer.attribute :name,    :indexed => :value
+    Customer.attribute :kind,    :indexed => :value
+    Customer.attribute :no_index
+  end
+
+  describe "building queries" do
+    describe "#and" do
+      it "returns a new query" do
+        query = Customer.and
+        query.should be_a(Ricordami::Query)
+      end
+
+      it "passes self as the query runner to the query" do
+        query = Customer.and
+        query.runner.should == Customer
+      end
+
+      it "delegates #and to the new query" do
+        query = Customer.and(:key => "value")
+        query.expressions.should == [[:and, {:key => "value"}]]
+      end
+    end
+
+    describe "#not" do
+      it "returns a new query" do
+        query = Customer.not
+        query.should be_a(Ricordami::Query)
+      end
+
+      it "delegates #not to the new query" do
+        query = Customer.not(:key => "value")
+        query.expressions.should == [[:not, {:key => "value"}]]
+      end
+    end
+
+    describe "#any" do
+      it "returns a new query" do
+        query = Customer.any
+        query.should be_a(Ricordami::Query)
+      end
+
+      it "delegates #any to the new query" do
+        query = Customer.any(:key => "value")
+        query.expressions.should == [[:any, {:key => "value"}]]
+      end
+    end
+
+    describe "#sort" do
+      it "returns a new query" do
+        query = Customer.sort(:sex)
+        query.should be_a(Ricordami::Query)
+      end
+
+      it "delegates #sort to the new query" do
+        query = Customer.sort(:sex, :desc_alpha)
+        query.sort_by.should == :sex
+        query.sort_dir.should == :desc_alpha
+      end
+    end
+  end
+
+  describe "running queries" do
+    before(:each) do
+      Customer.create(:name => "Zhanna", :sex => "F", :country => "Latvia", :kind => "human")
+      Customer.create(:name => "Mathieu", :sex => "M", :country => "France", :kind => "human")
+      Customer.create(:name => "Sophie", :sex => "F", :country => "USA", :kind => "human")
+      Customer.create(:name => "Brioche", :sex => "F", :country => "USA", :kind => "dog")
+    end
+
+    describe ":and" do
+      it "raises an error if there's no value index for one of the conditions" do
+        lambda {
+          Customer.and(:no_index => "Blah").all
+        }.should raise_error(Ricordami::MissingIndex)
+      end
+
+      it "returns all entries if no conditions where passed" do
+        Customer.and.all.map(&:name).should =~ %w(Zhanna Mathieu Sophie Brioche)
+      end
+
+      it "returns the models found with #all (1 condition, 1 result)" do
+        Customer.index :value => :name
+        found = Customer.and(:name => "Zhanna").all
+        found.map(&:name).should == ["Zhanna"]
+      end
+
+      it "returns the models found with #all (2 conditions, 2 results)" do
+        found = Customer.and(:country => "USA", :sex => "F").all
+        found.map(&:name).should =~ ["Sophie", "Brioche"]
+      end
+
+      it "returns the models found with #all for a composed query" do
+        found = Customer.and(:country => "USA").and(:sex => "F").all
+        found.map(&:name).should =~ ["Sophie", "Brioche"]
+      end
+
+      it "can use #where instead of #and" do
+        found = Customer.where(:country => "USA").and(:sex => "F").all
+        found.map(&:name).should =~ ["Sophie", "Brioche"]
+      end
+
+      it "doesn't require #all if another method call is chained" do
+        Customer.where(:country => "USA").and(:sex => "F").map(&:name).should =~ ["Sophie", "Brioche"]
+      end
+    end
+
+    describe ":any" do
+      it "raises an error if there's no value index for one of the conditions" do
+        lambda {
+          Customer.any(:no_index => "Blah").all
+        }.should raise_error(Ricordami::MissingIndex)
+      end
+
+      it "returns all entries if no conditions where passed" do
+        Customer.any.all.map(&:name).should =~ %w(Zhanna Mathieu Sophie Brioche)
+      end
+
+      it "returns the models found with #all (1 condition, 1 result)" do
+        Customer.index :value => :name
+        found = Customer.any(:name => "Zhanna").all
+        found.map(&:name).should == ["Zhanna"]
+      end
+
+      it "returns the models found with #all (2 conditions, 3 results)" do
+        found = Customer.any(:country => "USA", :sex => "F").all
+        found.map(&:name).should =~ ["Sophie", "Brioche", "Zhanna"]
+      end
+
+      it "returns the models found with #all for a composed query" do
+        found = Customer.where(:country => "USA").any(:name => "Sophie", :kind => "dog").all
+        found.map(&:name).should =~ ["Sophie", "Brioche"]
+        found = Customer.where(:country => "USA").any(:name => "Sophie", :kind => "human").all
+        found.map(&:name).should == ["Sophie"]
+      end
+
+      it "doesn't require #all if another method call is chained" do
+        Customer.any(:country => "USA", :sex => "F").map(&:name).should =~ ["Sophie", "Brioche", "Zhanna"]
+      end
+    end
+
+    describe ":not" do
+      it "raises an error if there's no value index for one of the conditions" do
+        lambda {
+          Customer.not(:no_index => "Blah").all
+        }.should raise_error(Ricordami::MissingIndex)
+      end
+
+      it "returns all entries if no conditions where passed" do
+        Customer.not.all.map(&:name).should =~ %w(Zhanna Mathieu Sophie Brioche)
+      end
+
+      it "returns the models found with #all (1 condition, 1 result)" do
+        Customer.index :value => :name
+        found = Customer.not(:name => "Zhanna").all
+        found.map(&:name).should =~ ["Sophie", "Brioche", "Mathieu"]
+      end
+
+      it "returns the models found with #all (2 conditions, 1 result)" do
+        found = Customer.not(:country => "USA", :sex => "F").all
+        found.map(&:name).should == ["Mathieu"]
+      end
+
+      it "returns the models found with #all for a composed query" do
+        found = Customer.where(:country => "USA").not(:name => "Sophie", :kind => "dog").all
+        found.map(&:name).should be_empty
+        found = Customer.where(:country => "USA").not(:name => "Sophie", :kind => "human").all
+        found.map(&:name).should == ["Brioche"]
+      end
+
+      it "doesn't require #all if another method call is chained" do
+        Customer.not(:country => "USA", :sex => "F").map(&:name).should == ["Mathieu"]
+      end
+    end
+  end
+
+  describe "sorting result" do
+    uses_constants("Student")
+
+    before(:each) do
+      Student.send(:include, Ricordami::CanBeQueried)
+      Student.attribute :name,    :indexed => :value
+      Student.attribute :grade,   :indexed => :value
+      Student.attribute :school,  :indexed => :value
+      [["Zhanna", 12], ["Sophie", 19],
+       ["Brioche", 4], ["Mathieu", 15]].each do |name, grade|
+         Student.create(:name => name, :grade => grade, :school => "Lajoo")
+       end
+    end
+
+    it "can sort the result alphanumerically with #sort" do
+      result = Student.where(:school => "Lajoo").sort(:name, :asc_alpha)
+      result.map(&:name).should == %w(Brioche Mathieu Sophie Zhanna)
+    end
+
+    it "can sort the result numerically with #sort" do
+      result = Student.where(:school => "Lajoo").sort(:grade, :asc_num)
+      result.map(&:name).should == %w(Brioche Zhanna Mathieu Sophie)
+    end
+
+    it "defaults to sorting ascending / alphanumerically" do
+      result = Student.where(:school => "Lajoo").sort(:name)
+      result.map(&:name).should == %w(Brioche Mathieu Sophie Zhanna)
+    end
+  end
+
+  describe "fetching result" do
+    before(:each) do
+      Student.send(:include, Ricordami::CanBeQueried)
+      Student.attribute :name,    :indexed => :value
+      Student.attribute :grade,   :indexed => :value
+      Student.attribute :school,  :indexed => :value
+      [["Zhanna", 12], ["Sophie", 19],
+       ["Brioche", 4], ["Mathieu", 15]].each do |name, grade|
+         Student.create(:name => name, :grade => grade, :school => "Lajoo")
+       end
+      @query = Student.where(:school => "Lajoo").sort(:name)
+    end
+    let(:query) { @query }
+
+    it "fetches all the results with #all" do
+      query.all.map(&:name).should == %w(Brioche Mathieu Sophie Zhanna)
+    end
+
+    it "fetches the requested page of the results with #paginate" do
+      fetched = query.paginate(:page => 1, :per_page => 2)
+      fetched.map(&:name).should == %w(Brioche Mathieu)
+      fetched = query.paginate(:page => 2, :per_page => 2)
+      fetched.map(&:name).should == %w(Sophie Zhanna)
+      query.paginate(:page => 3, :per_page => 2).should be_empty
+    end
+
+    it "fetches the first instance with #first" do
+      query.first.name.should == "Brioche"
+    end
+
+    it "fetches the last instance with #last" do
+      query.last.name.should == "Zhanna"
+    end
+
+    it "fetches a random instance with #rand" do
+      %w(Brioche Mathieu Sophie Zhanna).should include(query.rand.name)
+    end
+  end
+end

data/spec/ricordami/can_be_validated_spec.rb

@@ -0,0 +1,115 @@
+require "spec_helper"
+require "ricordami/can_be_validated"
+
+describe Ricordami::CanBeValidated do
+  describe "Active Model validations" do
+    uses_constants("Call")
+
+    before(:each) do
+      Call.class_eval do
+        include Ricordami::CanBeValidated
+        attribute :ani
+        attribute :dnis
+        validates_presence_of :ani
+        validates_numericality_of :dnis, :allow_blank => true, :message => "is not numeric"
+        validate :cant_call_iself
+
+        private
+        def cant_call_iself
+          return true if ani.blank?
+          errors.add(:ani, "can't be the same as dnis") if ani == dnis
+        end
+      end
+    end
+
+    it "can validate the presence of an attribute value" do
+      call = Call.new
+      call.should_not be_valid
+      call.should have(1).errors
+      call.errors[:ani].should == ["can't be blank"]
+    end
+
+    it "can validate that a field is numeric" do
+      call = Call.new(:ani => "123", :dnis => "nope")
+      call.should_not be_valid
+      call.should have(1).errors
+      call.errors[:dnis].should == ["is not numeric"]
+    end
+
+    it "can do custom validation" do
+      call = Call.new(:ani => "123", :dnis => "123")
+      call.should_not be_valid
+      call.should have(1).errors
+      call.errors[:ani].should == ["can't be the same as dnis"]
+    end
+
+    it "can't validate a model that was deleted" do
+      call = Call.create(:ani => "123", :dnis => "456")
+      call.delete
+      lambda { call.valid? }.should raise_error(Ricordami::ModelHasBeenDeleted)
+    end
+  end
+
+  describe "#save" do
+    uses_constants("Post")
+
+    before(:each) do
+      Post.class_eval do
+        include Ricordami::CanBeValidated
+        attribute :title
+        validates_presence_of :title
+      end
+    end
+
+    it "can't #save if it is not valid" do
+      post = Post.new
+      post.save.should be_false
+    end
+
+    it "can save if it is not valid but passed :validate => false" do
+      Post.new.save(:validate => false).should be_true
+    end
+  end
+
+  describe "validate attribute uniqueness" do
+    uses_constants("User")
+
+    before(:each) do
+      User.class_eval do
+        include Ricordami::CanBeValidated
+        attribute :username, :read_only => true
+        attribute :wife
+        validates_uniqueness_of :username
+      end
+    end
+
+    it "is valid if no other instance uses the same attribute value" do
+      user = User.new(:username => "Serge Gainsbourg")
+      user.should be_valid
+    end
+
+    it "is not valid if another instance uses the same attribute value" do
+      serge = User.new(:username => "Gainsbourg")
+      serge.save.should be_true
+      serge.should be_valid
+
+      usurpateur = User.new(:username => "Gainsbourg")
+      usurpateur.should_not be_valid
+      usurpateur.should have(1).error
+      usurpateur.errors[:username].should == ["is already used"]
+    end
+
+    it "allows to validate the uniqueness of an attribute that can be changed" do
+      User.validates_uniqueness_of(:wife)
+      User.create(:id => "serge", :username => "Gainsbourg", :wife => "Rita")
+      serge = User["serge"]
+      serge.should be_valid
+      serge.save
+
+      fred = User.new(:username => "Chichin", :wife => "Rita")
+      fred.should_not be_valid
+      fred.should have(1).error
+      fred.errors[:wife].should == ["is already used"]
+    end
+  end
+end