card 1.16.6 → 1.16.7

data/lib/card/env.rb

@@ -7,7 +7,7 @@ class Card
   module Env
     class << self
       def reset args={}
-        @@env = { :main_name => nil }
+        @@env = { main_name: nil }
 
         if c = args[:controller]
           self[:controller] = c

data/lib/card/format.rb

@@ -4,9 +4,9 @@ class Card
   class Format
     include Card::Location
 
-    DEPRECATED_VIEWS = { :view=>:open, :card=>:open, :line=>:closed, :bare=>:core, :naked=>:core }
-    INCLUSION_MODES  = { :closed=>:closed, :closed_content=>:closed, :edit=>:edit,
-      :layout=>:layout, :new=>:edit, :setup=>:edit, :normal=>:normal, :template=>:template } #should be set in views
+    DEPRECATED_VIEWS = { view: :open, card: :open, line: :closed, bare: :core, naked: :core }
+    INCLUSION_MODES  = { closed: :closed, closed_content: :closed, edit: :edit,
+      layout: :layout, new: :edit, setup: :edit, normal: :normal, template: :template } #should be set in views
 
     cattr_accessor :ajax_call, :registered
     [ :perms, :denial_views, :closed_views, :error_codes, :view_tags, :aliases ].each do |acc|
@@ -122,7 +122,7 @@ class Card
     end
 
     def get_inclusion_defaults nested_card
-      { :view => :name }
+      { view: :name }
     end
 
     def params
@@ -168,7 +168,7 @@ class Card
     def template
       @template ||= begin
         c = controller
-        t = ActionView::Base.new c.class.view_paths, {:_routes=>c._routes}, c
+        t = ActionView::Base.new c.class.view_paths, {_routes: c._routes}, c
         t.extend c.class._helpers
         t
       end
@@ -179,7 +179,7 @@ class Card
       when /(_)?(optional_)?render(_(\w+))?/
         view = $3 ? $4 : opts.shift
         args = opts[0] ? opts.shift.clone : {}
-        args.merge!( :optional=>true, :default_visibility=>opts.shift) if $2
+        args.merge!( optional: true, default_visibility: opts.shift) if $2
         args[ :skip_permissions ] = true if $1
         render view, args
       when /^_view_(\w+)/
@@ -299,11 +299,11 @@ class Card
     #
 
     def subformat subcard
-      subcard = Card.fetch( subcard, :new=>{} ) if String===subcard
-      sub = self.class.new subcard, :parent=>self, :depth=>@depth+1, :root=>@root,
+      subcard = Card.fetch( subcard, new: {} ) if String===subcard
+      sub = self.class.new subcard, parent: self, depth: @depth+1, root: @root,
         # FIXME - the following four should not be hard-coded here.  need a generalized mechanism
         # for attribute inheritance
-        :context_names=>@context_names, :mode=>@mode, :mainline=>@mainline, :form=>@form
+        context_names: @context_names, mode: @mode, mainline: @mainline, form: @form
     end
 
 
@@ -433,7 +433,7 @@ class Card
       end
 
       if val=params[:item] and val.present?
-        opts[:items] = (opts[:items] || {}).reverse_merge :view=>val.to_sym
+        opts[:items] = (opts[:items] || {}).reverse_merge view: val.to_sym
       end
     end
 
@@ -492,7 +492,7 @@ class Card
     end
 
     def fetch_nested_card options
-      args = { :name=>options[:inc_name], :type=>options[:type], :supercard=>card }
+      args = { name: options[:inc_name], type: options[:type], supercard: card }
       args.delete(:supercard) if options[:inc_name].strip.blank? # special case.  gets absolutized incorrectly. fix in smartname?
       if options[:inc_name] =~ /^_main\+/
         # FIXME this is a rather hacky (and untested) way to get @superleft to work on new cards named _main+whatever
@@ -502,7 +502,7 @@ class Card
       if content=get_inclusion_content(options[:inc_name])
         args[:content]=content
       end
-      Card.fetch options[:inc_name], :new=>args
+      Card.fetch options[:inc_name], new: args
     end
 
     def default_item_view

data/lib/card/loader.rb

@@ -133,7 +133,7 @@ class Card
         if rewrite_tmp_files?
           p = Card.paths[ path ]
           if p.existent.first
-            FileUtils.rm_rf p.first, :secure=>true
+            FileUtils.rm_rf p.first, secure: true
           end
           Dir.mkdir p.first
         end

data/lib/card/migration.rb

@@ -78,7 +78,7 @@ class Card::Migration < ActiveRecord::Migration
 
   def import_json filename, merge_opts={}
     Card.config.action_mailer.perform_deliveries = false
-    merge_opts.reverse_merge! :output_file=>File.join(data_path,"unmerged_#{ filename }")
+    merge_opts.reverse_merge! output_file: File.join(data_path,"unmerged_#{ filename }")
     Card.merge_list read_json(filename), merge_opts
   end
 

data/lib/card/name.rb

@@ -22,14 +22,14 @@ class Card
       junction? && begin
         right_key = right_name.key
         !!traitlist.find do |codename|
-          card_id = Card::Codename[ codename ] and card = Card.fetch( card_id, :skip_modules=>true, :skip_virtual=>true ) and
+          card_id = Card::Codename[ codename ] and card = Card.fetch( card_id, skip_modules: true, skip_virtual: true ) and
             card.key == right_key
         end
       end
     end
 
     def trait_name tag_code
-      card_id = Card::Codename[ tag_code ] and card = Card.fetch( card_id, :skip_modules=>true, :skip_virtual=>true ) and
+      card_id = Card::Codename[ tag_code ] and card = Card.fetch( card_id, skip_modules: true, skip_virtual: true ) and
         [ self, card.cardname ].to_name
     end
 
@@ -53,11 +53,11 @@ class Card
         self.s.match /^\s*\+/
       end
     end
-    
+
     def is_setting?
       Set::Type::Setting.member_names[ key ]
     end
-    
+
     def is_set?
       SetPattern.card_keys[ tag_name.key ]
     end

data/lib/card/query.rb

@@ -1,91 +1,285 @@
 # -*- encoding : utf-8 -*-
 
-class Card::Query
-  require_dependency 'card/query/clause'
-  require_dependency 'card/query/card_clause'
-  require_dependency 'card/query/value_clause'
-  require_dependency 'card/query/ref_clause'
+class Card
+  # Card::Query is for finding implicit lists (or counts of lists) of cards.
+  #
+  # Search and Set cards use Card::Query to query the database, and it's also
+  # frequently used directly in code.
+  #
+  # Query "statements" (objects, really) are made in WQL (Wagn Query
+  # Language). Because WQL is used by Wagneers, the primary language
+  # documentation is on wagn.org. (http://wagn.org/WQL_Syntax). Note that the
+  # examples there are in JSON, like Search card content, but statements in
+  # Card::Query are in ruby form.
+  #
+  # In Wagn's current form, Card::Query generates and executes SQL statements.
+  # However, the SQL generation is largely (not yet fully) separated from the
+  # WQL statement interpretation.
+  #
+  # The most common way to use Card::Query is as follows:
+  #     list_of_cards = Card::Query.run(statement)
+  #
+  # This is equivalent to:
+  #     query = Card::Query.new(statement)
+  #     list_of_cards = query.run
+  #
+  # Upon initiation, the query is interpreted, and the following key objects
+  # are populated:
+  #
+  # - @join - an Array of Card::Query::Join objects
+  # - @conditions - an Array of conditions
+  # - @mod - a Hash of other query-altering keys
+  # - @subqueries - a list of other queries nested within this one
+  #
+  # Each condition is either a SQL-ready string (boo) or an Array in this form:
+  #    [ field_string_or_sym, Card::Value::Query object ]
+  class Query
+    require_dependency 'card/query/clause'
+    require_dependency 'card/query/value'
+    require_dependency 'card/query/reference'
+    require_dependency 'card/query/attributes'
+    require_dependency 'card/query/sql_statement'
+    require_dependency 'card/query/join'
 
-  MODIFIERS = {};  %w{ conj return sort sort_as group dir limit offset }.each{|key| MODIFIERS[key.to_sym] = nil }
+    include Clause
+    include Attributes
 
-  OPERATORS = %w{ != = =~ < > in ~ }.inject({}) {|h,v| h[v]=nil; h }.merge({
-    :eq    => '=',   :gt => '>',    :lt      => '<',
-    :match => '~',   :ne => '!=',   'not in' => nil
-  }.stringify_keys)
+    ATTRIBUTES = {
+      basic:           %w( id name key type_id content left_id right_id
+                           creator_id updater_id codename                     ),
+      relational:      %w( type part left right
+                           editor_of edited_by last_editor_of last_edited_by
+                           creator_of created_by member_of member             ),
+      plus_relational: %w( plus left_plus right_plus                          ),
+      ref_relational:  %w( refer_to referred_to_by
+                           link_to linked_to_by
+                           include included_by                                ),
+      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 }
 
-  def initialize query
-    @card_clause = CardClause.build query
-  end
+    CONJUNCTIONS = { any: :or, in: :or, or: :or, all: :and, and: :and }
 
-  def query
-    @card_clause.query
-  end
+    MODIFIERS = %w( conj return sort sort_as group dir limit offset )
+      .inject({}) { |h,v| h[v.to_sym]=nil; h }
 
-  def sql
-    @sql ||= @card_clause.to_sql
-  end
+    OPERATORS = %w( != = =~ < > in ~ ).inject({}) {|h,v| h[v]=v; h }.merge({
+      eq: '=', gt: '>', lt: '<', match: '~', ne: '!=', :'not in'=> nil
+    }.stringify_keys)
 
-  def run
-    retrn = query[:return].present? ? query[:return].to_s : 'card'
-    if retrn == 'card'
-      simple_run('name').map do |name|
-        Card.fetch name, :new=>{}
-      end
-    else
-      simple_run retrn
+    DEFAULT_ORDER_DIRS =  { :update => "desc", :relevance => "desc" }
+
+    attr_reader :statement, :mods, :conditions,
+      :subqueries, :superquery
+    attr_accessor :joins, :table_seq, :unjoined, :conditions_on_join
+
+    def initialize statement
+      @subqueries = []
+      @conditions = []
+      @joins = []
+      @mods = {}
+      @statement = statement.clone
+
+      @unjoined   = @statement.delete(:unjoined  ) || nil
+      @context    = @statement.delete(:context   ) || nil
+      @superquery = @statement.delete(:superquery) || nil
+      @vars       = @statement.delete(:vars      ) || {}
+      @vars.symbolize_keys!
+
+      interpret @statement
+      self
     end
-  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
+    # Card::Fetch)
+
+    def self.run statement
+      query = new statement
+      query.run
+    end
 
-  def simple_run retrn
-    rows = run_sql
+    # run the current query
+    # @return array of card objects by default
+    def run
+      retrn = statement[:return].present? ? statement[:return].to_s : 'card'
+      if retrn == 'card'
+        get_results('name').map do |name|
+          Card.fetch name, new: {}
+        end
+      else
+        get_results retrn
+      end
+    end
 
-    case retrn
-    when 'name' #common case
-      if query[:prepend] || query[:append]
+    # @return Integer for :count, otherwise Array of Strings or Integers
+    def get_results retrn
+      rows = run_sql
+      if retrn == 'name' && (statement[:prepend] || statement[:append])
         rows.map do |row|
-          [ query[:prepend], row['name'], query[:append] ].compact * '+'
+          [statement[:prepend], row['name'], statement[:append]].compact * '+'
         end
       else
-        rows.map { |row| row['name'] }
+        case retrn
+        when 'count' then rows.first['count'].to_i
+        when 'raw'   then rows
+        when /id$/   then rows.map { |row| row[retrn].to_i }
+        else              rows.map { |row| row[retrn]      }
+        end
       end
-    when 'count'
-      rows.first['count'].to_i
-    when 'raw'
-      rows
-    when /id$/
-      rows.map { |row| row[retrn].to_i }
-    else
-      rows.map { |row| row[retrn]      }
     end
-  end
 
-  def run_sql
-    ActiveRecord::Base.connection.select_all( sql )
-  end
+    def run_sql
+      # puts "\nstatement = #{@statement}"
+      # puts "sql = #{sql}"
+      ActiveRecord::Base.connection.select_all(sql)
+    end
+
+    def sql
+      @sql ||= SqlStatement.new(self).build.to_s
+    end
 
+    # Query Hierarchy
+    # @root, @subqueries, and @superquery are used to track a hierarchy of
+    # query objects.  This nesting allows to find, for example, cards that
+    # link to cards that link to cards....
 
-  class SqlCond < String
-    def to_sql(*args) self end
-  end
+    def root
+      @root ||= @superquery ? @superquery.root : self
+    end
 
+    def subquery opts={}
+      subquery = Query.new opts.merge(superquery: self)
+      @subqueries << subquery
+      subquery
+    end
 
-  class SqlStatement
-    attr_accessor :fields, :tables, :joins, :conditions, :group, :order, :limit, :offset, :distinct
+    # Query Interpretation
 
-    def initialize
-      @fields, @joins, @conditions = [],[],[],[]
-      @tables = @group = @order = @limit =  @offset = @distinct = nil
+    # normalize and extract meaning from a clause
+    # @param clause [Hash, String, Integer] statement or chunk thereof
+    def interpret clause
+      interpret_by_key normalize_clause(clause)
     end
 
-    def to_s
-      select = fields.reject(&:blank?) * ', '
-      where = conditions.reject(&:blank?) * ' and '
+    def normalize_clause clause
+      clause = clause_to_hash clause
+      clause.symbolize_keys!
+      clause.each do |key, val|
+        clause[key] = normalize_value val
+      end
+      clause
+    end
 
-      ['(SELECT', distinct, select, 'FROM', tables, joins, 'WHERE', where, group, order, limit, offset, ')'].compact * ' '
+    def clause_to_hash clause
+      case clause
+      when Hash    then clause
+      when String  then { key: clause.to_name.key }
+      when Integer then { id: clause }
+      else fail BadQuery, "Invalid query args #{clause.inspect}"
+      end
     end
-  end
 
+    def normalize_value val
+      case val
+      when Integer, Float, Symbol, Hash then val
+      when String, Card::Name           then normalize_string_value val
+      when Array                        then val.map { |v| normalize_value v }
+      else fail BadQuery, "unknown WQL value type: #{val.class}"
+      end
+    end
 
-end
+    def normalize_string_value val
+      case val.to_s
+      when /^\$(\w+)$/                       # replace from @vars
+        @vars[Regexp.last_match[1].to_sym].to_s.strip
+      when /\b_/                             # absolutize based on @context
+        val.to_name.to_absolute(context)
+      else
+        val
+      end
+    end
+
+    def context
+      if !@context.nil?
+        @context
+      else
+        @context = @superquery ? @superquery.context : ''
+      end
+    end
+
+    def interpret_by_key clause
+      clause.each do |key, val|
+        case
+        when OPERATORS.key?(key.to_s) && !ATTRIBUTES[key]
+          # eg "match" is both operator and attribute;
+          # interpret as attribute when "match" is key
+          interpret content: [key, val]
+        when MODIFIERS.key?(key) && !clause[key].is_a?(Hash)
+          # eg when "sort" is hash, it can have subqueries
+          # and must be interpreted like an attribute
+          @mods[key] = val.is_a?(Array) ? val : val.to_s
+        else
+          interpret_attributes key, val
+        end
+      end
+    end
+
+    def add_condition *args
+      @conditions <<
+        if args.size > 1
+          [args.shift, Value.new(args.shift, self)]
+        else
+          args[0]
+        end
+    end
+
+    def interpret_attributes key, val
+      case ATTRIBUTES[key]
+      when :basic            then add_condition key, val
+      when :conjunction      then send key, val
+      when :relational       then relate key, val
+      when :special          then relate key, val
+      when :ref_relational   then relate key, val, method: :join_references
+      when :plus_relational  then relate_compound key, val
+      when :ignore           then # noop
+      else                   fail BadQuery, "Invalid attribute #{key}"
+      end
+    end
+
+    def relate_compound key, val
+      has_multiple_values =
+        val.is_a?(Array) &&
+        (val.first.is_a?(Array) || conjunction(val.first).present?)
+      relate key, val, multiple: has_multiple_values
+    end
 
+    def relate key, val, opts={}
+      multiple = opts[:multiple].nil? ? val.is_a?(Array) : opts[:multiple]
+      method = opts[:method] || :send
+
+      if multiple
+        conj = conjunction(val.first) ? conjunction(val.shift) : :and
+        if conj == current_conjunction
+          # same conjunction as container, no need for subcondition
+          val.each { |v| send method, key, v }
+        else
+          send conj, val.map { |v| { key => v } }
+        end
+      else
+        send method, key, val
+      end
+    end
+
+    def current_conjunction
+      @mods[:conj].blank? ? :and : @mods[:conj]
+    end
+
+    def all_joins
+      @all_joins ||=
+        (joins + subqueries.find_all(&:unjoined).map(&:all_joins)).flatten
+    end
+  end
+end