card 1.19.6 → 1.20.0

data/lib/card/name.rb

@@ -4,7 +4,14 @@ require_dependency "card/env"
 require "smart_name"
 
 class Card
+  # The SmartName class provides generalized of Card naming patterns
+  # (compound names, key-based variants, etc)
+  #
+  # Card::Name adds support for deeper card integration
   class Name < SmartName
+    include FieldsAndTraits
+    include Variants
+
     RELATIVE_REGEXP = /\b_(left|right|whole|self|user|main|\d+|L*R?)\b/
 
     self.params  = Card::Env # yuck!
@@ -33,54 +40,10 @@ class Card
       right && "*" == right[0, 1]
     end
 
-    def trait_name? *traitlist
-      junction? && begin
-        right_key = right_name.key
-        traitlist.find do |codename|
-          (card_id = Card::Codename[codename]) &&
-            (card = Card.quick_fetch card_id) &&
-            card.key == right_key
-        end.present?
-      end
-    end
-
-    def trait_name tag_code
-      (card_id = Card::Codename[tag_code]) &&
-        (card = Card.quick_fetch card_id) &&
-        [self, card.cardname].to_name
-    end
-
-    def trait tag_code
-      if (name = trait_name tag_code)
-        name.s
-      else
-        raise Card::Error::NotFound, "unknown codename: #{tag_code}"
-      end
-    end
-
-    def field tag_name
-      field_name(tag_name).s
-    end
-
     def code
       Card::Codename[Card.fetch_id self]
     end
 
-    # returns full name for a field
-    def field_name tag_name
-      case tag_name
-      when Symbol
-        trait_name tag_name
-      else
-        tag_name = tag_name.to_s[1..-1] if tag_name.to_s[0] == "+"
-        [self, tag_name].to_name
-      end
-    end
-
-    def relative_field_name tag_name
-      field_name(tag_name).relative_name(self)
-    end
-
     def relative_name context_name
       to_show(*context_name.to_name.parts).to_name
     end
@@ -99,14 +62,6 @@ class Card
       end
     end
 
-    def field_of? context_name
-      if context_name.present?
-        child_of?(context_name) && relative_name(context_name).length == 2
-      else
-        s.match(/^\s*\+[^+]+$/)
-      end
-    end
-
     def setting?
       Set::Type::Setting.member_names[key]
     end
@@ -119,6 +74,10 @@ class Card
       s =~ RELATIVE_REGEXP || starts_with_joint?
     end
 
+    def simple_relative?
+      relative? && stripped.to_name.starts_with_joint?
+    end
+
     def absolute?
       !relative?
     end
@@ -134,5 +93,10 @@ class Card
     def to_sym
       s.to_sym
     end
+
+    # processes contextual title argument used in nests like "title: _left"
+    def title title_directive, context_names
+      title_directive.to_name.to_absolute_name(self).to_show(*context_names)
+    end
   end
 end

data/lib/card/name/fields_and_traits.rb

@@ -0,0 +1,67 @@
+class Card
+  class Name
+    # Name-based "Fields" are compound names in which the right name is treated
+    # as an attribute of the left.  (Eg MyName+address)
+    #
+    # "Traits" are the subset of fields in which the right name corresponds to a
+    # card with a codename
+    module FieldsAndTraits
+      # @return [String]
+      def field tag_name
+        field_name(tag_name).s
+      end
+
+      # @return [Card::Name]
+      def field_name tag_name
+        case tag_name
+        when Symbol
+          trait_name tag_name
+        else
+          tag_name = tag_name.to_s[1..-1] if tag_name.to_s[0] == "+"
+          [self, tag_name].to_name
+        end
+      end
+
+      # @return [True/False]
+      def field_of? context_name
+        if context_name.present?
+          child_of?(context_name) && relative_name(context_name).length == 2
+        else
+          s.match(/^\s*\+[^+]+$/).present?
+        end
+      end
+
+      def relative_field_name tag_name
+        field_name(tag_name).relative_name self
+      end
+
+      # @return [String]
+      def trait tag_code
+        name = trait_name tag_code
+        raise Card::Error::NotFound, "unknown codename: #{tag_code}" unless name
+        name.s
+      end
+
+      # @return [Card::Name]
+      def trait_name tag_code
+        return unless (card_id = Card::Codename[tag_code])
+        [self, Card.quick_fetch(card_id).name].to_name
+      end
+
+      # @return [True/False]
+      def trait_name? *traitlist
+        junction? && begin
+          right_key = right_name.key
+          traitlist.find do |codename|
+            (card_id = Card::Codename[codename]) &&
+              (card = Card.quick_fetch card_id) &&
+              card.key == right_key
+          end.present?
+        end
+      end
+
+
+
+    end
+  end
+end

data/lib/card/name/variants.rb

@@ -0,0 +1,17 @@
+class Card
+  class Name
+    module Variants
+      @@variant_methods = [:capitalize, :singularize, :pluralize, :titleize,
+                           :downcase, :upcase, :swapcase, :reverse, :succ]
+      @@variant_aliases = { capitalized: :capitalize, singular: :singularize,
+                            plural: :pluralize,       title: :titleize }
+
+      def vary variants
+        variants.to_s.split(/[\s,]+/).inject(self.s) do |name, variant|
+          variant = @@variant_aliases[variant.to_sym] || variant.to_sym
+          @@variant_methods.include?(variant) ? name.send(variant) : name
+        end
+      end
+    end
+  end
+end

data/lib/card/query.rb

@@ -81,7 +81,7 @@ class Card
     DEFAULT_ORDER_DIRS = { update: "desc", relevance: "desc" }.freeze
 
     attr_reader :statement, :mods, :conditions, :comment,
-                :subqueries, :superquery
+                :subqueries, :superquery, :vars
     attr_accessor :joins, :table_seq, :unjoined, :conditions_on_join
 
     # Query Execution
@@ -121,7 +121,7 @@ class Card
     # run the current query
     # @return array of card objects by default
     def run
-      retrn = statement[:return].present? ? statement[:return].to_s : "card"
+      retrn ||= statement[:return].present? ? statement[:return].to_s : "card"
       if retrn == "card"
         get_results("name").map do |name|
           Card.fetch name, new: {}
@@ -180,5 +180,9 @@ class Card
         @context = @superquery ? @superquery.context : ""
       end
     end
+
+    def limit
+      @mods[:limit].to_i
+    end
   end
 end

data/lib/card/query/attributes.rb

@@ -8,7 +8,7 @@ class Card
             # FIXME: - move this check to set mods!
 
             subquery(
-              c.get_query.merge(unjoined: true, context: c.name)
+              c.wql_hash.merge(unjoined: true, context: c.name)
             )
           else
             raise Card::Error::BadQuery,

data/lib/card/query/interpretation.rb

@@ -49,9 +49,9 @@ class Card
 
       def clause_to_hash clause
         case clause
-        when Hash    then clause
-        when String  then { key: clause.to_name.key }
-        when Integer then { id: clause }
+        when Hash              then clause
+        when String, SmartName then { key: clause.to_name.key }
+        when Integer           then { id: clause }
         else raise Card::Error::BadQuery, "Invalid query args #{clause.inspect}"
         end
       end

data/lib/card/set/event.rb

@@ -33,7 +33,8 @@ class Card
 
   def log_event_call event
     Rails.logger.debug "#{name}: #{event}"
-    # puts "#{Card::DirectorRegister.to_s}".green
+    # puts "#{name}: #{event}"
+    # puts "#{Card::ActManager.to_s}".green
   end
 
   module Set

data/lib/card/set/format.rb

@@ -85,16 +85,27 @@ class Card
         def view view, *args, &block
           view = view.to_viewname.key.to_sym
           views[self] ||= {}
-          view_block = views[self][view] =
-                         if block_given?
-                           Card::Format.extract_class_vars view, args[0]
-                           block
-                         else
-                           lookup_alias_block view, args
-                         end
+          interpret_view_opts view, args[0] if block_given?
+          view_block = views[self][view] = view_block view, args, &block
           define_method "_view_#{view}", view_block
         end
 
+        def interpret_view_opts view, opts
+          return unless opts.present?
+          Card::Format.interpret_view_opts view, opts
+          extract_view_cache_rules view, opts.delete(:cache)
+        end
+
+        def extract_view_cache_rules view, cache_rule
+          return unless cache_rule
+          methodname = Card::Format.view_cache_setting_method view
+          define_method(methodname) { cache_rule }
+        end
+
+        def view_block view, args, &block
+          block_given? ? block : lookup_alias_block(view, args)
+        end
+
         def lookup_alias_block view, args
           opts = args[0].is_a?(Hash) ? args.shift : { view: args.shift }
           opts[:mod] ||= self

data/lib/card/set_pattern.rb

@@ -169,13 +169,12 @@ EOF
       end
 
       def lookup_module_list modules_hash
-        if module_key
-          modules_hash[module_key]
-        else
-          inherited_key && modules_hash[inherited_key]
-        end
+        lookup_key = module_key || inherited_key
+        modules_hash[lookup_key] if lookup_key
       end
 
+      private
+
       def inherited_key
         if defined?(@inherited_key)
           @inherited_key
@@ -188,15 +187,20 @@ EOF
         return unless @inherit_card
         card = @inherit_card
         @inherit_card = nil
+        return unless (type_code = default_type_code card)
+        mod_key = "Type::#{type_code.to_s.camelize}"
+        mod_key if mods_exist_for_key? mod_key
+      end
+
+      def default_type_code card
+        default_rule = card.rule_card :default
+        default_rule && default_rule.type_code
+      end
 
-        (default_rule = card.rule_card(:default)) &&
-          (type_code = default_rule.type_code) &&
-          # default_rule.cardname.size > 2 and
-          # default_rule.left.right.codename == self.class.pattern_code
-          (mod_key = "Type::#{type_code.to_s.camelize}") &&
-          (Card::Set.modules[:nonbase_format].values +
-            [Card::Set.modules[:nonbase]]).any? { |hash| hash[mod_key] } &&
-          mod_key
+      def mods_exist_for_key? mod_key
+        list_of_hashes = Card::Set.modules[:nonbase_format].values
+        list_of_hashes << Card::Set.modules[:nonbase]
+        list_of_hashes.any? { |h| h[mod_key] }
       end
     end
   end

data/lib/card/tasks/card.rake

@@ -7,7 +7,7 @@ namespace :card do
 
   desc "merge all import card data into the the database"
   task merge_all: :environment do
-    Card::Migration::Import.merge true
+    Card::Migration::Import.merge all: true
   end
 
   desc "add card to import data"

data/lib/card/view.rb

@@ -0,0 +1,55 @@
+require_dependency "card/view/visibility"
+require_dependency "card/view/fetch"
+require_dependency "card/view/cache"
+require_dependency "card/view/stub"
+require_dependency "card/view/options"
+
+class Card
+  class View
+    include Visibility
+    include Fetch
+    include Cache
+    include Stub
+    include Options
+    extend Cache::ClassMethods
+
+    attr_reader :format, :parent, :card
+    attr_accessor :unsupported_view
+
+    def self.canonicalize view
+      return if view.blank? # error?
+      view.to_viewname.key.to_sym
+    end
+
+    def initialize format, view, raw_options={}, parent=nil
+      @format = format
+      @raw_view = view
+      @raw_options = raw_options
+      @parent = parent
+
+      @card = @format.card
+      normalize_options
+    end
+
+    # handle rendering, including optional visibility, permissions, and caching
+    def process
+      process_live_options
+      process_visibility_options
+      return if optional? && hide?(requested_view)
+      fetch { yield ok_view, foreign_live_options }
+    end
+
+    # the view to "attempt".  Typically the same as @raw_view, but @raw_view is
+    # often overridden for the main view (top view of the main card on a page)
+    def requested_view
+      @requested_view ||= View.canonicalize live_options[:view]
+    end
+
+    # the final view.  can be different from @requested_view when there are
+    # issues with permissions, recursions, unknown cards, etc.
+    def ok_view
+      @ok_view ||= format.ok_view requested_view,
+                                  normalized_options[:skip_perms]
+    end
+  end
+end

data/lib/card/view/cache.rb

@@ -0,0 +1,90 @@
+class Card
+  class View
+    # cache mechanics for view caching
+    module Cache
+      # adds tracking, mapping, and stub handling to standard cache fetching
+      def cache_fetch
+        cached_view = caching do
+          self.class.cache.fetch cache_key do
+            card.register_view_cache_key cache_key
+            yield
+          end
+        end
+
+        caching? ? cached_view : format.stub_render(cached_view)
+      end
+
+      # tracks that a cache fetch is in progress
+      def caching
+        self.class.caching(self) { yield }
+      end
+
+      # answers: should this cache fetch depend on one already in progress?
+      # Note that f you create a brand new format object (ie, not a subformat)
+      # midrender, (eg card.format...), it needs to be treated as unrelated to
+      # any caching in progress.
+      def caching?
+        deep_root? ? false : self.class.caching?
+      end
+
+      # neither view nor format has a parent
+      def deep_root?
+        !parent && !format.parent
+      end
+
+      def root
+        @root = parent ? parent.root : self
+      end
+
+      def cache_key
+        @cache_key ||= [
+          card.key, format.class, format.mode, options_for_cache_key
+        ].map(&:to_s).join "-"
+      end
+
+      def options_for_cache_key
+        hash_for_cache_key(live_options) + hash_for_cache_key(viz_hash)
+      end
+
+      def hash_for_cache_key hash
+        hash.keys.sort.map do |key|
+          option_for_cache_key key, hash[key]
+        end.join ";"
+      end
+
+      def option_for_cache_key key, value
+        string_value =
+          case value
+          when Hash then "{#{hash_for_cache_key value}}"
+          when Array then
+            # TODO: needs better handling of edit_structure
+            #       currently we pass complete structure as nested array
+            value.map do |item|
+              item.is_a?(Array) ? item.join(":") : item.to_s
+            end.sort.join ","
+          else value.to_s
+          end
+        "#{key}:#{string_value}"
+      end
+
+      # cache-related Card::View class methods
+      module ClassMethods
+        def cache
+          Card::Cache[Card::View]
+        end
+
+        def caching?
+          @caching
+        end
+
+        def caching voo
+          old_caching = @caching
+          @caching = voo
+          yield
+        ensure
+          @caching = old_caching
+        end
+      end
+    end
+  end
+end