card 0.0.1 → 1.15.pre

data/mod/01_core/set/all/content.rb

@@ -0,0 +1,64 @@
+::Card.error_codes[:conflict] = [:conflict, 409]
+
+def content
+  db_content or (new_card? && template.db_content)
+end
+
+def content=(value)
+  self.db_content = value
+end
+
+def raw_content
+  structure ? template.db_content : content
+end
+
+
+format do
+  def chunk_list #override to customize by set
+    :default
+  end
+end
+
+def label
+  name
+end
+
+def creator
+  Card[ creator_id ]
+end
+
+def updater
+  Card[ updater_id ]
+end
+
+def clean_html?
+  true
+end
+
+def save_content_draft content
+  clear_drafts
+end
+
+def clear_drafts
+  drafts.created_by(Card::Auth.current_id).each do |draft|
+    draft.delete
+  end
+end
+
+event :save_draft, :before=>:store, :on=>:update, :when=>proc{ |c| Env.params['draft'] == 'true' } do
+  save_content_draft content
+  abort :success
+end
+
+
+event :set_default_content, :on=>:create, :before=>:approve do  
+  if !db_content_changed? and template and template.db_content.present?
+    self.db_content = template.db_content
+  end
+end
+
+event :detect_conflict, :before=>:approve, :on=>:update do
+  if last_action_id_before_edit and last_action_id_before_edit.to_i != last_action_id and last_action.act.actor_id != Auth.current_id
+    errors.add :conflict, "changes not based on latest revision"
+  end
+end

data/mod/01_core/set/all/erb.rb

@@ -0,0 +1,11 @@
+format do
+  def render_erb locals={}, template=nil, a_binding=nil, &block
+    template ||= block.call
+    a_binding ||= binding
+    locals.each do |k,v|
+      #a_binding.local_variable_set(k, v) # needs ruby 2.1
+      instance_variable_set("@#{k}",v)
+    end
+    ERB.new(template,nil,'-').result(binding)
+  end
+end

data/mod/01_core/set/all/fetch.rb

@@ -0,0 +1,228 @@
+# = Card#fetch
+#
+# A multipurpose retrieval operator that incorporates caching, "virtual" card retrieval
+
+module ClassMethods
+  
+  # === fetch
+  #
+  # looks for cards in
+  #   - cache
+  #   - database
+  #   - virtual cards
+  #
+  # "mark" here means a generic identifier -- can be a numeric id, a name, a string name, etc.
+  #
+  #   Options:
+  #     :skip_virtual               Real cards only
+  #     :skip_modules               Don't load Set modules
+  #     :new => {  card opts }      Return a new card when not found
+  #
+  
+
+  
+  
+  def fetch mark, opts={}
+    if String === mark
+      case mark
+      when /^\~(\d+)$/ # get by id
+        mark = $1.to_i 
+      when /^\:(\w+)$/ # get by codename
+        mark = $1.to_sym
+      end
+    end
+    mark = Card::Codename[mark] if Symbol === mark # id from codename
+
+    if mark.present?
+      card, mark, needs_caching = fetch_from_cache_or_db mark, opts # have existing
+    else
+      return unless opts[:new]
+    end
+
+    if Integer===mark
+      return if card.nil? || mark.nil?
+    else
+      return card.renew(opts) if card and card.eager_renew?(opts)
+      if !card or card.type_id==-1 && clean_cache_opts?(opts)       # new (or improved) card for cache
+        needs_caching = true  
+        card = new_for_cache mark, opts
+      end  
+    end
+  
+    write_to_cache card if Card.cache && needs_caching
+  
+    if card.new_card?
+      if opts[:new]
+        return card.renew(opts) if !clean_cache_opts? opts
+      elsif opts[:skip_virtual]
+        return
+      else
+        card.include_set_modules unless opts[:skip_modules]  # need to load modules here to call the right virtual? method 
+        return unless card.virtual?
+      end
+      card.name = mark.to_s if mark && mark.to_s != card.name
+    end
+
+    card.include_set_modules unless opts[:skip_modules]
+    card
+  end
+  
+  def fetch_id mark #should optimize this.  what if mark is int?  or codename?
+    card = fetch mark, :skip_virtual=>true, :skip_modules=>true
+    card and card.id
+  end
+
+  def [](mark)
+    fetch mark, :skip_virtual=>true
+  end
+
+  def exists? mark
+    card = fetch mark, :skip_virtual=>true, :skip_modules=>true
+    card.present?
+  end
+  
+  def known? mark
+    card = fetch mark, :skip_modules=>true
+    card.present?
+  end
+
+  def expire name
+    #note: calling instance method breaks on dirty names
+    key = name.to_name.key
+    if card = Card.cache.read( key ) 
+      Card.cache.delete key
+      Card.cache.delete "~#{card.id}" if card.id
+    end
+    #Rails.logger.warn "expiring #{name}, #{card.inspect}"
+  end
+
+  # set_names reverse map (cached)
+  def members key
+    (v=Card.cache.read "$#{key}").nil? ? [] : v.keys
+  end
+
+  def set_members set_names, key
+    set_names.compact.map(&:to_name).map(&:key).map do |set_key|
+      skey = "$#{set_key}" # dollar sign avoids conflict with card keys
+      h = Card.cache.read skey
+      if h.nil?
+        h = {}
+      elsif h[key]
+        next
+      end
+      h = h.dup if h.frozen?
+      h[key] = true
+      Card.cache.write skey, h
+    end
+  end
+  
+  def cache
+    Card::Cache[Card]
+  end
+  
+  def fetch_from_cache cache_key
+    Card.cache.read cache_key if Card.cache
+  end
+  
+  def fullname_from_name name, new_opts={}
+    if new_opts and supercard = new_opts[:supercard]
+      name.to_name.to_absolute_name supercard.name
+    else
+      name.to_name
+    end
+  end
+  
+  def fetch_from_cache_or_db mark, opts
+    needs_caching = false  
+    mark_type = Integer===mark ? :id : :key
+    
+    if mark_type == :key
+      mark = fullname_from_name mark, opts[:new]
+      val = mark.key
+    else
+      val = mark
+    end
+    
+    card = send( "fetch_from_cache_by_#{mark_type}", val ) || begin
+      needs_caching = true
+      send "find_by_#{mark_type}_and_trash", val, false
+    end
+    
+    [ card, mark, needs_caching ]
+  end
+  
+  def fetch_from_cache_by_id id
+    if name = fetch_from_cache("~#{id}")
+      fetch_from_cache name
+    end
+  end
+    
+  def fetch_from_cache_by_key key
+    fetch_from_cache key
+  end
+
+  def new_for_cache name, opts
+    new_args = { :name=>name, :skip_modules=>true }
+    new_args[:type_id] = -1 unless clean_cache_opts? opts
+    # The -1 type_id allows us to skip all the type lookup and flag the need for
+    # reinitialization later.  *** It should NEVER be seen elsewhere ***
+    new new_args
+  end
+  
+  def clean_cache_opts? opts
+    !opts[:skip_virtual] && !opts[:new].present?
+  end
+  
+  def write_to_cache card
+    Card.cache.write card.key, card
+    Card.cache.write "~#{card.id}", card.key if card.id and card.id != 0
+  end  
+  
+
+end
+
+# ~~~~~~~~~~ Instance ~~~~~~~~~~~~~
+
+def fetch opts={}
+  if traits = opts.delete(:trait)
+    traits = [traits] unless Array===traits
+    traits.inject(self) { |card, trait| Card.fetch( card.cardname.trait(trait), opts ) }
+  end
+end
+
+
+def renew args={}
+  opts = args[:new].clone
+  opts[:name] ||= cardname
+  opts[:skip_modules] = args[:skip_modules]
+  Card.new opts
+end
+
+def expire_pieces
+  cardname.piece_names.each do |piece|
+    Card.expire piece
+  end
+end
+
+
+def expire
+  #Rails.logger.warn "expiring i:#{id}, #{inspect}"
+  Card.cache.delete key
+  Card.cache.delete "~#{id}" if id
+end
+
+def refresh force=false
+  if force || self.frozen? || self.readonly?
+    fresh_card = self.class.find id
+    fresh_card.include_set_modules
+    fresh_card
+  else
+    self
+  end
+end
+
+def eager_renew? opts
+  opts[:skip_virtual] && new_card? && opts[:new].present?
+end
+
+

data/mod/01_core/set/all/haml.rb

@@ -0,0 +1,7 @@
+format do
+  def render_haml locals={}, template=nil, a_binding=nil, &block
+    template ||= block.call
+    a_binding ||= binding
+    ::Haml::Engine.new(template).render(a_binding, locals)
+  end
+end

data/mod/01_core/set/all/initialize.rb

@@ -0,0 +1,49 @@
+JUNK_INIT_ARGS = %w{ missing skip_virtual id }
+
+module ClassMethods
+  def new args={}, options={}
+    args = (args || {}).stringify_keys
+    JUNK_INIT_ARGS.each { |a| args.delete(a) }
+    %w{ type type_code }.each { |k| args.delete(k) if args[k].blank? }
+    args.delete('content') if args['attach'] # should not be handled here!
+    super args
+  end
+end
+
+def initialize args={}
+  args['name']    = args['name'   ].to_s
+  args['type_id'] = args['type_id'].to_i
+
+  args.delete('type_id') if args['type_id'] == 0 # can come in as 0, '', or nil
+  @type_args = {
+    :type      => args.delete('type'     ),
+    :type_code => args.delete('type_code'),
+    :type_id   => args[       'type_id'  ]
+  }
+  
+  args['db_content'] = args.delete('content') if args['content']
+
+  #FIXME -- too much of the above is duplicated by assign_attributes (tracked_attributes.rb)
+
+  @supercard = args.delete 'supercard' # must come before name =
+  skip_modules = args.delete 'skip_modules'
+
+  super args # ActiveRecord #initialize
+  
+  if tid = get_type_id( @type_args )
+    self.type_id = tid
+  end
+  
+  include_set_modules unless skip_modules
+  self
+end
+
+def include_set_modules
+  unless @set_mods_loaded
+    set_modules.each do |m|
+      singleton_class.send :include, m
+    end
+    @set_mods_loaded=true
+  end
+  self
+end

data/mod/01_core/set/all/name.rb

@@ -0,0 +1,275 @@
+require 'uuid'
+
+def name= newname
+  cardname = newname.to_name
+  if @supercard
+    @relative_name = cardname.to_s
+    relparts = @relative_name.to_name.parts
+    @superleft = @supercard if relparts.size==2 && relparts.first.blank?
+    cardname = @relative_name.to_name.to_absolute_name @supercard.name
+  end
+  
+  newkey = cardname.key
+  if key != newkey
+    self.key = newkey
+    reset_patterns_if_rule # reset the old name - should be handled in tracked_attributes!!
+    reset_patterns
+  end
+  
+  subcards.each do |subkey, subcard|
+    next unless Card===subcard
+    subcard.name = subkey.to_name.to_absolute cardname
+  end
+  
+  super cardname.s
+end
+
+def cardname
+  name.to_name
+end
+
+def autoname name
+  if Card.exists? name
+    autoname name.next
+  else
+    name
+  end
+end
+
+# FIXME: use delegations and include all cardname functions
+def simple?
+  cardname.simple?
+end
+
+def junction?
+  cardname.junction?
+end
+
+
+def relative_name
+  @relative_name || name
+end
+
+def left *args
+  if !simple?
+    @superleft or begin
+      unless name_changed? and name.to_name.trunk_name.key == name_was.to_name.key
+        # prevent recursion when, eg, renaming A+B to A+B+C
+        Card.fetch cardname.left, *args      
+      end
+    end
+  end
+end
+
+def right *args
+  Card.fetch( cardname.right, *args ) if !simple?
+end
+
+def [] *args
+  if args[0].kind_of?(Fixnum) || args[0].kind_of?(Range)
+    fetch_name = Array.wrap(cardname.parts[args[0]]).compact.join '+'
+    Card.fetch( fetch_name, args[1] || {} ) if !simple?
+  else
+    super
+  end
+end
+
+def trunk *args
+  simple? ? self : left( *args )
+end
+
+def tag *args
+  simple? ? self : Card.fetch( cardname.right, *args )
+end
+
+def left_or_new args={}
+  left args or Card.new args.merge(:name=>cardname.left)
+end
+
+def children
+  Card.search( { (simple? ? :part : :left) => name } ).to_a
+end
+
+def dependents
+  return [] if new_card?
+
+  if @dependents.nil?
+    @dependents =
+      Auth.as_bot do
+        deps = children
+        deps.inject(deps) do |array, card|
+          array + card.dependents
+        end
+      end
+    #Rails.logger.warn "dependents[#{inspect}] #{@dependents.inspect}"
+  end
+  @dependents
+end
+
+def repair_key
+  Auth.as_bot do
+    correct_key = cardname.key
+    current_key = key
+    return self if current_key==correct_key
+
+    if key_blocker = Card.find_by_key_and_trash(correct_key, true)
+      key_blocker.cardname = key_blocker.cardname + "*trash#{rand(4)}"
+      key_blocker.save
+    end
+
+    saved =   ( self.key  = correct_key and self.save! )
+    saved ||= ( self.cardname = current_key and self.save! )
+
+    if saved
+      self.dependents.each { |c| c.repair_key }
+    else
+      Rails.logger.debug "FAILED TO REPAIR BROKEN KEY: #{key}"
+      self.name = "BROKEN KEY: #{name}"
+    end
+    self
+  end
+rescue
+  Rails.logger.info "BROKE ATTEMPTING TO REPAIR BROKEN KEY: #{key}"
+  self
+end
+
+
+event :permit_codename, :before=>:approve, :on=>:update, :changed=>:codename do
+  errors.add :codename, 'only admins can set codename' unless Auth.always_ok?
+end
+
+event :validate_unique_codename, :after=>:permit_codename do
+  if codename.present? and errors.empty? and Card.find_by_codename(codename).present?
+    errors.add :codename, "codename #{codename} already in use" 
+  end
+end
+
+event :validate_name, :before=>:approve, :on=>:save do 
+  cdname = name.to_name
+  if name.length > 255
+    errors.add :name, "is too long (255 character maximum)"
+  elsif cdname.blank?
+    errors.add :name, "can't be blank"
+  elsif name_changed?
+    #Rails.logger.debug "valid name #{card.name.inspect} New #{name.inspect}"
+
+    unless cdname.valid?
+      errors.add :name, "may not contain any of the following characters: #{ Card::Name.banned_array * ' ' }"
+    end
+    # this is to protect against using a plus card as a tag
+    if cdname.junction? and simple? and id and Auth.as_bot { Card.count_by_wql :right_id=>id } > 0
+      errors.add :name, "#{name} in use as a tag"
+    end
+
+    # validate uniqueness of name
+    condition_sql = "cards.key = ? and trash=?"
+    condition_params = [ cdname.key, false ]
+    unless new_record?
+      condition_sql << " AND cards.id <> ?"
+      condition_params << id
+    end
+    if c = Card.find(:first, :conditions=>[condition_sql, *condition_params])
+      errors.add :name, "must be unique; '#{c.name}' already exists."
+    end
+  end
+end
+
+
+event :set_autoname, :before=>:validate_name, :on=>:create do
+  if name.blank? and autoname_card = rule_card(:autoname)
+    self.name = autoname autoname_card.content
+    Auth.as_bot { autoname_card.refresh.update_attributes! :content=>name }   #fixme, should give placeholder on new, do next and save on create
+  end
+end
+
+
+event :validate_key, :after=>:validate_name, :on=>:save do
+  if key.empty?
+    errors.add :key, "cannot be blank" if errors.empty?
+  elsif key != cardname.key
+    errors.add :key, "wrong key '#{key}' for name #{name}"
+  end
+end
+
+event :set_name, :before=>:store, :changed=>:name do
+  Card.expire name
+  Card.expire name_was
+  if cardname.junction?
+    [:left, :right].each do |side|
+      sidename = cardname.send "#{side}_name"
+      #warn "sidename #{name} / #{name_was} / #{cardname}, #{side}: #{sidename}"
+      sidecard = Card[sidename]
+      old_name_in_way = (sidecard && sidecard.id==self.id) # eg, renaming A to A+B
+      suspend_name(sidename) if old_name_in_way
+      send "#{side}_id=", begin
+        if !sidecard || old_name_in_way
+          Card.create! :name=>sidename, :supercard => self
+        else
+          sidecard
+        end.id
+      end
+    end
+  else
+    self.left_id = self.right_id = nil
+  end
+end
+
+
+event :rename, :after=>:set_name, :on=>:update do
+  if existing_card = Card.find_by_key_and_trash(cardname.key, true) and existing_card != self
+    existing_card.name = existing_card.name+'*trash'
+    existing_card.rename_without_callbacks
+    existing_card.save!
+  end
+end
+
+def suspend_name(name)
+  # move the current card out of the way, in case the new name will require
+  # re-creating a card with the current name, ie.  A -> A+B
+  Card.expire name
+  tmp_name = "tmp:" + UUID.new.generate
+  Card.where(:id=>self.id).update_all(:name=>tmp_name, :key=>tmp_name)
+end
+
+
+event :cascade_name_changes, :after=>:store, :on=>:update, :changed=>:name do
+
+  Rails.logger.debug "-------------------#{name_was}- CASCADE #{self.name} -------------------------------------"
+
+  self.update_referencers = false if self.update_referencers == 'false' #handle strings from cgi
+  Card::Reference.update_on_rename self, name, self.update_referencers
+
+  deps = self.dependents
+  #warn "-------------------#{name_was}---- CASCADE #{self.name} -> deps: #{deps.map(&:name)*", "} -----------------------"
+
+  @dependents = nil #reset
+
+  deps.each do |dep|
+    # here we specifically want NOT to invoke recursive cascades on these cards, have to go this low level to avoid callbacks.
+    Card.expire dep.name #old name
+    newname = dep.cardname.replace_part name_was, name
+    Card.where( :id=> dep.id ).update_all :name => newname.to_s, :key => newname.key
+    Card::Reference.update_on_rename dep, newname, update_referencers
+    Card.expire newname
+  end
+
+  if update_referencers
+    Auth.as_bot do
+      [self.name_referencers(name_was)+(deps.map &:referencers)].flatten.uniq.each do |card|
+        # FIXME  using "name_referencers" instead of plain "referencers" for self because there are cases where trunk and tag
+        # have already been saved via association by this point and therefore referencers misses things
+        # eg.  X includes Y, and Y is renamed to X+Z.  When X+Z is saved, X is first updated as a trunk before X+Z gets to this point.
+        # so at this time X is still including Y, which does not exist.  therefore #referencers doesn't find it, but name_referencers(old_name) does.
+        # some even more complicated scenario probably breaks on the dependents, so this probably needs a more thoughtful refactor
+        # aligning the dependent saving with the name cascading
+
+        Rails.logger.debug "------------------ UPDATE REFERER #{card.name}  ------------------------"
+        unless card == self or card.structure
+          card = card.refresh
+          card.db_content = card.replace_references name_was, name
+          card.save!
+        end
+      end
+    end
+  end
+end