the_jobbook_admin_data 1.3.0a

data/lib/admin_data/rails_version_check.rb

@@ -0,0 +1,8 @@
+unless Rails.version >= '3.0'
+  msg = []
+  msg << "It seems you are not using Rails 3."
+  msg << "Please see documentation at"
+  msg << "http://github.com/neerajdotname/admin_data/wiki"
+  msg << "to find out how to use this gem with rails 2.3.x"
+  raise msg.join(' ')
+end

data/lib/admin_data/search.rb

@@ -0,0 +1,188 @@
+module AdminData
+  module Search
+
+    class Dbbase
+      def initialize(operands, table_name, field_name, operator)
+        @operands = operands
+        @table_name = table_name
+        @field_name = field_name
+        @operator = operator
+      end
+
+      def like_operator
+        'LIKE'
+      end
+
+      def sql_field_name
+        "#{@table_name}.#{@field_name}"
+      end
+
+      def operands
+        @operands
+      end
+    end
+
+    class PostgresqlSpecific < Dbbase
+      def like_operator
+        'ILIKE'
+      end
+    end
+
+    class OracleSpecific < Dbbase
+      def sql_field_name
+        result = super
+        %w(contains is_exactly does_not_contain).include?(@operator) ?  "upper(#{result})" : result
+      end
+
+      def operands
+        result = super
+        %w(contains is_exactly does_not_contain).include?(@operator) ?  result.upcase : result
+      end
+    end
+
+    class Term
+
+      attr_accessor :error, :table_name, :field, :operator, :operands, :dbbase
+
+      def initialize(klass, value, search_type)
+        @table_name = klass.table_name
+        compute_search_fields(value)
+
+        adapter = AdminData.config.adapter_name.downcase
+        if adapter =~ /postgresql/
+          self.dbbase = PostgresqlSpecific.new(@operands, table_name, field, operator)
+        elsif adapter =~ /oracle/
+          self.dbbase = OracleSpecific.new(@operands, table_name, field, operator)
+        else
+          self.dbbase = Dbbase.new(@operands, table_name, field, operator)
+        end
+      end
+
+      def attribute_condition
+        return if valid? && operand_required? && operands.blank?
+        case operator
+        when 'contains'
+          ["#{sql_field_name} #{like_operator} ?","%#{operands}%"]
+
+        when 'is_exactly'
+          ["#{sql_field_name} = ?", operands]
+
+        when 'does_not_contain'
+          ["#{sql_field_name} IS NULL OR #{sql_field_name} NOT #{like_operator} ?","%#{operands}%"]
+
+        when 'is_false'
+          ["#{sql_field_name} = ?",false]
+
+        when 'is_true'
+          ["#{sql_field_name} = ?",true]
+
+        when 'is_null'
+          ["#{sql_field_name} IS NULL"]
+
+        when 'is_not_null'
+          ["#{sql_field_name} IS NOT NULL"]
+
+        when 'is_on'
+          ["#{sql_field_name} >= ? AND #{sql_field_name} < ?",   values_after_cast.beginning_of_day,
+          values_after_cast.end_of_day]
+
+        when 'is_on_or_before_date'
+          ["#{sql_field_name} <= ?",values_after_cast.end_of_day]
+
+        when 'is_on_or_after_date'
+          ["#{sql_field_name} >= ?",values_after_cast.beginning_of_day]
+
+        when 'is_equal_to'
+          ["#{sql_field_name} = ?",values_after_cast]
+
+        when 'greater_than'
+          ["#{sql_field_name} > ?",values_after_cast]
+
+        when 'less_than'
+          ["#{sql_field_name} < ?",values_after_cast]
+
+        else
+          # it means user did not select anything in operator. Ignore it.
+        end
+      end
+
+      def valid?
+        @error = nil
+        @error = validate
+        @error.blank?
+      end
+
+      private
+
+      def like_operator
+        dbbase.like_operator
+      end
+
+      def sql_field_name
+        dbbase.sql_field_name
+      end
+
+      def operands
+        dbbase.operands
+      end
+
+      def operand_required?
+        operator =~ /(contains|is_exactly|does_not_contain|is_on |is_on_or_before_date|is_on_or_after_date |greater_than|less_than|is_equal_to)/
+      end
+
+      def compute_search_fields(value)
+        @field, @operator, @operands = value.values_at(:col1, :col2, :col3)
+        # field value is directly used in the sql statement. So it is important to sanitize it
+        @field      = @field.gsub(/\W/,'')
+        @operands   = (@operands.blank? ? @operands : @operands.strip)
+      end
+
+      def values_after_cast
+        case operator
+        when /(is_on|is_on_or_before_date|is_on_or_after_date)/
+          AdminData::DateUtil.parse(operands)
+        when /(is_equal_to|greater_than|less_than)/
+          operands.to_i
+        else
+          operands
+        end
+      end
+
+      def validate
+        case operator
+        when /(is_on|is_on_or_before_date|is_on_or_after_date)/
+          "#{operands} is not a valid date" unless AdminData::DateUtil.valid?(operands)
+        when /(is_equal_to|greater_than|less_than)/
+          unless operands.blank?
+            "#{operands} is not a valid integer" unless operands =~ /^\d+$/
+          end
+        end
+      end
+
+    end # end of Term
+
+
+    def build_quick_search_condition( klass, search_term )
+      return nil if search_term.blank?
+      str_columns = klass.columns.select { |column| column.type.to_s =~ /(string|text)/i }
+      conditions = str_columns.collect do |column|
+        t = Term.new(klass, {:col1 => column.name, :col2 => 'contains', :col3 => search_term}, 'quick_search')
+        t.attribute_condition
+      end
+      AdminData::Util.or_merge_conditions(klass, *conditions)
+    end
+
+    def build_advance_search_condition(klass, options)
+      values        = ( options.blank? ? [] : options.values )
+      terms         = values.collect {|value| Term.new(klass, value, 'advance_search') }
+      valid_terms   = terms.select{ |t| t.valid? }
+      errors        = (terms - valid_terms).collect { |t| t.error }
+      return {:errors => errors} if errors.any?
+
+      r = klass.unscoped
+      valid_terms.each { |t|  r = r.where(t.attribute_condition) }
+      { :cond => r }
+    end
+
+  end
+end

data/lib/admin_data/setup_config.rb

@@ -0,0 +1,24 @@
+module AdminData
+
+  module SetupConfig
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      # See AdminData::Configuration for details.
+      attr_accessor :configuration
+
+      # Call this method to customize the behavior of admin_data .
+      #
+      # @example
+      #   AdminData.config do |config|
+      #     config.number_of_records_per_page = 20
+      #   end
+      def config
+        self.configuration ||= Configuration.new
+        block_given? ? yield(configuration) : configuration
+      end
+    end
+
+  end
+end

data/lib/admin_data/util.rb

@@ -0,0 +1,102 @@
+module AdminData
+  class Util
+
+    def self.label_values_pair_for(model, view)
+      data = model.class.columns.inject([]) do |sum, column|
+        tmp = view.get_value_for_column(column, model, :limit => nil)
+        sum << [ column.name, (tmp.html_safe? ? tmp : view.send(:h,tmp)) ]
+      end
+      data
+    end
+
+    def self.custom_value_for_column(column, model)
+      # some would say that if I use try method then I will not be raising exception and
+      # I agree. However in this case for clarity I would prefer to not to have try after each call
+      begin
+        column_name = column.respond_to?(:name) ? column.name : column
+        tmp = AdminData.config.column_settings[model.class.name.to_s]
+        _proc = tmp.fetch(column_name.intern)
+        _proc.call(model)
+      rescue
+        model.send(column_name)
+      end
+    end
+
+    def self.get_serialized_value(html, column_value)
+      html << %{ <i>Cannot edit serialized field.</i> }
+      unless column_value.blank?
+        html << %{ <i>Raw contents:</i><br/> }
+        html << column_value.inspect
+      end
+      html.join
+    end
+
+    def self.pluralize(count, text)
+      count > 1 ? text+'s' : text
+    end
+
+    # Rails method merge_conditions ANDs all the conditions. I need to ORs all the conditions
+    def self.or_merge_conditions(klass, *conditions)
+      s = ') OR ('
+      cond = conditions.inject([]) do |sum, condition|
+        condition.blank? ? sum : sum << klass.send(:sanitize_sql, condition)
+      end.compact.join(s)
+      "(#{cond})" unless cond.blank?
+    end
+
+    def self.camelize_constantize(klassu)
+      klasss = klassu.camelize
+      self.constantize_klass(klasss)
+    end
+
+    # klass_name = model_name.sub(/\.rb$/,'').camelize
+    # constantize_klass(klass_name)
+    def self.constantize_klass(klass_name)
+      klass_name.split('::').inject(Object) do |klass, part|
+        klass.const_get(part)
+      end
+    end
+
+    # Usage: write 'hello world' to tmp/hello.txt file
+    # Util.write_to_file('hello world', 'a+', 'tmp', 'hello.txt')
+    def self.write_to_file(data, mode, *path)
+      path = File.expand_path(Rails.root.join(*path.flatten.compact))
+      FileUtils.mkdir_p(File.dirname(path))
+      File.open(path, mode) {|fh| fh.puts(data) }
+    end
+
+    def self.string_representation_of_data(value)
+      case value
+      when BigDecimal
+        value.to_s
+      when Date, DateTime, Time
+        "'#{value.to_s(:db)}'"
+      else
+        value.inspect
+      end
+    end
+
+    def self.build_sort_options(klass, sortby)
+      klass.columns.inject('') do |result, column|
+        name = column.name
+
+        selected_text = (sortby == "#{name} desc") ? "selected='selected'" : ''
+        result << "<option value='#{name} desc' #{selected_text}>#{name} desc</option>"
+
+        selected_text = (sortby == "#{name} asc") ? "selected='selected'" : ''
+        result << "<option value='#{name} asc' #{selected_text}>#{name} asc</option>"
+      end.html_safe
+    end
+
+    def self.associations_for(klass, association_type)
+      klass.name.camelize.constantize.reflections.values.select do |value|
+        value.macro == association_type
+      end
+    end
+
+    def self.exception_info(e)
+      "#{e.class}: #{e.message}#$/#{e.backtrace.join($/)}"
+    end
+
+  end
+end

data/lib/admin_data/version.rb

@@ -0,0 +1,3 @@
+module AdminData
+  VERSION = "1.3.0a"
+end

data/lib/tasks/admin_data_tasks.rake

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

data/script/rails

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/admin_data/engine', __FILE__)
+
+require 'rails/all'
+require 'rails/engine/commands'

data/test/admin_data_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class AdminDataTest < ActiveSupport::TestCase
+  test "truth" do
+    assert_kind_of Module, AdminData
+  end
+end

data/test/dummy/README.md

@@ -0,0 +1,19 @@
+# Test setup #
+
+    bundle install
+    rake db:migrate
+    rake db:test:prepare
+
+# Cucumber test #
+
+    bundle exec cucumber
+
+# Unit test #
+
+    ruby -I test test/unit/car_test.rb
+
+# Switch database #
+
+    rake db:use:pg
+    rake db:use:sqlite3
+    rake db:use:mysql

data/test/dummy/Rakefile

@@ -0,0 +1,7 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+require 'rake'
+
+AdminDataDemo::Application.load_tasks

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,5 @@
+module ApplicationHelper
+  def foo
+    "inside main app"
+  end
+end

data/test/dummy/app/models/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+
+end

data/test/dummy/app/models/user/student.rb

@@ -0,0 +1,2 @@
+class User::Student < User
+end

data/test/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>AdminDataDemo</title>
+  <%= stylesheet_link_tag :all %>
+  <%= javascript_include_tag :defaults %>
+  <%= csrf_meta_tag %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/test/dummy/config.ru

@@ -0,0 +1,4 @@
+# This file is used by Rack-based servers to start the application.
+
+require ::File.expand_path('../config/environment',  __FILE__)
+run AdminDataDemo::Application

data/test/dummy/config/application.rb

@@ -0,0 +1,15 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+# If you have a Gemfile, require the gems listed there, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(:default, Rails.env) if defined?(Bundler)
+
+module AdminDataDemo
+  class Application < Rails::Application
+    config.time_zone = 'Central Time (US & Canada)'
+    config.encoding = "utf-8"
+    config.filter_parameters += [:password]
+  end
+end