card 1.16.6 → 1.16.7

data/lib/card/query/sql_statement.rb

@@ -0,0 +1,228 @@
+class Card
+  class Query
+    class SqlStatement
+      def initialize query
+        @query = query
+        @mods = query.mods
+      end
+
+      def build
+        @fields = fields
+        @tables = tables
+        @joins  = joins @query.all_joins
+        @where  = where
+        @group  = group
+        @order  = order
+        @limit_and_offset = limit_and_offset
+        self
+      end
+
+      def to_s
+        ["SELECT DISTINCT #{@fields}",
+         "FROM #{@tables}",
+         @joins,
+         @where,
+         @group,
+         @order,
+         @limit_and_offset
+        ].compact * "\n"
+      end
+
+      def tables
+        "cards #{@query.table_alias}"
+      end
+
+      def fields
+        table = @query.table_alias
+        field = @mods[:return]
+        field = field.blank? ? :card : field.to_sym
+        field = full_field(table, field)
+        [field, @mods[:sort_join_field]].compact * ', '
+      end
+
+      def full_field table, field
+        case field
+        when :raw      then "#{table}.*"
+        when :card     then "#{table}.name"
+        when :content  then "#{table}.db_content"
+        when :count
+          "coalesce(count( distinct #{table}.id),0) as count"
+        else
+          if ATTRIBUTES[field.to_sym] == :basic
+            "#{table}.#{field}"
+          else
+            safe_sql field
+          end
+        end
+      end
+
+      def joins join_list
+        clauses = []
+        join_list.each do |join|
+          clauses << join_on_clause(join)
+          clauses << joins(deeper_joins join) unless join.left?
+        end
+        clauses.flatten * "\n"
+      end
+
+      def join_on_clause join
+        [join_clause(join), 'ON', on_clause(join)].join ' '
+      end
+
+      def deeper_joins join
+        deeper_joins = join.subjoins
+        deeper_joins += join.to.all_joins if join.to.is_a? Card::Query
+        deeper_joins
+      end
+
+      def join_clause join
+        to_table = join.to_table
+        to_table = "(#{to_table.sql})" if to_table.is_a? Card::Query
+        table_segment = [to_table, join.to_alias].join ' '
+
+        if join.left?
+          djoins = deeper_joins(join)
+          unless djoins.empty?
+            table_segment = "(#{table_segment} #{joins djoins})"
+          end
+        end
+        [join.side, 'JOIN', table_segment].compact.join ' '
+      end
+
+      def on_clause join
+        on_conditions = join.conditions
+        on_ids = [
+          "#{join.from_alias}.#{join.from_field}",
+          "#{join.to_alias}.#{join.to_field}"
+        ].join ' = '
+        on_conditions.unshift on_ids
+        if join.to.is_a? Card::Query
+          if join.to.conditions_on_join == join
+            on_conditions.push query_conditions(join.to)
+          end
+          on_conditions.push standard_conditions(join.to)
+        end
+        basic_conditions(on_conditions) * ' AND '
+      end
+
+      def where
+        conditions = [query_conditions(@query), standard_conditions(@query)]
+        conditions = conditions.reject(&:blank?).join "\nAND "
+        "WHERE #{conditions}" unless conditions.blank?
+      end
+
+      def query_conditions query
+        cond_list = basic_conditions query.conditions
+        cond_list +=
+          query.subqueries.map do |subquery|
+            next if subquery.conditions_on_join
+            query_conditions subquery
+          end
+        cond_list.reject!(&:blank?)
+
+        if cond_list.size > 1
+          cond_list = cond_list.join "\n#{query.current_conjunction.upcase} "
+          "(#{cond_list})"
+        else
+          cond_list.join
+        end
+      end
+
+      def basic_conditions conditions
+        conditions.map do |condition|
+          if condition.is_a? String
+            condition
+          else
+            field, val = condition
+            val.to_sql field
+          end
+        end
+      end
+
+      def standard_conditions query
+        [trash_condition(query), permission_conditions(query)].compact * ' AND '
+      end
+
+      def trash_condition query
+        "#{query.table_alias}.trash is false"
+      end
+
+      def permission_conditions query
+        return if Auth.always_ok?
+        read_rules = Auth.as_card.read_rules
+        read_rule_list = read_rules.nil? ? 1 : read_rules.join(',')
+        "#{query.table_alias}.read_rule_id IN (#{read_rule_list})"
+      end
+
+      def group
+        group = @mods[:group]
+        "GROUP BY #{safe_sql group}" if group.present?
+      end
+
+      def limit_and_offset
+        full_syntax do
+          limit = @mods[:limit]
+          offset = @mods[:offset]
+          if limit.to_i > 0
+            string =  "LIMIT  #{limit.to_i} "
+            string += "OFFSET #{offset.to_i} " if offset.present?
+            string
+          end
+        end
+      end
+
+      def full_syntax
+        return if @query.superquery || @mods[:return] == 'count'
+        yield
+      end
+
+      def order
+        full_syntax do
+          order_key ||= @mods[:sort].blank? ? 'update' : @mods[:sort]
+
+          order_directives = [order_key].flatten.map do |key|
+            dir = if @mods[:dir].blank?
+                    DEFAULT_ORDER_DIRS[key.to_sym] || 'asc'
+                  else
+                    safe_sql @mods[:dir]
+                  end
+            sort_field key, @mods[:sort_as], dir
+          end.join ', '
+          "ORDER BY #{order_directives}"
+        end
+      end
+
+      def sort_field key, as, dir
+        table = @query.table_alias
+        order_field =
+          case key
+          when 'id'             then "#{table}.id"
+          when 'update'         then "#{table}.updated_at"
+          when 'create'         then "#{table}.created_at"
+          when /^(name|alpha)$/ then "LOWER( #{table}.key )"
+          when 'content'        then "#{table}.db_content"
+          when 'relevance'      then "#{table}.updated_at" # deprecated
+          else
+            safe_sql(key)
+          end
+        order_field = "CAST(#{order_field} AS #{cast_type(safe_sql as)})" if as
+        @fields += ", #{order_field}"
+        "#{order_field} #{dir}"
+      end
+
+      def safe_sql(txt)
+        txt = txt.to_s
+        if txt.match(/[^\w\*\(\)\s\.\,]/)
+          fail "WQL contains disallowed characters: #{txt}"
+        else
+          txt
+        end
+      end
+
+      def cast_type(type)
+        cxn ||= ActiveRecord::Base.connection
+        (val = cxn.cast_types[type.to_sym]) ? val[:name] : safe_sql(type)
+      end
+    end
+  end
+end

data/lib/card/query/value.rb

@@ -0,0 +1,66 @@
+class Card
+  class Query
+    class Value
+
+      include Clause
+
+      attr_reader :query, :operator, :value
+
+      def initialize rawvalue, query
+        @query = query
+        @operator, @value = parse_value rawvalue
+        canonicalize_operator
+      end
+
+      def parse_value rawvalue
+        operator =
+          case rawvalue
+          when Array;     rawvalue.shift
+          when String;    '='
+          when Integer;   '='
+          else raise("Invalid Condition Clause #{rawvalue}.inspect}")
+          end
+        [operator, rawvalue]
+      end
+
+      def canonicalize_operator
+        if target = OPERATORS[@operator.to_s]
+          @operator = target
+        else
+          fail BadQuery, "Invalid Operator #{@operator}"
+        end
+      end
+
+
+      def sqlize v
+        case v
+        when Query;  v.to_sql
+        when Array;  "(" + v.flatten.collect {|x| sqlize(x)}.join(',') + ")"
+        else quote(v.to_s)
+        end
+      end
+
+      def to_sql field
+        op,v = @operator, @value
+        table = @query.table_alias
+
+        field, v = case field.to_s
+          when "name"
+            ["#{table}.key", [v].flatten.map(&:to_name).map(&:key)]
+          when "content"
+            ["#{table}.db_content", v]
+          else
+            ["#{table}.#{safe_sql field}", v]
+          end
+
+        v = v[0] if Array===v && v.length==1 && op != 'in'
+        if op=='~'
+          cxn, v = match_prep(v)
+          %{#{field} #{cxn.match(sqlize(v))}}
+        else
+          "#{field} #{op} #{sqlize(v)}"
+        end
+      end
+    end
+  end
+end

data/lib/card/reference.rb

@@ -12,22 +12,22 @@ class Card::Reference < ActiveRecord::Base
   class << self
 
     def delete_all_from card
-      delete_all :referer_id => card.id
+      delete_all referer_id: card.id
     end
 
     def delete_all_to card
-      where( :referee_id => card.id ).update_all :present=>0, :referee_id => nil
+      where( referee_id: card.id ).update_all present: 0, referee_id: nil
     end
 
     def update_existing_key card, name=nil
       key = (name || card.name).to_name.key
-      where( :referee_key => key ).update_all :present => 1, :referee_id => card.id
+      where( referee_key: key ).update_all present: 1, referee_id: card.id
     end
 
     def update_on_rename card, newname, update_referers=false
       if update_referers
         # not currentlt needed because references are deleted and re-created in the process of adding new revision
-        #where( :referee_id=>card.id ).update_all :referee_key => newname.to_name.key
+        #where( referee_id: card.id ).update_all referee_key: newname.to_name.key
       else
         delete_all_to card
       end
@@ -41,7 +41,7 @@ class Card::Reference < ActiveRecord::Base
     end
 
     def repair_missing_referees
-      joins('LEFT JOIN cards ON card_references.referee_id = cards.id').where('(cards.id IS NULL OR cards.trash IS TRUE) AND referee_id IS NOT NULL').update_all :referee_id=>nil
+      joins('LEFT JOIN cards ON card_references.referee_id = cards.id').where('(cards.id IS NULL OR cards.trash IS TRUE) AND referee_id IS NOT NULL').update_all referee_id: nil
     end
 
     def delete_missing_referers
@@ -51,7 +51,7 @@ class Card::Reference < ActiveRecord::Base
     def repair_all
       delete_missing_referers
 
-      Card.where(:trash=>false).find_each do |card|
+      Card.where(trash: false).find_each do |card|
         Rails.logger.info "\nRepairing references for '#{card.name}' (id: #{card.id}) ... "
         card.update_references
       end

data/lib/card/set.rb

@@ -6,7 +6,7 @@ class Card
   module Set
 
     mattr_accessor :modules, :traits
-    @@modules = { :base=>[], :base_format=>{}, :nonbase=>{}, :nonbase_format=>{} }
+    @@modules = { base: [], base_format: {}, nonbase: {}, nonbase_format: {} }
 
 
 =begin
@@ -99,7 +99,7 @@ class Card
       end
 
       def alias_block view, args
-        opts = Hash===args[0] ? args.shift : { :view => args.shift }
+        opts = Hash===args[0] ? args.shift : { view: args.shift }
         opts[:mod]  ||= self
         opts[:view] ||= view
         views[ opts[:mod] ][ opts[:view] ] or fail
@@ -168,9 +168,9 @@ class Card
                    value = self.instance_variable_get("@#{name}")
                    hash[name] =
                      if Symbol === value  # ActiveJob doesn't accept symbols as arguments
-                       { :value => value.to_s, :symbol => true }
+                       { value: value.to_s, symbol: true }
                      else
-                       { :value => value }
+                       { value: value }
                      end
                 end
           Object.const_get(event.to_s.camelize).perform_later(self, s_attr)
@@ -220,17 +220,17 @@ class Card
     #
     def card_accessor *args
       options = args.extract_options!
-      add_traits args, options.merge( :reader=>true, :writer=>true )
+      add_traits args, options.merge( reader: true, writer: true )
     end
 
     def card_reader *args
       options = args.extract_options!
-      add_traits args, options.merge( :reader=>true )
+      add_traits args, options.merge( reader: true )
     end
 
     def card_writer *args
       options = args.extract_options!
-      add_traits args, options.merge( :writer=>true )
+      add_traits args, options.merge( writer: true )
     end
 
 
@@ -383,7 +383,7 @@ EOF
         if object_method = opts.delete(kind)
           this_set_module = self
           Card.class_eval do
-            set_callback object_method, kind, event, :prepend=>true, :if=> proc { |c|
+            set_callback object_method, kind, event, prepend: true, if: proc { |c|
               c.singleton_class.include?( this_set_module ) and c.event_applies? opts
             }
           end
@@ -401,8 +401,8 @@ EOF
   #    raise "Can't define card traits on all set" if mod == Card
       mod_traits = get_traits mod
 
-      new_opts = options[:type] ? {:type=>options[:type]} : {}
-      new_opts.merge!( {:content => options[:default]} ) if options[:default]
+      new_opts = options[:type] ? {type: options[:type]} : {}
+      new_opts.merge!( {content: options[:default]} ) if options[:default]
 
       args.each do |trait|
         define_trait_card trait, new_opts
@@ -416,7 +416,7 @@ EOF
     def define_trait_card trait, opts
       define_method "#{trait}_card" do
         trait_var "@#{trait}_card" do
-          fetch :trait=>trait.to_sym, :new=>opts.clone
+          fetch trait: trait.to_sym, new: opts.clone
         end
       end
     end
@@ -433,7 +433,7 @@ EOF
       define_method "#{trait}=" do |value|
         card = send "#{trait}_card"
         self.subcards ||= {}
-        self.subcards[card.name] = {:type_id => card.type_id, :content=>value }
+        self.subcards[card.name] = {type_id: card.type_id, content: value }
         instance_variable_set "@#{trait}", value
       end
     end

data/lib/card/set_pattern.rb

@@ -1,26 +1,26 @@
 class Card
 
   class SetPattern
-    
+
     class << self
       attr_accessor :pattern_code, :pattern_id, :junction_only, :assigns_type, :anchorless, :anchor_parts_count
-      
+
       def card_keys
         @@card_keys ||= Card.set_patterns.inject({}) do |hash, set_pattern|
-          card_key = Card.fetch( set_pattern.pattern_code.to_sym, :skip_modules=>true ).key
+          card_key = Card.fetch( set_pattern.pattern_code.to_sym, skip_modules: true ).key
           hash[ card_key ] = true
           hash
         end
       end
-      
+
       def find pattern_code
-        Card.set_patterns.find { |sub| sub.pattern_code == pattern_code }        
+        Card.set_patterns.find { |sub| sub.pattern_code == pattern_code }
       end
-    
+
       def junction_only?
         !!junction_only
       end
-    
+
       def anchorless?
         !!anchorless
       end
@@ -30,7 +30,7 @@ class Card
       end
 
       def pattern
-        Card.fetch(self.pattern_id, :skip_modules=>true).cardname
+        Card.fetch(self.pattern_id, skip_modules: true).cardname
       end
 
       def register pattern_code, opts={}
@@ -48,7 +48,7 @@ class Card
         junction_only? ? card.cardname.junction? : true
       end
 
-      def anchor_parts_count 
+      def anchor_parts_count
         @anchor_parts_count ||= ( anchorless? ? 0 : 1 )
       end