card 1.104.2 → 1.105.0

data/lib/card/model/save_helper/save_arguments.rb

@@ -14,16 +14,6 @@ class Card
           end
         end
 
-        def standardize_ensure_args name_or_args, content_or_args
-          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
           return name_or_args if name_or_args.is_a?(Hash)
 
@@ -56,40 +46,6 @@ class Card
 
           args[:name] = Card.uniquify_name args[:name], rename
         end
-
-        def ensure_attributes card, args
-          subcards = card.extract_subcard_args! args.symbolize_keys!
-          update_args = changing_args card, args
-
-          return if update_args.empty? && subcards.empty?
-
-          # FIXME: use ensure_attributes for subcards
-          card.update! update_args.merge(subcards: subcards, skip: :validate_renaming)
-        end
-
-        def changing_args card, args
-          args.select do |key, value|
-            case key.to_s
-            when /^\+/
-              changing_field_arg key, value
-            when /name$/
-              card.send(key).to_s != value
-            else
-              standard_changing_arg card, key, value
-            end
-          end
-        end
-
-        def changing_field_arg key, value
-          subfields[key] = value
-          false
-        end
-
-        def standard_changing_arg card, key, value
-          return true if value.is_a? ::File
-
-          card.send(key) != value
-        end
       end
     end
   end

data/lib/card/model/save_helper/save_helper_helper.rb

@@ -17,14 +17,6 @@ class Card
           Card.exist? name
         end
 
-        def add_coderule_item name, prefix, type_id, to
-          codename = "#{prefix}_#{name.tr(' ', '_').underscore}"
-          name = "#{prefix}: #{name}"
-
-          ensure_card name, type_id: type_id, codename: codename
-          Card[to].add_item! name
-        end
-
         def method_missing method, *args
           method_name, cardtype_card = extract_cardtype_from_method_name method
           return super unless method_name
@@ -51,35 +43,6 @@ class Card
           Card::Codename[type.to_sym] ? Card[type.to_sym] : Card[type]
         end
 
-        def ensure_card_simplified name, args
-          ensure_card_update(name, args) || Card.create!(add_name(name, args))
-        end
-
-        def ensure_card_update name, args
-          card = Card[name]
-          return unless card
-
-          ensure_attributes card, args
-          card
-        rescue Card::Error::CodenameNotFound => _e
-          false
-        end
-
-        def validate_setting setting
-          return if Codename.exist?(setting) && Card.fetch_type_id(setting) == SettingID
-
-          raise ArgumentError, "not a valid setting: #{setting}"
-        end
-
-        def normalize_trait_rule_args setting, value
-          return value if value.is_a? Hash
-
-          if Card.fetch_type_id([setting, :right, :default]) == PointerID
-            value = Array(value).to_pointer_content
-          end
-          { content: value }
-        end
-
         def add_name name, content_or_args
           if content_or_args.is_a?(Hash)
             content_or_args.reverse_merge name: name

data/lib/card/model/save_helper.rb

@@ -37,18 +37,6 @@ class Card
         update_card name, args.reverse_merge(rename_if_conflict: :new)
       end
 
-      def create_or_update_card name_or_args, content_or_args=nil
-        name = name_from_args name_or_args
-
-        if Card[name]
-          args = standardize_update_args name_or_args, content_or_args
-          update_card(name, args)
-        else
-          args = standardize_args name_or_args, content_or_args
-          create_card(args)
-        end
-      end
-
       def delete_card name
         return unless Card.exist?(name)
 
@@ -63,80 +51,10 @@ class Card
         card.delete!
       end
 
-      # create if card doesn't exist
-      # updates existing card only if given attributes are different except the
-      # name
-      # @example if a card with name "under_score" exists
-      #   ensure_card "Under Score"                 # => no change
-      #   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, 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] = codename_from_name(name) unless args[:codename]
-        ensure_card_simplified name, args
-      end
-
-      # create if card doesn't exist
-      # updates existing card only if given attributes are different including
-      # the name
-      # 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, args = standardize_ensure_args name_or_args, content_or_args
-        ensure_card_simplified name, add_name(name, args)
-      end
-
-      # Creates or updates a trait card with codename and right rules.
-      # Content for rules that are pointer cards by default
-      # is converted to pointer format.
-      # @example
-      #   ensure_trait "*a_or_b", :a_or_b,
-      #                default: { type_id: Card::PointerID },
-      #                options: ["A", "B"],
-      #                input: "radio"
-      def ensure_trait name, codename, args={}
-        ensure_card name, codename: codename
-        args.each do |setting, value|
-          ensure_trait_rule name, setting, value
-        end
-      end
-
-      def ensure_trait_rule trait, setting, value
-        validate_setting setting
-        card_args = normalize_trait_rule_args setting, value
-        ensure_card [trait, :right, setting], card_args
-      end
-
-      def create_or_update_card! name_or_args, content_or_args=nil
-        args = standardize_args name_or_args, content_or_args
-        create_or_update args.reverse_merge(rename_if_conflict: :new)
-      end
-
-      # TODO: this is too specific for this
-      def add_script name, opts={}
-        name.sub!(/^script:?\s?/, "") # in case name is given with prefix
-        # remove it so that we don't double it
-
-        add_coderule_item name, "script",
-                          opts[:type_id] || Card::CoffeeScriptID,
-                          opts[:to] || "*all+*script"
-      end
-
       alias_method :create, :create_card
       alias_method :update, :update_card
-      alias_method :create_or_update, :create_or_update_card
       alias_method :create!, :create_card!
       alias_method :update!, :update_card!
-      alias_method :create_or_update!, :create_or_update_card!
-      alias_method :ensure, :ensure_card
-      alias_method :ensure!, :ensure_card!
       alias_method :delete, :delete_card
     end
   end

data/lib/card/name/all.rb

@@ -11,6 +11,7 @@ class Card
       def name
         @name ||= left_id ? Lexicon.lex_to_name([left_id, right_id]) : super.to_name
       end
+      alias_method :cardname, :name
 
       def key
         @key ||= left_id ? name.key : super
@@ -71,10 +72,6 @@ class Card
         @key
       end
 
-      def field tag, opts={}
-        Card.fetch name.field(tag), opts
-      end
-
       private
 
       def assign_side_ids

data/lib/card/name/card_class.rb

@@ -17,8 +17,6 @@ class Card
         name
       end
 
-      private
-
       def generate_alternative_name name
         uniq_name = "#{name} 1"
         uniq_name.next! while Card.exists?(uniq_name)

data/lib/card/name/name_variants.rb

@@ -34,6 +34,10 @@ class Card
       def codename_or_string
         codename || s
       end
+
+      def alternative
+        Card.generate_alternative_name self
+      end
     end
   end
 end

data/lib/card/name.rb

@@ -10,7 +10,6 @@ class Card
   #
   # Card::Name adds support for deeper card integration
   class Name < Cardname
-    include FieldsAndTraits
     include NameVariants
 
     class << self
@@ -72,9 +71,5 @@ class Card
     def rstar?
       right && right[0, 1] == "*"
     end
-
-    def code
-      Card::Codename[card_id]
-    end
   end
 end

data/lib/card/query/abstract_query/query_helper.rb

@@ -23,15 +23,13 @@ class Card
             if fasten == :direct
               @superquery.table_alias
             else
-              "#{table_prefix}#{next_table_suffix}"
+              "#{table_prefix}#{root.table_seq}#{@table_suffix}"
             end
           end
         end
 
-        def next_table_suffix
-          return root.next_table_suffix unless root?
-
-          @table_suffix = (@table_suffix || -1) + 1
+        def table_seq
+          @table_seq = @table_seq ? (@table_seq + 1) : 0
         end
 
         def fld field_name

data/lib/card/query/abstract_query/tie.rb

@@ -84,7 +84,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
             tie :card, val, from: id_field

data/lib/card/query/abstract_query.rb

@@ -17,7 +17,9 @@ class Card
       include QueryHelper
       include Tie
 
-      attr_reader :statement, :mods, :conditions, :vars,
+      ROOT_VAR_DEFAULTS = { vars: {}, table_suffix: "" }.freeze
+
+      attr_reader :statement, :mods, :conditions, :vars, :table_suffix,
                   :subqueries, :superquery, :comment, :negate
       attr_accessor :joins, :conditions_on_join
 
@@ -29,23 +31,10 @@ class Card
 
         @statement = statement.clone
         init_instance_vars :context, :superquery, :fasten, :negate
-        @vars = init_query_vars
+        init_root_vars
         table_alias
       end
 
-      def init_instance_vars *varnames
-        varnames.each do |varname|
-          instance_variable_set "@#{varname}", (@statement.delete(varname) || nil)
-        end
-      end
-
-      def init_query_vars
-        if (v = @statement.delete :vars) then v.symbolize_keys
-        elsif @superquery                then @superquery.vars
-        else                                  {}
-        end
-      end
-
       def interpret hash
         hash.each do |action, card|
           send action, card
@@ -57,11 +46,17 @@ class Card
       end
 
       def sql
-        @sql ||= Query::SqlStatement.new(self).build.to_s
+        @sql ||= sql_statement.build.to_s
+      end
+
+      def sql_statement
+        SqlStatement.new self
       end
 
       def root
-        @root ||= @superquery ? @superquery.root : self
+        return @root unless @root.nil?
+
+        @root = @superquery ? @superquery.root : self
       end
 
       def root?
@@ -90,6 +85,30 @@ class Card
                    else                        superquery.depth + 1
                    end
       end
+
+      private
+
+      def init_instance_vars *varnames
+        varnames.each do |varname|
+          instance_variable_set "@#{varname}", (@statement.delete(varname) || nil)
+        end
+      end
+
+      def init_root_vars
+        ROOT_VAR_DEFAULTS.each do |varname, default|
+          val = root_var_value varname, default
+          val = val.symbolize_keys if varname == :vars
+          instance_variable_set "@#{varname}", val
+        end
+      end
+
+      def root_var_value varname, default
+        if root?
+          @statement.delete(varname) || default
+        else
+          root.send varname
+        end
+      end
     end
   end
 end

data/lib/card/query/card_class.rb

@@ -0,0 +1,36 @@
+class Card
+  module Query
+    module CardClass
+      def search spec, comment=nil, &block
+        results = ::Card::Query.run(spec, comment)
+        results.each(&block) if block_given? && results.is_a?(Array)
+        results
+      end
+
+      def count_by_cql spec
+        spec = spec.clone
+        spec.delete(:offset)
+        search spec.merge(return: "count")
+      end
+
+      def find_each **options, &block
+        # this is a copy from rails (3.2.16) and is needed because this
+        # is performed by a relation (ActiveRecord::Relation)
+        find_in_batches(**options) do |records|
+          records.each(&block)
+        end
+      end
+
+      def find_in_batches **options
+        if block_given?
+          super do |records|
+            yield(records)
+            Card::Cache.reset_soft
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+class Card
+  module Query
+    class CardQuery
+      # for query attributes requiring custom handling
+      module Custom
+        def compound val
+          add_condition "left_id IS #{'NOT' if val} NULL"
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ class Card
         INTERPRET_METHOD = { basic: :add_condition,
                              relational: :relate,
                              plus_relational: :relate_compound,
+                             custom: :send,
                              conjunction: :send }.freeze
 
         # normalize and extract meaning from a clause

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

@@ -3,6 +3,14 @@ class Card
     class CardQuery
       # normalize clause's keys and values.
       module Normalization
+        private
+
+        OK_VALUE_CLASSES = [
+          Integer, Float, Hash, Symbol,
+          TrueClass, FalseClass, NilClass,
+          ActiveRecord::Relation
+        ].freeze
+
         def normalize_clause clause
           clause = clause_to_hash clause
           clause.symbolize_keys!
@@ -28,9 +36,9 @@ class Card
 
         def normalize_value val
           case val
-          when Integer, Float, Hash, Symbol, NilClass, ActiveRecord::Relation then val
-          when String                                 then normalize_string_value val
-          when Array                                  then normalize_array_value val
+          when String            then normalize_string_value val
+          when Array             then normalize_array_value val
+          when *OK_VALUE_CLASSES then val
           else raise Error::BadQuery, "Invalid value type: #{val.class} (#{val.inspect})"
           end
         end

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

@@ -33,11 +33,12 @@ class Card
         # DEPRECATE?
 
         def member_of val
-          interpret right_plus: [Card::RolesID, { refer_to: val }]
+          interpret referred_to_by: { left: val, right: { codename: "members" } }
         end
 
         def member val
-          interpret referred_to_by: { left: val, right: Card::RolesID }
+          interpret type_id: Card::RoleID,
+                    right_plus: [{ codename: "members" }, refer_to: val]
         end
       end
     end

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

@@ -2,6 +2,7 @@ class Card
   module Query
     class CardQuery
       # handle relational (not simple) CQL sort values
+      # (see #interpret_as_modifier? and #order_directives)
       #
       # sorting with subqueries is not fully supported; only a few experimental
       # examples have been attempted, and even for those the syntax is likely
@@ -14,7 +15,7 @@ class Card
         SORT_BY_ITEM_JOIN_MAP = { left: "left_id", right: "right_id" }.freeze
 
         def sort val
-          return nil unless full?
+          return nil unless full? # eg, no sorting on simple count queries
 
           interpret_sort_hash val do |value, item, sort_field|
             sort_by value, item, sort_field
@@ -34,7 +35,7 @@ class Card
           join = join_cards val, to_field: join_field,
                                  side: "LEFT",
                                  conditions_on_join: true
-          @mods[:sort] ||= "#{join.table_alias}.#{sort_field}"
+          @mods[:sort_by] ||= "#{join.table_alias}.#{sort_field}"
         end
 
         def sort_by_item_join_field item
@@ -42,7 +43,7 @@ class Card
         end
 
         # EXPERIMENTAL!
-        # sort: { referred_to_by { right: "*follow" }, return count }
+        # sort_by: { referred_to_by { right: "*follow" }, return count }
 
         def sort_by_count val, item
           method_name = "sort_by_count_#{item}"
@@ -55,7 +56,7 @@ class Card
         end
 
         def sort_by_count_referred_to val
-          @mods[:sort] = "coalesce(count,0)" # needed for postgres
+          @mods[:sort_by] = "coalesce(count,0)" # needed for postgres
           sort_query = count_sort_query
           sort_query.add_condition "referer_id in (#{count_subselect(val).sql})"
           # FIXME: - SQL generated before SQL phase

data/lib/card/query/card_query.rb

@@ -12,6 +12,7 @@ class Card
       include Normalization
       include Sorting
       include Conjunctions
+      include Custom
       # Query Execution
 
       # By default a query returns card objects. This is accomplished by returning

data/lib/card/query/sql_statement/order.rb

@@ -1,8 +1,8 @@
 class Card
   module Query
     # convert @query sort rep into order by statement
-    # order information is stored in @mods[:sort], @mods[:sort_as], and
-    # @mods[:dir]
+    # order information is stored in @mods[:sort_by], @mods[:sort_as], and
+    # @mods[:sort_dir]
     class SqlStatement
       ORDER_MAP = {
         "id" => "id",
@@ -24,17 +24,18 @@ class Card
         end
 
         def order_directives
-          return if @mods[:sort].blank?
+          sort_mod = @mods[:sort_by] || @mods[:sort]
+          return if sort_mod.blank?
 
-          Array.wrap(@mods[:sort]).map do |order_key|
-            order_directive order_key
+          Array.wrap(sort_mod).map.with_index do |order_key, index|
+            order_directive order_key, index
           end
         end
 
-        def order_directive order_key
+        def order_directive order_key, index
           field = order_field order_key
           @fields += ", #{field}"
-          "#{field} #{order_dir order_key}"
+          "#{field} #{order_dir order_key, index}"
         end
 
         def order_field order_key
@@ -54,11 +55,12 @@ class Card
           "CAST(#{field} AS #{cast_type(safe_sql(as))})"
         end
 
-        def order_dir order_key
-          if @mods[:dir].blank?
+        def order_dir order_key, index
+          dir = @mods[:sort_dir] || @mods[:dir] # dir is DEPRECATED
+          if dir.blank?
             DEFAULT_ORDER_DIRS[order_key.to_sym] || "asc"
           else
-            safe_sql @mods[:dir]
+            safe_sql Array.wrap(dir)[index]
           end
         end
       end

data/lib/card/query/sql_statement/where.rb

@@ -3,10 +3,10 @@ class Card
     class SqlStatement
       # handle where clause in SqlStatement
       module Where
-        def where
+        def where explicit=true
           conditions = [explicit_conditions(@query), implicit_conditions(@query)]
           conditions = conditions.reject(&:blank?).join " AND "
-          "WHERE #{conditions}" unless conditions.blank?
+          "#{'WHERE ' if explicit}#{conditions}" unless conditions.blank?
         end
 
         # conditions explicitly specified in the query object

data/lib/card/query.rb

@@ -68,6 +68,7 @@ class Card
 
       plus_relational: %i[plus left_plus right_plus],
       conjunction: %i[and or all any],
+      custom: [:compound],
       ignore: %i[prepend append vars],
       deprecated: %i[view params size]
     }.each_with_object({}) do |pair, h|
@@ -76,7 +77,10 @@ class Card
 
     CONJUNCTIONS = { any: :or, in: :or, or: :or, all: :and, and: :and }.freeze
 
-    MODIFIERS = %i[conj return sort sort_as group dir limit offset]
+    # "dir" is DEPRECATED in favor of sort_dir
+    # "sort" is DEPRECATED in favor of sort_by, except in cases where sort's value
+    # is a hash
+    MODIFIERS = %i[conj return sort_by sort_as sort_dir sort dir group limit offset]
                 .each_with_object({}) { |v, h| h[v] = nil }
 
     OPERATORS =

data/lib/card/reference/all.rb

@@ -73,16 +73,6 @@ class Card
 
       private
 
-      def with_normalized_referee referee_name
-        return unless referee_name # eg commented nest has no referee_name
-
-        referee_name = referee_name.to_name
-        referee_key = referee_name.key
-        return if referee_key == key # don't create self reference
-
-        yield referee_name, referee_key, Lexicon.id(referee_name)
-      end
-
       # interpretation phase helps to prevent duplicate references
       # results in hash like:
       # { referee1_key: [referee1_id, referee1_type2],
@@ -96,6 +86,16 @@ class Card
         end
       end
 
+      def with_normalized_referee referee_name
+        return unless referee_name # eg commented nest has no referee_name
+
+        referee_name = referee_name.to_name
+        referee_key = referee_name.key
+        return if referee_key == key # don't create self reference
+
+        yield referee_name, referee_key, Lexicon.id(referee_name)
+      end
+
       # translate interpreted reference hash into values array,
       # removing duplicate and unnecessary ref_types
       def reference_values_array ref_hash

data/lib/card/set/advanced_api.rb

@@ -4,7 +4,7 @@ class Card
     module AdvancedApi
       def assign_type type, module_key=nil
         module_key ||= shortname
-        Type.assignment[module_key] = type.card_id
+        Type.assignment[module_key] = type
       end
 
       def setting_opts opts