yeti 0.1.0 → 0.1.1

data/lib/yeti/context.rb

@@ -4,12 +4,15 @@ module Yeti
       attr_reader :id
     end
 
+    delegate :id, to: :account, prefix: :account
+
     def initialize(hash)
       @given_account_id = hash.fetch(:account_id)
     end
 
     def account
-      @account ||= find_account_by_id(given_id) || no_account
+      @account ||= find_account_by_id given_account_id if given_account_id
+      @account ||= no_account
     end
 
     def find_account_by_id(id)

data/lib/yeti/editor.rb

@@ -74,16 +74,27 @@ module Yeti
     attr_reader :given_id
 
     def self.attribute(name, opts={})
-      self.attributes << name
+      opts[:attribute_name] = name
+      opts[:from] = :edited unless opts.has_key? :from
+      attribute_options[name.to_sym] = opts
       define_attribute_methods attributes
-      from = opts[:from] || :edited
+      from =     case opts[:from].to_s
+      when ""    then "nil"
+      when /^\./ then "self#{opts[:from]}"
+      when /\./  then opts[:from]
+      else            "#{opts[:from]}.#{name}"
+      end
       class_eval """
         def #{name}
-          @#{name} = #{from}.#{name} unless defined? @#{name}
+          unless defined? @#{name}
+            opts = self.class.attribute_options[:#{name}]
+            @#{name} = format_input #{from}, opts
+          end
           @#{name}
         end
         def #{name}=(value)
-          value = (value.to_s.clean.strip if value)
+          opts = self.class.attribute_options[:#{name}]
+          value = format_output value, opts
           return if value==#{name}
           #{name}_will_change!
           @#{name} = value
@@ -94,7 +105,11 @@ module Yeti
     end
 
     def self.attributes
-      @attributes ||= []
+      attribute_options.keys
+    end
+
+    def self.attribute_options
+      @attribute_options ||= {}
     end
 
     def self.dont_translate_error_messages
@@ -105,5 +120,13 @@ module Yeti
       !!@untranslated
     end
 
+    def format_input(value, attribute_opts)
+      value.to_s if value
+    end
+
+    def format_output(value, attribute_opts)
+      value.to_s.clean.strip if value
+    end
+
   end
 end

data/lib/yeti/search.rb

@@ -1,18 +1,29 @@
 module Yeti
   class Search
 
-    attr_reader :search, :page
+    attr_reader :context
     delegate :to_ary, :empty?, :each, :group_by, :size, to: :results
+    delegate :page_count, to: :paginated_results
 
     def initialize(context, hash)
       @context = context
-      @search = hash[:search] || {}.with_indifferent_access
-      @page = hash[:page] || 1
-      @per_page = hash[:per_page] || 20
+      @hash = hash
     end
 
-    def page_count
-      paginated_results.page_count
+    def search
+      @search ||= (hash[:search] || {}).with_indifferent_access
+    end
+
+    def page
+      @page ||= [1, (hash[:page] || 1).to_i].max
+    end
+
+    def per_page
+      @per_page ||= begin
+        per_page = [1, (hash[:per_page] || 20).to_i].max
+        max = self.class.max_per_page
+        max ? [per_page, max].min : per_page
+      end
     end
 
     def count
@@ -38,18 +49,23 @@ module Yeti
       end
     end
 
+    def paginated_results
+      raise NotImplementedError
+    end
+
   private
 
-    attr_reader :context, :per_page
+    attr_reader :hash
+
+    # ~~~ private class methods ~~~
+    def self.max_per_page(value=nil)
+      value ? @max_per_page = value : @max_per_page
+    end
 
     # ~~~ private instance methods ~~~
     def delegate_to_search_pattern
       /(?:_equals|_contains|_gte|_lte)\z/
     end
 
-    def paginated_results
-      raise NotImplementedError
-    end
-
   end
 end

data/lib/yeti/version.rb

@@ -1,3 +1,3 @@
 module Yeti
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/yeti.rb

@@ -1,3 +1,5 @@
+require "active_support/core_ext/module/delegation"
+require "active_support/core_ext/hash/indifferent_access"
 require "active_model"
 require "string_cleaner"
 require "yeti/context"

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 require "bundler/setup"
 require "logger"
 require "yeti"
+require "support/matchers"
 
 RSpec.configure do |config|
   config.before(:all) do

data/spec/support/matchers.rb

@@ -0,0 +1,35 @@
+RSpec::Matchers.define :delegates do |delegated_method|
+  match do |subject|
+    stubbed = send(@delegate).stub(@delegate_method)
+    stubbed.with @delegate_params if @delegate_params
+    stubbed.and_return expected=mock
+    subject.send(delegated_method) === expected
+  end
+
+  chain :to do |delegate|
+    if delegate.is_a?(String) && delegate.include?("#")
+      @delegate, @delegate_method = delegate.split "#"
+    else
+      @delegate = delegate
+      @delegate_method = delegated_method
+    end
+  end
+
+  chain :with do |delegate_params|
+    @delegate_params = delegate_params
+  end
+
+  description do
+    delegate_method = ("##{@delegate_method}" if delegated_method.to_s!=@delegate_method.to_s)
+    delegate_params = (" with params #{@delegate_params.inspect}" if @delegate_params)
+    "delegates #{delegated_method} to #{@delegate}#{delegate_method}#{delegate_params}"
+  end
+
+  failure_message_for_should do |text|
+    "expected delegation of #{delegated_method} to #{@delegate}"
+  end
+
+  failure_message_for_should do |text|
+    "do not expected delegation of #{delegated_method} to #{@delegate}"
+  end
+end

data/spec/yeti/context_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Yeti::Context do
+  context "initialization" do
+    it "requires a hash with account_id" do
+      lambda{ Yeti::Context.new }.should raise_error ArgumentError, "wrong number of arguments (0 for 1)"
+      lambda{ Yeti::Context.new key: nil }.should raise_error KeyError, "key not found: :account_id"
+    end
+  end
+  context "when account_id is nil" do
+    subject{ Yeti::Context.new account_id: nil }
+    it "#account is an instance of Yeti::Context::NoAccount" do
+      subject.account.should be_kind_of Yeti::Context::NoAccount
+    end
+    it("#account_id is nil"){ subject.account_id.should be_nil }
+    it "no account can be overriden by subclasses" do
+      subclass = Class.new Yeti::Context do
+        def no_account
+          :custom_no_account
+        end
+      end
+      subject = subclass.new account_id: nil
+      subject.account.should == :custom_no_account
+    end
+  end
+  context "when account_id" do
+    subject{ Yeti::Context.new account_id: 1 }
+    it "uses find_account_by_id to find account" do
+      subject.stub(:find_account_by_id).with(1).and_return(expected = mock)
+      subject.account.should be expected
+    end
+    it "#find_account_by_id is virtual" do
+      lambda do
+        subject.find_account_by_id 1
+      end.should raise_error NotImplementedError
+    end
+    it "#account_id returns account.id" do
+      subject.stub(:find_account_by_id).with(1).and_return mock(id: 2)
+      subject.account_id.should be 2
+    end
+  end
+end

data/spec/yeti/editor_spec.rb

@@ -1,50 +1,50 @@
 require "spec_helper"
 
-describe ::Yeti::Editor do
+describe Yeti::Editor do
   let(:context){ mock :context }
-  subject{ ::Yeti::Editor.new context, nil }
-  it "should keep given context" do
+  subject{ Yeti::Editor.new context, nil }
+  it "keeps given context" do
     subject.context.should be context
   end
-  it "#find_by_id should be virtual" do
+  it "#find_by_id is virtual" do
     lambda{ subject.find_by_id 1 }.should raise_error NotImplementedError
   end
-  it "#new_object should be virtual" do
+  it "#new_object is virtual" do
     lambda{ subject.new_object }.should raise_error NotImplementedError
   end
-  it "#persist! should be virtual" do
+  it "#persist! is virtual" do
     lambda{ subject.persist! }.should raise_error NotImplementedError
   end
   context "with a given id" do
-    subject{ ::Yeti::Editor.new context, 1 }
+    subject{ Yeti::Editor.new context, 1 }
     it{ should be_persisted }
-    it "#edited should use #find_by_id" do
+    it "uses #find_by_id to find the main object being edited" do
       subject.stub(:find_by_id).with(1).and_return(expected = mock)
       subject.edited.should be expected
     end
   end
   context "without id" do
     it{ should_not be_persisted }
-    it "#edited should use #new_object" do
+    it "uses #new_object to initialize main object being edited" do
       subject.stub(:new_object).and_return(expected = mock)
       subject.edited.should be expected
     end
   end
   context "when not valid" do
     before{ subject.stub(:valid?).and_return false }
-    it "#save should return false" do
+    it "#save returns false" do
       subject.save.should be false
     end
   end
   context "when valid" do
-    it "#save should call persist! then return true" do
+    it "#save calls persist! then returns true" do
       subject.should_receive :persist!
       subject.save.should be true
     end
   end
   context "editor of one record" do
-    let :object_editor do
-      Class.new ::Yeti::Editor do
+    let :editor_class do
+      Class.new Yeti::Editor do
         attribute :name
         validates_presence_of :name
         def self.name
@@ -53,45 +53,45 @@ describe ::Yeti::Editor do
       end
     end
     context "new record" do
-      subject{ object_editor.new context, nil }
+      subject{ editor_class.new context, nil }
       let(:new_record){ mock :new_record, name: nil, id: nil }
       before{ subject.stub(:new_object).and_return new_record }
       its(:id){ should be_nil }
       its(:name){ should be_nil }
-      it "#name= should convert input to string" do
+      it "#name= converts input to string" do
         subject.name = ["test"]
         subject.name.should == "[\"test\"]"
       end
-      it "#name= should clean the value" do
+      it "#name= cleans the value of any harmful content" do
         subject.name = "\tInfected\210\004"
         subject.name.should == "Infected"
       end
-      it "#name= should accept nil" do
+      it "#name= accepts nil" do
         subject.name = "Valid"
         subject.name = nil
         subject.name.should be_nil
       end
-      it "#attributes should return a hash" do
+      it "#attributes returns a hash" do
         subject.attributes.should == {name: nil}
       end
-      it "#attributes= should assign each attribute" do
+      it "#attributes= assigns each attribute" do
         subject.should_receive(:name=).with "Anthony"
         subject.attributes = {name: "Anthony"}
       end
-      it "#attributes= should skip unknown attributes" do
+      it "#attributes= skips unknown attributes" do
         subject.attributes = {unknown: "Anthony"}
       end
       context "before validation" do
         its(:errors){ should be_empty }
       end
       context "after validation" do
-        it "should have an error on name" do
+        it "has an error on name" do
           subject.valid?
           subject.errors[:name].should have(1).item
           subject.errors[:name].should == ["can't be blank"]
         end
-        it "should be able to return untranslated error messages" do
-          object_editor.class_eval do
+        it "can return untranslated error messages" do
+          editor_class.class_eval do
             dont_translate_error_messages
           end
           subject.valid?
@@ -104,12 +104,12 @@ describe ::Yeti::Editor do
       context "when name is changed" do
         before{ subject.name = "Anthony" }
         it{ should be_valid }
-        it "#attributes should be updated" do
+        it "#attributes is updated" do
           subject.attributes.should == {name: "Anthony"}
         end
-        it("name should be updated"){ subject.name.should == "Anthony" }
-        it("name should be dirty"){ subject.name_changed?.should be true }
-        it "name should not be dirty anymore if original value is reset" do
+        it("name is updated"){ subject.name.should == "Anthony" }
+        it("name is dirty"){ subject.name_changed?.should be true }
+        it "name isn't dirty anymore if original value is set back" do
           subject.name = nil
           subject.name_changed?.should be false
         end
@@ -120,32 +120,88 @@ describe ::Yeti::Editor do
           subject.stub :persist!
           subject.save
         end
-        it "should reset dirty attributes" do
+        it "resets dirty attributes" do
           subject.name_changed?.should be false
         end
-        it "should still know previous changes" do
+        it "still knows previous changes" do
           subject.previous_changes.should == {"name"=>[nil, "Anthony"]}
         end
       end
     end
     context "existing record" do
-      subject{ object_editor.new context, 1 }
+      subject{ editor_class.new context, 1 }
       let(:existing_record){ mock :existing_record, name: "Anthony", id: 1 }
       before{ subject.stub(:find_by_id).with(1).and_return existing_record }
-      it("should get id from record"){ subject.id.should be 1 }
-      it "should get name from record" do
+      it("gets id from record"){ subject.id.should be 1 }
+      it "gets name from record" do
         subject.name.should == "Anthony"
       end
       it{ should be_valid }
+      it "input formatting can be customized" do
+        subject.stub(:format_input).with("Anthony", {
+          attribute_name: :name,
+          from: :edited,
+        }).and_return(expected = mock)
+        subject.name.should be expected
+      end
+      it "output formatting can be customized" do
+        subject.stub(:format_output).with("Tony", {
+          attribute_name: :name,
+          from: :edited,
+        }).and_return(expected = mock)
+        subject.name = "Tony"
+        subject.name.should be expected
+      end
       context "when name is changed" do
         before{ subject.name = nil }
-        it("name should be updated"){ subject.name.should be_nil }
-        it("name should be dirty"){ subject.name_changed?.should be true }
-        it "name should not be dirty anymore if original value is reset" do
+        it("name is updated"){ subject.name.should be_nil }
+        it("name is dirty"){ subject.name_changed?.should be true }
+        it "name isn't dirty anymore if original value is set back" do
           subject.name = "Anthony"
           subject.name_changed?.should be false
         end
       end
     end
   end
+  context "editor of multiple records" do
+    let :editor_class do
+      Class.new Yeti::Editor do
+        attribute :name
+        attribute :description, from: :related
+        attribute :password, from: nil
+        attribute :timestamp, from: ".timestamp_str"
+        attribute :related_id, from: "related.id"
+        attribute :invalid
+        def find_by_id(id)
+          Struct.new(:id, :name).new(id, "Anthony")
+        end
+        def related
+          Struct.new(:id, :description).new 2, "Business man"
+        end
+        def timestamp_str
+          "2001-01-01"
+        end
+      end
+    end
+    subject{ editor_class.new context, 1 }
+    it "attribute default value comes from edited" do
+      subject.id.should == 1
+      subject.name.should == "Anthony"
+    end
+    it "attribute value can come from another object" do
+      subject.description.should == "Business man"
+    end
+    it "attribute value can come from nowhere" do
+      subject.password.should be_nil
+    end
+    it "attribute value can come from specified method on self" do
+      subject.timestamp.should == "2001-01-01"
+    end
+    it "attribute value can come from specified method on another object" do
+      subject.related_id.should == "2"
+    end
+    it "attribute raises if value cannot be found in source" do
+      lambda{ subject.invalid }.should raise_error NoMethodError
+    end
+  end
 end

data/spec/yeti/search_spec.rb

@@ -0,0 +1,101 @@
+require "spec_helper"
+
+describe Yeti::Search do
+  let(:context){ mock :context }
+  context "initialization" do
+    it "does require a context and a hash" do
+      message = "wrong number of arguments (1 for 2)"
+      lambda do
+        Yeti::Search.new context
+      end.should raise_error ArgumentError, message
+    end
+  end
+  context "given context and an empty hash" do
+    subject{ Yeti::Search.new context, {} }
+    it "keeps given context" do
+      subject.context.should be context
+    end
+    it "#search defaults to {}" do
+      subject.search.should == {}
+    end
+    it "#page defaults to 1" do
+      subject.page.should == 1
+    end
+    it "#per_page defaults to 20" do
+      subject.per_page.should == 20
+    end
+  end
+  context "given context and params" do
+    let :search do
+      {
+        "name_contains" => "tony",
+        "popular_equals" => "1",
+        "created_at_gte" => "2001-01-01",
+        "created_at_lte" => "2002-01-01",
+        "uncommon_filter" => "1",
+      }
+    end
+    let(:results){ mock :results }
+    subject{ Yeti::Search.new context, search: search }
+    before{ subject.stub(:results).and_return results }
+    it "#search comes from hash" do
+      subject.search.should == search
+    end
+    it "gets common filters from search" do
+      subject.should respond_to(:name_contains)
+      subject.should respond_to(:popular_equals)
+      subject.should respond_to(:created_at_gte)
+      subject.should respond_to(:created_at_lte)
+      subject.name_contains.should == "tony"
+      subject.popular_equals.should == "1"
+      subject.created_at_gte.should == "2001-01-01"
+      subject.created_at_lte.should == "2002-01-01"
+    end
+    it "doesn't get everything from search" do
+      subject.should_not respond_to(:uncommon_filter)
+      lambda{ subject.invalid_method }.should raise_error NoMethodError
+      lambda{ subject.uncommon_filter }.should raise_error NoMethodError
+    end
+    it "#page comes from hash" do
+      Yeti::Search.new(context, page: "2").page.should be 2
+    end
+    it "doesn't accept page to be lower than 1" do
+      Yeti::Search.new(context, page: "0").page.should be 1
+    end
+    it "#per_page comes from hash" do
+      Yeti::Search.new(context, per_page: "10").per_page.should be 10
+    end
+    it "doesn't accept per_page to be lower than 1" do
+      Yeti::Search.new(context, per_page: "0").per_page.should be 1
+    end
+    it "by default per_page has no limit" do
+      Yeti::Search.max_per_page.should be_nil
+      Yeti::Search.new(context, per_page: "9999").per_page.should be 9999
+    end
+    it "per_page can be limited" do
+      search_class = Class.new Yeti::Search do
+        max_per_page 50
+      end
+      search_class.max_per_page.should be 50
+      search_class.new(context, per_page: "9999").per_page.should be 50
+    end
+    it "#paginated_results is virtual" do
+      lambda do
+        subject.paginated_results
+      end.should raise_error NotImplementedError
+    end
+    it{ should delegates(:to_ary).to :results }
+    it{ should delegates(:empty?).to :results }
+    it{ should delegates(:each).to :results }
+    it{ should delegates(:group_by).to :results }
+    it{ should delegates(:size).to :results }
+  end
+  context "when paginated_results is defined" do
+    let(:paginated_results){ mock :paginated_results }
+    subject{ Yeti::Search.new context, {} }
+    before{ subject.stub(:paginated_results).and_return paginated_results }
+    it{ should delegates(:page_count).to :paginated_results }
+    it{ should delegates(:count).to "paginated_results#pagination_record_count" }
+    it{ should delegates(:results).to "paginated_results#all" }
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: yeti
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-19 00:00:00.000000000 Z
+date: 2012-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -94,7 +94,10 @@ files:
 - lib/yeti/search.rb
 - lib/yeti/version.rb
 - spec/spec_helper.rb
+- spec/support/matchers.rb
+- spec/yeti/context_spec.rb
 - spec/yeti/editor_spec.rb
+- spec/yeti/search_spec.rb
 - spec/yeti_spec.rb
 - yeti.gemspec
 homepage: ''
@@ -111,7 +114,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 955757267782825945
+      hash: -488456883026859265
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -120,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 955757267782825945
+      hash: -488456883026859265
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24
@@ -129,5 +132,8 @@ specification_version: 3
 summary: Editor pattern simplifies edition of multiple objects at once using ActiveModel
 test_files:
 - spec/spec_helper.rb
+- spec/support/matchers.rb
+- spec/yeti/context_spec.rb
 - spec/yeti/editor_spec.rb
+- spec/yeti/search_spec.rb
 - spec/yeti_spec.rb