card 1.16.14 → 1.16.15

data/lib/card/query.rb

@@ -57,41 +57,47 @@ class Card
       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 }
+    }.inject({}) { |h, pair| pair[1].each { |v| h[v.to_sym] = pair[0] }; h }
 
     CONJUNCTIONS = { any: :or, in: :or, or: :or, all: :and, and: :and }
 
     MODIFIERS = %w( conj return sort sort_as group dir limit offset )
-      .inject({}) { |h,v| h[v.to_sym]=nil; h }
+                .inject({}) { |h,v| h[v.to_sym] = nil; h }
 
     OPERATORS = %w( != = =~ < > in ~ ).inject({}) {|h,v| h[v]=v; h }.merge({
-      eq: '=', gt: '>', lt: '<', match: '~', ne: '!=', :'not in'=> nil
+      eq: '=', gt: '>', lt: '<', match: '~', ne: '!=', 'not in' => nil
     }.stringify_keys)
 
     DEFAULT_ORDER_DIRS =  { :update => "desc", :relevance => "desc" }
 
     attr_reader :statement, :mods, :conditions, :comment,
-      :subqueries, :superquery
+                :subqueries, :superquery
     attr_accessor :joins, :table_seq, :unjoined, :conditions_on_join
 
     def initialize statement, comment=nil
-      @comment = comment
       @subqueries = []
       @conditions = []
       @joins = []
       @mods = {}
       @statement = statement.clone
 
-      @unjoined   = @statement.delete(:unjoined  ) || nil
-      @context    = @statement.delete(:context   ) || nil
+      @context    = @statement.delete(:context) || nil
+      @unjoined   = @statement.delete(:unjoined) || nil
       @superquery = @statement.delete(:superquery) || nil
-      @vars       = @statement.delete(:vars      ) || {}
+      @vars       = @statement.delete(:vars) || {}
       @vars.symbolize_keys!
 
+      @comment = comment || default_comment
+
       interpret @statement
       self
     end
 
+    def default_comment
+      return if @superquery || !Card.config.sql_comments
+      statement.to_s
+    end
+
     # Query Execution
     # By default a query returns card objects. This is accomplished by returning
     # a card identifier from SQL and then hooking into our caching system (see
@@ -185,7 +191,7 @@ class Card
     def normalize_value val
       case val
       when Integer, Float, Symbol, Hash then val
-      when String, Card::Name           then normalize_string_value val
+      when String, SmartName            then normalize_string_value val
       when Array                        then val.map { |v| normalize_value v }
       else fail BadQuery, "unknown WQL value type: #{val.class}"
       end

data/lib/card/query/attributes.rb

@@ -26,12 +26,12 @@ class Card
       def editor_of val
         act_join = Join.new(
           from: self,
-          to: ['card_acts', "a#{table_id force=true}", 'actor_id']
+          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 force=true}", 'card_act_id'],
+          to: ['card_actions', "an#{table_id true}", 'card_act_id'],
           superjoin: act_join
         )
         join_cards val, from: action_join, from_field: 'card_id'
@@ -40,13 +40,13 @@ class Card
       def edited_by val
         action_join = Join.new(
           from: self,
-          to: ['card_actions', "an#{table_id force=true}", 'card_id']
+          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 force=true}"]
+          to: ['card_acts', "a#{table_id true}"]
         )
         join_cards val, from: act_join, from_field: 'actor_id'
       end
@@ -100,72 +100,68 @@ class Card
       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!
+            # FIXME: - move this check to set mods!
 
             subquery(
               c.get_query.merge unjoined: true, context: c.name
             )
           else
             raise BadQuery,
-              '"found_by" value must be valid Search, ' +
-              "but #{c.name} is a #{c.type_name}"
+                  '"found_by" value must be valid Search, ' \
+                  "but #{c.name} is a #{c.type_name}"
           end
         end
       end
 
-
       def found_by_cards val
-        if Hash===val
+        if val.is_a? Hash
           Query.run val
         else
           Array.wrap(val).map do |v|
-            Card.fetch val.to_name.to_absolute(context), :new=>{}
+            Card.fetch v.to_name.to_absolute(context), new: {}
           end
         end
-
       end
 
-      def match(val)
+      def match val
         cxn, val = match_prep val
         val.gsub! /[^#{Card::Name::OK4KEY_RE}]+/, ' '
         return nil if val.strip.empty?
 
         val_list = val.split(/\s+/).map do |v|
           name_or_content = [
-            "replace(#{self.table_alias}.name,'+',' ')",
-            "#{self.table_alias}.db_content"
+            "replace(#{table_alias}.name,'+',' ')",
+            "#{table_alias}.db_content"
           ].map do |field|
-            %{#{field} #{ cxn.match quote("[[:<:]]#{v}[[:>:]]") }}
+            %{#{field} #{cxn.match quote("[[:<:]]#{v}[[:>:]]")}}
           end
           "(#{name_or_content.join ' OR '})"
         end
         add_condition "(#{val_list.join ' AND '})"
       end
 
-
-      def complete(val)
-        no_plus_card = (val =~ /\+/ ? '' : "and right_id is null")
-        # FIXME -- this should really be more nuanced --
+      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
 
         add_condition(
-          " lower(name) LIKE lower(#{quote(val.to_s+'%')}) #{no_plus_card}"
+          " lower(#{table_alias}.name) LIKE" \
+          " lower(#{quote(val.to_s + '%')}) #{no_plus_card}"
         )
       end
 
-      def extension_type val
+      def extension_type _val
         # DEPRECATED LONG AGO!!!
-        Rails.logger.info "using DEPRECATED extension_type in WQL"
-        interpret :right_plus => AccountID
+        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)
+        r = Reference.new(key, val, self)
+        refjoin = Join.new(from: self, to: r, to_field: r.infield)
         joins << refjoin
         if r.cardquery
           join_cards r.cardquery, from: refjoin, from_field: r.outfield
@@ -188,37 +184,35 @@ class Card
         if sort_field == 'count'
           sort_by_count val, item
         else
-          if join_field = SORT_JOIN_TO_ITEM_MAP[item.to_sym]
-            sq = join_cards val,
-              to_field: join_field,
-              side: 'LEFT',
-              conditions_on_join: true
+          if (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
-
       end
 
       # EXPERIMENTAL!
       def sort_by_count val, item
         if item == 'referred_to'
-          @mods[:sort] = "coalesce(count,0)" # needed for postgres
+          @mods[:sort] = 'coalesce(count,0)' # needed for postgres
           cs = Query.new(
-            :return=>'coalesce(count(*), 0) as count',
-            :group=>'sort_join_field',
-            :superquery=>self
+            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
+          # FIXME: - SQL generated before SQL phase
           cs.joins << Join.new(
             from: cs,
-            to:['card_references', 'wr', 'referee_id']
+            to: ['card_references', 'wr', 'referee_id']
           )
           cs.mods[:sort_join_field] = "#{cs.table_alias}.id as sort_join_field"
-          #HACK!
+          # HACK!
 
           joins << Join.new(
             from: self,
@@ -261,8 +255,7 @@ class Card
         s
       end
 
-
-      #~~~~~~~  CONJUNCTION
+      # ~~~~~~~  CONJUNCTION
 
       def all val
         conjoin val, :and
@@ -276,8 +269,8 @@ class Card
       alias_method :in, :any
 
       def conjoin val, conj
-        sq = subquery( unjoined: true, conj: conj )
-        unless Array===val
+        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|
@@ -291,7 +284,7 @@ class Card
       end
 
       def restrict id_field, val
-        if id = id_from_val(val)
+        if (id = id_from_val(val))
           interpret id_field => id
         else
           join_cards val, from_field: id_field
@@ -300,11 +293,10 @@ class Card
 
       def id_from_val val
         case val
-        when Integer ; val
-        when String  ; Card.fetch_id(val)
+        when Integer then val
+        when String  then Card.fetch_id(val)
         end
       end
-
     end
   end
-end
+end

data/lib/card/set.rb

@@ -1,7 +1,6 @@
 # -*- encoding : utf-8 -*-
 
 class Card
-  # remove_const :Set if const_defined?(:Set, false)
 
   module Set
     mattr_accessor :modules, :traits
@@ -101,16 +100,16 @@ class Card
           else
             alias_block view, args
           end
-        define_method "_view_#{ view }", view_block
+        define_method "_view_#{view}", view_block
       end
 
       def alias_block view, args
         opts = args[0].is_a?(Hash) ? args.shift : { view: args.shift }
-        opts[:mod]  ||= self
+        opts[:mod] ||= self
         opts[:view] ||= view
         views[opts[:mod]][opts[:view]] || fail
       rescue
-        raise "cannot find #{ opts[:view] } view in #{ opts[:mod] }; " \
+        raise "cannot find #{opts[:view]} view in #{opts[:mod]}; " \
               "failed to alias #{view} in #{self}"
       end
     end
@@ -119,8 +118,8 @@ class Card
       if format_names.empty?
         format_names = [:base]
       elsif format_names.first == :all
-        format_names = Card::Format.registered
-          .reject { |f| Card::Format.aliases[f] }
+        format_names =
+          Card::Format.registered.reject { |f| Card::Format.aliases[f] }
       end
       format_names.each do |f|
         define_on_format f, &block
@@ -215,7 +214,6 @@ class Card
     def define_event_method event, call_method, _opts
       class_eval do
         define_method event do
-          # Rails.logger.rspec event
           run_callbacks event do
             send call_method
           end
@@ -229,7 +227,8 @@ class Card
     # (when the job is executed ActiveJob fetches the card from the database so
     #  all attributes get lost)
     # @param name [String] the name for the ActiveJob child class
-    # @param final_method [String] the name of the card instance method to be queued
+    # @param final_method [String] the name of the card instance method to be
+    #   queued
     # @option queue [Symbol] (:default) the name of the queue
     def define_active_job name, final_method, queue=:default
       class_name = name.to_s.camelize
@@ -240,12 +239,13 @@ class Card
       }
       Object.const_get(class_name).class_eval do
         define_method :perform, proc { |card, attributes|
-          attributes.each do |name, args|
+          attributes.each do |attname, args|
             # symbols are not allowed so all symbols arrive here as strings
             # convert strings that were symbols before back to symbols
             value = args[:symbol] ? args[:value].to_sym : args[:value]
-            card.instance_variable_set("@#{name}", value)
+            card.instance_variable_set("@#{attname}", value)
           end
+          card.include_set_modules
           card.send final_method
         }
       end
@@ -480,8 +480,11 @@ EOF
 
     def attachment name, args
       include Abstract::Attachment
-      set_specific_attributes name, :load_from_mod, :action_id_of_cached_upload,
-                                    "remote_#{name}_url".to_sym
+      set_specific_attributes name,
+                              :load_from_mod,
+                              :action_id_of_cached_upload,
+                              :empty_ok,
+                              "remote_#{name}_url".to_sym
       uploader_class = args[:uploader] || FileUploader
       mount_uploader name, uploader_class
     end

data/lib/card/set_pattern.rb

@@ -1,14 +1,13 @@
 class Card
-
   class SetPattern
-
     class << self
-      attr_accessor :pattern_code, :pattern_id, :junction_only, :assigns_type, :anchorless, :anchor_parts_count
+      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
-          hash[ card_key ] = true
+          card_key = Card.quick_fetch(set_pattern.pattern_code.to_sym).key
+          hash[card_key] = true
           hash
         end
       end

data/lib/card/spec_helper.rb

@@ -1,26 +1,23 @@
 module SpecHelper
 end
 module Card::SpecHelper
-
   include Rails::Dom::Testing::Assertions::SelectorAssertions
-  #~~~~~~~~~  HELPER METHODS ~~~~~~~~~~~~~~~#
+  # ~~~~~~~~~  HELPER METHODS ~~~~~~~~~~~~~~~#
 
   def login_as user
-    Card::Auth.current_id = (uc=Card[user.to_s] and uc.id)
-    if @request
-      @request.session[:user] = Card::Auth.current_id
-    end
-    #warn "(ath)login_as #{user.inspect}, #{Card::Auth.current_id}, #{@request.session[:user]}"
+    Card::Auth.current_id = (uc = Card[user.to_s]) && uc.id
+    return unless @request
+    @request.session[:user] = Card::Auth.current_id
+    # warn "(ath)login_as #{user.inspect}, #{Card::Auth.current_id}, #{@request.session[:user]}"
   end
 
-  def newcard name, content=""
+  def newcard name, content=''
     #FIXME - misleading name; sounds like it doesn't save.
     Card.create! name: name, content: content
   end
 
-  def assert_view_select(view_html, *args, &block)
+  def assert_view_select view_html, *args, &block
     node = Nokogiri::HTML::Document.parse(view_html).root
-    #node = HTML::Document.new(view_html).root
     if block_given?
       assert_select node, *args, &block
     else
@@ -28,9 +25,9 @@ module Card::SpecHelper
     end
   end
 
-  def debug_assert_view_select(view_html, *args, &block)
+  def debug_assert_view_select view_html, *args, &block
     Rails.logger.rspec %(
-      #{CodeRay.scan(Nokogiri::XML(view_html,&:noblanks).to_s, :html).div}
+      #{CodeRay.scan(Nokogiri::XML(view_html, &:noblanks).to_s, :html).div}
       <style>
         .CodeRay {
           background-color: #FFF;
@@ -43,17 +40,17 @@ module Card::SpecHelper
     assert_view_select view_html, *args, &block
   end
 
-  def render_editor(type)
+  def render_editor type
     card = Card.create(name: "my favority #{type} + #{rand(4)}", type: type)
     card.format.render(:edit)
   end
 
   def render_content content, format_args={}
-    render_content_with_args( content, format_args )
+    render_content_with_args content, format_args
   end
 
   def render_content_with_args content, format_args={}, view_args={}
-    @card ||= Card.new name: "Tempo Rary 2"
+    @card ||= Card.new name: 'Tempo Rary 2'
     @card.content = content
     @card.format(format_args)._render :core, view_args
   end
@@ -67,7 +64,7 @@ module Card::SpecHelper
       if card_args[:name]
         Card.fetch card_args[:name], new: card_args
       else
-        Card.new card_args.merge( name: 'Tempo Rary' )
+        Card.new card_args.merge(name: 'Tempo Rary')
       end
     end
     card.format(format_args)._render(view, view_args)
@@ -76,4 +73,45 @@ module Card::SpecHelper
   def users
     SharedData::USERS.sort
   end
+
+  # Make expectations in the event phase.
+  # Takes the usual event options :on and :before/:after/:around
+  # and registers the event_block with these options as an event.
+  # Unknown methods in the event_block are executed in the rspec context
+  # instead of the card's context.
+  # An additionaly :trigger block in opts is expected that is called
+  # to start the event phase.
+  # Example:
+  # in_phase before: :approve, on: :save,
+  #          trigger: ->{ test_card.update_attributes! content: '' } do
+  #            expect(item_names).to eq []
+  #          end
+  def in_phase opts, &event_block
+    $rspec_binding = binding
+    Card.class_eval do
+      def method_missing m, *args
+        begin
+          method = eval('method(%s)' % m.inspect, $rspec_binding)
+        rescue NameError
+        else
+          return method.call(*args)
+        end
+        begin
+          value = eval(m.to_s, $rspec_binding)
+          return value
+        rescue NameError
+        end
+        super
+#        raise NoMethodError
+      end
+      define_method :in_phase_test, event_block
+    end
+    Card.define_callbacks :in_phase_test
+    kind =  ([:before, :after, :around] & opts.keys).first
+    name = opts.delete(kind)
+    Card.set_callback name, kind, :in_phase_test, prepend: true
+    opts[:trigger].call
+  ensure
+    Card.skip_callback name, kind, :in_phase_test
+  end
 end