search_object 0.1

data/example/db/seeds.rb

@@ -0,0 +1,37 @@
+User.delete_all
+Post.delete_all
+
+users = [
+  User.create!(name: 'John'),
+  User.create!(name: 'Jake'),
+  User.create!(name: 'Jade'),
+]
+
+category_names = [
+  'Books',
+  'Code',
+  'Design',
+  'Database',
+  'Education',
+  'Personal',
+  'News',
+  'Stuff',
+  'Others'
+]
+
+400.times do |i|
+  Post.create!(
+    user:           users.sample,
+    category_name:  category_names.sample,
+    title:          "Example post #{i + 1}",
+    body:           'Body text',
+    views_count:    rand(1000),
+    likes_count:    rand(1000),
+    comments_count: rand(1000),
+    published:      [true, false].sample,
+    created_at:     rand(30).days.ago
+  )
+  print '.'
+end
+
+puts ''

data/example/spec/models/post_search_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe PostSearch do
+  let(:user) { create_user }
+
+  def create_user
+    User.create! name: "User #{User.count + 1}"
+  end
+
+  def create(attributes = {})
+    Post.create! attributes.reverse_merge(
+      user:           user,
+      title:          'Title',
+      body:           'Body',
+      category_name:  'Tech',
+      published:      true,
+    )
+  end
+
+  def expect_search(options)
+    expect(PostSearch.new(options, 0).results)
+  end
+
+  it "can search by category name" do
+    post  = create category_name: 'Personal'
+    other = create category_name: 'Other'
+
+    expect_search(category_name: 'Personal').to eq [post]
+  end
+
+  it "can search by user_id" do
+    post  = create user: create_user
+    other = create user: create_user
+
+    expect_search(user_id: post.user_id).to eq [post]
+  end
+
+  it "can search by title" do
+    post  = create title: 'Title'
+    other = create title: 'Other'
+
+    expect_search(title: 'itl').to eq [post]
+  end
+
+  it "can search by published" do
+    post  = create published: true
+    other = create published: false
+
+    expect_search(published: true).to eq [post]
+  end
+
+  it "can search by term" do
+    post_with_body  = create body: 'pattern'
+    post_with_title = create title: 'pattern'
+    other           = create
+
+    expect_search(term: 'pattern').to eq [post_with_title, post_with_body]
+  end
+
+  it "can search by created after" do
+    post  = create created_at: 1.month.ago
+    other = create created_at: 3.month.ago
+
+    expect_search(created_after: 2.month.ago.strftime('%Y-%m-%d')).to eq [post]
+  end
+
+  it "can search by created before" do
+    post  = create created_at: 3.month.ago
+    other = create created_at: 1.month.ago
+
+    expect_search(created_before: 2.month.ago.strftime('%Y-%m-%d')).to eq [post]
+  end
+
+  it "can sort by views count" do
+    post_3 = create views_count: 3
+    post_2 = create views_count: 2
+    post_1 = create views_count: 1
+
+    expect_search(sort: 'views_count').to eq [post_3, post_2, post_1]
+  end
+end

data/example/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+# This file is copied to spec/ when you run 'rails generate rspec:install'
+ENV['RAILS_ENV'] ||= 'test'
+
+require File.expand_path("../../config/environment", __FILE__)
+require 'rspec/rails'
+require 'rspec/autorun'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[Rails.root.join('spec/support/**/*.rb')].each { |f| require f }
+
+# Checks for pending migrations before tests are run.
+# If you are not using ActiveRecord, you can remove this line.
+ActiveRecord::Migration.check_pending! if defined?(ActiveRecord::Migration)
+
+RSpec.configure do |config|
+  config.use_transactional_fixtures = true
+  config.infer_base_class_for_anonymous_controllers = false
+end

data/lib/search_object.rb

@@ -0,0 +1,20 @@
+require 'search_object/version'
+require 'search_object/helper'
+require 'search_object/base'
+require 'search_object/search'
+require 'search_object/plugin/model'
+require 'search_object/plugin/paging'
+require 'search_object/plugin/will_paginate'
+require 'search_object/plugin/kaminari'
+require 'search_object/plugin/sorting'
+
+module SearchObject
+  def self.module(*plugins)
+    return Base if plugins.empty?
+
+    Helper.define_module do
+      include Base
+      plugins.each { |plugin_name| include Plugin.const_get(Helper.camelize(plugin_name)) }
+    end
+  end
+end

data/lib/search_object/base.rb

@@ -0,0 +1,64 @@
+module SearchObject
+  module Base
+    def self.included(base)
+      base.extend ClassMethods
+      base.instance_eval do
+        @defaults = {}
+        @actions  = {}
+        @scope    = nil
+      end
+    end
+
+    def initialize(*args)
+      @search = self.class.search args
+    end
+
+    def results
+      @results ||= fetch_results
+    end
+
+    def results?
+      results.any?
+    end
+
+    def count
+      @count ||= @search.count self
+    end
+
+    def params(additions = {})
+      if additions.empty?
+        @search.params
+      else
+        @search.params.merge Helper.stringify_keys(additions)
+      end
+    end
+
+    private
+
+    def fetch_results
+      @search.query self
+    end
+
+    module ClassMethods
+      def search(args)
+        scope  = (@scope && @scope.call) || args.shift
+        params = @defaults.merge(Helper.select_keys Helper.stringify_keys(args.shift || {}), @actions.keys)
+
+        Search.new scope, params, @actions
+      end
+
+      def scope(&block)
+        @scope = block
+      end
+
+      def option(name, default = nil, &block)
+        name = name.to_s
+
+        @defaults[name] = default unless default.nil?
+        @actions[name]  = block || ->(scope, value) { scope.where name => value unless value.blank? }
+
+        define_method(name) { @search.param name }
+      end
+    end
+  end
+end

data/lib/search_object/helper.rb

@@ -0,0 +1,36 @@
+module SearchObject
+  module Helper
+    class << self
+      def stringify_keys(hash)
+        Hash[(hash || {}).map { |k, v| [k.to_s, v]}]
+      end
+
+      def select_keys(hash, keys)
+        keys.inject({}) do |memo, key|
+          memo[key] = hash[key] if hash.has_key? key
+          memo
+        end
+      end
+
+      def camelize(text)
+        text.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      end
+
+      def ensure_included(item, collection)
+        if collection.include? item
+          item
+        else
+          collection.first
+        end
+      end
+
+      def define_module(&block)
+        Module.new do
+          define_singleton_method :included do |base|
+            base.class_eval &block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/search_object/plugin/kaminari.rb

@@ -0,0 +1,18 @@
+module SearchObject
+  module Plugin
+    module Kaminari
+      include Paging
+
+      def self.included(base)
+        base.extend Paging::ClassMethods
+      end
+
+      private
+
+      def apply_paging(scope)
+        scope.page(page).per(per_page)
+      end
+    end
+  end
+end
+

data/lib/search_object/plugin/model.rb

@@ -0,0 +1,16 @@
+module SearchObject
+  module Plugin
+    module Model
+      def self.included(base)
+        base.class_eval do
+          include ActiveModel::Conversion
+          extend ActiveModel::Naming
+        end
+      end
+
+      def persisted?
+        false
+      end
+    end
+  end
+end

data/lib/search_object/plugin/paging.rb

@@ -0,0 +1,42 @@
+module SearchObject
+  module Plugin
+    module Paging
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def initialize(*args)
+        @page = args.pop.to_i.abs
+        super *args
+      end
+
+      def page
+        @page
+      end
+
+      def per_page
+        self.class.get_per_page
+      end
+
+      private
+
+      def fetch_results
+        apply_paging super
+      end
+
+      def apply_paging(scope)
+        scope.limit(page * per_page).offset(per_page)
+      end
+
+      module ClassMethods
+        def per_page(number)
+          @per_page = number.to_i.abs
+        end
+
+        def get_per_page
+          @per_page ||= 25
+        end
+      end
+    end
+  end
+end

data/lib/search_object/plugin/sorting.rb

@@ -0,0 +1,54 @@
+module SearchObject
+  module Plugin
+    module Sorting
+      def self.included(base)
+        base.extend ClassMethods
+        base.instance_eval do
+          option :sort do |scope, value|
+            scope.order "#{sort_attribute} #{sort_direction}"
+          end
+        end
+      end
+
+      def sort?(attribute)
+        attribute == sort || sort.to_s.starts_with?("#{attribute} ")
+      end
+
+      def sort_attribute
+        @sort_attribute ||= Helper.ensure_included sort.to_s.split(' ', 2).first, self.class.sort_attributes
+      end
+
+      def sort_direction
+        @sort_direction ||= Helper.ensure_included sort.to_s.split(' ', 2).last, %w(desc asc)
+      end
+
+      def sort_direction_for(attribute)
+        if sort_attribute == attribute.to_s
+          reverted_sort_direction
+        else
+          'desc'
+        end
+      end
+
+      def sort_params_for(attribute, options = {})
+        options['sort'] = "#{attribute} #{sort_direction_for(attribute)}"
+        params options
+      end
+
+      def reverted_sort_direction
+        sort_direction == 'desc' ? 'asc' : 'desc'
+      end
+
+      module ClassMethods
+        def sort_by(*attributes)
+          @sort_attributes = attributes.map(&:to_s)
+          @defaults['sort'] = "#{@sort_attributes.first} desc"
+        end
+
+        def sort_attributes
+          @sort_attributes ||= []
+        end
+      end
+    end
+  end
+end

data/lib/search_object/plugin/will_paginate.rb

@@ -0,0 +1,17 @@
+module SearchObject
+  module Plugin
+    module WillPaginate
+      include Paging
+
+      def self.included(base)
+        base.extend Paging::ClassMethods
+      end
+
+      private
+
+      def apply_paging(scope)
+        scope.paginate per_page: per_page, page: page == 0 ? nil : page
+      end
+    end
+  end
+end

data/lib/search_object/search.rb

@@ -0,0 +1,26 @@
+module SearchObject
+  class Search
+    attr_reader :params
+
+    def initialize(scope, params, actions)
+      @scope    = scope
+      @actions  = actions
+      @params   = params
+    end
+
+    def param(name)
+      @params[name]
+    end
+
+    def query(context)
+      @params.inject(@scope) do |scope, (name, value)|
+        new_scope = context.instance_exec scope, value, &@actions[name]
+        new_scope || scope
+      end
+    end
+
+    def count(context)
+      query(context).count
+    end
+  end
+end