rails_core_extensions 0.0.1

data/lib/rails_core_extensions/position_initializer.rb

@@ -0,0 +1,27 @@
+module RailsCoreExtensions
+  class PositionInitializer
+    def initialize(model_class, scope_name = nil, position_column = nil)
+      @model_class = model_class
+      @scope_name = scope_name
+      @position_column = position_column
+      @position_column ||= :position
+    end
+
+    def positionalize
+      groups.each do |objects|
+        objects.each.with_index do |object, index|
+          next if object.position == index + 1
+          scope = @model_class.where(id: object.id)
+          scope.update_all(@position_column => index + 1)
+        end
+      end
+    end
+
+    private
+
+    def groups
+      objects = @model_class.order(@position_column)
+      @scope_name ? objects.group_by(&@scope_name.to_sym).values : [objects]
+    end
+  end
+end

data/lib/rails_core_extensions/railtie.rb

@@ -0,0 +1,7 @@
+module RailsCoreExtensions
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load 'rails_core_extensions/tasks/position_initializer.rake'
+    end
+  end
+end

data/lib/rails_core_extensions/sortable.rb

@@ -0,0 +1,52 @@
+module RailsCoreExtensions
+  class Sortable
+    # params is either:
+    # SIMPLE:
+    #   model_body (where model is the model name)
+    # SCOPED:
+    #   scope (name of the scope, e.g. category_id)
+    #   category_id (or whatever the name of scope is)
+    #   model_1_body (or whatever id of scope id)
+    def initialize(params, controller_name)
+      @params = params.symbolize_keys
+      @controller_name = controller_name
+      @klass = controller_name.classify.constantize
+    end
+
+    def sort
+      scope = @params[:scope].try(:to_sym)
+
+      param_key = @controller_name.singularize
+      param_key += "_#{@params[scope]}" if scope
+
+      params_collection = @params["#{param_key}_body".to_sym]
+
+      if params_collection.blank?
+        name = "#{scope.to_s.gsub('_id', '')}_#{@params[scope]}_body".to_sym
+        params_collection = @params[name]
+      end
+
+      collection = @klass.reorder(:position)
+      collection = collection.where(@params.slice(scope.to_sym)) if scope
+
+      sort_collection(collection, params_collection.map(&:to_i))
+    end
+
+    private
+
+    def sort_collection(collection_old, collection_new_ids)
+      @klass.transaction do
+        collection_old.each.with_index do |object, index|
+          next if object.id == collection_new_ids[index]
+
+          new_position = collection_new_ids.index(object.id) + 1
+          update(object, new_position)
+        end
+      end
+    end
+
+    def update(object, new_position)
+      @klass.where(id: object.id).limit(1).update_all(position: new_position)
+    end
+  end
+end

data/lib/rails_core_extensions/tasks/position_initializer.rake

@@ -0,0 +1,12 @@
+namespace :fix do
+  desc 'Fix acts as list positions if they ever get out of sync for a model'
+  task :acts_as_list_positions => :environment do
+    raise ArgumentError, 'You must specify model with MODEL environment variable' if ENV['MODEL'].nil?
+
+    model_class     = ENV['MODEL'].camelize.constantize
+    scope_name      = ENV['SCOPE'].try(:to_sym)
+    position_column = ENV['POSITION'].try(:to_sym)
+
+    PositionInitializer.positionalize(model_class, scope_name, position_column)
+  end
+end

data/lib/rails_core_extensions/time_with_zone.rb

@@ -0,0 +1,16 @@
+module ActiveSupport
+  class TimeWithZone
+    def seconds_since
+      (Time.now - self).to_i
+    end
+
+    def minutes_since
+      seconds_since/60
+    end
+
+    def hours_since
+      minutes_since/60
+    end
+  end
+end
+

data/lib/rails_core_extensions/version.rb

@@ -0,0 +1,3 @@
+module RailsCoreExtensions
+  VERSION = '0.0.1'
+end

data/rails_core_extensions.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rails_core_extensions/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rails_core_extensions'
+  spec.version       = RailsCoreExtensions::VERSION
+  spec.authors       = ['Michael Noack', 'Allesandro Berardi']
+  spec.email         = ['support@travellink.com.au']
+  spec.description   = %q{Set of extensions to core rails libraries.}
+  spec.summary       = %q{Set of extensions to core rails libraries.}
+  spec.homepage      = 'http://github.com/sealink/rails_core_extensions'
+
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord', ['>= 2.3.0', '< 5.0.0']
+  spec.add_dependency 'actionpack', ['>= 2.3.0', '< 5.0.0']
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'activerecord-nulldb-adapter'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'simplecov-rcov'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'travis'
+
+  # breadcrumbs optional dependencies
+  spec.add_development_dependency 'make_resourceful'
+  spec.add_development_dependency 'inherited_resources'
+end

data/spec/action_controller_sortable_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+require 'rails_core_extensions/sortable'
+
+connect_to_sqlite
+
+describe RailsCoreExtensions::Sortable do
+  before do
+    Model = Class.new(ActiveRecord::Base) do
+      default_scope -> { order(:name) }
+    end
+    @one = Model.create!(name: 'One', position: 1, category_id: 1)
+    @two = Model.create!(name: 'Two', position: 2, category_id: 1)
+    @thr = Model.create!(name: 'Thr', position: 3, category_id: 2)
+  end
+
+  after do
+    Model.delete_all
+    Object.send(:remove_const, 'Model')
+  end
+
+  let(:params) { { model_body: [@one.id, @thr.id, @two.id] } }
+  subject { RailsCoreExtensions::Sortable.new(params, 'models') }
+
+  describe 'when unscoped' do
+    let(:scope) { Model.reorder(:position) }
+    specify { expect(scope.pluck(:name)).to eq %w(One Two Thr) }
+    it 'should correctly sort' do
+      subject.sort
+      expect(scope.pluck(:name)).to eq %w(One Thr Two)
+    end
+  end
+
+  describe 'when scoped' do
+    let(:scope) { Model.where(category_id: 1).reorder(:position) }
+    specify { expect(scope.pluck(:name)).to eq %w(One Two) }
+
+    let(:params) { { category_id: 1, scope: :category_id, model_1_body: [@two.id, @one.id] } }
+    it 'should correctly sort' do
+      subject.sort
+      expect(scope.pluck(:name)).to eq %w(Two One)
+    end
+
+    describe 'when params scoped differently' do
+      let(:params) { { category_id: 1, scope: :category_id, category_1_body: [@two.id, @one.id] } }
+      it 'should correctly sort' do
+        subject.sort
+        expect(scope.pluck(:name)).to eq %w(Two One)
+      end
+    end
+  end
+end

data/spec/action_view_extensions_spec.rb

@@ -0,0 +1,25 @@
+require 'rails_core_extensions/action_view_extensions'
+
+require 'action_view'
+
+describe RailsCoreExtensions::ActionViewExtensions do
+  before do
+    class TestModel1
+      include ActionView::Helpers::FormTagHelper
+      include ActionView::Helpers::FormOptionsHelper
+      include RailsCoreExtensions::ActionViewExtensions
+    end
+  end
+
+  after { Object.send(:remove_const, 'TestModel1') }
+
+  subject { TestModel1.new }
+
+  context '#boolean_select_tag' do
+    it 'should generate and have selected element selected' do
+      expect(subject.boolean_select_tag('name', selected: '0')).to eq(
+        subject.select_tag('name', subject.options_for_select([['Yes', '1'], ['No', '0']], selected: '0'))
+      )
+    end
+  end
+end

data/spec/active_model_extensions_spec.rb

@@ -0,0 +1,130 @@
+begin
+require 'active_model'
+require 'rails_core_extensions/active_model_extensions'
+require 'spec_helper_model_base'
+
+describe ActiveModelExtensions do
+  include NullDB::CustomNullifiedDatabase if defined?(NullDB)
+
+  before do
+    class ActiveModelExtensionsTestModel1 < ModelBase
+      include ActiveModelExtensions::Validations
+
+      attr_accessor :name
+
+      def initialize(options = {})
+        @name = options[:name]
+      end
+
+      validate :validate_required
+
+      def validate_required
+        CustomPresenceValidator.new(:attributes => lambda { ['name'] }).validate(self)
+      end
+    end
+  end
+
+  after { Object.send(:remove_const, klass.name) }
+
+  let(:klass) { ActiveModelExtensionsTestModel1 }
+
+  context 'when model missing name' do
+    subject { klass.new }
+    it { should_not be_valid }
+  end
+
+  context 'when model complete' do
+    subject { klass.new(:name => 'Valid') }
+    it { should be_valid }
+  end
+end
+
+describe ActiveModelExtensions do
+  include NullDB::CustomNullifiedDatabase if defined?(NullDB)
+
+  before do
+    class ActiveModelExtensionsTestModel2 < ModelBase
+      include ActiveModelExtensions::Validations
+
+      attr_accessor :name
+
+      def initialize(options = {})
+        @name = options[:name]
+      end
+
+      validate_presence_by_custom_rules lambda { ['name'] }
+    end
+
+    class ActiveModelExtensionsTestModel3 < ModelBase
+      include ActiveModelExtensions::Validations
+
+      attr_accessor :name, :phone, :mobile
+
+      def initialize(options = {})
+        @name = options[:name]
+        @phone = options[:phone]
+        @mobile = options[:mobile]
+
+      end
+
+      validate_presence_by_custom_rules lambda { ['name', 'phone or mobile'] }
+    end
+
+    class ActiveModelExtensionsTestModelNil < ModelBase
+      include ActiveModelExtensions::Validations
+      def initialize(options = {})
+      end
+      validate_presence_by_custom_rules lambda { nil }
+    end
+  end
+
+  after { Object.send(:remove_const, klass.name) }
+
+  let(:klass) { ActiveModelExtensionsTestModel2 }
+
+  context 'when model missing name' do
+    subject { klass.new }
+    it { should_not be_valid }
+  end
+
+  context 'when model complete' do
+    subject { klass.new(:name => 'Valid') }
+    it { should be_valid }
+  end
+
+  context 'with or case' do
+    let(:klass) { ActiveModelExtensionsTestModel3 }
+
+    context 'when model has none of conditions' do
+      subject { klass.new(:name => 'Valid') }
+      it { should_not be_valid }
+    end
+
+    context 'when model has first of conditions' do
+      subject { klass.new(:name => 'Valid', :phone => '555-1234') }
+      it { should be_valid }
+    end
+
+    context 'when model has second of conditions' do
+      subject { klass.new(:name => 'Valid', :mobile => '555-1234') }
+      it { should be_valid }
+    end
+
+    context 'when model has all conditions' do
+      subject { klass.new(:name => 'Valid', :phone => '555-1234', :mobile => '555-4321') }
+      it { should be_valid }
+    end
+  end
+
+  context 'with nil requirements' do
+    let(:klass) { ActiveModelExtensionsTestModelNil }
+
+    context 'when model valid' do
+      subject { klass.new(:name => 'Valid') }
+      it { should be_valid }
+    end
+  end
+end
+
+rescue LoadError # Spec doesn't run for rails 2
+end

data/spec/active_record_extensions_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+connect_to_sqlite
+
+describe "optional_fields" do
+  before do
+    Model = Class.new(ActiveRecord::Base) do
+      optional_fields :name, :age, -> { [:age] }
+    end
+  end
+  after { Object.send(:remove_const, 'Model') }
+
+  it 'should know what fields are optional' do
+    expect(Model).to be_age_enabled
+    expect(Model).to_not be_name_enabled
+  end
+
+  it 'should be able to change optional fields' do
+    Model.enabled_fields = [:age, :name]
+    expect(Model).to be_name_enabled
+  end
+end
+
+describe "ActiveRecord::Base" do
+  before(:all) { Model = Class.new(ActiveRecord::Base) }
+  after (:all) { Object.send(:remove_const, 'Model') }
+
+  before do
+    @mock_model = double("mock model")
+  end
+
+  it "should create a new record if new_or_update! is passed a hash without an :id" do
+    attributes = {:fake_column => 'nothing really'}
+    expect(Model).to receive(:new).with(attributes)
+    Model.new_or_update!(attributes)
+  end
+
+  it "should update record if new_or_update! is passed hash with :id" do
+    attributes = {:fake_column => 'nothing really', :id => 1}
+    expect(Model).to receive(:find) { @mock_model }
+    expect(@mock_model).to receive(:update_attributes!)
+    Model.new_or_update!(attributes)
+  end
+
+end
+
+describe RailsCoreExtensions::ActionControllerSortable do
+  class NormalController < ActionController::Base
+  end
+
+  class SortableController < ActionController::Base
+    sortable
+  end
+
+  it 'should sort' do
+    # map(&:to_sym) for ruby 1.8 compatibility
+    expect(NormalController.new.methods.map(&:to_sym)).to_not include(:sort)
+    expect(SortableController.new.methods.map(&:to_sym)).to include(:sort)
+  end
+end
+
+describe ActiveRecordExtensions do
+  class Parent < ActiveRecord::Base
+    has_many :children
+    def transfer_children_from(old_parent)
+      transfer_records(Child, [old_parent])
+    end
+  end
+  class Child < ActiveRecord::Base
+    belongs_to :parent
+  end
+
+  let(:old) { Parent.create! }
+  let(:new) { Parent.create! }
+
+  before do
+    new.children.create!
+    old.children.create!
+  end
+
+  after do
+    Parent.delete_all
+    Child.delete_all
+  end
+
+  it 'should transfer records' do
+    expect(new.children.size).to eq 1
+    expect(old.children.size).to eq 1
+    new.transfer_children_from(old)
+    expect(new.reload.children.size).to eq 2
+    expect(old.reload.children.size).to eq 0
+  end
+end
+
+describe ActiveRecordExtensions do
+  before(:all) do
+    Model = Class.new(ActiveRecord::Base) do
+      cache_all_attributes :by => 'name'
+    end
+  end
+  after (:all) { Object.send(:remove_const, 'Model') }
+
+  before do
+    allow(Model).to receive(:cache) { ActiveSupport::Cache::MemoryStore.new }
+    allow(Model).to receive(:should_cache?) { true }
+  end
+
+  after do
+    Model.delete_all
+  end
+
+  it 'should cache all attributes' do
+    @first = Model.create!(:name => 'First')
+    @second = Model.create!(:name => 'Second')
+
+    expected = {'First' => @first.attributes, 'Second' => @second.attributes}
+
+    # Test underlying generate attributes hash method works
+    expect(Model.generate_attributes_hash).to eq expected
+    expect(Model.attribute_cache).to eq expected
+
+    # Test after save/destroy it updates
+    @first.destroy
+    expect(Model.attribute_cache).to eq 'Second' => @second.attributes
+  end
+end