card 1.18.4 → 1.18.5

data/lib/card/query/attributes.rb

@@ -2,108 +2,13 @@
 class Card
   class Query
     module Attributes
-      SORT_JOIN_TO_ITEM_MAP = { left: 'left_id', right: 'right_id' }.freeze
-
-      # ~~~~~~ RELATIONAL
-
-      def type val
-        restrict :type_id, val
-      end
-
-      def part val
-        right_val = val.is_a?(Integer) ? val : val.clone
-        any(left: val, right: right_val)
-      end
-
-      def left val
-        restrict :left_id, val
-      end
-
-      def right val
-        restrict :right_id, val
-      end
-
-      def editor_of val
-        act_join = Join.new(
-          from: self,
-          to: ['card_acts', "a#{table_id true}", 'actor_id']
-        )
-        joins << act_join
-        action_join = Join.new(
-          from: act_join,
-          to: ['card_actions', "an#{table_id true}", 'card_act_id'],
-          superjoin: act_join
-        )
-        join_cards val, from: action_join, from_field: 'card_id'
-      end
-
-      def edited_by val
-        action_join = Join.new(
-          from: self,
-          to: ['card_actions', "an#{table_id true}", 'card_id']
-        )
-        joins << action_join
-        act_join = Join.new(
-          from: action_join,
-          from_field: 'card_act_id',
-          to: ['card_acts', "a#{table_id true}"]
-        )
-        join_cards val, from: act_join, from_field: 'actor_id'
-      end
-
-      def last_editor_of val
-        join_cards val, to_field: 'updater_id'
-      end
-
-      def last_edited_by val
-        restrict :updater_id, val
-      end
-
-      def creator_of val
-        join_cards val, to_field: 'creator_id'
-      end
-
-      def created_by val
-        restrict :creator_id, val
-      end
-
-      def member_of val
-        interpret right_plus: [RolesID, refer_to: val]
-      end
-
-      def member val
-        interpret referred_to_by: { left: val, right: RolesID }
-      end
-
-      # ~~~~~~ PLUS RELATIONAL
-
-      def left_plus val
-        junction val, :left, :right_id
-      end
-
-      def right_plus val
-        junction val, :right, :left_id
-      end
-
-      def plus val
-        any(left_plus: val, right_plus: val.deep_clone)
-      end
-
-      def junction val, side, to_field
-        part_clause, junction_clause = val.is_a?(Array) ? val : [val, {}]
-        junction_val = clause_to_hash(junction_clause).merge side => part_clause
-        join_cards junction_val, to_field: to_field
-      end
-
-      # ~~~~~~ SPECIAL
-
       def found_by val
         found_by_cards(val).compact.each do |c|
           if c && [SearchTypeID, SetID].include?(c.type_id)
             # FIXME: - move this check to set mods!
 
             subquery(
-              c.get_query.merge unjoined: true, context: c.name
+              c.get_query.merge(unjoined: true, context: c.name)
             )
           else
             raise BadQuery,
@@ -125,7 +30,7 @@ class Card
 
       def match val
         cxn, val = match_prep val
-        val.gsub! /[^#{Card::Name::OK4KEY_RE}]+/, ' '
+        val.gsub!(/[^#{Card::Name::OK4KEY_RE}]+/, ' ')
         return nil if val.strip.empty?
 
         val_list = val.split(/\s+/).map do |v|
@@ -156,153 +61,6 @@ class Card
         Rails.logger.info 'using DEPRECATED extension_type in WQL'
         interpret right_plus: AccountID
       end
-
-      # ATTRIBUTE HELPERS
-
-      def join_references key, val
-        r = Reference.new(key, val, self)
-        refjoin = Join.new(from: self, to: r, to_field: r.infield)
-        joins << refjoin
-        restrict_reference r, refjoin if r.cardquery
-        r.conditions.each do |condition|
-          refjoin.conditions << "#{r.table_alias}.#{condition}"
-        end
-      end
-
-      def restrict_reference ref, refjoin
-        val = ref.cardquery
-        if (id = id_from_val(val))
-          add_condition "#{ref.table_alias}.#{ref.outfield} = #{id}"
-        else
-          join_cards val, from: refjoin, from_field: ref.outfield
-        end
-      end
-
-      def conjunction val
-        return unless [String, Symbol].member? val.class
-        CONJUNCTIONS[val.to_sym]
-      end
-
-      def sort val
-        return nil if @superquery
-        sort_field = val[:return] || 'db_content'
-        item = val.delete(:item) || 'left'
-
-        if sort_field == 'count'
-          sort_by_count val, item
-        elsif (join_field = SORT_JOIN_TO_ITEM_MAP[item.to_sym])
-          sq = join_cards(val, to_field: join_field,
-                               side: 'LEFT',
-                               conditions_on_join: true)
-          @mods[:sort] ||= "#{sq.table_alias}.#{sort_field}"
-        else
-          raise BadQuery, "sort item: #{item} not yet implemented"
-        end
-      end
-
-      # EXPERIMENTAL!
-      def sort_by_count val, item
-        if item == 'referred_to'
-          @mods[:sort] = 'coalesce(count,0)' # needed for postgres
-          cs = Query.new(
-            return: 'coalesce(count(*), 0) as count',
-            group: 'sort_join_field',
-            superquery: self
-          )
-          subselect = Query.new val.merge(return: 'id', superquery: self)
-          cs.add_condition "referer_id in (#{subselect.sql})"
-          # FIXME: - SQL generated before SQL phase
-          cs.joins << Join.new(
-            from: cs,
-            to: %w(card_references wr referee_id)
-          )
-          cs.mods[:sort_join_field] = "#{cs.table_alias}.id as sort_join_field"
-          # HACK!
-
-          joins << Join.new(
-            from: self,
-            to: [cs, 'srtbl', 'sort_join_field']
-          )
-        else
-          raise BadQuery, "count with item: #{item} not yet implemented"
-        end
-      end
-
-      def table_alias
-        @table_alias ||= begin
-          if @unjoined
-            @superquery.table_alias
-          else
-            "c#{table_id}"
-          end
-        end
-      end
-
-      def table_id force=false
-        if force
-          tick_table_seq!
-        else
-          @table_id ||= tick_table_seq!
-        end
-      end
-
-      def tick_table_seq!
-        root.table_seq = root.table_seq.to_i + 1
-      end
-
-      def join_cards val, opts={}
-        conditions_on_join = opts.delete :conditions_on_join
-        s = subquery
-        join_opts = { from: self, to: s }.merge opts
-        card_join = Join.new join_opts
-        joins << card_join unless opts[:from].is_a? Join
-        s.conditions_on_join = card_join if conditions_on_join
-        s.interpret val
-        s
-      end
-
-      # ~~~~~~~  CONJUNCTION
-
-      def all val
-        conjoin val, :and
-      end
-      alias and all
-
-      def any val
-        conjoin val, :or
-      end
-      alias or any
-      alias in any
-
-      def conjoin val, conj
-        sq = subquery unjoined: true, conj: conj
-        unless val.is_a? Array
-          val = clause_to_hash(val).map { |key, value| { key => value } }
-        end
-        val.each do |val_item|
-          sq.interpret val_item
-        end
-      end
-
-      def not val
-        notjoin = join_cards val, conditions_on_join: true, side: 'LEFT'
-        add_condition "#{notjoin.table_alias}.id is null"
-      end
-
-      def restrict id_field, val
-        if (id = id_from_val(val))
-          interpret id_field => id
-        else
-          join_cards val, from_field: id_field
-        end
-      end
-
-      def id_from_val val
-        case val
-        when Integer then val
-        when String  then Card.fetch_id(val)
-        end
-      end
     end
   end
 end

data/lib/card/query/conjunctions.rb

@@ -0,0 +1,36 @@
+class Card
+  class Query
+    module Conjunctions
+      def all val
+        conjoin val, :and
+      end
+      alias and all
+
+      def any val
+        conjoin val, :or
+      end
+      alias or any
+      alias in any
+
+      def conjoin val, conj
+        sq = subquery unjoined: true, conj: conj
+        unless val.is_a? Array
+          val = clause_to_hash(val).map { |key, value| { key => value } }
+        end
+        val.each do |val_item|
+          sq.interpret val_item
+        end
+      end
+
+      def not val
+        notjoin = join_cards val, conditions_on_join: true, side: 'LEFT'
+        add_condition "#{notjoin.table_alias}.id is null"
+      end
+
+      def conjunction val
+        return unless [String, Symbol].member? val.class
+        CONJUNCTIONS[val.to_sym]
+      end
+    end
+  end
+end

data/lib/card/query/helpers.rb

@@ -0,0 +1,72 @@
+class Card
+  class Query
+    module Helpers
+      def restrict id_field, val
+        if (id = id_from_val(val))
+          interpret id_field => id
+        else
+          join_cards val, from_field: id_field
+        end
+      end
+
+      def restrict_reference ref, refjoin
+        val = ref.cardquery
+        if (id = id_from_val(val))
+          add_condition "#{ref.table_alias}.#{ref.outfield} = #{id}"
+        else
+          join_cards val, from: refjoin, from_field: ref.outfield
+        end
+      end
+
+      def join_references key, val
+        r = Reference.new(key, val, self)
+        refjoin = Join.new(from: self, to: r, to_field: r.infield)
+        joins << refjoin
+        restrict_reference r, refjoin if r.cardquery
+        r.conditions.each do |condition|
+          refjoin.conditions << "#{r.table_alias}.#{condition}"
+        end
+      end
+
+      def id_from_val val
+        case val
+        when Integer then val
+        when String  then Card.fetch_id(val)
+        end
+      end
+
+      def table_alias
+        @table_alias ||= begin
+          if @unjoined
+            @superquery.table_alias
+          else
+            "c#{table_id}"
+          end
+        end
+      end
+
+      def table_id force=false
+        if force
+          tick_table_seq!
+        else
+          @table_id ||= tick_table_seq!
+        end
+      end
+
+      def tick_table_seq!
+        root.table_seq = root.table_seq.to_i + 1
+      end
+
+      def join_cards val, opts={}
+        conditions_on_join = opts.delete :conditions_on_join
+        s = subquery
+        join_opts = { from: self, to: s }.merge opts
+        card_join = Join.new join_opts
+        joins << card_join unless opts[:from].is_a? Join
+        s.conditions_on_join = card_join if conditions_on_join
+        s.interpret val
+        s
+      end
+    end
+  end
+end

data/lib/card/query/interpretation.rb

@@ -0,0 +1,124 @@
+class Card
+  class Query
+    module Interpretation
+      # normalize and extract meaning from a clause
+      # @param clause [Hash, String, Integer] statement or chunk thereof
+      def interpret clause
+        interpret_by_key normalize_clause(clause)
+      end
+
+      def interpret_by_key clause
+        clause.each do |key, val|
+          case
+          when OPERATORS.key?(key.to_s) && !ATTRIBUTES[key]
+            # eg "match" is both operator and attribute;
+            # interpret as attribute when "match" is key
+            interpret content: [key, val]
+          when MODIFIERS.key?(key) && !clause[key].is_a?(Hash)
+            # eg when "sort" is hash, it can have subqueries
+            # and must be interpreted like an attribute
+            @mods[key] = val.is_a?(Array) ? val : val.to_s
+          else
+            interpret_attributes key, val
+          end
+        end
+      end
+
+      def interpret_attributes key, val
+        case ATTRIBUTES[key]
+        when :basic            then add_condition key, val
+        when :conjunction      then send key, val
+        when :relational       then relate key, val
+        when :special          then relate key, val
+        when :ref_relational   then relate key, val, method: :join_references
+        when :plus_relational  then relate_compound key, val
+        when :ignore           then # noop
+        else                   raise BadQuery, "Invalid attribute #{key}"
+        end
+      end
+
+      def normalize_clause clause
+        clause = clause_to_hash clause
+        clause.symbolize_keys!
+        clause.each do |key, val|
+          clause[key] = normalize_value val
+        end
+        clause
+      end
+
+      def clause_to_hash clause
+        case clause
+        when Hash    then clause
+        when String  then { key: clause.to_name.key }
+        when Integer then { id: clause }
+        else raise BadQuery, "Invalid query args #{clause.inspect}"
+        end
+      end
+
+      def normalize_value val
+        case val
+        when Integer, Float, Symbol, Hash then val
+        when String, SmartName            then normalize_string_value val
+        when Array                        then val.map { |v| normalize_value v }
+        else raise BadQuery, "unknown WQL value type: #{val.class}"
+        end
+      end
+
+      def normalize_string_value val
+        case val.to_s
+        when /^\$(\w+)$/                       # replace from @vars
+          @vars[Regexp.last_match[1].to_sym].to_s.strip
+        when /\b_/                             # absolutize based on @context
+          val.to_name.to_absolute(context)
+        else
+          val
+        end
+      end
+
+      def add_condition *args
+        @conditions <<
+          if args.size > 1
+            [args.shift, Value.new(args.shift, self)]
+          else
+            args[0]
+          end
+      end
+
+      def relate_compound key, val
+        has_multiple_values =
+          val.is_a?(Array) &&
+          (val.first.is_a?(Array) || conjunction(val.first).present?)
+        relate key, val, multiple: has_multiple_values
+      end
+
+      def relate key, val, opts={}
+        multiple = opts[:multiple].nil? ? val.is_a?(Array) : opts[:multiple]
+        method = opts[:method] || :send
+        if multiple
+          relate_multi_value method, key, val
+        else
+          send method, key, val
+        end
+      end
+
+      def relate_multi_value method, key, val
+        conj = conjunction(val.first) ? conjunction(val.shift) : :and
+        if conj == current_conjunction
+          # same conjunction as container, no need for subcondition
+          val.each { |v| send method, key, v }
+        else
+          send conj, val.map { |v| { key => v } }
+        end
+      end
+
+      def current_conjunction
+        @mods[:conj].blank? ? :and : @mods[:conj]
+      end
+
+      def all_joins
+        @all_joins ||=
+          (joins + subqueries.select(&:unjoined).map(&:all_joins)).flatten
+      end
+    end
+  end
+end