ransack 0.1.0

data/lib/ransack/search.rb

@@ -0,0 +1,114 @@
+require 'ransack/nodes'
+require 'ransack/context'
+require 'ransack/naming'
+
+module Ransack
+  class Search
+    include Naming
+
+    attr_reader :base, :context
+
+    delegate :object, :klass, :to => :context
+    delegate :new_and, :new_or, :new_condition,
+             :build_and, :build_or, :build_condition,
+             :translate, :to => :base
+
+    def initialize(object, params = {})
+      params ||= {}
+      @context = Context.for(object)
+      @base = Nodes::And.new(@context)
+      build(params.with_indifferent_access)
+    end
+
+    def result(opts = {})
+      @result ||= @context.evaluate(self, opts)
+    end
+
+    def build(params)
+      collapse_multiparameter_attributes!(params).each do |key, value|
+        case key
+        when 's', 'sorts'
+          send("#{key}=", value)
+        else
+          base.send("#{key}=", value) if base.attribute_method?(key)
+        end
+      end
+      self
+    end
+
+    def sorts=(args)
+      case args
+      when Array
+        args.each do |sort|
+          sort = Nodes::Sort.extract(@context, sort)
+          self.sorts << sort
+        end
+      when Hash
+        args.each do |index, attrs|
+          sort = Nodes::Sort.new(@context).build(attrs)
+          self.sorts << sort
+        end
+      else
+        self.sorts = [args]
+      end
+    end
+    alias :s= :sorts=
+
+    def sorts
+      @sorts ||= []
+    end
+    alias :s :sorts
+
+    def build_sort(opts = {})
+      new_sort(opts).tap do |sort|
+        self.sorts << sort
+      end
+    end
+
+    def new_sort(opts = {})
+      Nodes::Sort.new(@context).build(opts)
+    end
+
+    def respond_to?(method_id)
+      super or begin
+        method_name = method_id.to_s
+        writer = method_name.sub!(/\=$/, '')
+        base.attribute_method?(method_name) ? true : false
+      end
+    end
+
+    def method_missing(method_id, *args)
+      method_name = method_id.to_s
+      writer = method_name.sub!(/\=$/, '')
+      if base.attribute_method?(method_name)
+        base.send(method_id, *args)
+      else
+        super
+      end
+    end
+
+    private
+
+    def collapse_multiparameter_attributes!(attrs)
+      attrs.keys.each do |k|
+        if k.include?("(")
+          real_attribute, position = k.split(/\(|\)/)
+          cast = %w(a s i).include?(position.last) ? position.last : nil
+          position = position.to_i - 1
+          value = attrs.delete(k)
+          attrs[real_attribute] ||= []
+          attrs[real_attribute][position] = if cast
+            (value.blank? && cast == 'i') ? nil : value.send("to_#{cast}")
+          else
+            value
+          end
+        elsif Hash === attrs[k]
+          collapse_multiparameter_attributes!(attrs[k])
+        end
+      end
+
+      attrs
+    end
+
+  end
+end

data/lib/ransack/translate.rb

@@ -0,0 +1,92 @@
+I18n.load_path += Dir[File.join(File.dirname(__FILE__), 'locale', '*.yml')]
+
+module Ransack
+  module Translate
+    def self.word(key, options = {})
+      I18n.translate(:"ransack.#{key}", :default => key.to_s)
+    end
+
+    def self.predicate(key, options = {})
+      I18n.translate(:"ransack.predicates.#{key}", :default => key.to_s)
+    end
+
+    def self.attribute(key, options = {})
+      unless context = options.delete(:context)
+        raise ArgumentError, "A context is required to translate associations"
+      end
+
+      original_name = key.to_s
+      base_class = context.klass
+      base_ancestors = base_class.ancestors.select { |x| x.respond_to?(:model_name) }
+      predicate = Ransack::Configuration.predicate_keys.detect {|p| original_name.match(/_#{p}$/)}
+      attributes_str = original_name.sub(/_#{predicate}$/, '')
+      attribute_names = attributes_str.split(/_and_|_or_/)
+      combinator = attributes_str.match(/_and_/) ? :and : :or
+      defaults = base_ancestors.map do |klass|
+        :"ransack.attributes.#{klass.model_name.underscore}.#{original_name}"
+      end
+
+      translated_names = attribute_names.map do |attr|
+        attribute_name(context, attr, options[:include_associations])
+      end
+
+      interpolations = {}
+      interpolations[:attributes] = translated_names.join(" #{Translate.word(combinator)} ")
+
+      if predicate
+        defaults << "%{attributes} %{predicate}"
+        interpolations[:predicate] = Translate.predicate(predicate)
+      else
+        defaults << "%{attributes}"
+      end
+
+      defaults << options.delete(:default) if options[:default]
+      options.reverse_merge! :count => 1, :default => defaults
+      I18n.translate(defaults.shift, options.merge(interpolations))
+    end
+
+    def self.association(key, options = {})
+      unless context = options.delete(:context)
+        raise ArgumentError, "A context is required to translate associations"
+      end
+
+      defaults = key.blank? ? [:"#{context.klass.i18n_scope}.models.#{context.klass.model_name.underscore}"] : [:"ransack.associations.#{context.klass.model_name.underscore}.#{key}"]
+      defaults << context.traverse(key).model_name.human
+      options = {:count => 1, :default => defaults}
+      I18n.translate(defaults.shift, options)
+    end
+
+    private
+
+    def self.attribute_name(context, name, include_associations = nil)
+      assoc_path = context.association_path(name)
+      associated_class = context.traverse(assoc_path) if assoc_path.present?
+      attr_name = name.sub(/^#{assoc_path}_/, '')
+      interpolations = {}
+      interpolations[:attr_fallback_name] = I18n.translate(
+        (associated_class ?
+          :"ransack.attributes.#{associated_class.model_name.underscore}.#{attr_name}" :
+          :"ransack.attributes.#{context.klass.model_name.underscore}.#{attr_name}"
+        ),
+        :default => [
+          (associated_class ?
+            :"#{associated_class.i18n_scope}.attributes.#{associated_class.model_name.underscore}.#{attr_name}" :
+            :"#{context.klass.i18n_scope}.attributes.#{context.klass.model_name.underscore}.#{attr_name}"
+          ),
+          attr_name.humanize
+        ]
+      )
+      defaults = [
+        :"ransack.attributes.#{context.klass.model_name.underscore}.#{name}"
+      ]
+      if include_associations && associated_class
+        defaults << '%{association_name} %{attr_fallback_name}'
+        interpolations[:association_name] = association(assoc_path, :context => context)
+      else
+        defaults << '%{attr_fallback_name}'
+      end
+      options = {:count => 1, :default => defaults}
+      I18n.translate(defaults.shift, options.merge(interpolations))
+    end
+  end
+end

data/lib/ransack/version.rb

@@ -0,0 +1,3 @@
+module Ransack
+  VERSION = "0.1.0"
+end

data/ransack.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ransack/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ransack"
+  s.version     = Ransack::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Ernie Miller"]
+  s.email       = ["ernie@metautonomo.us"]
+  s.homepage    = "http://metautonomo.us/projects/ransack"
+  s.summary     = %q{Object-based searching. Like MetaSearch, but this time, with a better name.}
+  s.description = %q{Not yet ready for public consumption.}
+
+  s.rubyforge_project = "ransack"
+
+  s.add_dependency 'activerecord', '~> 3.1.0.alpha'
+  s.add_dependency 'activesupport', '~> 3.1.0.alpha'
+  s.add_dependency 'actionpack', '~> 3.1.0.alpha'
+  s.add_development_dependency 'rspec', '~> 2.5.0'
+  s.add_development_dependency 'machinist', '~> 1.0.6'
+  s.add_development_dependency 'faker', '~> 0.9.5'
+  s.add_development_dependency 'sqlite3', '~> 1.3.3'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/blueprints/articles.rb

@@ -0,0 +1,5 @@
+Article.blueprint do
+  person
+  title
+  body
+end

data/spec/blueprints/comments.rb

@@ -0,0 +1,5 @@
+Comment.blueprint do
+  article
+  person
+  body
+end

data/spec/blueprints/notes.rb

@@ -0,0 +1,3 @@
+Note.blueprint do
+  note
+end

data/spec/blueprints/people.rb

@@ -0,0 +1,4 @@
+Person.blueprint do
+  name
+  salary
+end

data/spec/blueprints/tags.rb

@@ -0,0 +1,3 @@
+Tag.blueprint do
+  name    { Sham.tag_name }
+end

data/spec/console.rb

@@ -0,0 +1,22 @@
+Bundler.setup
+require 'machinist/active_record'
+require 'sham'
+require 'faker'
+
+Dir[File.expand_path('../../spec/{helpers,support,blueprints}/*.rb', __FILE__)].each do |f|
+  require f
+end
+
+Sham.define do
+  name     { Faker::Name.name }
+  title    { Faker::Lorem.sentence }
+  body     { Faker::Lorem.paragraph }
+  salary   {|index| 30000 + (index * 1000)}
+  tag_name { Faker::Lorem.words(3).join(' ') }
+  note     { Faker::Lorem.words(7).join(' ') }
+end
+
+Schema.create
+
+require 'ransack'
+

data/spec/helpers/ransack_helper.rb

@@ -0,0 +1,2 @@
+module RansackHelper
+end

data/spec/playground.rb

@@ -0,0 +1,37 @@
+$VERBOSE = false
+require 'bundler'
+Bundler.setup
+require 'machinist/active_record'
+require 'sham'
+require 'faker'
+
+Dir[File.expand_path('../../spec/{helpers,support,blueprints}/*.rb', __FILE__)].each do |f|
+  require f
+end
+
+Sham.define do
+  name     { Faker::Name.name }
+  title    { Faker::Lorem.sentence }
+  body     { Faker::Lorem.paragraph }
+  salary   {|index| 30000 + (index * 1000)}
+  tag_name { Faker::Lorem.words(3).join(' ') }
+  note     { Faker::Lorem.words(7).join(' ') }
+end
+
+Schema.create
+
+require 'ransack'
+
+Article.joins{person.comments}.where{person.comments.body =~ '%hello%'}.to_sql
+# => "SELECT \"articles\".* FROM \"articles\" INNER JOIN \"people\" ON \"people\".\"id\" = \"articles\".\"person_id\" INNER JOIN \"comments\" ON \"comments\".\"person_id\" = \"people\".\"id\" WHERE \"comments\".\"body\" LIKE '%hello%'"
+
+Person.where{(id + 1) == 2}.first
+# => #<Person id: 1, parent_id: nil, name: "Aric Smith", salary: 31000>
+
+Person.where{(salary - 40000) < 0}.to_sql
+# => "SELECT \"people\".* FROM \"people\"  WHERE \"people\".\"salary\" - 40000 < 0"
+
+p = Person.select{[id, name, salary, (salary + 1000).as('salary_after_increase')]}.first
+# => #<Person id: 1, name: "Aric Smith", salary: 31000>
+
+p.salary_after_increase # =>

data/spec/ransack/adapters/active_record/base_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      describe Base do
+
+        it 'adds a ransack method to ActiveRecord::Base' do
+          ::ActiveRecord::Base.should respond_to :ransack
+        end
+
+        it 'aliases the method to search if available' do
+          ::ActiveRecord::Base.should respond_to :search
+        end
+
+        describe '#search' do
+          before do
+            @s = Person.search
+          end
+
+          it 'creates a search with Relation as its object' do
+            @s.should be_a Search
+            @s.object.should be_an ::ActiveRecord::Relation
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/ransack/adapters/active_record/context_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Ransack
+  module Adapters
+    module ActiveRecord
+      describe Context do
+        before do
+          @c = Context.new(Person)
+        end
+
+        it 'contextualizes strings to attributes' do
+          attribute = @c.contextualize 'children_children_parent_name'
+          attribute.should be_a Arel::Attributes::Attribute
+          attribute.name.should eq 'name'
+          attribute.relation.table_alias.should eq 'parents_people'
+        end
+
+        it 'builds new associations if not yet built' do
+          attribute = @c.contextualize 'children_articles_title'
+          attribute.should be_a Arel::Attributes::Attribute
+          attribute.name.should eq 'title'
+          attribute.relation.name.should eq 'articles'
+          attribute.relation.table_alias.should be_nil
+        end
+
+      end
+    end
+  end
+end

data/spec/ransack/configuration_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+module Ransack
+  describe Configuration do
+    it 'yields self on configure' do
+      Ransack.configure do
+        self.should eq Ransack::Configuration
+      end
+    end
+  end
+end

data/spec/ransack/helpers/form_builder_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Ransack
+  module Helpers
+    describe FormBuilder do
+
+      router = ActionDispatch::Routing::RouteSet.new
+      router.draw do
+        resources :people
+        match ':controller(/:action(/:id(.:format)))'
+      end
+
+      include router.url_helpers
+
+      # FIXME: figure out a cleaner way to get this behavior
+      before do
+        @controller = ActionView::TestCase::TestController.new
+        @controller.instance_variable_set(:@_routes, router)
+        @controller.class_eval do
+          include router.url_helpers
+        end
+
+        @s = Person.search
+        @controller.view_context.search_form_for @s do |f|
+          @f = f
+        end
+      end
+
+      it 'selects previously-entered time values with datetime_select' do
+        @s.created_at_eq = [2011, 1, 2, 3, 4, 5]
+        html = @f.datetime_select :created_at_eq
+        [2011, 1, 2, 3, 4, 5].each do |val|
+          html.should match /<option selected="selected" value="#{val}">#{val}<\/option>/o
+        end
+      end
+
+    end
+  end
+end