wagn 1.12.7

data/lib/card/query/ref_spec.rb

@@ -0,0 +1,23 @@
+class Card::Query
+  class RefSpec < Spec
+    REFSPECS = {
+      :refer_to       => ['referer_id','referee_id',''],
+      :link_to        => ['referer_id','referee_id',"ref_type='L' AND"],
+      :include        => ['referer_id','referee_id',"ref_type='I' AND"],
+      :link_to_missing=> ['referer_id','referee_id',"present = 0 AND ref_type='L'"],
+      :referred_to_by => ['referee_id','referer_id',''],
+      :linked_to_by   => ['referee_id','referer_id',"ref_type='L' AND"],
+      :included_by    => ['referee_id','referer_id',"ref_type='I' AND"]
+    }
+    
+    def initialize key, cardspec
+      @key, @cardspec = key, cardspec
+    end
+
+    def to_sql *args
+      field1, field2, where = REFSPECS[ @key.to_sym ]
+      and_where = @key != :link_to_missing && "#{ field2 } IN #{ @cardspec.to_sql }"
+      %{(select #{field1} from card_references where #{where} #{and_where})}
+    end
+  end
+end

data/lib/card/query/spec.rb

@@ -0,0 +1,21 @@
+
+class Card::Query::Spec
+  attr_accessor :spec
+
+  def safe_sql(txt)
+    txt = txt.to_s
+    txt.match( /[^\w\*\(\)\s\.\,]/ ) ? raise( "WQL contains disallowed characters: #{txt}" ) : txt
+  end
+
+  def quote(v)  ActiveRecord::Base.connection.quote(v)  end
+
+  def match_prep(v,cardspec=self)
+    cxn ||= ActiveRecord::Base.connection
+    [cxn, v]
+  end
+
+  def cast_type(type)
+    cxn ||= ActiveRecord::Base.connection
+    (val = cxn.cast_types[type.to_sym]) ? val[:name] : safe_sql(type)
+  end
+end

data/lib/card/query/value_spec.rb

@@ -0,0 +1,66 @@
+class Card::Query
+  class ValueSpec < Spec
+    def initialize spec, cardspec
+      @cardspec = cardspec
+
+      # bare value shortcut
+      @spec = case spec
+        when ValueSpec; spec.instance_variable_get('@spec')  # FIXME what a hack (what's this for?)
+        when Array;     spec
+        when String;    ['=', spec]
+        when Integer;   ['=', spec]
+        else raise("Invalid Condition Spec #{spec.inspect}")
+      end
+
+      # operator aliases
+      @spec[0] = @spec[0].to_s
+      if target = OPERATORS[@spec[0]]
+        @spec[0] = target
+      end
+
+      # check valid operator
+      raise("Invalid Operator #{@spec[0]}") unless OPERATORS.has_key?(@spec[0])
+
+      # handle IN  #FIXME -- shouldn't this handle "not in", too?
+      if @spec[0]=='in' and !@spec[1].is_a?(CardSpec) and !@spec[1].is_a?(RefSpec)
+        @spec = [@spec[0], @spec[1..-1]]
+      end
+    end
+
+    def op
+      @spec[0]
+    end
+
+    def sqlize(v)
+      case v
+        when CardSpec, RefSpec, SqlCond; v.to_sql
+        when Array;    "(" + v.flatten.collect {|x| sqlize(x)}.join(',') + ")"
+        else quote(v.to_s)
+      end
+    end
+
+    def to_sql field
+      op,v = @spec
+      #warn "to_sql(#{field}), #{op}, #{v}, #{@cardspec.inspect}"
+      v=@cardspec.selfname if v=='_self'
+      table = @cardspec.table_alias
+
+      #warn "to_sql #{field}, #{v} (#{op})"
+      field, v = case field
+        when "cond";     return "(#{sqlize(v)})"
+        when "name";     ["#{table}.key",      [v].flatten.map(&:to_name).map(&:key)]
+        when "content";   join_alias = @cardspec.add_revision_join
+                         ["#{join_alias}.content", v]
+        else;            ["#{table}.#{safe_sql(field)}", v]
+        end
+
+      v = v[0] if Array===v && v.length==1
+      if op=='~'
+        cxn, v = match_prep(v,@cardspec)
+        %{#{field} #{cxn.match(sqlize(v))}}
+      else
+        "#{field} #{op} #{sqlize(v)}"
+      end
+    end
+  end
+end

data/lib/card/set.rb

@@ -0,0 +1,239 @@
+# -*- encoding : utf-8 -*-
+
+module Card::Set
+
+  mattr_accessor :includable_modules, :base_modules, :traits, :current
+  @@includable_modules, @@base_modules = {}, []
+
+
+  # View definitions
+  #
+  #   When you declare:
+  #     view :view_name, "<set>" do |args|
+  #
+  #   Methods are defined on the format
+  #
+  #   The external api with checks:
+  #     render(:viewname, args)
+  #
+  #   Roughly equivalent to:
+  #     render_viewname(args)
+  #
+  #   The internal call that skips the checks:
+  #     _render_viewname(args)
+  #
+  #   Each of the above ultimately calls:
+  #     _final(_set_key)_viewname(args)
+
+  #
+  # ~~~~~~~~~~  VIEW DEFINITION
+  #
+
+  def view *args, &block
+    format do view *args, &block end
+  end
+
+  def format fmt=nil, &block
+    if block_given?
+      f = Card::Format
+      format = fmt.nil? ? f : f.get_format(fmt)
+      format.class_eval &block
+    else
+      fail "block required"
+    end
+  end
+
+
+  def event event, opts={}, &final
+    opts[:on] = [:create, :update ] if opts[:on] == :save
+
+    mod = Card::Set.current[:module]
+    Card.define_callbacks event
+
+    mod.class_eval do
+      final_method = "#{event}_without_callbacks" #should be private?
+      define_method final_method, &final
+
+      define_method event do
+        run_callbacks event do
+          send final_method
+        end
+      end
+    end
+    
+    set_event_callbacks event, mod, opts
+  end
+
+
+
+  #
+  # ActiveCard support: accessing plus cards as attributes
+  #
+
+
+  def card_accessor *args
+    options = args.extract_options!
+    add_traits args, options.merge( :reader=>true, :writer=>true )
+  end
+
+  def card_reader *args
+    options = args.extract_options!
+    add_traits args, options.merge( :reader=>true )
+  end
+
+  def card_writer *args
+    options = args.extract_options!
+    add_traits args, options.merge( :writer=>true )
+  end
+  
+  
+  
+  #
+  # Singleton methods
+  #
+
+  class << self
+    
+    def extended mod
+      register_set mod
+    end
+    
+    def register_set set_module
+      if all_set?( set_module )
+        self.current = { :module=>Card, :opts=>{} }
+        base_modules << set_module unless set_module == Card
+      else
+        self.current = { :module=>set_module, :opts=>opts_from_module( set_module ) }
+      end      
+
+      includable_modules[ set_module.name ] = set_module unless set_module == Card
+    end
+    
+    def all_set? set_module
+      set_module == Card or set_module.name =~ /^Card::Set::All::/
+    end
+
+    def opts_from_module set_module
+      if name_parts = set_module.to_s.split('::')[2..-1]
+        #FIXME - does not handle set patterns with multiple opts (eg type plus right)
+        pattern, anchor = name_parts.map { |part| part.underscore.to_sym }
+        { pattern => anchor }
+      else
+        { }
+      end
+    end
+
+    def set_module_from_name *args
+      # FIXME - this does not properly handle anchorless sets
+      # There are special hacks for *all, but others (like *rstar) will not be found by
+      # include_set_modules, which will look for Card::Set::Rstar, not Card::Set::Rstar::Blah
+      
+      module_name_parts = args.length == 1 ? args[0].split('::') : args
+      module_name_parts.inject Card::Set do |base, part|
+        return if base.nil?
+        part = part.camelize
+        module_name = "#{base.name}::#{part}"
+        if includable_modules.has_key?(module_name)
+          includable_modules[module_name]
+        else
+          base.const_get_or_set( part ) { Module.new }
+        end
+      end
+    rescue NameError => e
+      Rails.logger.warn "set_module_from_name error #{args.inspect}: #{e.inspect}"
+      return nil if NameError ===e
+    end
+    
+    def process_base_modules
+      base_modules.each do |mod|
+        if mod.instance_methods.any?
+          Card.send :include, mod
+        end
+        if class_methods = mod.const_get_if_defined( :ClassMethods )
+          Card.send :extend, class_methods
+        end
+        includable_modules.delete mod.name
+      end
+      @@base_modules = []
+    end
+    
+    def clean_empty_modules
+      includable_modules.each do |mod_name, mod|
+        if mod.instance_methods.empty?
+          includable_modules.delete mod_name
+        end
+      end
+    end
+    
+  end
+
+
+  private
+
+
+  def set_event_callbacks event, mod, opts
+    [:before, :after, :around].each do |kind|
+      if object_method = opts.delete(kind)
+        options = { :prepend => true } 
+        if mod == Card
+          options[:if] = proc { |c| c.event_applies? opts }
+        else
+          parts = mod.name.split '::'
+          set_class_key, anchor_or_placeholder = parts[-2].underscore.to_sym, parts[-1].underscore
+          set_key = Card.method_key( set_class_key => anchor_or_placeholder )
+          options[:if] = proc { |c| c.method_keys.member? set_key and c.event_applies? opts }
+        end        
+        Card.class_eval { set_callback object_method, kind, event, options }
+      end
+    end
+  end
+
+  def get_traits mod
+    Card::Set.traits ||= {}
+    Card::Set.traits[mod] or Card::Set.traits[mod] = {}
+  end
+
+  def add_traits args, options
+    mod = Card::Set.current[:module]
+    raise "Can't define card traits on all set" if mod == Card
+    mod_traits = get_traits mod
+    
+    new_opts = options[:type] ? {:type=>options[:type]} : {}
+    new_opts.merge!( {:content => options[:default]} ) if options[:default]
+    
+    args.each do |trait|   
+      define_trait_card trait, new_opts
+      define_trait_reader trait if options[:reader]
+      define_trait_writer trait if options[:writer]
+
+      mod_traits[trait.to_sym] = options
+    end
+  end
+  
+  def define_trait_card trait, opts
+    define_method "#{trait}_card" do
+      trait_var "@#{trait}_card" do
+        fetch :trait=>trait.to_sym, :new=>opts
+      end
+    end
+  end
+  
+  def define_trait_reader trait
+    define_method trait do
+      trait_var "@#{trait}" do
+        send( "#{trait}_card" ).content
+      end
+    end
+  end
+
+  def define_trait_writer trait
+    define_method "#{trait}=" do |value|
+      card = send "#{trait}_card"
+      self.cards ||= {}
+      self.cards[card.name] = {:type_id => card.type_id, :content=>value }
+      instance_variable_set "@#{trait}", value
+    end
+  end
+
+end
+

data/lib/card/set_pattern.rb

@@ -0,0 +1,140 @@
+class Card::SetPattern
+
+  class << self
+    attr_accessor :key, :key_id, :opt_keys, :junction_only, :method_key, :assigns_type, :anchorless
+    
+    def junction_only?
+      !!junction_only
+    end
+    
+    def anchorless?
+      !!anchorless
+    end
+
+    def new card
+      super if pattern_applies? card
+    end
+
+    def key_name
+      Card.fetch(self.key_id, :skip_modules=>true).cardname
+    end
+
+    def register key, opts={}
+      if self.key_id = Card::Codename[key]
+        self.key = key
+        Card.set_patterns.insert opts.delete(:index).to_i, self
+        if self.anchorless = !respond_to?( :anchor_name )
+          self.method_key = opts[:method_key] || key
+        end
+        self.opt_keys = Array.wrap( opts.delete(:opt_keys) || key.to_sym )
+        opts.each { |key, val| send "#{key}=", val }
+      else
+        warn "no codename for key #{key}"
+      end
+    end
+
+    def method_key_from_opts opts
+      method_key || ((opt_keys.map do |opt_key|
+        opts[opt_key].to_name.key.gsub('+', '-')
+      end << key) * '_' )
+    end
+
+    def pattern_applies? card
+      junction_only? ? card.cardname.junction? : true
+    end
+  end
+
+
+  # Instance methods
+
+  def initialize card
+    
+    unless self.class.anchorless?
+      @anchor_name = self.class.anchor_name(card).to_name
+
+      @anchor_id = if self.class.respond_to? :anchor_id
+        self.class.anchor_id card
+      else
+        Card.fetch_id @anchor_name
+      end
+    end
+
+    self
+  end
+
+
+  def set_module_name
+    tail = case
+      when self.class.anchorless?   ; self.class.key.camelize
+      when opt_vals.member?( nil )  ; nil
+      else "#{self.class.key.camelize}::#{opt_vals.map(&:to_s).map(&:camelize) * '::'}"
+      end
+    tail && "Card::Set::#{ tail }"
+  end
+
+  def set_const
+    if set_module = self.set_module_name
+      Card::Set.includable_modules[ set_module ]
+    end
+
+  rescue Exception => e
+    warn "exception set_const #{e.inspect}, #{e.backtrace*"\n"}"
+  end
+
+  def get_method_key
+    if self.class.anchorless?
+      self.class.method_key
+    else
+      opts = {}
+      self.class.opt_keys.each_with_index do |key, index|
+        return nil unless opt_vals[index]
+        opts[key] = opt_vals[index]
+      end
+      self.class.method_key_from_opts opts
+    end
+  end
+
+  def opt_vals
+    if @opt_vals.nil?
+      @opt_vals = self.class.anchorless? ? [] : find_opt_vals
+    end
+    @opt_vals
+  end
+
+  def find_opt_vals
+    anchor_parts = if self.class.opt_keys.size > 1
+      [ @anchor_name.left, @anchor_name.right ]
+    else
+      [ @anchor_name ]
+    end
+    anchor_parts.map do |part|
+      part_id = Card.fetch_id part
+      part_id && Card::Codename[ part_id.to_i ] or return []
+    end
+  end
+
+  def key_name
+    @key_name ||= self.class.key_name
+  end
+
+  def to_s
+    self.class.anchorless? ? key_name.s : "#{@anchor_name}+#{key_name}"
+  end
+
+  def inspect
+    "<#{self.class} #{to_s.to_name.inspect}>"
+  end
+
+  def safe_key()
+    caps_part = self.class.key.gsub(' ','_').upcase
+    self.class.anchorless? ? caps_part : "#{caps_part}-#{@anchor_name.safe_key}"
+  end
+
+  def rule_set_key
+    if self.class.anchorless?
+      self.class.key
+    elsif @anchor_id
+      [ @anchor_id, self.class.key ].map( &:to_s ) * '+'
+    end
+  end
+end