effective_resources 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0162b9865a0d7b0f8792b361f46f886c905286a
-  data.tar.gz: d3b8a389e8ff5e40860603aa22ed948bde07cc37
+  metadata.gz: a75f5adcc4a20f0f1a18cd2496657b439934e596
+  data.tar.gz: c72e11e7e702d75cafa264dab8c538f6e61962b1
 SHA512:
-  metadata.gz: 7868a5dc8b09f78c1fd044878b9872e65a27e6698a8f52878d6a09a87dbde581c84a33b029d6d0c1869c2e362c24ab446c7b8e3d78ae95fd8e6f071d8c9786e1
-  data.tar.gz: 63eb662a68bb241d51b441dad12c2bcbba3cceaa8a04495e2fb868c56cb1aa441a64258ce347e69ccc268d98e7c08f16d345c906f954b92fa1a3e246d44daa07
+  metadata.gz: 5027571db1c5f1ebad0870f99a1606dc7bd8cc4e5282d472656f2aaf4d9d010a71d26ff7dadb55fd7386906d8eedb67fd1ee24e08e8133c07b8ec18045caf2cb
+  data.tar.gz: 96ed7d36303ad72394afa8dc2c7c6533500abca4e85fbdb56d3868b91897446f1fb36f9af4653bb6ca610c78f159a2568cb95a76cfb79248a07c027255d27808

data/app/models/effective/attribute.rb

@@ -1,13 +1,12 @@
 module Effective
   class Attribute
-    attr_accessor :name, :type
+    attr_accessor :name, :type, :klass
 
-    REGEX = /^\W*(\w+)\W*:(\w+)/
-
-    def self.parse(input)
+    # This parses the written attributes
+    def self.parse_written(input)
       input = input.to_s
 
-      if (scanned = input.scan(REGEX).first).present?
+      if (scanned = input.scan(/^\W*(\w+)\W*:(\w+)/).first).present?
         new(*scanned)
       elsif input.start_with?('#')
         new(nil)
@@ -16,31 +15,102 @@ module Effective
       end
     end
 
-    def initialize(name, type = nil, options = {})
-      @name = name.to_s
-      @type = (type.presence || :string).to_sym
-      @options = options
-    end
+    # This kind of follows the rails GeneratedAttribute method.
+    # In that case it will be initialized with a name and a type.
 
-    def to_s
-      name
+    # We also use this class to do value parsing in Datatables.
+    # In that case it will be initialized with just a 'name'
+    def initialize(obj, type = nil, klass: nil)
+      @klass = klass
+
+      if obj.present? && type.present?
+        @name = obj.to_s
+        @type = type.to_sym
+      end
+
+      @type ||= (
+        case obj
+        when :boolean   ; :boolean
+        when :date      ; :date
+        when :datetime  ; :datetime
+        when :decimal   ; :decimal
+        when :integer   ; :integer
+        when :price     ; :price
+        when :nil       ; :nil
+        when :string    ; :string
+        when FalseClass ; :boolean
+        when Fixnum     ; :integer
+        when Float      ; :decimal
+        when NilClass   ; :nil
+        when String     ; :string
+        when TrueClass  ; :boolean
+        when ActiveSupport::TimeWithZone  ; :datetime
+        when :belongs_to                  ; :belongs_to
+        when :belongs_to_polymorphic      ; :belongs_to_polymorphic
+        when :has_many                    ; :has_many
+        when :has_and_belongs_to_many     ; :has_and_belongs_to_many
+        when :has_one                     ; :has_one
+        when :effective_addresses         ; :effective_addresses
+        when :effective_obfuscation       ; :effective_obfuscation
+        when :effective_roles             ; :effective_roles
+        else
+          raise 'unsupported type'
+        end
+      )
     end
 
-    def field_type
-      @field_type ||= case type
-        when :integer              then :number_field
-        when :float, :decimal      then :text_field
-        when :time                 then :time_select
-        when :datetime, :timestamp then :datetime_select
-        when :date                 then :date_select
-        when :text                 then :text_area
-        when :boolean              then :check_box
-        else :text_field
+    def parse(value, name: nil)
+      case type
+      when :boolean
+        [true, 'true', 't', '1'].include?(value)
+      when :date, :datetime
+        date = Time.zone.local(*value.to_s.scan(/(\d+)/).flatten)
+        name.to_s.start_with?('end_') ? date.end_of_day : date
+      when :decimal
+        (value.kind_of?(String) ? value.gsub(/[^0-9|\.]/, '') : value).to_f
+      when :effective_obfuscation
+        klass.respond_to?(:deobfuscate) ? klass.deobfuscate(value) : value.to_s
+      when :effective_roles
+        EffectiveRoles.roles_for(value)
+      when :integer
+        (value.kind_of?(String) ? value.gsub(/\D/, '') : value).to_i
+      when :nil
+        value.presence
+      when :price
+        (value.kind_of?(Integer) ? value : (value.to_s.gsub(/[^0-9|\.]/, '').to_f * 100.0)).to_i
+      when :string
+        value.to_s
+      when :belongs_to_polymorphic
+        value.to_s
+      when :belongs_to, :has_many, :has_and_belongs_to_many, :has_one  # Returns an Array of ints, an Int or String
+        if value.kind_of?(Integer) || value.kind_of?(Array)
+          value
+        else
+          digits = value.to_s.gsub(/[^0-9|,]/, '') # '87' or '87,254,300' or 'something'
+
+          if digits == value && digits.index(',').present?
+            if klass.respond_to?(:deobfuscate)
+              digits.split(',').map { |str| klass.deobfuscate(str).to_i }
+            else
+              digits.split(',').map { |str| str.to_i }
+            end
+          elsif digits == value
+            klass.respond_to?(:deobfuscate) ? klass.deobfuscate(digits).to_i : digits.to_i
+          else
+            value.to_s
+          end
+        end
+      else
+        raise 'unsupported type'
       end
     end
 
+    def to_s
+      name
+    end
+
     def present?
-      name.present?
+      name.present? || type.present?
     end
 
     def human_name

data/app/models/effective/resource.rb

@@ -4,9 +4,12 @@ module Effective
     include Effective::Resources::Attributes
     include Effective::Resources::Init
     include Effective::Resources::Instance
+    include Effective::Resources::Forms
     include Effective::Resources::Klass
     include Effective::Resources::Naming
     include Effective::Resources::Paths
+    include Effective::Resources::Relation
+    include Effective::Resources::Sql
 
     # post, Post, Admin::Post, admin::Post, admin/posts, admin/post, admin/effective::post
     def initialize(input)

data/app/models/effective/resources/associations.rb

@@ -2,6 +2,10 @@ module Effective
   module Resources
     module Associations
 
+      def macros
+        [:belongs_to, :belongs_to_polymorphic, :has_many, :has_and_belongs_to_many, :has_one]
+      end
+
       def belong_tos
         return [] unless klass.respond_to?(:reflect_on_all_associations)
         @belong_tos ||= klass.reflect_on_all_associations(:belongs_to)
@@ -14,17 +18,57 @@ module Effective
 
       def has_manys
         return [] unless klass.respond_to?(:reflect_on_all_associations)
-        @has_manys ||= klass.reflect_on_all_associations(:has_many).reject { |association| association.options[:autosave] }
+        @has_manys ||= klass.reflect_on_all_associations(:has_many).reject { |ass| ass.options[:autosave] }
+      end
+
+      def has_and_belongs_to_manys
+        return [] unless klass.respond_to?(:reflect_on_all_associations)
+        @has_and_belongs_to_manys ||= klass.reflect_on_all_associations(:has_and_belongs_to_many)
       end
 
       def nested_resources
         return [] unless klass.respond_to?(:reflect_on_all_associations)
-        @nested_resources ||= klass.reflect_on_all_associations(:has_many).select { |association| association.options[:autosave] }
+        @nested_resources ||= klass.reflect_on_all_associations(:has_many).select { |ass| ass.options[:autosave] }
       end
 
       def scopes
       end
 
+      def associated(name)
+        name = (name.to_s.end_with?('_id') ? name.to_s[0...-3] : name).to_sym
+        klass.reflect_on_all_associations.find { |ass| ass.name == name }
+      end
+
+      def belongs_to(name)
+        name = (name.to_s.end_with?('_id') ? name.to_s[0...-3] : name).to_sym
+        belong_tos.find { |ass| ass.name == name }
+      end
+
+      def belongs_to_polymorphic(name)
+        name = (name.to_s.end_with?('_id') ? name.to_s[0...-3] : name).to_sym
+        belong_tos.find { |ass| ass.name == name && ass.options[:polymorphic] }
+      end
+
+      def has_and_belongs_to_many(name)
+        name = name.to_sym
+        has_and_belongs_to_manys.find { |ass| ass.name == name }
+      end
+
+      def has_many(name)
+        name = name.to_sym
+        (has_manys + nested_resources).find { |ass| ass.name == name }
+      end
+
+      def has_one(name)
+        name = name.to_sym
+        has_ones.find { |ho| ass.name == name }
+      end
+
+      def nested_resource(name)
+        name = name.to_sym
+        nested_resources.find { |ass| ass.name == name }
+      end
+
     end
   end
 end

data/app/models/effective/resources/attributes.rb

@@ -18,13 +18,13 @@ module Effective
 
         attributes = (attributes.keys - [klass.primary_key, 'created_at', 'updated_at'] - belong_tos.map { |reference| reference.foreign_key }).map do |att|
           if klass.respond_to?(:column_for_attribute) # Rails 4+
-            Effective::Attribute.new(att, klass.column_for_attribute(att).try(:type))
+            Effective::Attribute.new(att, klass.column_for_attribute(att).type)
           else
-            Effective::Attribute.new(att, klass.columns_hash[att].try(:type))
+            Effective::Attribute.new(att, klass.columns_hash[att].type)
           end
         end
 
-        sort(attributes)
+        sort_by_written_attributes(attributes)
       end
 
       def belong_tos_attributes
@@ -42,7 +42,7 @@ module Effective
 
       private
 
-      def sort(attributes)
+      def sort_by_written_attributes(attributes)
         attributes.sort do |a, b|
           index = nil
 

data/app/models/effective/resources/forms.rb

@@ -0,0 +1,59 @@
+module Effective
+  module Resources
+    module Forms
+
+      # Used by datatables
+      def search_form_field(name, type = nil)
+        case (type || sql_type(name))
+        when :belongs_to
+          { as: :select }.merge(associated_search_collection(belongs_to(name)))
+        when :belongs_to_polymorphic
+          { as: :grouped_select, polymorphic: true, collection: nil}
+        when :has_and_belongs_to_many
+          { as: :select }.merge(associated_search_collection(has_and_belongs_to_many(name)))
+        when :has_many
+          { as: :select, multiple: true }.merge(associated_search_collection(has_many(name)))
+        when :has_one
+          { as: :select, multiple: true }.merge(associated_search_collection(has_one(name)))
+        when :effective_addresses
+          { as: :string }
+        when :effective_roles
+          { as: :select, collection: EffectiveRoles.roles }
+        when :effective_obfuscation
+          { as: :effective_obfuscation }
+        when :boolean
+          { as: :boolean, collection: [['true', true], ['false', false]] }
+        when :datetime
+          { as: :datetime }
+        when :date
+          { as: :date }
+        when :integer
+          { as: :number }
+        when :text
+          { as: :text }
+        else
+          { as: :string }
+        end
+      end
+
+      private
+
+      def associated_search_collection(association, max_id = 1000)
+        res = Effective::Resource.new(association)
+
+        if res.max_id > max_id
+          { as: :string }
+        else
+          if res.klass.unscoped.respond_to?(:datatables_filter)
+            { collection: res.klass.datatables_filter.map { |obj| [obj.to_s, obj.to_param] } }
+          elsif res.klass.unscoped.respond_to?(:sorted)
+            { collection: res.klass.sorted.map { |obj| [obj.to_s, obj.to_param] } }
+          else
+            { collection: res.klass.all.map { |obj| [obj.to_s, obj.to_param] }.sort { |x, y| x[0] <=> y[0] } }
+          end
+        end
+      end
+
+    end
+  end
+end

data/app/models/effective/resources/init.rb

@@ -6,6 +6,7 @@ module Effective
 
       def _initialize(obj)
         @input_name = _initialize_input_name(obj)
+        @relation = _initialize_relation(obj)
         @instance = obj if (klass && obj.instance_of?(klass))
       end
 
@@ -14,13 +15,25 @@ module Effective
         when String ; input
         when Symbol ; input
         when Class  ; input.name
-        when (ActiveRecord::Reflection::MacroReflection rescue false); input.name
-        when (ActionDispatch::Journey::Route rescue false); input.defaults[:controller]
+        when ActiveRecord::Relation ; input.klass
+        when ActiveRecord::Reflection::AbstractReflection ; input.name
+        when ActionDispatch::Journey::Route ; input.defaults[:controller]
         when nil    ; raise 'expected a string or class'
         else        ; input.class.name
         end.to_s.underscore
       end
 
+      def _initialize_relation(input)
+        return nil unless klass && klass.respond_to?(:where)
+
+        case input
+        when ActiveRecord::Relation
+          input
+        when ActiveRecord::Reflection::AbstractReflection
+          klass.where(nil).merge(input.scope) if input.scope
+        end || klass.where(nil)
+      end
+
       # Lazy initialized
       def _initialize_written
         @written_attributes = []
@@ -35,7 +48,7 @@ module Effective
 
           if first && last
             @written_attributes = reader.select(from: first+1, to: last-1).map do |line|
-              Effective::Attribute.parse(line).presence
+              Effective::Attribute.parse_written(line).presence
             end.compact
           end
 

data/app/models/effective/resources/relation.rb

@@ -0,0 +1,215 @@
+module Effective
+  module Resources
+    module Relation
+      attr_reader :relation
+
+      # When Effective::Resource is initialized with an ActiveRecord relation, the following
+      # methods will be available to operate on that relation, and be chainable and such
+
+      # name: sort by this column, or this relation
+      # sort: when a symbol or boolean, this is the relation's column to sort by
+
+      def order(name, direction = :asc, as: nil, sort: nil, sql_column: nil)
+        raise 'expected relation to be present' unless relation
+
+        sql_column ||= sql_column(name)
+        sql_type = (as || sql_type(name))
+
+        association = associated(name)
+        sql_direction = sql_direction(direction)
+
+        case sql_type
+        when :belongs_to
+          relation
+            .order(postgres? ? "#{sql_column} IS NULL ASC" : "ISNULL(#{sql_column}) ASC")
+            .order(order_by_associated_conditions(association, sort: sort, direction: direction))
+        when :belongs_to_polymorphic
+          relation
+            .order("#{sql_column.sub('_id', '_type')} #{sql_direction}")
+            .order("#{sql_column} #{sql_direction}")
+        when :has_and_belongs_to_many, :has_many, :has_one
+          relation
+            .order(order_by_associated_conditions(association, sort: sort, direction: direction))
+            .order("#{sql_column(klass.primary_key)} #{sql_direction}")
+        when :effective_roles
+          relation.order("#{sql_column(:roles_mask)} #{sql_direction}")
+        else
+          relation.order("#{sql_column} #{sql_direction}")
+        end
+      end
+
+      def search(name, value, as: nil, fuzzy: true, sql_column: nil)
+        raise 'expected relation to be present' unless relation
+
+        sql_column ||= sql_column(name)
+        sql_type = (as || sql_type(name))
+        fuzzy = true unless fuzzy == false
+
+        if ['SUM(', 'COUNT(', 'MAX(', 'MIN(', 'AVG('].any? { |str| sql_column.to_s.include?(str) }
+          return relation.having("#{sql_column} = ?", value)
+        end
+
+        association = associated(name)
+        term = Effective::Attribute.new(sql_type, klass: association.try(:klass) || klass).parse(value, name: name)
+
+        case sql_type
+        when :belongs_to, :has_and_belongs_to_many, :has_many, :has_one
+          relation.where(search_by_associated_conditions(association, term, fuzzy: fuzzy))
+        when :belongs_to_polymorphic
+          (type, id) = term.split('_')
+          relation.where("#{sql_column} = ?", id).where("#{sql_column.sub('_id', '_type')} = ?", type)
+        when :effective_addresses
+          raise 'not yet implemented'
+        when :effective_obfuscation
+          # If value == term, it's an invalid deobfuscated id
+          relation.where("#{sql_column} = ?", (value == term ? 0 : term))
+        when :effective_roles
+          relation.with_role(term)
+        when :boolean
+          relation.where("#{sql_column} = ?", term)
+        when :datetime, :date
+          end_at = (
+            case (value.to_s.scan(/(\d+)/).flatten).length
+            when 1 ; term.end_of_year     # Year
+            when 2 ; term.end_of_month    # Year-Month
+            when 3 ; term.end_of_day      # Year-Month-Day
+            when 4 ; term.end_of_hour     # Year-Month-Day Hour
+            when 5 ; term.end_of_minute   # Year-Month-Day Hour-Minute
+            when 6 ; term + 1.second      # Year-Month-Day Hour-Minute-Second
+            else term
+            end
+          )
+          relation.where("#{sql_column} >= ? AND #{sql_column} <= ?", term, end_at)
+        when :decimal
+          relation.where("#{sql_column} = ?", term)
+        when :integer
+          relation.where("#{sql_column} = ?", term)
+        when :price
+          relation.where("#{sql_column} = ?", term)
+        when :string, :text
+          if fuzzy
+            relation.where("#{sql_column} #{ilike} ?", "%#{term}%")
+          else
+            relation.where("#{sql_column} = ?", term)
+          end
+        else
+          raise 'unsupported sql type'
+        end
+      end
+
+      def search_any(value, columns: nil, fuzzy: nil)
+        raise 'expected relation to be present' unless relation
+
+        # Assume this is a set of IDs
+        if value.kind_of?(Integer) || value.kind_of?(Array)
+          return relation.where(klass.primary_key => value)
+        end
+
+        # Otherwise, we fall back to a string/text search of all columns
+        columns = Array(columns || search_columns)
+        fuzzy = true unless fuzzy == false
+
+        conditions = (
+          if fuzzy
+            columns.map { |name| "#{sql_column(name)} #{ilike} :fuzzy" }
+          else
+            columns.map { |name| "#{sql_column(name)} = :value" }
+          end
+        ).join(' OR ')
+
+        relation.where(conditions, fuzzy: "%#{value}%", value: value)
+      end
+
+      private
+
+      def search_by_associated_conditions(association, value, fuzzy: nil)
+        resource = Effective::Resource.new(association)
+
+        # Search the target model for its matching records / keys
+        relation = resource.search_any(value, fuzzy: fuzzy)
+
+        if association.options[:as] # polymorphic
+          relation = relation.where(association.type => klass.name)
+        end
+
+        # key: the id, or associated_id on my table
+        # keys: the ids themselves as per the target table
+
+        if association.macro == :belongs_to
+          key = sql_column(association.foreign_key)
+          keys = relation.pluck(association.klass.primary_key)
+        elsif association.macro == :has_and_belongs_to_many
+          key = sql_column(klass.primary_key)
+          values = relation.pluck(association.source_reflection.klass.primary_key).uniq.compact
+
+          keys = klass.joins(association.name)
+            .where(association.name => { association.source_reflection.klass.primary_key => values })
+            .pluck(klass.primary_key)
+        elsif association.macro == :has_many && association.options[:through].present?
+          key = sql_column(klass.primary_key)
+          values = relation.pluck(association.source_reflection.klass.primary_key).uniq.compact
+
+          keys = association.through_reflection.klass
+            .where(association.source_reflection.foreign_key => values)
+            .pluck(association.through_reflection.foreign_key)
+        elsif association.macro == :has_many
+          key = sql_column(klass.primary_key)
+          keys = relation.pluck(association.foreign_key)
+        elsif association.macro == :has_one
+          key = sql_column(klass.primary_key)
+          keys = relation.pluck(association.foreign_key)
+        end
+
+        "#{key} IN (#{(keys.uniq.compact.presence || [0]).join(',')})"
+      end
+
+      def order_by_associated_conditions(association, sort: nil, direction: :asc)
+        resource = Effective::Resource.new(association)
+
+        # Order the target model for its matching records / keys
+        sort_column = (sort unless sort == true) || resource.sort_column
+
+        relation = resource.relation.order("#{resource.sql_column(sort_column)} #{sql_direction(direction)}")
+
+        if association.options[:as] # polymorphic
+          relation = relation.where(association.type => klass.name)
+        end
+
+        # key: the id, or associated_id on my table
+        # keys: the ids themselves as per the target table
+
+        if association.macro == :belongs_to
+          key = sql_column(association.foreign_key)
+          keys = relation.pluck(association.klass.primary_key)
+        elsif association.macro == :has_and_belongs_to_many
+          key = sql_column(klass.primary_key)
+
+          source = "#{association.join_table}.#{association.source_reflection.association_foreign_key}"
+          values = relation.pluck(association.source_reflection.klass.primary_key).uniq.compact # The searched keys
+
+          keys = klass.joins(association.name)
+            .order(values.uniq.compact.map { |value| "#{source}=#{value} DESC" }.join(','))
+            .pluck(klass.primary_key)
+        elsif association.macro == :has_many && association.options[:through].present?
+          key = sql_column(klass.primary_key)
+
+          source = association.source_reflection.foreign_key
+          values = relation.pluck(association.source_reflection.klass.primary_key).uniq.compact # The searched keys
+
+          keys = association.through_reflection.klass
+            .order(values.uniq.compact.map { |value| "#{source}=#{value} DESC" }.join(','))
+            .pluck(association.through_reflection.foreign_key)
+        elsif association.macro == :has_many
+          key = sql_column(klass.primary_key)
+          keys = relation.pluck(association.foreign_key)
+        elsif association.macro == :has_one
+          key = sql_column(klass.primary_key)
+          keys = relation.pluck(association.foreign_key)
+        end
+
+        keys.uniq.compact.map { |value| "#{key}=#{value} DESC" }.join(',')
+      end
+
+    end
+  end
+end

data/app/models/effective/resources/sql.rb

@@ -0,0 +1,100 @@
+module Effective
+  module Resources
+    module Sql
+
+      def column(name)
+        name = name.to_s
+        columns.find { |col| col.name == name || (belongs_to(name) && col.name == belongs_to(name).foreign_key) }
+      end
+
+      def columns
+        klass.columns
+      end
+
+      def column_names
+        @column_names ||= columns.map { |col| col.name }
+      end
+
+      def table
+        klass.unscoped.table
+      end
+
+      def max_id
+        @max_id ||= klass.maximum(klass.primary_key).to_i
+      end
+
+      def sql_column(name)
+        column = column(name)
+        return nil unless table && column
+
+        [klass.connection.quote_table_name(table.name), klass.connection.quote_column_name(column.name)].join('.')
+      end
+
+      def sql_direction(name)
+        name.to_s.downcase == 'desc' ? 'DESC' : 'ASC'
+      end
+
+      # This is for EffectiveDatatables (col as:)
+      def sql_type(name)
+        name = name.to_s
+
+        if belongs_to_polymorphic(name)
+          :belongs_to_polymorphic
+        elsif belongs_to(name)
+          :belongs_to
+        elsif has_and_belongs_to_many(name)
+          :has_and_belongs_to_many
+        elsif has_many(name)
+          :has_many
+        elsif has_one(name)
+          :has_one
+        elsif name.end_with?('_address') && defined?(EffectiveAddresses) && instance.respond_to?(:effective_addresses)
+          :effective_addresses
+        elsif name == 'id' && defined?(EffectiveObfuscation) && klass.respond_to?(:deobfuscate)
+          :effective_obfuscation
+        elsif name == 'roles' && defined?(EffectiveRoles) && klass.respond_to?(:with_role)
+          :effective_roles
+        elsif (column = column(name))
+          column.type
+        elsif name.ends_with?('_id')
+          :integer
+        else
+          :string
+        end
+      end
+
+      # This tries to figure out the column we should order this collection by.
+      # Whatever would match up with the .to_s
+      def sort_column
+        ['name', 'title', 'label', 'first_name', 'subject', 'description', 'email'].each do |name|
+          return name if column_names.include?(name)
+        end
+
+        klass.primary_key
+      end
+
+      # Any string or text columns
+      # TODO: filter out _type columns for polymorphic
+      def search_columns
+        columns.map { |column| column.name if [:string, :text].include?(column.type) }.compact
+      end
+
+      private
+
+      def postgres?
+        return @postgres unless @postgres.nil?
+        @postgres ||= (klass.connection.kind_of?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter) rescue false)
+      end
+
+      def mysql?
+        return @mysql unless @mysql.nil?
+        @mysql ||= (klass.connection.kind_of?(ActiveRecord::ConnectionAdapters::Mysql2Adapter) rescue false)
+      end
+
+      def ilike
+        @ilike ||= (postgres? ? 'ILIKE' : 'LIKE')  # Only Postgres supports ILIKE, Mysql and Sqlite3 use LIKE
+      end
+
+    end
+  end
+end

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '0.2.2'.freeze
+  VERSION = '0.2.3'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-03 00:00:00.000000000 Z
+date: 2017-02-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -43,11 +43,14 @@ files:
 - app/models/effective/resource.rb
 - app/models/effective/resources/associations.rb
 - app/models/effective/resources/attributes.rb
+- app/models/effective/resources/forms.rb
 - app/models/effective/resources/init.rb
 - app/models/effective/resources/instance.rb
 - app/models/effective/resources/klass.rb
 - app/models/effective/resources/naming.rb
 - app/models/effective/resources/paths.rb
+- app/models/effective/resources/relation.rb
+- app/models/effective/resources/sql.rb
 - config/effective_resources.rb
 - lib/effective_resources.rb
 - lib/effective_resources/engine.rb