ransack_ffcrm 0.6.0

data/lib/ransack/nodes/sort.rb

@@ -0,0 +1,41 @@
+module Ransack
+  module Nodes
+    class Sort < Node
+      include Bindable
+
+      attr_reader :name, :dir
+      i18n_word :asc, :desc
+
+      class << self
+        def extract(context, str)
+          attr, direction = str.split(/\s+/,2)
+          self.new(context).build(:name => attr, :dir => direction)
+        end
+      end
+
+      def build(params)
+        params.with_indifferent_access.each do |key, value|
+          if key.match(/^(name|dir)$/)
+            self.send("#{key}=", value)
+          end
+        end
+
+        self
+      end
+
+      def valid?
+        bound? && attr
+      end
+
+      def name=(name)
+        @name = name
+        context.bind(self, name) unless name.blank?
+      end
+
+      def dir=(dir)
+        @dir = %w(asc desc).include?(dir) ? dir : 'asc'
+      end
+
+    end
+  end
+end

data/lib/ransack/nodes/value.rb

@@ -0,0 +1,108 @@
+module Ransack
+  module Nodes
+    class Value < Node
+      attr_accessor :value
+      delegate :present?, :blank?, :to => :value
+
+      def initialize(context, value = nil)
+        super(context)
+        @value = value
+      end
+
+      def persisted?
+        false
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+        self.value == other.value
+      end
+      alias :== :eql?
+
+      def hash
+        value.hash
+      end
+
+      def cast(type)
+         case type
+         when :date
+           cast_to_date(value)
+         when :datetime, :timestamp, :time
+           cast_to_time(value)
+         when :boolean
+           cast_to_boolean(value)
+         when :integer
+           cast_to_integer(value)
+         when :float
+           cast_to_float(value)
+         when :decimal
+           cast_to_decimal(value)
+         else
+           cast_to_string(value)
+         end
+       end
+
+       def cast_to_date(val)
+         if val.is_a?(String)
+           Chronic.parse(val).in_time_zone.to_date rescue nil
+         elsif val.respond_to?(:to_date)
+           val.to_date rescue nil
+         else
+           y, m, d = *[val].flatten
+           m ||= 1
+           d ||= 1
+           Date.new(y,m,d) rescue nil
+         end
+       end
+
+       def cast_to_time(val)
+         if val.is_a?(Array)
+           Time.zone.local(*val) rescue nil
+         else
+           unless val.acts_like?(:time)
+             val = val.is_a?(String) ? Chronic.parse(val) : val.to_time rescue nil
+           end
+           val.in_time_zone rescue nil
+         end
+       end
+
+       def cast_to_boolean(val)
+         if Constants::TRUE_VALUES.include?(val)
+           true
+         elsif Constants::FALSE_VALUES.include?(val)
+           false
+         else
+           nil
+         end
+       end
+
+       def cast_to_string(val)
+         val.respond_to?(:to_s) ? val.to_s : String.new(val)
+       end
+
+       def cast_to_integer(val)
+         val.blank? ? nil : val.to_i
+       end
+
+       def cast_to_float(val)
+         val.blank? ? nil : val.to_f
+       end
+
+       def cast_to_decimal(val)
+         if val.blank?
+           nil
+         elsif val.class == BigDecimal
+           val
+         elsif val.respond_to?(:to_d)
+           val.to_d
+         else
+           val.to_s.to_d
+         end
+       end
+
+       def array_of_arrays?(val)
+         Array === val && Array === val.first
+       end
+    end
+  end
+end

data/lib/ransack/nodes.rb

@@ -0,0 +1,7 @@
+require 'ransack/nodes/bindable'
+require 'ransack/nodes/node'
+require 'ransack/nodes/attribute'
+require 'ransack/nodes/value'
+require 'ransack/nodes/condition'
+require 'ransack/nodes/sort'
+require 'ransack/nodes/grouping'

data/lib/ransack/predicate.rb

@@ -0,0 +1,70 @@
+module Ransack
+  class Predicate
+    attr_reader :name, :arel_predicate, :type, :formatter, :validator, :compound, :wants_array
+
+    class << self
+
+      def names
+        Ransack.predicates.keys
+      end
+
+      def names_by_decreasing_length
+        names.sort {|a,b| b.length <=> a.length}
+      end
+
+      def named(name)
+        Ransack.predicates[name.to_s]
+      end
+
+      def detect_and_strip_from_string!(str)
+        names_by_decreasing_length.detect {|p| str.sub!(/_#{p}$/, '')}
+      end
+
+      def detect_from_string(str)
+        names_by_decreasing_length.detect {|p| str.match(/_#{p}$/)}
+      end
+
+      def name_from_attribute_name(attribute_name)
+        names_by_decreasing_length.detect {|p| attribute_name.to_s.match(/_#{p}$/)}
+      end
+
+      def for_attribute_name(attribute_name)
+        self.named(detect_from_string(attribute_name.to_s))
+      end
+
+    end
+
+    def initialize(opts = {})
+      @name = opts[:name]
+      @arel_predicate = opts[:arel_predicate]
+      @type = opts[:type]
+      @formatter = opts[:formatter]
+      @validator = opts[:validator] || lambda { |v| v.respond_to?(:empty?) ? !v.empty? : !v.nil? }
+      @compound = opts[:compound]
+      @wants_array = @compound || ['in', 'not_in'].include?(@arel_predicate)
+    end
+
+    def eql?(other)
+      self.class == other.class &&
+      self.name == other.name
+    end
+    alias :== :eql?
+
+    def hash
+      name.hash
+    end
+
+    def format(val)
+      if formatter
+        formatter.call(val)
+      else
+        val
+      end
+    end
+
+    def validate(vals, type = @type)
+      vals.select {|v| validator.call(type ? v.cast(type) : v.value)}.any?
+    end
+
+  end
+end

data/lib/ransack/ransacker.rb

@@ -0,0 +1,24 @@
+module Ransack
+  class Ransacker
+
+    attr_reader :name, :type, :formatter, :args
+
+    delegate :call, :to => :@callable
+
+    def initialize(klass, name, opts = {}, &block)
+      @klass, @name = klass, name
+
+      @type = opts[:type] || :string
+      @args = opts[:args] || [:parent]
+      @formatter = opts[:formatter]
+      @callable = opts[:callable] || block ||
+                  (@klass.method(name) if @klass.respond_to?(name)) ||
+                  proc {|parent| parent.table[name]}
+    end
+
+    def attr_from(bindable)
+      call(*args.map {|arg| bindable.send(arg)})
+    end
+
+  end
+end

data/lib/ransack/search.rb

@@ -0,0 +1,123 @@
+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_grouping, :new_condition,
+             :build_grouping, :build_condition,
+             :translate, :to => :base
+
+    def initialize(object, params = {}, options = {})
+      params ||= {}
+      @context = Context.for(object, options)
+      @context.auth_object = options[:auth_object]
+      @base = Nodes::Grouping.new(@context, 'and')
+      build(params.with_indifferent_access)
+    end
+
+    def result(opts = {})
+      @context.evaluate(self, opts)
+    end
+
+    def inspect
+      # Replace the inspect method on object's singleton class to call to_s() instead of to_a().
+      object.class_eval { alias :inspect :to_s }
+      super
+    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
+      when String
+        self.sorts = [args]
+      else
+        raise ArgumentError, "Invalid argument (#{args.class}) supplied to sorts="
+      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 attributes"
+      end
+
+      original_name = key.to_s
+      base_class = context.klass
+      base_ancestors = base_class.ancestors.select { |x| x.respond_to?(:model_name) }
+      predicate = Predicate.detect_from_string(original_name)
+      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.6.0"
+end

data/lib/ransack/visitor.rb

@@ -0,0 +1,68 @@
+module Ransack
+  class Visitor
+
+    def accept(object)
+      visit(object)
+    end
+
+    def can_accept?(object)
+      respond_to? DISPATCH[object.class]
+    end
+
+    def visit_Array(object)
+      object.map {|o| accept(o)}.compact
+    end
+
+    def visit_Ransack_Nodes_Condition(object)
+      object.arel_predicate if object.valid?
+    end
+
+    def visit_Ransack_Nodes_Grouping(object)
+      object.combinator == 'or' ? visit_or(object) : visit_and(object)
+    end
+
+    def visit_and(object)
+      nodes = object.values.map {|o| accept(o)}.compact
+      return nil unless nodes.size > 0
+
+      if nodes.size > 1
+        Arel::Nodes::Grouping.new(Arel::Nodes::And.new(nodes))
+      else
+        nodes.first
+      end
+    end
+
+    def visit_or(object)
+      nodes = object.values.map {|o| accept(o)}.compact
+      return nil unless nodes.size > 0
+
+      if nodes.size > 1
+        nodes.inject(&:or)
+      else
+        nodes.first
+      end
+    end
+
+    def visit_Ransack_Nodes_Sort(object)
+      object.attr.send(object.dir) if object.valid?
+    end
+
+    def quoted?(object)
+      case object
+      when Arel::Nodes::SqlLiteral, Bignum, Fixnum
+        false
+      else
+        true
+      end
+    end
+
+    def visit(object)
+      send(DISPATCH[object.class], object)
+    end
+
+    DISPATCH = Hash.new do |hash, klass|
+      hash[klass] = "visit_#{klass.name.gsub('::', '_')}"
+    end
+
+  end
+end

data/lib/ransack.rb

@@ -0,0 +1,27 @@
+require 'ransack/configuration'
+
+module Ransack
+  extend Configuration
+
+  class UntraversableAssociationError < StandardError; end;
+end
+
+Ransack.configure do |config|
+  Ransack::Constants::AREL_PREDICATES.each do |name|
+    config.add_predicate name, :arel_predicate => name
+  end
+
+  Ransack::Constants::DERIVED_PREDICATES.each do |args|
+    config.add_predicate *args
+  end
+end
+
+require 'ransack/translate'
+require 'ransack/search'
+require 'ransack/ransacker'
+require 'ransack/adapters/active_record'
+require 'ransack/helpers'
+require 'action_controller'
+require 'chronic'
+
+ActionController::Base.helper Ransack::Helpers::FormHelper

data/ransack_ffcrm.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ransack/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ransack_ffcrm"
+  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 for ActiveRecord (currently).}
+  s.description = %q{Ransack is the successor to the MetaSearch gem. It improves and expands upon MetaSearch's functionality, but does not have a 100%-compatible API.}
+
+  s.rubyforge_project = "ransack"
+
+  s.add_dependency 'activerecord', '~> 3.0'
+  s.add_dependency 'actionpack', '~> 3.0'
+  s.add_dependency 'polyamorous', '~> 0.5.0'
+  s.add_dependency 'chronic', '~> 0.6.7'
+  s.add_development_dependency 'rspec', '~> 2.8.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,21 @@
+Bundler.setup
+require 'machinist/active_record'
+require 'sham'
+require 'faker'
+require 'ransack'
+
+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
+

data/spec/helpers/ransack_helper.rb

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