card 1.18.6 → 1.19.0

data/lib/card/query/value.rb

@@ -13,7 +13,7 @@ class Card
 
       def parse_value rawvalue
         case rawvalue
-        when String, Integer then ['=', rawvalue]
+        when String, Integer then ["=", rawvalue]
         when Array           then [rawvalue[0], rawvalue[1..-1]]
         else raise("Invalid Condition Clause #{rawvalue}.inspect}")
         end
@@ -23,14 +23,14 @@ class Card
         if target = OPERATORS[@operator.to_s]
           @operator = target
         else
-          raise BadQuery, "Invalid Operator #{@operator}"
+          raise Card::Error::BadQuery, "Invalid Operator #{@operator}"
         end
       end
 
       def sqlize v
         case v
         when Query then  v.to_sql
-        when Array then  '(' + v.flatten.map { |x| sqlize(x) }.join(',') + ')'
+        when Array then  "(" + v.flatten.map { |x| sqlize(x) }.join(",") + ")"
         else quote(v.to_s)
         end
       end
@@ -41,16 +41,16 @@ class Card
         table = @query.table_alias
 
         field, v = case field.to_s
-                   when 'name'
+                   when "name"
                      ["#{table}.key", [v].flatten.map(&:to_name).map(&:key)]
-                   when 'content'
+                   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 == '~'
+        v = v[0] if Array === v && v.length == 1 && op != "in"
+        if op == "~"
           cxn, v = match_prep(v)
           %(#{field} #{cxn.match(sqlize(v))})
         else

data/lib/card/reference.rb

@@ -10,8 +10,8 @@ class Card
       def mass_insert array
         return if array.empty?
         value_statements = array.map { |values| "\n(#{values.join ', '})" }
-        sql = 'INSERT into card_references '\
-              '(referer_id, referee_id, referee_key, ref_type) '\
+        sql = "INSERT into card_references "\
+              "(referer_id, referee_id, referee_key, ref_type) "\
               "VALUES #{value_statements.join ', '}"
         Card.connection.execute sql
       end
@@ -29,21 +29,21 @@ class Card
       # find all references to missing (eg deleted) cards and reset them
       def unmap_if_referee_missing
         joins(
-          'LEFT JOIN cards ON card_references.referee_id = cards.id'
+          "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'
+          "(cards.id IS NULL OR cards.trash IS TRUE) AND referee_id IS NOT NULL"
         ).update_all referee_id: nil
       end
 
       # remove all references from missing (eg deleted) cards
       def delete_if_referer_missing
         joins(
-          'LEFT JOIN cards ON card_references.referer_id = cards.id'
+          "LEFT JOIN cards ON card_references.referer_id = cards.id"
         ).where(
-          'cards.id IS NULL'
+          "cards.id IS NULL"
         ).find_in_batches do |group|
           # used to be .delete_all here, but that was failing on large dbs
-          puts 'deleting batch of references'
+          puts "deleting batch of references"
           where("id in (#{group.map(&:id).join ','})").delete_all
         end
       end

data/lib/card/set.rb

@@ -67,11 +67,14 @@ class Card
   module Set
     include Event
     include Trait
+    include Basket
+    include Inheritance
 
     include Set::Format
-    include Set::Helpers
+    include AdvancedApi
+    include Helpers
 
-    extend Set::Loader
+    extend Loader
 
     mattr_accessor :modules, :traits
     self.modules = { base: [], base_format: {}, nonbase: {}, nonbase_format: {},

data/lib/card/set/advanced_api.rb

@@ -0,0 +1,44 @@
+class Card
+  module Set
+    # advanced set module API
+    module AdvancedApi
+      def ensure_set &block
+        set_module = yield
+      rescue NameError => e
+        if e.message =~ /uninitialized constant (?:Card::Set::)?(.+)$/
+          constant_pieces = Regexp.last_match(1).split("::")
+          constant_pieces.inject(Card::Set) do |set_mod, module_name|
+            set_mod.const_get_or_set module_name do
+              Module.new
+            end
+          end
+        end
+        # try again - there might be another submodule that doesn't exist
+        ensure_set(&block)
+      else
+        set_module.extend Card::Set
+      end
+
+      def attachment name, args
+        include Abstract::Attachment
+        add_attributes name, "remote_#{name}_url".to_sym, :load_from_mod,
+                       :action_id_of_cached_upload, :empty_ok
+        uploader_class = args[:uploader] || CarrierWave::FileUploader
+        mount_uploader name, uploader_class
+      end
+
+      def stage_method method, opts={}, &block
+        class_eval do
+          define_method "_#{method}", &block
+          define_method method do |*args|
+            if (error = wrong_stage(opts) || wrong_action(opts[:on]))
+              raise Card::Error, error
+            else
+              send "_#{method}", *args
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/set/basket.rb

@@ -0,0 +1,52 @@
+class Card
+  module Set
+    # The purpose of a basket it that you can throw something in from
+    # the same set in another mod.
+    # A basket can be defined on a format or directly on a set
+    #
+    # @example:
+    #   # mod/core/set/self/head.rb:
+    #   basket :basket_on_set
+    #
+    #   format :html do
+    #     basket :js_tags  # only available in HtmlFormat
+    #     view :core { output basket(:js_tags) }
+    #   end
+    #
+    #   # mod/shell/set/self/head.rb:
+    #   add_to_basket :basket_on_set, 'hello world'
+    #
+    #   format :html do
+    #     add_to_basket :js_tags "<script/>"
+    #     add_to_basket :js_tags do |format_obj|
+    #       format_obj.render_special_view
+    #     end
+    #   end
+    module Basket
+      # Define a basket in a set or format
+      def basket name
+        mattr_accessor "#{name}_content"
+        send("#{name}_content=", [])
+        define_method name do
+          send("#{name}_content").map do |item|
+            item.respond_to?(:call) ? item.call(self) : item
+          end
+        end
+      end
+
+      # Define a basket in an abstract set
+      def abstract_basket name
+        # the basket has to be defined on the including set
+        # (instead on the set itself)
+        define_singleton_method :included do |host|
+          host.basket name
+        end
+      end
+
+      def add_to_basket name, content=nil, &block
+        content ||= block
+        send("#{name}_content").send("<<", content)
+      end
+    end
+  end
+end

data/lib/card/set/event.rb

@@ -1,5 +1,43 @@
 class Card
+  def deserialize_for_active_job! attr, env, current_id
+    attr.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]
+      instance_variable_set("@#{attname}", value)
+    end
+    include_set_modules
+    # If active jobs (and hence the integrate_with_delay events) don't run
+    # in a background process then Card::Env.deserialize! decouples the
+    # controller's params hash and the Card::Env's params hash with the
+    # effect that params changes in the CardController get lost
+    # (a crucial example are success params that are processed in
+    # CardController#update_params_for_success)
+    return if Wagn.config.active_job.queue_adapter == :inline
+    Card::Env.deserialize! env
+    Card::Auth.current_id = current_id
+  end
+
+  def serialize_for_active_job
+    serializable_attributes.each_with_object({}) do |name, hash|
+      value = instance_variable_get("@#{name}")
+      hash[name] =
+        # ActiveJob doesn't accept symbols as arguments
+        if value.is_a? Symbol
+          { value: value.to_s, symbol: true }
+        else
+          { value: value }
+        end
+    end
+  end
+
+  def log_event_call event
+    Rails.logger.debug "#{name}: #{event}"
+    # puts "#{Card::DirectorRegister.to_s}".green
+  end
+
   module Set
+    # Implements the event API for card sets
     module Event
       def event event, stage_or_opts={}, opts={}, &final
         if stage_or_opts.is_a? Symbol
@@ -14,6 +52,8 @@ class Card
         set_event_callbacks event, opts
       end
 
+      private
+
       def define_event event, opts, &final
         final_method_name = "#{event}_without_callbacks" # should be private?
         class_eval do
@@ -23,24 +63,22 @@ class Card
         if with_delay? opts
           delaying_method = "#{event}_with_delay"
           define_event_delaying_method event, delaying_method
-          define_event_method event, delaying_method, opts
+          define_event_method event, delaying_method
           define_active_job event, final_method_name, opts[:queue_as]
         else
-          define_event_method event, final_method_name, opts
+          define_event_method event, final_method_name
         end
       end
 
-      private
-
       def with_delay? opts
-        opts[:after] == :integrate_with_delay_stage
+        opts[:after] == :integrate_with_delay_stage ||
+          opts[:before] == :integrate_with_delay_stage
       end
 
       def process_stage_opts opts
-        case
-        when opts[:after] || opts[:before]
+        if opts[:after] || opts[:before]
           # ignore :in options
-        when opts[:in]
+        elsif opts[:in]
           opts[:after] = :"#{opts.delete(:in)}_stage" if opts[:in]
         end
         opts[:on] = [:create, :update] if opts[:on] == :save
@@ -48,28 +86,19 @@ class Card
 
       def define_event_delaying_method event, method_name
         class_eval do
-          define_method method_name, proc {
-            s_attr =
-              serializable_attributes.each_with_object({}) do |name, hash|
-                value = instance_variable_get("@#{name}")
-                hash[name] =
-                  # ActiveJob doesn't accept symbols as arguments
-                  if value.is_a? Symbol
-                    { value: value.to_s, symbol: true }
-                  else
-                    { value: value }
-                  end
-              end
-            Object.const_get(event.to_s.camelize).perform_later(self, s_attr)
-          }
+          define_method(method_name, proc do
+            Object.const_get(event.to_s.camelize).perform_later(
+              self, serialize_for_active_job, Card::Env.serialize,
+              Card::Auth.current_id
+            )
+          end)
         end
       end
 
-      def define_event_method event, call_method, _opts
+      def define_event_method event, call_method
         class_eval do
           define_method event do
-            # puts "#{name}:#{event}".red
-            # puts "#{Card::DirectorRegister.to_s}".green
+            log_event_call event
             run_callbacks event do
               send call_method
             end
@@ -85,39 +114,41 @@ class Card
       # @param name [String] the name for the ActiveJob child class
       # @param final_method [String] the name of the card instance method to be
       # queued
-      # @option queue [Symbol] (:default) the name of the queue8
-      def define_active_job name, final_method, queue=:default
+      # @option queue [Symbol] (:default) the name of the queue
+      def define_active_job name, final_method, queue=:integrate_with_delay
         class_name = name.to_s.camelize
+        define_active_job_class class_name, queue || :integrate_with_delay
+        define_active_job_perform_method class_name, final_method
+      end
+
+      def define_active_job_class class_name, queue
         eval %(
           class ::#{class_name} < ActiveJob::Base
-            queue_as #{queue}
+            queue_as :#{queue}
           end
         )
+      end
+
+      def define_active_job_perform_method class_name, method_name
         Object.const_get(class_name).class_eval do
-          define_method :perform, proc { |card, attributes|
-            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("@#{attname}", value)
+          define_method(
+            :perform,
+            proc do |card, card_attribs, env, current_id|
+              card.deserialize_for_active_job! card_attribs, env, current_id
+              card.send method_name
             end
-            card.include_set_modules
-            card.send final_method
-          }
+          )
         end
       end
 
       def set_event_callbacks event, opts
+        opts[:set] ||= self
         [:before, :after, :around].each do |kind|
           next unless (object_method = opts.delete(kind))
-          this_set_module = self
           Card.class_eval do
             set_callback(
               object_method, kind, event,
-              prepend: true, if: proc do |c|
-                c.singleton_class.include?(this_set_module) &&
-                  c.event_applies?(opts)
-              end
+              prepend: true, if: proc { |c| c.event_applies?(opts) }
             )
           end
         end

data/lib/card/set/format.rb

@@ -46,7 +46,7 @@ class Card
         mod = const_get_or_set klass do
           # yielding set format module, eg Card::Set::Type::Pointer::HtmlFormat
           m = Module.new
-          register_set_format Card.const_get(klass), m
+          register_set_format Card::Format.class_from_name(klass), m
           m.extend Card::Set::AbstractFormat
           m
         end
@@ -71,26 +71,13 @@ class Card
         modules[:base_format][format_class] << mod
       end
 
-      # iterate through each format associated with a set
-      def each_format set
-        set_type = set.abstract_set? ? :abstract : :nonbase
-        format_type = "#{set_type}_format".to_sym
-        modules[format_type].each_pair do |format, set_format_mod_hash|
-          next unless (format_mods = set_format_mod_hash[set.shortname])
-          yield format, format_mods
-        end
-      end
-
-      def applicable_format? format, except, only
-        return false if except && Array(except).include?(format)
-        return false if only && !Array(only).include?(format)
-        true
-      end
-
       # All Format modules are extended with this module in order to support
       # the basic format API (ok, view definitions.  It's just view
       # definitions.)
+      # No longer just view definitions. Also basket definitions now.
       module AbstractFormat
+        include Set::Basket
+
         mattr_accessor :views
         self.views = {}
 

data/lib/card/set/helpers.rb

@@ -1,91 +1,17 @@
 class Card
   module Set
-    # advanced set module API
     module Helpers
-      # include a set module and all its format modules
-      # @param [Module] set
-      # @param [Hash] opts choose the formats you want to include
-      # @option opts [Symbol, Array<Symbol>] :only include only these formats
-      # @option opts [Symbol, Array<Symbol>] :except don't include these formats
-      # @example
-      # include_set Type::Basic, except: :css
-      def include_set set, opts={}
-        set_type = set.abstract_set? ? :abstract : :nonbase
-        Card::Set.modules[set_type][set.shortname].each do |set_mod|
-          include set_mod
-        end
-        include_set_formats set, opts
-      end
-
-      # include a format modules of a set
-      # @param [Module] set
-      # @param [Hash] opts choose the formats you want to include
-      # @option opts [Symbol, Array<Symbol>] :only include only these formats
-      # @option opts [Symbol, Array<Symbol>] :except don't include these formats
-      # @example
-      # include_set Type::Basic, except: :css
-      def include_set_formats set, opts={}
-        each_format set do |format, format_mods|
-          match = format.to_s.match(/::(?<format>[^:]+)Format/)
-          format_sym = match ? match[:format] : :base
-          next unless applicable_format?(format_sym, opts[:except], opts[:only])
-          format_mods.each do |format_mod|
-            define_on_format format_sym do
-              include format_mod
-            end
-          end
-        end
-      end
-
-      def ensure_set &block
-        set_module = yield
-      rescue NameError => e
-        if e.message =~ /uninitialized constant (?:Card::Set::)?(.+)$/
-          constant_pieces = Regexp.last_match(1).split('::')
-          constant_pieces.inject(Card::Set) do |set_mod, module_name|
-            set_mod.const_get_or_set module_name do
-              Module.new
-            end
-          end
-        end
-        # try again - there might be another submodule that doesn't exist
-        ensure_set(&block)
-      else
-        set_module.extend Card::Set
-      end
-
-      def attachment name, args
-        include Abstract::Attachment
-        add_attributes name, "remote_#{name}_url".to_sym, :load_from_mod,
-                       :action_id_of_cached_upload, :empty_ok
-        uploader_class = args[:uploader] || FileUploader
-        mount_uploader name, uploader_class
-      end
-
-      def stage_method method, opts={}, &block
-        class_eval do
-          define_method "_#{method}", &block
-          define_method method do |*args|
-            if (error = wrong_stage(opts) || wrong_action(opts[:on]))
-              raise Card::Error, error
-            else
-              send "_#{method}", *args
-            end
-          end
-        end
-      end
-
       def shortname
-        parts = name.split '::'
+        parts = name.split "::"
         first = 2 # shortname eliminates Card::Set
         pattern_name = parts[first].underscore
-        last = if pattern_name == 'abstract'
+        last = if pattern_name == "abstract"
                  first + 1
                else
-                 set_class = Card::SetPattern.find pattern_name
+                 set_class = Pattern.find pattern_name
                  first + set_class.anchor_parts_count
                end
-        parts[first..last].join '::'
+        parts[first..last].join "::"
       end
 
       def abstract_set?