with_filters 0.1.0

data/spec/models/filter/base_range_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe WithFilters::Filter::BaseStart do
+  subject {described_class.new(:year, :foo, '')}
+
+  its(:field_name) {should == 'foo[year][start]'}
+end
+
+describe WithFilters::Filter::BaseStop do
+  subject {described_class.new(:year, :foo, '')}
+
+  its(:field_name) {should == 'foo[year][stop]'}
+end
+
+describe WithFilters::Filter::BaseRange do
+  subject {described_class.new(:year, :foo, {})}
+
+  its(:start) {should be_an_instance_of(WithFilters::Filter::BaseStart)}
+  its(:stop)  {should be_an_instance_of(WithFilters::Filter::BaseStop)}
+
+  context 'options' do
+    it 'uses the :start and :stop option hashes for the individual filters and default any values not passed to the range options provided' do
+      filter = described_class.new(:year, :foo, {}, label: 'Nobel Prize Won In')
+      filter.start.label.should == 'Nobel Prize Won In'
+      filter.stop.label.should  == 'Nobel Prize Won In'
+
+      filter = described_class.new(:year, :foo, {}, label: 'Nobel Prize Won In', start: {label: 'Nobel Prize Won Between'}, stop: {label: 'and'})
+      filter.start.label.should == 'Nobel Prize Won Between'
+      filter.stop.label.should  == 'and'
+    end
+  end
+end

data/spec/models/filter/base_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe WithFilters::Filter::Base do
+  describe '#initialize(name, namespace, value, options = {})' do
+    context 'defaults' do
+      subject {described_class.new(:first_name, :foo, 'Aaron')}
+
+      its(:to_partial_path) {should == File.join('with_filters', 'filter', 'base')}
+      its(:label)           {should == 'First Name'}
+      its(:label_attrs)     {should == {}}
+      its(:field_name)      {should == 'foo[first_name]'}
+      its(:value)           {should == 'Aaron'}
+      it 'has no collection' do
+        subject.collection.should be_nil
+      end
+    end
+
+    context 'options' do
+      context ':field_name' do
+        it 'manually sets the field name' do
+          field_name = 'fname'
+          described_class.new(:first_name, :foo, 'Aaron', field_name: field_name).field_name.should == field_name
+        end
+      end
+
+      context ':label' do
+        it 'uses the provided label' do
+          label = 'Given Name'
+          described_class.new(:first_name, :foo, 'Aaron', label: label).label.should == label
+        end
+      end
+
+      context ':label_attrs' do
+        it 'uses the provided label attrs' do
+          label_attrs = {
+            class: 'label_class'
+          }
+          described_class.new(:first_name, :foo, 'Aaron', label_attrs: label_attrs).label_attrs.should == label_attrs
+        end
+      end
+
+      context ':collection' do
+        it 'creates collection from the provided list' do
+          collection = described_class.new(:gender, :foo, 'Male', collection: ['Male', 'Female']).collection
+          collection.should be_a_kind_of(WithFilters::Filter::Collection)
+          collection.first.label.should == 'Male'
+          collection.last.label.should  == 'Female'
+        end
+      end
+
+      context ':theme' do
+        it 'uses the provided theme to create a partial path' do
+          Dir.stub(:glob).and_return([File.join(Rails.root, 'app', 'views', 'with_filters', 'foo', 'filter', '_base.html.erb')])
+
+          filter = described_class.new(:first_name, :foo, 'Aaron', theme: 'foo')
+
+          filter.to_partial_path.should == File.join('with_filters', 'foo', 'filter', 'base')
+        end
+
+        it 'falls back to the original partials if the theme version can not be found' do
+          Dir.stub(:glob).and_return([])
+
+          filter = described_class.new(:first_name, :foo, 'Aaron', theme: 'foo')
+
+          filter.to_partial_path.should == File.join('with_filters', 'filter', 'base')
+        end
+      end
+
+      context 'everything else' do
+        it 'gets put in attrs' do
+          described_class.new(:first_name, :foo, 'Aaron', {label: 'Given Name', class: 'input_class'}).attrs.should == {class: 'input_class'}
+        end
+      end
+    end
+  end
+end

data/spec/models/filter/check_box_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe WithFilters::Filter::CheckBox do
+  describe '#initialize(name, namespace, value, options = {})' do
+    context 'without collection' do
+      subject {described_class.new(:active, :foo, 'on')}
+
+      its(:to_partial_path) {should == 'with_filters/filter/check_box'}
+
+      context 'and value is "on"' do
+        its(:selected?) {should be true}
+      end
+
+      context 'and value is "off"' do
+        subject {described_class.new(:active, :foo, 'off')}
+        its(:selected?) {should be false}
+      end
+    end
+
+    context 'with collection' do
+      let(:collection) {['Chemistry', 'Literature', 'Peace', 'Physics', 'Physiology or Medicine']}
+      subject {described_class.new(:categories, :foo, ['Chemistry', 'Physics'], collection: collection)}
+
+      its(:to_partial_path) {should == 'with_filters/filter/check_boxes'}
+
+      context 'and there are values' do
+        its(:selected?) {should be true}
+      end
+
+      context 'and there are not values' do
+        subject {described_class.new(:categories, :foo, [], collection: collection)}
+        its(:selected?) {should be false}
+      end
+    end
+  end
+end

data/spec/models/filter/choice_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe WithFilters::Filter::Choice do
+  describe '#initialize(field_name, label, value, options = {})' do
+    context 'default' do
+      subject {described_class.new('field', 'One', 1)}
+
+      its(:field_name) {should == 'field[]'}
+      its(:label)      {should == 'One'}
+      its(:value)      {should be 1}
+      its(:selected?)  {should be_false}
+      its(:attrs)      {should == {id: 'field_1'}}
+    end
+
+    context 'options' do
+      context ':selected' do
+        subject {described_class.new('field', 'One', 1, selected: true)}
+        
+        its(:selected?) {should be_true}
+        its(:attrs)     {should == {id: 'field_1'}}
+      end
+    end
+  end
+end

data/spec/models/filter/collection_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe WithFilters::Filter::Collection do
+  describe '#initialize(field_name, choices, options = {})' do
+    context 'choices' do
+      context 'is an Array ([1,2,3])' do
+        let(:values) {[1,2,3]}
+        subject {described_class.new('field', values)}
+
+        it 'should create Choice objects' do
+          values.each_with_index do |v, i|
+            subject[i].label.should == v.to_s
+            subject[i].value.should == v
+          end
+        end
+      end
+
+      context 'is an Array of Arrays ([[:one, 1], [:two, 2], [:three, 3]])' do
+        let(:values) {[[:one, 1], [:two, 2], [:three, 3]]}
+        subject {described_class.new('field', values)}
+
+        it 'should create Choice objects' do
+          values.each_with_index do |a, i|
+            k, v = a
+            subject[i].label.should == k.to_s
+            subject[i].value.should == v
+          end
+        end
+      end
+
+      context 'is an Array of Arrays with options ([[:one, 1], [:two, 2, {class: "foo"}], [:three, 3]])' do
+        let(:values) {[[:one, 1], [:two, 2, {class: 'foo'}], [:three, 3]]}
+        subject {described_class.new('field', values)}
+
+        it 'should create Choice objects' do
+          values.each_with_index do |a, i|
+            k, v = a
+            subject[i].label.should == k.to_s
+            subject[i].value.should == v
+            subject[i].attrs[:class].should == 'foo' if i == 1
+          end
+        end
+      end
+
+      context 'is a Range (1..3)' do
+        let(:values) {1..3}
+        subject {described_class.new('field', values)}
+
+        it 'should create Choice objects' do
+          values.to_a.each_with_index do |v, i|
+            subject[i].label.should == v.to_s
+            subject[i].value.should == v
+          end
+        end
+      end
+
+      context 'is a Hash ({one: 1, two: 2, three: 3})' do
+        let(:values) {{one: 1, two: 2, three: 3}}
+        subject {described_class.new('field', values)}
+
+        it 'should create Choice objects' do
+          i = 0
+          values.each do |k, v|
+            subject[i].label.should == k.to_s
+            subject[i].value.should == v
+            i += 1
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/filter/filter_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe WithFilters::Filter do
+  describe '#create(name, namespace, value, options = {})' do
+    context 'options' do
+      context ':as' do
+        subject {described_class.create(:email, :foo, '', as: :email)}
+
+        it 'sets the input type' do
+          subject.attrs[:type].should == 'email'
+        end
+
+        it 'returns a filter based on the type' do
+          subject.should be_an_instance_of(WithFilters::Filter::Text)
+        end
+      end
+    end
+  end
+
+  describe '#create_range(name, namespace, value, options = {})' do
+    context 'options' do
+      context ':as' do
+        subject {described_class.create_range(:year, :foo, {}, as: :number)}
+
+        it 'sets the input type' do
+          subject.attrs[:type].should == 'number'
+        end
+
+        it 'returns a filter based on the type' do
+          subject.should be_an_instance_of(WithFilters::Filter::TextRange)
+        end
+      end
+    end
+  end
+end

data/spec/models/filter/select_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe WithFilters::Filter::Select do
+  describe '#initialize(name, namespace, value, options = {})' do
+    context 'options' do
+      it 'allows :collection to accept a string' do
+        subject = described_class.new(:gender, :foo, 'Male', collection: '<option>Male</option><option>Female</option>')
+        subject.collection.should == '<option selected="selected">Male</option><option>Female</option>'
+      end
+    end
+  end
+end

data/spec/models/filter/text_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe WithFilters::Filter::Text do
+  it 'should look for a partial based on the input type and use it if found' do
+    described_class.new(:email, :foo, '').to_partial_path.should == File.join('with_filters', 'filter', 'text')
+  end
+
+  it 'should look for a partial based on the input type and use the default if it is not found' do
+    # there must be a better way to do this
+    Dir.stub(:glob).and_return([File.join('with_filters', 'filter', '_text_as_email.html.erb')])
+    described_class.new(:email, :foo, '', type: :email).to_partial_path.should == File.join('with_filters', 'filter', 'text_as_email')
+    
+    Dir.stub(:glob).and_return([])
+    described_class.new(:email, :foo, '', type: :email).to_partial_path.should == File.join('with_filters', 'filter', 'text')
+  end
+end

data/spec/models/filter_form_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+
+describe WithFilters::FilterForm do
+  describe '#initialize(records, params = {}, options = {})' do
+    context 'defaults' do
+      subject {described_class.new(NobelPrizeWinner.with_filters)}
+
+      its(:attrs)           {should == {novalidate: 'novalidate', method: 'get'}}
+      its(:to_partial_path) {should == File.join('with_filters', 'filter_form')}
+      its(:param_namespace) {should be :nobel_prize_winners}
+      its(:filters)         {should be_empty}
+      its(:hidden_filters)  {should be_empty}
+      its(:actions)         {should be_empty}
+    end
+
+    context 'options' do
+      context ':attrs' do
+        it 'attrs should override the defaults' do
+          described_class.new(NobelPrizeWinner.with_filters, {}, method: 'post').attrs.should == {novalidate: 'novalidate', method: 'post'}
+        end
+      end
+
+      context ':theme' do
+        it 'passes the theme to the inputs' do
+          path = [Rails.root, 'app', 'views', 'with_filters', 'foo', 'filter']
+          Dir.stub(:glob).and_return([])
+          Dir.should_receive(:glob).
+            with(File.join(*path, '_text.*')).
+            and_return([File.join(*path, 'text')])
+
+          ff = described_class.new(NobelPrizeWinner.with_filters, {}, theme: 'foo')
+          ff.input(:first_name)
+
+          ff.filters.first.to_partial_path.should == File.join('with_filters', 'foo', 'filter', 'text')
+        end
+      end
+    end
+  end
+
+  describe '#hidden(name, options = {})' do
+    it 'adds a hidden filter' do
+      ff = described_class.new(NobelPrizeWinner.with_filters)
+      ff.hidden(:hidden)
+
+      ff.hidden_filters.length.should == 1
+      ff.hidden_filters.first.should be_a_kind_of(WithFilters::Filter::Text)
+      ff.hidden_filters.first.attrs[:type].should == 'hidden'
+    end
+  end
+
+  describe '#input(name, options = {})' do
+    it 'adds a filter' do
+      label = 'Given Name'
+      ff = described_class.new(NobelPrizeWinner.with_filters)
+      ff.input(:first_name, label: label)
+
+      ff.filters.length.should == 1
+      ff.filters.first.should be_a_kind_of(WithFilters::Filter::Base)
+      ff.filters.first.label.should == label
+    end
+
+    let(:ff) {described_class.new(FieldFormatTester.with_filters)}
+
+    context 'the type is :hidden' do
+      it 'adds to the hidden_filters list' do
+        ff.input(:foo, as: :hidden)
+
+        ff.filters.should be_empty
+        ff.hidden_filters[0].should be_a_kind_of(WithFilters::Filter::Text)
+        ff.hidden_filters[0].attrs[:type].should == 'hidden'
+      end
+    end
+
+    context 'the database field is an integer, float or decimal' do
+      it 'uses a number filter' do
+        ff.input(:integer_field)
+        ff.input(:float_field)
+        ff.input(:decimal_field)
+
+        ff.filters[0].should be_a_kind_of(WithFilters::Filter::Text)
+        ff.filters[0].attrs[:type].should == 'number'
+        ff.filters[1].should be_a_kind_of(WithFilters::Filter::Text)
+        ff.filters[1].attrs[:type].should == 'number'
+        ff.filters[2].should be_a_kind_of(WithFilters::Filter::Text)
+        ff.filters[2].attrs[:type].should == 'number'
+      end
+    end
+
+    context 'the database field is a date' do
+      it 'uses a date filter' do
+        ff.input(:date_field)
+
+        ff.filters.first.should be_a_kind_of(WithFilters::Filter::Text)
+        ff.filters.first.attrs[:type].should == 'date'
+      end
+    end
+
+    context 'the database field is a time' do
+      it 'uses a time filter' do
+        ff.input(:time_field)
+
+        ff.filters.first.should be_a_kind_of(WithFilters::Filter::Text)
+        ff.filters.first.attrs[:type].should == 'time'
+      end
+    end
+
+    context 'the database field is a datetime or timestamp' do
+      it 'uses a time filter' do
+        ff.input(:datetime_field)
+        ff.input(:timestamp_field)
+
+        ff.filters[0].should be_a_kind_of(WithFilters::Filter::Text)
+        ff.filters[0].attrs[:type].should == 'datetime'
+        ff.filters[1].should be_a_kind_of(WithFilters::Filter::Text)
+        ff.filters[1].attrs[:type].should == 'datetime'
+      end
+    end
+
+    context 'the database field is a boolean' do
+      it 'uses a checkbox filter' do
+        ff.input(:boolean_field)
+
+        ff.filters.first.should be_a_kind_of(WithFilters::Filter::CheckBox)
+        ff.filters.first.attrs[:type].should == 'checkbox'
+      end
+    end
+
+    context 'the database field is text' do
+      context 'and the name includes "email"' do
+        it 'uses an email filter' do
+          ff.input(:email_field)
+
+          ff.filters.first.should be_a_kind_of(WithFilters::Filter::Text)
+          ff.filters.first.attrs[:type].should == 'email'
+        end
+      end
+
+      context 'and the name includes "phone"' do
+        it 'uses a tel filter' do
+          ff.input(:phone_field)
+
+          ff.filters.first.should be_a_kind_of(WithFilters::Filter::Text)
+          ff.filters.first.attrs[:type].should == 'tel'
+        end
+      end
+
+      context 'and the name includes "url"' do
+        it 'uses a url filter' do
+          ff.input(:url_field)
+
+          ff.filters.first.should be_a_kind_of(WithFilters::Filter::Text)
+          ff.filters.first.attrs[:type].should == 'url'
+        end
+      end
+    end
+
+    context 'options' do
+      context ':collection' do
+        it 'defaults to a select filter' do
+          ff = described_class.new(FieldFormatTester.with_filters)
+          ff.input(:text_field)
+
+          ff.filters.first.should be_a_kind_of(WithFilters::Filter::Text)
+          ff.filters.first.attrs[:type].should == 'text'
+        end
+      end
+
+      context 'no :collection' do
+        it 'defaults to a select filter' do
+          ff = described_class.new(FieldFormatTester.with_filters)
+          ff.input(:text_field, collection: 1..10)
+
+          ff.filters.first.should be_a_kind_of(WithFilters::Filter::Select)
+        end
+      end
+    end
+  end
+
+  describe '#input_range(name, options = {})' do
+    it 'adds a ranged filter' do
+      label = 'Awarded'
+      ff = described_class.new(NobelPrizeWinner.with_filters)
+      ff.input_range(:year, label: label)
+
+      ff.filters.length.should == 1
+      ff.filters.first.should be_a_kind_of(WithFilters::Filter::BaseRange)
+      ff.filters.first.start.label.should == label
+    end
+  end
+
+  describe '#action(type, options = {})' do
+    context 'type' do
+      context ':submit' do
+        it 'adds an action' do
+          ff = described_class.new(NobelPrizeWinner.with_filters)
+          ff.action(:submit)
+
+          ff.actions.first.should be_a_kind_of(WithFilters::Action)
+        end
+      end
+
+      context ':reset' do
+        it 'adds an action' do
+          ff = described_class.new(NobelPrizeWinner.with_filters)
+          ff.action(:reset)
+
+          ff.actions.first.should be_a_kind_of(WithFilters::Action)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+
+require File.expand_path('../dummy/config/environment.rb',  __FILE__)
+
+require 'rspec/rails'
+require 'capybara/rspec'
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }

data/spec/value_prep/boolean_prep_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe WithFilters::ValuePrep::BooleanPrep do
+  describe '#value' do
+    it 'turns "on" into `true`' do
+      described_class.new('on').value.should be true
+    end
+
+    it 'turns "off" into `false`' do
+      described_class.new('off').value.should be false
+    end
+  end
+end

data/spec/value_prep/date_prep_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe WithFilters::ValuePrep::DatePrep do
+  describe '#value' do
+    context 'value is a String' do
+      it 'returns a Date' do
+        described_class.new('19140325').value.should be_an_instance_of(Date)
+      end
+    end
+
+    context 'value is an Array' do
+      it 'returns an array of Date objects' do
+        described_class.new(['19140325', '19140326']).value.each do |v|
+          v.should be_an_instance_of(Date)
+        end
+      end
+    end
+
+    context 'value is a Hash' do
+      it 'returns a Hash of Date objects' do
+        value = described_class.new({start: '19140325', stop: '19140326'}).value
+
+        value[:start].should be_an_instance_of(Date)
+        value[:stop].should be_an_instance_of(Date)
+      end
+    end
+  end
+end

data/spec/value_prep/date_time_prep_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe WithFilters::ValuePrep::DateTimePrep do
+  describe '#value' do
+    context 'is a String representing a datetime' do
+      context 'to a fraction of a second' do
+        it 'returns a value' do
+          datetime = '1914-03-25 12:34:56.123456'
+          described_class.new(datetime).value.should == Time.zone.parse(datetime).to_s(:db) + '.123456'
+        end
+      end
+
+      context 'to a second' do
+        it 'returns a value' do
+          datetime = '1914-03-25 12:34:56'
+          value = described_class.new(datetime).value
+          
+          value[:start].should == Time.zone.parse(datetime).to_s(:db)
+          value[:stop].should  == Time.zone.parse(datetime).advance(seconds: 1).to_s(:db)
+        end
+      end
+
+      context 'to a minute' do
+        it 'returns a value' do
+          datetime = '1914-03-25 12:34'
+          value = described_class.new(datetime).value
+          
+          value[:start].should == Time.zone.parse(datetime).to_s(:db)
+          value[:stop].should  == Time.zone.parse(datetime).advance(minutes: 1).to_s(:db)
+        end
+      end
+
+      context 'to an hour' do
+        it 'returns a value' do
+          datetime = '1914-03-25 12'
+          value = described_class.new(datetime).value
+          
+          value[:start].should == Time.zone.parse(datetime).to_s(:db)
+          value[:stop].should  == Time.zone.parse(datetime).advance(hours: 1).to_s(:db)
+        end
+      end
+
+      context 'to a day' do
+        it 'returns a value' do
+          date = '1914-03-25'
+          value = described_class.new(date).value
+
+          value[:start].should == Time.zone.parse(date).to_s(:db)
+          value[:stop].should  == Time.zone.parse(date).advance(days: 1).to_s(:db)
+        end
+      end
+    end
+
+    context 'is a Hash representing a datetime range' do
+      context 'to a fraction of a second' do
+        it 'returns a Hash of values' do
+          datetimes = {start: '1914-03-25 12:34:56.123456', stop: '1914-03-26 12:34:56.654321'}
+          value = described_class.new(datetimes).value
+
+          value[:start].should == Time.zone.parse(datetimes[:start]).to_s(:db) + '.123456'
+          value[:stop].should  == Time.zone.parse(datetimes[:stop]).to_s(:db) + '.654321'
+        end
+      end
+
+      context 'to a second' do
+        it 'returns a Hash of values' do
+          datetimes = {start: '1914-03-25 12:34:56', stop: '1914-03-26 12:34:56'}
+          value = described_class.new(datetimes).value
+
+          value[:start].should == Time.zone.parse(datetimes[:start]).to_s(:db)
+          value[:stop].should  == Time.zone.parse(datetimes[:stop]).advance(seconds: 1).to_s(:db)
+        end
+      end
+
+      context 'to a minute' do
+        it 'returns a Hash of values' do
+          datetimes = {start: '1914-03-25 12:34', stop: '1914-03-26 12:34'}
+          value = described_class.new(datetimes).value
+
+          value[:start].should == Time.zone.parse(datetimes[:start]).to_s(:db)
+          value[:stop].should  == Time.zone.parse(datetimes[:stop]).advance(minutes: 1).to_s(:db)
+        end
+      end
+
+      context 'to an hour' do
+        it 'returns a Hash of values' do
+          datetimes = {start: '1914-03-25 12', stop: '1914-03-26 12'}
+          value = described_class.new(datetimes).value
+
+          value[:start].should == Time.zone.parse(datetimes[:start]).to_s(:db)
+          value[:stop].should  == Time.zone.parse(datetimes[:stop]).advance(hours: 1).to_s(:db)
+        end
+      end
+
+      context 'to a day' do
+        it 'returns a Hash of values' do
+          dates = {start: '19140325', stop: '19140326'}
+          date_time_prep = described_class.new(dates)
+
+          date_time_prep.value[:start].should == Time.zone.parse(dates[:start]).to_s(:db)
+          date_time_prep.value[:stop].should  == Time.zone.parse(dates[:stop]).advance(days: 1).to_s(:db)
+        end
+      end
+    end
+  end
+end