card 1.96.1 → 1.96.2

data/lib/card/format/nesting/mode.rb

@@ -78,7 +78,7 @@ class Card
         # @return [Symbol] viewname
         def configured_view_in_closed_mode view
           closed_config = Card::Format.closed[view]
-          return view if closed_config == true || Card::Format.error_code[view]
+          return view if closed_config == true
           closed_config
         end
       end

data/lib/card/format/permission.rb

@@ -2,11 +2,9 @@ class Card
   class Format
     module Permission
       def ok_view view, skip_perms=false
-        return :too_deep if subformats_nested_too_deeply?
+        raise Card::Error::UserError, tr(:too_deep) if subformats_nested_too_deeply?
         approved_view = check_view view, skip_perms
         handle_view_denial view, approved_view
-        assign_view_error_status approved_view
-
         approved_view
       end
 
@@ -15,12 +13,6 @@ class Card
         @denied_view = view
       end
 
-      def assign_view_error_status view
-        return unless focal?
-        return unless (error_code = Card::Format.error_code[view])
-        root.error_status = error_code
-      end
-
       def check_view view, skip_perms
         case
         when skip_perms                       then view
@@ -47,12 +39,17 @@ class Card
 
       def permitted_view view
         if (@denied_task = task_denied_for_view view)
-          Card::Format.denial[view] || :denial
+          deny_view view
         else
           view
         end
       end
 
+      def deny_view view
+        root.error_status = 403 if focal? && voo.root?
+        Card::Format.denial[view] || :denial
+      end
+
       def task_denied_for_view view
         perms_required = Card::Format.perms[view] || :read
         if perms_required.is_a? Proc
@@ -64,6 +61,7 @@ class Card
 
       def view_for_unknown _view
         # note: overridden in HTML
+        root.error_status = 404 if focal?
         focal? ? :not_found : :missing
       end
 

data/lib/card/format/render.rb

@@ -111,8 +111,7 @@ class Card
 
       def view_method view
         unless supports_view? view
-          voo.unsupported_view = view
-          view = :unsupported_view
+          raise Card::Error::UserError, unsupported_view_error_message(view)
         end
         method view_method_name(view)
       end

data/lib/card/model/save_helper.rb

@@ -60,8 +60,15 @@ class Card
       #   ensure_card "Under Score", type: :pointer # => changes the type to pointer
       #                                             #    but not the name
       def ensure_card name_or_args, content_or_args=nil
-        name = name_or_args.is_a?(Hash) ? name_or_args[:name] : name_or_args
-        args = standardize_ensure_args name_or_args, content_or_args
+        name, args = standardize_ensure_args name_or_args, content_or_args
+        ensure_card_simplified name, args
+      end
+
+      # like ensure_card but derives codename from name if no codename is given.
+      # The derived codename is all lower case with underscores; "*" and ":" are removed
+      def ensure_code_card name_or_args, content_or_args=nil
+        name, args = standardize_ensure_args name_or_args, content_or_args
+        args[:codename] = name.downcase.tr(" ", "_").tr(":*", "") unless args[:codename]
         ensure_card_simplified name, args
       end
 
@@ -71,8 +78,7 @@ class Card
       # For example if a card with name "under_score" exists
       # then `ensure_card "Under Score"` renames it to "Under Score"
       def ensure_card! name_or_args, content_or_args=nil
-        name = name_or_args.is_a?(Hash) ? args[:name] : name_or_args
-        args = standardize_ensure_args name_or_args, content_or_args
+        name, args = standardize_ensure_args name_or_args, content_or_args
         ensure_card_simplified name, add_name(name, args)
       end
 
@@ -221,11 +227,13 @@ class Card
       end
 
       def standardize_ensure_args name_or_args, content_or_args
-        if name_or_args.is_a?(Hash)
-          name_or_args
-        else
-          hashify content_or_args, :content
-        end
+        name = name_or_args.is_a?(Hash) ? name_or_args[:name] : name_or_args
+        args = if name_or_args.is_a?(Hash)
+                 name_or_args
+               else
+                 hashify content_or_args, :content
+               end
+        [name, args]
       end
 
       def standardize_update_args name_or_args, content_or_args
@@ -244,10 +252,10 @@ class Card
       end
 
       def add_name name, content_or_args
-        if content_or_args.is_a?(String)
-          { content: content_or_args, name: name }
-        else
+        if content_or_args.is_a?(Hash)
           content_or_args.reverse_merge name: name
+        else
+          { content: content_or_args, name: name }
         end
       end
 

data/lib/card/query.rb

@@ -54,7 +54,7 @@ class Card
                           member_of member
 
                           found_by not sort match name_match complete
-                          junction_complete extension_type],
+                          extension_type],
 
       plus_relational: %w[plus left_plus right_plus],
       conjunction:     %w[and or all any],

data/lib/card/query/card_query.rb

@@ -4,10 +4,10 @@ class Card
     class CardQuery < AbstractQuery
       include Clause
       include Run
-      include SpecialAttributes
+      include MatchAttributes
       include RelationalAttributes
       include ReferenceAttributes
-      include AttributeHelper
+      include FoundBy
       include Interpretation
       include Normalization
       include Sorting

data/lib/card/query/card_query/found_by.rb

@@ -0,0 +1,43 @@
+class Card
+  module Query
+    class CardQuery
+      # nest independent query
+      module FoundBy
+        def found_by val
+          found_by_cards(val).compact.each do |card|
+            subquery found_by_subquery(card)
+          end
+        end
+
+        private
+
+        def found_by_subquery card
+          found_by_statement(card).merge(fasten: :direct, context: card.name)
+        end
+
+        def found_by_statement card
+          card&.try(:wql_hash) || invalid_found_by_card!(card)
+        end
+
+        def invalid_found_by_card! card
+          raise Card::Error::BadQuery, '"found_by" value must be valid Search, ' \
+                                       "but #{card.name} is a #{card.type_name}"
+        end
+
+        def found_by_cards val
+          if val.is_a? Hash
+            Query.run val
+          else
+            fetch_found_by_cards val
+          end
+        end
+
+        def fetch_found_by_cards val
+          Array.wrap(val).map do |v|
+            Card.fetch v.to_name.absolute(context), new: {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/query/card_query/match_attributes.rb

@@ -0,0 +1,72 @@
+class Card
+  module Query
+    class CardQuery
+      # Implements the match attributes that match always against content and/or name.
+      # Currently that's different from the match operator that can be restricted to
+      # names or content.
+      # Example: { match: "name or content" } vs. { name: ["match", "a name"] }
+      # TODO: unify handling for both using full text indexing
+      module MatchAttributes
+        # match term anywhere in name or content
+        def match val
+          val.gsub!(/[^#{Card::Name::OK4KEY_RE}]+/, " ")
+          return nil if val.strip.empty?
+          val.gsub!("*", '\\\\\\\\*')
+          val_list = val.split(/\s+/).map do |v|
+            name_or_content_match v
+          end
+          add_condition and_join(val_list)
+        end
+
+        # match names beginning with term
+        def complete val
+          add_condition key_like("#{val.to_name.key}%", val =~ /\+/)
+        end
+
+        # match term anywhere in name
+        # DEPRECATE - move handling to name: ["match", val]
+        def name_match val
+          add_condition name_like(val)
+        end
+
+        private
+
+        def name_or_content_match val
+          cxn = connection
+          or_join([name_like(val), content_match(val, cxn)])
+        end
+
+        def name_like val
+          key_like "%#{val.to_name.key}%"
+        end
+
+        def content_match val, cxn
+          field_match "#{table_alias}.db_content", val, cxn
+        end
+
+        def field_match field, val, cxn
+          %(#{field} #{cxn.match quote("[[:<:]]#{val}[[:>:]]")})
+        end
+
+        # TODO: move sql to SqlStatement
+        def key_like pattern, no_junction=false
+          conds = ["#{table_alias}.key LIKE #{quote pattern}"]
+          conds << "#{table_alias}.right_id is null" if no_junction
+          # FIXME: -- this should really be more nuanced --
+          # it includes all descendants after one plus
+          conds.join " AND "
+        end
+
+        # TODO: use standard conjunction handling
+
+        def or_join conditions
+          "(#{Array(conditions).join ' OR '})"
+        end
+
+        def and_join conditions
+          "(#{Array(conditions).join ' AND '})"
+        end
+      end
+    end
+  end
+end

data/lib/card/query/card_query/relational_attributes.rb

@@ -70,6 +70,25 @@ class Card
         def plus val
           any(left_plus: val, right_plus: val.deep_clone)
         end
+
+        private
+
+        def tie_action action, val
+          tie :action, { action => val }, to: :card_id
+        end
+
+        def tie_act action, val
+          tie :act, { action => val }, to: :actor_id
+        end
+
+        def junction val, side, field
+          tie :card, junction_val(val, side), to: field
+        end
+
+        def junction_val val, side
+          part_clause, junction_clause = val.is_a?(Array) ? val : [val, {}]
+          clause_to_hash(junction_clause).merge side => part_clause
+        end
       end
     end
   end

data/lib/card/view.rb

@@ -14,7 +14,6 @@ class Card
     extend Cache::ClassMethods
 
     attr_reader :format, :parent, :card
-    attr_accessor :unsupported_view
 
     # @return [Symbol]
     def self.canonicalize view

data/lib/card/view/cache_action.rb

@@ -64,16 +64,7 @@ class Card
 
       # @return [Symbol]
       def active_cache_action
-        validate_active_cache_action do
-          active_cache_ok? ? active_cache_action_from_setting : :stub
-        end
-      end
-
-      # catch recursive views and invalid stubs
-      def validate_active_cache_action
-        ok_view == :too_deep ? :yield : yield
-        # FIXME: this allows "too deep" error to be cached inside another view.
-        # may need a "raise" cache action?
+        active_cache_ok? ? active_cache_action_from_setting : :stub
       end
 
       # @return [True/False]

data/mod/account/set/right/token.rb

@@ -49,8 +49,6 @@ def term_from_string string
   return "permanent" if string == "none"
   re_match = /^(\d+)[\.\s]*(#{DURATIONS})s?$/.match(string)
   number, unit = re_match.captures if re_match
-  unless unit
-    raise Card::Error::BadContent, tr(:exception_bad_expiration, example: '2 days')
-  end
+  raise Card::Open::Error, tr(:exception_bad_expiration, example: '2 days') unless unit
   number.to_i.send unit
 end

data/mod/account/set/self/account_links.rb

@@ -1,7 +1,15 @@
 
 format :html do
+  view :core, cache: :never do
+    status_class = Auth.signed_in? ? "logged-in" : "logged-out"
+    wrap_with :span, id: "logging", class: status_class do
+      item_links.join " "
+    end
+  end
+
   def item_links _args=nil
-    %i[my_card invite sign_out sign_up sign_in].map do |link_view|
+    # removed invite for now
+    %i[my_card sign_out sign_up sign_in].map do |link_view|
       render link_view
     end.compact
   end
@@ -44,21 +52,10 @@ format :html do
       I18n.t(purpose, scope: "mod.account.set.self.account_links")
   end
 
-  view :raw do
-    item_links.join " "
-  end
-
   def nav_link_class type
     "nav-link #{classy(type)}"
   end
 
-  view :core, cache: :never do
-    status_class = Auth.signed_in? ? "logged-in" : "logged-out"
-    wrap_with :span, id: "logging", class: status_class do
-      render_raw
-    end
-  end
-
   def show_signup_link?
     !Auth.signed_in? && Card.new(type_id: Card::SignupID).ok?(:create)
   end

data/mod/basic_formats/set/all/json.rb

@@ -4,14 +4,12 @@ format :json do
     uniq_nested_cards
   end
 
-  AUTOCOMPLETE_LIMIT = 8 # number of name suggestions for autocomplete text fields
-
   def default_nest_view
     :atom
   end
 
   def default_item_view
-    params[:item] || :atom
+    params[:item] || :name
   end
 
   def max_depth
@@ -29,30 +27,6 @@ format :json do
     JSON.send method, raw
   end
 
-  # TODO: design better autocomplete API
-  # view :name_complete, cache: :never do
-  #   name_search
-  # end
-
-  view :name_complete, cache: :never do
-    name_search query_attribute: :junction_complete
-  end
-
-  view :name_match, cache: :never do
-    starts_with = name_search query_attribute: :junction_complete
-    remaining_slots = AUTOCOMPLETE_LIMIT - starts_with.size
-    return starts_with if remaining_slots.zero?
-    starts_with + name_search(query_attribute: :name_match,
-                              limit: remaining_slots)
-  end
-
-  def name_search query_attribute: :complete, limit: AUTOCOMPLETE_LIMIT
-    card.search limit: limit,
-                sort: "name",
-                return: "name",
-                query_attribute => params[:term]
-  end
-
   view :status, tags: :unknown_ok, perms: :none, cache: :never do
     status = card.state
     hash = { key: card.key,
@@ -68,36 +42,31 @@ format :json do
       card: _render_atom }
   end
 
-  view :content do
-    render_page
-  end
-
   view :core do
-    { card.name => card.content }
+    card.known? ? render_content : nil
+  end
+  view :content do
+    card.content
   end
 
   view :nucleus, cache: :never do
-    {
-      id: card.id,
-      name: card.name,
-      url: path(format: :json),
-      html_url: path
-    }
+    h = { id: card.id,
+          name: card.name,
+          type: card.type_name,
+          url: path(format: :json) }
+    h[:codename] = card.codename if card.codename
+    h
   end
 
-  view :atom, cache: :never do
+  # TODO: add simple values for fields
+  view :atom, cache: :never, tags: :unknown_ok do
     h = _render_nucleus
-    h[:type] = card.type_name
-    h[:type_url] = path mark: card.type_name, format: :json
-    h[:atom_url] = path format: :json, view: :atom
-    h[:nucleus_url] = path format: :json, view: :nucleus
-    h[:content] = card.db_content unless card.structure
-    h[:codename] = card.codename if card.codename
+    h[:content] = render_content if card.known? && !card.structure
     h
   end
 
   view :items, cache: :never do
-    listing item_cards
+    listing item_cards, view: :atom
   end
 
   view :links, cache: :never do
@@ -112,14 +81,16 @@ format :json do
 
   view :ancestors, cache: :never do
     card.name.ancestors.map do |name|
-      nest name
+      nest name, view: :nucleus
     end
   end
 
   view :molecule, cache: :never do
     _render_atom.merge items: _render_items,
                        links: _render_links,
-                       ancestors: _render_ancestors
+                       ancestors: _render_ancestors,
+                       html_url: path,
+                       type: nest(card.type_card, view: :nucleus)
 
   end
 
@@ -137,12 +108,6 @@ format :json do
     }
   end
 
-  view :export_item do
-    item = { name: card.name, type: card.type_name, content: card.content }
-    item[:codename] = card.codename if card.codename
-    item
-  end
-
   view :essentials do
     if voo.show? :marks
       render_marks.merge(essentials)