active_record_batteries 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 627d133bd03a971733af4b6c13f785c7818fc091
+  data.tar.gz: da576d73fc56b2908ee439d57602f16190393d05
+SHA512:
+  metadata.gz: dd346dedc4c333d84854dbf6ba7c207d64ee1c33cd27f3c14f7ed1decba4e66c64a86f0931616f03e05d811ec49caaf33e6b2e61dde007d20867f7f8e5859300
+  data.tar.gz: a9d073f004d367713145512ef781600970b3b39f177e29fa6c199836d0f37cf4132efc3c76e32edd6ae8a2dc665fd56a6a2ac39126a7d29c1cd578ac71e87fd9

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 
+
+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,14 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+load 'rails/tasks/statistics.rake'
+
+Bundler::GemHelper.install_tasks

data/lib/active_record_batteries.rb

@@ -0,0 +1,7 @@
+module ActiveRecordBatteries
+end
+
+require 'active_record_batteries/engine'
+require 'active_record_batteries/version'
+require 'active_record_batteries/concerns'
+require 'active_record_batteries/loader'

data/lib/active_record_batteries/concerns.rb

@@ -0,0 +1,11 @@
+module ActiveRecordBatteries
+  module Concerns
+    extend ActiveSupport::Autoload
+
+    autoload :Deletable,          'active_record_batteries/concerns/deletable'
+    autoload :Filterable,         'active_record_batteries/concerns/filterable'
+    autoload :Paginable,          'active_record_batteries/concerns/paginable'
+    autoload :Sluggable,          'active_record_batteries/concerns/sluggable'
+    autoload :RelationshipScopes, 'active_record_batteries/concerns/relationship_scopes'
+  end
+end

data/lib/active_record_batteries/concerns/deletable.rb

@@ -0,0 +1,22 @@
+module ActiveRecordBatteries
+  module Concerns
+    module Deletable
+      extend ActiveSupport::Concern
+
+      included do
+        default_scope { where(deleted_at: nil) }
+
+        scope :including_deleted, -> { unscope(where: :deleted_at) }
+      end
+
+      def delete!
+        self.deleted_at = Time.current
+        self
+      end
+
+      def deleted?
+        !!self.deleted_at
+      end
+    end
+  end
+end

data/lib/active_record_batteries/concerns/filterable.rb

@@ -0,0 +1,30 @@
+module ActiveRecordBatteries
+  module Concerns
+    module Filterable
+      extend ActiveSupport::Concern
+
+      included do
+        scope :filtered, ->(values) {
+          current = all
+          filters.each do |key, method|
+            if values.try(:key?, key) && current.respond_to?(method)
+              current = current.send(method, values[key])
+            end
+          end
+          current
+        }
+      end
+
+      module ClassMethods
+        def filter_add(method_name, callable = nil)
+          scope(method_name, callable) if callable
+          filters[method_name] = method_name
+        end
+
+        def filters
+          @filters ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/active_record_batteries/concerns/paginable.rb

@@ -0,0 +1,56 @@
+module ActiveRecordBatteries
+  module Concerns
+    module Paginable
+      extend ActiveSupport::Concern
+
+      included do
+        # Default items per page
+        page_items 25
+
+        scope :paginate, lambda { |page, page_items = @page_items|
+          limit(page_items)
+            .offset(([page.to_i, 1].max - 1) * page_items)
+            .extending do
+
+            def current_page
+              @current_page ||=
+                if total_pages.zero?
+                  0
+                else
+                  (offset_value / limit_value.to_f).ceil + 1
+                end
+            end
+
+            # If pagination is used this
+            def total_items
+              @total_items ||=
+                begin
+                  total_rows = except(:offset, :limit, :order)
+                  total_rows = total_rows.except(:includes) if eager_loading?
+                  total_rows.distinct(:id).count
+                end
+            end
+
+            def total_pages
+              @total_pages ||=
+                begin
+                  (total_items / limit_value.to_f).ceil
+                end
+            end
+          end
+        }
+      end
+
+      module ClassMethods
+        def page_items(items)
+          @page_items = items
+        end
+
+        def pages(page_items = @page_items)
+          (all.except(:offset, :limit, :order, :includes)
+            .distinct(:id).count / page_items.to_f).ceil
+        end
+      end
+    end
+  end
+end

data/lib/active_record_batteries/concerns/relationship_scopes.rb

@@ -0,0 +1,24 @@
+module ActiveRecordBatteries
+  module Concerns
+    module RelationshipScopes
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def relationship_scopes(relationship, suffix = nil)
+          suffix ||= relationship
+
+          with_scope_name    = "with_#{ suffix }".to_sym
+          include_scope_name = "include_#{ suffix }".to_sym
+
+          scope with_scope_name,              -> { joins(relationship) }
+          scope include_scope_name,           -> { includes(relationship) }
+          scope "and_#{ suffix }".to_sym,     -> { send(with_scope_name).send(include_scope_name) }
+          scope "pload_#{ suffix }".to_sym,   -> { preload(relationship) }
+          scope "eload_#{ suffix }".to_sym,   -> { eager_load(relationship) }
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/active_record_batteries/concerns/sluggable.rb

@@ -0,0 +1,70 @@
+module ActiveRecordBatteries
+  module Concerns
+    module Sluggable
+      extend ActiveSupport::Concern
+
+      included do
+        # Backwards compatibility
+        slug_base_column :name
+
+        # Be sure to create a valid slug before validating and saving.
+        before_validation :set_slug, on: [:create, :update]
+        after_validation :delete_slug_errors
+
+        # Scope to query by slug
+        scope :by_slug, ->(slug) { where(slug: slug) }
+
+        # Slug must be present
+        validates :slug, presence: true, uniqueness:true, length: { maximum: 256 }
+      end
+
+      module ClassMethods
+        def slug_base_column(column_name)
+          @slug_base_column_name = column_name.to_sym
+        end
+
+        # Find by slug
+        def find_by_slug(slug)
+          by_slug(slug).take
+        end
+      end
+
+      def to_param
+        slug
+      end
+
+      private
+
+      def slug_base_column_value
+        send(self.class.instance_variable_get(:@slug_base_column_name))
+      end
+
+      def set_slug
+        self.slug = qualify_slug(slug_base_column_value.parameterize) if
+          slug_base_column_value.present? && slug.blank?
+      end
+
+      def delete_slug_errors
+        errors.delete(:slug)
+      end
+
+      def qualify_slug(base_slug)
+        tentative_slug = base_slug
+        while duplicate_slug?(tentative_slug)
+          tentative_slug = generate_slug_name(base_slug)
+        end
+        tentative_slug
+      end
+
+      def duplicate_slug?(slug)
+        self.class
+          .where.not(id: id)
+          .exists?(slug: slug)
+      end
+
+      def generate_slug_name(slug)
+        "#{slug}-#{SecureRandom.urlsafe_base64(4)}"
+      end
+    end
+  end
+end

data/lib/active_record_batteries/engine.rb

@@ -0,0 +1,5 @@
+module ActiveRecordBatteries
+  class Engine < ::Rails::Engine
+    isolate_namespace ActiveRecordBatteries
+  end
+end

data/lib/active_record_batteries/loader.rb

@@ -0,0 +1,19 @@
+module ActiveRecordBatteries
+  module Loader
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def batteries! (*modules)
+        modules = modules.is_a?(Array) ? modules : [ modules ]
+
+        modules.each.map{|i| i.to_s.camelize }.each do |mod|
+          include ActiveRecordBatteries::Concerns.const_get(mod)
+        end
+
+        nil
+      end
+    end
+
+    ActiveRecord::Base.send(:include, self)
+  end
+end

data/lib/active_record_batteries/version.rb

@@ -0,0 +1,3 @@
+module ActiveRecordBatteries
+  VERSION = "1.0.0"
+end

data/lib/tasks/active_record_batteries_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :active_record_batteries do
+#   # Task goes here
+# end

data/spec/active_record_batteries_spec.rb

@@ -0,0 +1,200 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+RSpec.describe ActiveRecordBatteries do
+  before :all do
+    # Have some authors
+    Author.create((1..5).map { |i| { name: SecureRandom.urlsafe_base64(5) } })
+
+    # And have eah author have some articles
+    Author.all.each do |author|
+      Article.create((1..10).map { |i|
+                       {
+                         title:  SecureRandom.urlsafe_base64(10),
+                         body:   SecureRandom.urlsafe_base64(100),
+                         author: author
+                       }
+                     })
+    end
+  end
+
+  context "Deletable" do
+    before :all do
+      Article.create(title: "article_deletable", author: Author.first)
+    end
+
+    after :all do
+      Article.including_deleted.find_by(title: "article_deletable").destroy
+    end
+
+    it "new instance should not deleted" do
+       expect(Article.new.deleted?).to be false
+    end
+
+    it "new instance should be deleted" do
+      expect(Article.new(deleted_at: Date.today).deleted?).to be true
+    end
+
+    it "should delete a new instance" do
+      obj = Article.new
+      obj.delete!
+
+      expect(obj.deleted?).to be true
+    end
+
+    it "should not be deleted" do
+      obj = Article.find_by(title: "article_deletable")
+
+      expect(obj.deleted?).to be false
+    end
+
+    it "should delete" do
+      obj = Article.find_by(title: "article_deletable")
+      obj.delete!
+      obj.save
+
+      expect(obj.deleted?).to be true
+    end
+
+    it "should not find" do
+      obj = Article.find_by(title: "article_deletable")
+      expect(obj).to eq(nil)
+    end
+
+    it "should find" do
+      obj = Article.including_deleted.find_by(title: "article_deletable")
+      expect(obj).not_to eq(nil)
+    end
+
+    it "should stay deleted" do
+      obj = Article.including_deleted.find_by(title: "article_deletable")
+      expect(obj.deleted?).to be true
+    end
+  end
+
+  context "Filterable" do
+    before :all do
+      Article.create(title: "article_filterable",  author: Author.first)
+      Article.create(title: "article_filterable2", author: Author.first, slug: 'filtered_1')
+    end
+
+    after :all do
+      Article.by_title("article_filterable").destroy_all
+      Article.by_title("article_filterable2").destroy_all
+    end
+
+    it "should be hash" do
+       expect(Article.filters).to be_an_instance_of(Hash)
+    end
+
+    it "should have filters" do
+       expect(Article.filters.keys.size).to be > 0
+    end
+
+    it "should have filter" do
+      expect(Article.filters[:by_title]).to be_truthy
+    end
+
+    it "should find" do
+      results = Article.by_title("article_filterable")
+      expect(results).not_to be_empty
+    end
+
+    it "should filter" do
+      results = Article.filtered(by_title: "article_filterable2", by_slug: 'filtered_1')
+      expect(results).not_to be_empty
+    end
+  end
+
+  context "Paginable" do
+    it "should set items per page" do
+      expect(Author.page_items(2)).to eql(2)
+    end
+
+    it "should count pages" do
+      expect(Article.pages).to eql((Article.count / 5.0).ceil)
+    end
+
+    it "should count pages with parameter passed" do
+      expect(Article.pages(3)).to eql((Article.count / 3.0).ceil)
+    end
+
+    it "should paginate" do
+      expect(Article.paginate(2).current_page).to eq(2)
+    end
+
+    it "should paginate with params" do
+      expect(Article.paginate(3, 50).current_page).to eq(3)
+    end
+
+    it "should not lose items" do
+      expect(Article.paginate(1).total_items).to eq(Article.count)
+    end
+
+    it "should count pages correctly after pagination" do
+      expect(Article.paginate(2).total_pages).to eq(Article.pages)
+    end
+
+    it "should not be affected by includes" do
+      expect(Author.includes(:articles).
+              paginate(2).
+              total_pages).to eq(Author.pages)
+    end
+
+    it "should not be affected by joins" do
+      expect(Author.joins(:articles).
+              paginate(2).
+              total_pages).to eq(Author.pages)
+    end
+  end
+
+  context "RelationshipScopes" do
+    before :all do
+      Author.create(name: "articleless")
+    end
+
+    # Scopes should be added
+    [ :with_articles, :include_articles, :and_articles,
+      :pload_articles, :eload_articles ].each do |method|
+      it "should respond to #{method}" do
+        expect(Author.respond_to?(method)).to be true
+      end
+    end
+
+    it "should not have articles preloaded" do
+      author = Author.first
+      expect(author.articles.loaded?).to be false
+    end
+
+    it "should have articles included" do
+      author = Author.include_articles.first
+
+      expect(author.articles.loaded?).to be true
+    end
+
+    it "should have articles preloaded" do
+      author = Author.pload_articles.first
+
+      expect(author.articles.loaded?).to be true
+    end
+
+    it "should have articles eager loaded" do
+      author = Author.eload_articles.first
+
+      expect(author.articles.loaded?).to be true
+    end
+
+    it "should join but not preload" do
+      author = Author.with_articles.first
+
+      expect(author.articles.loaded?).to be false
+    end
+
+    it "should inner join" do
+      expect(Author.and_articles.where(name: "articleless")).to be_empty
+    end
+
+    it "should not inner join" do
+      expect(Author.pload_articles.where(name: "articleless")).not_to be_empty
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,55 @@
+require 'rails/all'
+require 'active_record_batteries'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+ActiveRecord::Schema.verbose = false
+
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :authors do |t|
+    t.string :name
+
+    # Sluggable
+    t.string :slug
+
+    t.timestamps null: false
+  end
+
+  create_table :articles do |t|
+    t.string :title
+    t.text   :body
+    t.references :author
+
+    # Sluggable
+    t.string :slug
+
+    # Deletable
+    t.datetime :deleted_at
+
+    t.timestamps null: false
+  end
+end
+
+class Author < ActiveRecord::Base
+  batteries! :sluggable, :paginable, :filterable, :relationship_scopes
+
+  has_many :articles
+
+  filter_add :by_slug
+
+  relationship_scopes :articles
+end
+
+class Article < ActiveRecord::Base
+  batteries! :sluggable, :paginable, :filterable, :relationship_scopes, :deletable
+
+  belongs_to :author
+
+  slug_base_column :title
+
+  filter_add :by_slug
+  filter_add :by_title, ->(title) { where(title: title) }
+
+  page_items 5
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: active_record_batteries
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Francisco Soto
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Several small active record modules to empower models in a simple way.
+email:
+- ebobby@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- lib/active_record_batteries.rb
+- lib/active_record_batteries/concerns.rb
+- lib/active_record_batteries/concerns/deletable.rb
+- lib/active_record_batteries/concerns/filterable.rb
+- lib/active_record_batteries/concerns/paginable.rb
+- lib/active_record_batteries/concerns/relationship_scopes.rb
+- lib/active_record_batteries/concerns/sluggable.rb
+- lib/active_record_batteries/engine.rb
+- lib/active_record_batteries/loader.rb
+- lib/active_record_batteries/version.rb
+- lib/tasks/active_record_batteries_tasks.rake
+- spec/active_record_batteries_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ebobby/active_record_batteries
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: ActiveRecord with Batteries. Extensions to make life easier.
+test_files:
+- spec/active_record_batteries_spec.rb
+- spec/spec_helper.rb