card 1.16.3 → 1.16.4

data/db/version_core_cards.txt

@@ -1 +1 @@
-20150724123438
+20150903130006

data/lib/card.rb

@@ -47,14 +47,16 @@ class Card < ActiveRecord::Base
     :comment, :comment_author,    # obviated soon
     :update_referencers,          # wrong mechanism for this
     :update_all_users,            # if the above is wrong then this one too
+    :silent_change,               # and this probably too
     :remove_rule_stash,
     :last_action_id_before_edit
 
   attr_accessor :follower_stash
 
 
-  define_callbacks :approve, :store, :stored, :extend, :subsequent
+  define_callbacks :prepare, :approve, :store, :stored, :extend, :subsequent, :select_action
 
+  before_validation :prepare
   before_validation :approve
   around_save :store
   after_save :extend

data/lib/card/cache.rb

@@ -15,17 +15,17 @@ class Card
 
   class Cache
 
-    TEST_ENVS = %w{test cucumber}
-    @@prepopulating     = TEST_ENVS.include? Rails.env
-    @@using_rails_cache = TEST_ENVS.include? Rails.env
-    @@cache_by_class    = {}
+    TEST_ENVS         = %w{test cucumber}
+    @@prepopulating   = TEST_ENVS.include? Rails.env
+    @@no_rails_cache  = TEST_ENVS.include?(Rails.env) || ENV['NO_RAILS_CACHE']
+    @@cache_by_class  = {}
 
     cattr_reader :cache_by_class
 
     class << self
       def [] klass
         raise "nil klass" if klass.nil?
-        cache_by_class[klass] ||= new :class=>klass, :store=>(@@using_rails_cache ? nil : Cardio.cache)
+        cache_by_class[klass] ||= new :class=>klass, :store=>(@@no_rails_cache ? nil : Cardio.cache)
       end
 
       def renew

data/lib/card/chunk.rb

@@ -60,6 +60,8 @@ class Card
       attr_reader :text, :process_chunk
 
       class << self
+
+        # if the prefix regex matched check that chunk against the full regex
         def full_match content, prefix=nil
   #        warn "attempting full match on #{content}.  class = #{self}"
           content.match full_re( prefix )

data/lib/card/env.rb

@@ -14,7 +14,6 @@ class Card
           self[:ajax]       = c.request.xhr? || c.request.params[:simulate_xhr]
           self[:host]       = Card.config.override_host     || c.request.env['HTTP_HOST']
           self[:protocol]   = Card.config.override_protocol || c.request.protocol
-
         end
       end
 
@@ -35,6 +34,7 @@ class Card
         self[:session] ||= {}
       end
 
+
       def ajax?
         self[:ajax]
       end

data/lib/card/query/card_clause.rb

@@ -2,20 +2,21 @@
 class Card
   class Query
     class CardClause < Clause
-    
+      PLUS_ATTRIBUTES = %w{ plus left_plus right_plus }
+
       ATTRIBUTES = {
-        :basic           => %w{ name type_id content id key updater_id left_id right_id creator_id updater_id codename }, 
+        :basic           => %w{ name type_id content id key updater_id left_id right_id creator_id updater_id codename },
         :relational      => %w{ type part left right editor_of edited_by last_editor_of last_edited_by creator_of created_by member_of member },
-        :plus_relational => %w{ plus left_plus right_plus },
+        :plus_relational => PLUS_ATTRIBUTES,
         :ref_relational  => %w{ refer_to referred_to_by link_to linked_to_by include included_by },
         :conjunction     => %w{ and or all any },
         :special         => %w{ found_by not sort match complete extension_type },
         :ignore          => %w{ prepend append view params vars size }
       }.inject({}) {|h,pair| pair[1].each {|v| h[v.to_sym]=pair[0] }; h }
-    
+
       DEFAULT_ORDER_DIRS =  { :update => "desc", :relevance => "desc" }
       CONJUNCTIONS = { :any=>:or, :in=>:or, :or=>:or, :all=>:and, :and=>:and }
-    
+
       attr_reader :sql, :query, :rawclause, :selfname
       attr_accessor :joins, :join_count
 
@@ -38,7 +39,7 @@ class Card
         @vars.symbolize_keys!
         @query = clean(@query)
         @rawclause = @query.deep_clone
-        
+
         @sql.distinct = 'DISTINCT' if @parent
 
         self
@@ -48,7 +49,7 @@ class Card
       #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # QUERY CLEANING - strip strings, absolutize names, interpret contextual parameters
       #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    
+
 
       def clean query
         query = query.symbolize_keys
@@ -74,11 +75,11 @@ class Card
         else                        ; raise BadQuery, "unknown WQL value type: #{val.class}"
         end
       end
-    
+
       def root
         @parent ? @parent.root : self
       end
-    
+
       def absolute_name name
         name =~ /\b_/ ? name.to_name.to_absolute(root.selfname) : name
       end
@@ -87,7 +88,7 @@ class Card
       #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # MERGE - reduce query to basic attributes and SQL subconditions
       #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    
+
 
       def merge s
         s = hashify s
@@ -96,7 +97,7 @@ class Card
         @clause.merge! s
         self
       end
-  
+
       def hashify s
         case s
           when String;   { :key => s.to_name.key }
@@ -134,21 +135,21 @@ class Card
             val = clause.delete key
             is_array = Array===val
             case ATTRIBUTES[keyroot]
-              when :ignore                               #noop         
+              when :ignore                               #noop
               when :relational, :special, :conjunction ; relate is_array, keyroot, val, :send
               when :ref_relational                     ; relate is_array, keyroot, val, :refclause
               when :plus_relational
                 # Arrays can have multiple interpretations for these, so we have to look closer...
                 subcond = is_array && ( Array===val.first || conjunction(val.first) )
-            
+
                                                          relate subcond, keyroot, val, :send
               else                                     ; raise BadQuery, "Invalid attribute #{key}"
             end
           end
         end
-  
+
       end
-  
+
       def relate subcond, key, val, method
         if subcond
           conj = conjunction( val.first ) ? conjunction( val.shift ) : :and
@@ -162,7 +163,7 @@ class Card
         end
       end
 
-      def refclause key, val        
+      def refclause key, val
         add_join :ref, RefClause.new( key, val, self ).to_sql, :id, :ref_id
       end
 
@@ -177,7 +178,7 @@ class Card
       #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # ATTRIBUTE METHODS - called during merge
       #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-    
+
 
       #~~~~~~ RELATIONAL
 
@@ -190,15 +191,15 @@ class Card
         subcondition :left=>val, :right=>right, :conj=>:or
       end
 
-      
+
       def left val
         restrict :left_id, val
       end
-    
+
       def right val
         restrict :right_id, val
       end
-      
+
       def editor_of val
         action_clause :actor_id, "card_actions.card_id", val
       end
@@ -206,14 +207,14 @@ class Card
       def edited_by val
         action_clause "card_actions.card_id", :actor_id, val
       end
-      
+
       def last_editor_of val
         restrict_by_join :id, val, :return=>'updater_id'
       end
 
       def last_edited_by val
         restrict :updater_id, val
-      end    
+      end
 
       def creator_of val
         restrict_by_join :id, val, :return=>'creator_id'
@@ -226,7 +227,7 @@ class Card
       def member_of val
         merge field(:right_plus) => [RolesID, {:refer_to=>val}]
       end
-  
+
       def member val
         merge field(:referred_to_by) => {:left=>val, :right=>RolesID }
       end
@@ -245,30 +246,30 @@ class Card
       def plus val
         any( { :left_plus=>val, :right_plus=>val.deep_clone } )
       end
-      
+
       def junction side, val
         part_clause, junction_clause = val.is_a?(Array) ? val : [ val, {} ]
         restrict_by_join :id, junction_clause, side=>part_clause, :return=>"#{ side==:left ? :right : :left}_id"
       end
-    
-    
+
+
       #~~~~~~~  CONJUNCTION
-    
+
       def and val
         subcondition val
       end
       alias :all :and
-  
+
       def or val
         subcondition val, :conj=>:or
       end
       alias :any :or
-    
+
       #~~~~~~ SPECIAL
 
 
       def found_by val
-      
+
         cards = if Hash===val
           Query.new(val).run
         else
@@ -284,10 +285,10 @@ class Card
           restrict_by_join :id, CardClause.new(c.get_query).rawclause
         end
       end
-  
+
       def not val
         subselect = CardClause.build(:return=>:id, :_parent=>self).merge(val).to_sql
-        join_alias = add_join :not, subselect, :id, :id, :side=>'LEFT'        
+        join_alias = add_join :not, subselect, :id, :id, :side=>'LEFT'
         merge field(:cond) => SqlCond.new("#{join_alias}.id is null")
       end
 
@@ -319,18 +320,18 @@ class Card
         cs.sql.fields << "#{cs.table_alias}.#{join_field} as sort_join_field"
         join_table = add_join :sort, cs.to_sql, :id, :sort_join_field, :side=>'LEFT'
         @mods[:sort] ||= "#{join_table}.#{val[:return]}"
-        
+
       end
 
       def match(val)
         cxn, val = match_prep val
         val.gsub! /[^#{Card::Name::OK4KEY_RE}]+/, ' '
         return nil if val.strip.empty?
-    
+
 
         cond = begin
           val_list = val.split(/\s+/).map do |v|
-            name_or_content = ["replace(#{self.table_alias}.name,'+',' ')","#{self.table_alias}.db_content"].map do |field| 
+            name_or_content = ["replace(#{self.table_alias}.name,'+',' ')","#{self.table_alias}.db_content"].map do |field|
               %{#{field} #{ cxn.match quote("[[:<:]]#{v}[[:>:]]") }}
             end
             "(#{name_or_content.join ' OR '})"
@@ -340,8 +341,8 @@ class Card
 
         merge field(:cond)=>SqlCond.new(cond)
       end
-    
-    
+
+
       def complete(val)
         no_plus_card = (val=~/\+/ ? '' : "and right_id is null")  #FIXME -- this should really be more nuanced -- it breaks down after one plus
         merge field(:cond) => SqlCond.new(" lower(name) LIKE lower(#{quote(val.to_s+'%')}) #{no_plus_card}")
@@ -349,10 +350,10 @@ class Card
 
       def extension_type val
         # DEPRECATED LONG AGO!!!
-        Rails.logger.info "using DEPRECATED extension_type in WQL" 
+        Rails.logger.info "using DEPRECATED extension_type in WQL"
         merge field(:right_plus) => AccountID
       end
-    
+
 
       #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # ATTRIBUTE METHOD HELPERS - called by attribute methods above
@@ -365,7 +366,7 @@ class Card
           @parent ? @parent.table_alias : "t"
         when @parent
           @parent.table_alias + "x"
-        else 
+        else
           "t"
         end
       end
@@ -375,7 +376,7 @@ class Card
         join_alias = "#{name}_#{root.join_count}"
         on = "#{table_alias}.#{cardfield} = #{join_alias}.#{otherfield}"
         #is_subselect = !table.is_a?( Symbol )
-        
+
         if @mods[:conj] == 'or'  #and is_subselect
           opts[:side] ||= 'LEFT'
           merge field(:cond) => SqlCond.new(on)
@@ -400,8 +401,8 @@ class Card
         cardclause = CardClause.build( args )
         merge field(:cond) => cardclause.merge(val)
         self.joins.merge! cardclause.joins
-      end      
-      
+      end
+
       def action_clause(field, linkfield, val)
         card_select = CardClause.build(:_parent=>self, :return=>'id').merge(val).to_sql
         sql =  "(SELECT DISTINCT #{field} AS join_card_id FROM card_acts INNER JOIN card_actions ON card_acts.id = card_act_id "
@@ -415,7 +416,7 @@ class Card
         when String  ; Card.fetch_id(clause)
         end
       end
-            
+
       def restrict id_field, val, opts={}
         if id = id_from_clause(val)
           merge field(id_field) => id
@@ -423,13 +424,13 @@ class Card
           restrict_by_join id_field, val, opts
         end
       end
-      
+
       def restrict_by_join id_field, val, opts={}
         opts.reverse_merge!(:return=>:id, :_parent=>self)
         subselect = CardClause.build(opts).merge(val).to_sql
         add_join "card_#{id_field}", subselect, id_field, opts[:return]
       end
-    
+
       #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # SQL GENERATION - translate merged hash into complete SQL statement.
       #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -437,12 +438,12 @@ class Card
 
       def to_sql *args
         sql.conditions << basic_conditions
-        
+
         if @mods[:return]=='condition'
           conds = sql.conditions.last
           return conds.blank? ? nil : "(#{conds})"
         end
-    
+
         if pconds = permission_conditions
           sql.conditions << pconds
         end
@@ -453,7 +454,7 @@ class Card
         sql.joins += @joins.values
 
         sql.conditions << "#{table_alias}.trash is false"
-      
+
         sql.group = "GROUP BY #{safe_sql(@mods[:group])}" if !@mods[:group].blank?
         unless @parent or @mods[:return]=='count'
           if @mods[:limit].to_i > 0
@@ -464,21 +465,21 @@ class Card
 
         sql.to_s
       end
-  
+
       def basic_conditions
         @clause.map { |key, val| val.to_sql field_root(key) }.compact.join " #{ current_conjunction } "
       end
-  
+
       def current_conjunction
         @mods[:conj].blank? ? :and : @mods[:conj]
       end
-    
+
       def permission_conditions
         unless Auth.always_ok? #or ( Card::Query.root_perms_only && !root? )
           read_rules = Auth.as_card.read_rules
           read_rule_list = read_rules.nil? ? 1 : read_rules.join(',')
           "(#{table_alias}.read_rule_id IN (#{ read_rule_list }))"
-        end      
+        end
       end
 
       def fields_to_sql
@@ -495,10 +496,10 @@ class Card
 
       def sort_to_sql
         #fail "order_key = #{@mods[:sort]}, class = #{order_key.class}"
-    
+
         return nil if @parent or @mods[:return]=='count' #FIXME - extend to all root-only clauses
         order_key ||= @mods[:sort].blank? ? "update" : @mods[:sort]
-    
+
         order_directives = [order_key].flatten.map do |key|
           dir = @mods[:dir].blank? ? (DEFAULT_ORDER_DIRS[key.to_sym]||'asc') : safe_sql(@mods[:dir]) #wonky
           sort_field key, @mods[:sort_as], dir
@@ -506,7 +507,7 @@ class Card
         "ORDER BY #{order_directives}"
 
       end
-  
+
       def sort_field key, as, dir
         order_field = case key
           when "id";              "#{table_alias}.id"
@@ -514,13 +515,13 @@ class Card
           when "create";          "#{table_alias}.created_at"
           when /^(name|alpha)$/;  "LOWER( #{table_alias}.key )"
           when 'content';         "#{table_alias}.db_content"
-          when "relevance";       "#{table_alias}.updated_at" #deprecated            
+          when "relevance";       "#{table_alias}.updated_at" #deprecated
           else
             safe_sql(key)
           end
         order_field = "CAST(#{order_field} AS #{cast_type(as)})" if as
         "#{order_field} #{dir}"
-    
+
       end
     end
   end