card 0.0.1 → 1.15.pre

data/mod/01_history/lib/card/action.rb

@@ -0,0 +1,176 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  
+  class Action < ActiveRecord::Base
+    belongs_to :card
+    belongs_to :act,  :foreign_key=>:card_act_id, :inverse_of=>:actions 
+    has_many   :changes, :foreign_key=>:card_action_id, :inverse_of=>:action, :dependent=>:delete_all
+    
+    belongs_to :super_action, :class_name=> "Action", :inverse_of=>:sub_actions
+    has_many   :sub_actions,  :class_name=> "Action", :inverse_of=>:super_action
+    
+    scope :created_by, lambda { |actor_id| joins(:act).where('card_acts.actor_id = ?', actor_id) }
+    
+    # replace with enum if we start using rails 4 
+    TYPE = [:create, :update, :delete]
+    
+    class << self
+      def cache
+        Card::Cache[Action]
+      end
+    
+      def fetch id
+        cache.read(id.to_s) or begin
+          cache.write id.to_s, Action.find(id.to_i)
+        end
+      end
+      
+    
+      def delete_cardless
+        Card::Action.where( Card.where( :id=>arel_table[:card_id] ).exists.not ).delete_all
+      end
+    
+      def delete_old 
+        Card.find_each do |card|
+          card.delete_old_actions
+        end    
+        Card::Act.delete_actionless
+      end
+    end
+
+    #
+    # This is the main API from Cards to history
+    # See also create_act_and_action, which needs to happen before this or we
+    # don't have the action to call this method on.
+    #
+    # When changes are stored for versioned attributes, this is the signal method
+    # By overriding this method in a module, the module takes over handling of
+    # changes.  Although the standard version stores the Changes in active record
+    # models (Act, Action and Change records), these could be /dev/nulled for a
+    # history-less implementation, or handled by an external service.
+    #
+    # If change streams are generated from database triggers, and we aren't writing
+    # here (disabled history), we still have to generate change stream events in
+    # another way.
+    #
+    def changed_fields obj, changed_fields
+      #changed_fields.each{ |f| changes.build :field => f, :value => self[f] }
+      changed_fields.each{ |f| Card::Change.create :field => f, :value => obj[f], :card_action_id=>id }
+    end
+
+    def edit_info
+      @edit_info ||= {
+        :action_type  => "#{action_type}d",
+        :new_content  => new_values[:content],
+        :new_name     => new_values[:name],
+        :new_cardtype => new_values[:cardtype],
+        :old_content  => old_values[:content],
+        :old_name     => old_values[:name],
+        :old_cardtype => old_values[:cardtype]
+      }
+    end
+    
+    def new_values
+      @new_values ||= {
+        :content  => new_value_for(:db_content),
+        :name     => new_value_for(:name),
+        :cardtype => ( typecard = Card[new_value_for(:type_id).to_i] and typecard.name.capitalize )
+      }
+    end
+    
+    def old_values
+      @old_values ||= {
+        :content  => last_value_for(:db_content),
+        :name     => last_value_for(:name),
+        :cardtype => ( value = last_value_for(:type_id) and 
+                       typecard = Card.find(value) and  typecard.name.capitalize )
+      }
+    end
+    
+    def last_value_for field
+       ch = self.card.last_change_on(field, :before=>self) and ch.value
+    end
+    
+    def new_value_for(field)
+       ch = changes.find_by_field(field) and ch.value
+    end
+    def change_for(field) 
+      field_integer = ( field.is_a?(Integer) ? field : Card::TRACKED_FIELDS.index(field.to_s) )
+      changes.where 'card_changes.field = ?', field_integer
+    end
+    
+    
+    def new_type?
+      new_value_for(:type_id)
+    end
+    def new_content?
+      new_value_for(:db_content)
+    end
+    def new_name?
+      new_value_for(:name)
+    end
+    
+    
+    def action_type=(value)
+      write_attribute(:action_type, TYPE.index(value))
+    end
+    
+    def action_type
+      TYPE[read_attribute(:action_type)]
+    end
+    
+    def set_act
+      self.set_act ||= self.acts.last
+    end
+    
+    def revision_nr 
+      self.card.actions.index_of(self)
+    end
+    
+    def red?
+      content_diff_builder.red?
+    end
+    
+    def green?
+      content_diff_builder.green?
+    end
+    
+    
+    # def diff
+    #   @diff ||= { :cardtype=>type_diff, :content=>content_diff, :name=>name_diff}
+    # end
+      
+  
+    def name_diff opts={}
+      if new_name?
+        Card::Diff.complete old_values[:name], new_values[:name], opts
+      end
+    end
+  
+    def cardtype_diff opts={}
+      if new_type?
+        Card::Diff.complete old_values[:cardtype], new_values[:cardtype], opts
+      end
+    end
+  
+    def content_diff diff_type=:expanded, opts=nil
+      if new_content?
+        if diff_type == :summary
+          content_diff_builder(opts).summary
+        else
+          content_diff_builder(opts).complete 
+        end
+      end
+    end
+    
+    def content_diff_builder opts=nil
+      @content_diff_builder ||= begin
+        Card::Diff::DiffBuilder.new(old_values[:content], new_values[:content], opts || card.diff_args)
+      end
+    end
+    
+  end
+end
+
+

data/mod/01_history/lib/card/change.rb

@@ -0,0 +1,29 @@
+# -*- encoding : utf-8 -*-
+class Card
+  class Change < ActiveRecord::Base
+    belongs_to :action, :foreign_key=>:card_action_id, :inverse_of=>:changes
+    
+    # replace with enum if we start using rails 4 
+    def field=(value)
+      write_attribute(:field, Card::TRACKED_FIELDS.index(value.to_s))
+    end
+    
+    def field
+      Card::TRACKED_FIELDS[read_attribute(:field)]
+    end
+    
+    def self.delete_actionless
+      Card::Change.where(
+        "card_action_id NOT IN (?)",
+        Card::Action.pluck("id"),
+      ).delete_all
+    end
+    
+    def self.find_by_field(value)
+      index = value.is_a?(Integer) ? value : Card::TRACKED_FIELDS.index(value.to_s)
+      super(index)
+    end
+  end
+end
+
+

data/mod/01_history/set/all/actions.rb

@@ -0,0 +1,47 @@
+# -*- encoding : utf-8 -*-
+
+def select_action_by_params params
+  action = find_action_by_params(params) and self.selected_action_id = action.id
+end
+
+def find_action_by_params args
+  case 
+  when args[:rev]
+    nth_action args[:rev]
+  when args[:rev_id]
+    if action = Action.fetch(args[:rev_id]) and action.card_id == id 
+      action 
+    end
+  end
+end
+
+def nth_action index
+  index = index.to_i
+  if id and index > 0
+    Action.where("draft is not true AND card_id = #{id}").order(:id).limit(1).offset(index-1).first
+  end
+end
+
+def revision action
+  # a "revision" refers to the state of all tracked fields at the time of a given action
+  if action.is_a? Integer
+    action = Card::Action.fetch(action)
+  end
+  action and Card::TRACKED_FIELDS.inject({}) do |attr_changes, field|
+    last_change = action.changes.find_by_field(field) || last_change_on(field, :not_after=>action)
+    attr_changes[field.to_sym] = (last_change ? last_change.value : self[field])
+    attr_changes
+  end
+end
+
+def delete_old_actions
+  Card::TRACKED_FIELDS.each do |field|
+    # assign previous changes on each tracked field to the last action
+    if (not last_action.change_for(field).present?) and (last_change = last_change_on(field))
+      last_change = Card::Change.find(last_change.id)   # last_change comes as readonly record
+      last_change.update_attributes!(:card_action_id=>last_action_id)
+    end
+  end
+  actions.where('id != ?', last_action_id ).delete_all
+end
+

data/mod/01_history/set/all/content_history.rb

@@ -0,0 +1,131 @@
+
+# if these aren't in a nested module, the methods just overwrite the base methods,
+# but we need a distict module so that super will be able to refer to the base methods.
+def content
+  if @selected_action_id
+    @selected_content ||= begin
+      (change = last_change_on( :db_content, :not_after=> @selected_action_id ) and change.value) || db_content
+    end
+  else
+    super
+  end
+end
+
+def content= value
+  @selected_content = nil
+  super
+end
+
+def save_content_draft content
+  super
+  acts.create do |act|
+    act.actions.build(:draft => true, :card_id=>id).changes.build(:field=>:db_content, :value=>content)
+  end
+end
+
+def last_change_on(field, opts={})
+  where_sql =  'card_actions.card_id = :card_id AND field = :field AND (draft is not true) '
+  where_sql += if opts[:before]
+    'AND card_action_id < :action_id'      
+  elsif opts[:not_after]
+    'AND card_action_id <= :action_id'
+  else
+    ''
+  end
+  
+  action_arg = opts[:before] || opts[:not_after]
+  action_id = action_arg.kind_of?(Card::Action) ? action_arg.id : action_arg
+  field_index = Card::TRACKED_FIELDS.index(field.to_s)
+  Change.joins(:action).where( where_sql, 
+    {:card_id=>id, :field=>field_index, :action_id=>action_id}
+  ).order(:id).last
+end
+
+def selected_action_id
+  @selected_action_id || (@current_action and @current_action.id) || last_action_id 
+end
+
+def selected_action_id= action_id
+  @selected_content = nil
+  @selected_action_id = action_id
+end
+
+def selected_action
+  selected_action_id and Action.fetch(selected_action_id)
+end
+
+def selected_content_action_id
+  @selected_action_id ||  
+  (@current_action and @current_action.new_content? and @current_action.id) || 
+  last_content_action_id 
+end
+
+def last_action_id
+  la = last_action and la.id
+end
+
+def last_action
+  actions.where('id IS NOT NULL').last
+end
+
+def last_content_action
+  l_c = last_change_on(:db_content) and l_c.action
+end
+
+def last_content_action_id
+  l_c = last_change_on(:db_content) and l_c.card_action_id
+end
+
+def last_actor
+  last_act.actor
+end
+
+def last_act
+  last_act_on_self = acts.last
+  if last_act_on_self and (last_action.act == last_act_on_self or last_act_on_self.acted_at > last_action.act.acted_at)
+    last_act_on_self
+  else
+    last_action.act
+  end
+end
+
+def acted_at
+  last_act.acted_at
+end
+
+
+def previous_action action_id
+  if action_id
+    action_index = actions.find_index do |a|
+      a.id == action_id
+    end
+    actions[action_index - 1] if action_index.to_i != 0
+  end
+end
+
+def revised_at
+  (last_action and act=last_action.act and act.acted_at) or Time.now
+end
+
+def creator
+  Card[ creator_id ]
+end
+
+def updater
+  Card[ updater_id ]
+end
+
+def clean_html?
+  true
+end
+
+def draft_acts
+  drafts.created_by(Card::Auth.current_id).map(&:act)
+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_history/set/all/history.rb

@@ -0,0 +1,296 @@
+REVISIONS_PER_PAGE = Card.config.revisions_per_page
+
+# must be called on all actions and before :set_name, :process_subcards and :validate_delete_children
+def create_act_and_action
+  @current_act = if @supercard 
+    @supercard.current_act || @supercard.acts.build(:ip_address=>Env.ip)
+  else
+    acts.build(:ip_address=>Env.ip)
+  end
+
+  @current_action = actions.build(:action_type=>@action, :draft=>(Env.params['draft'] == 'true') )
+  @current_action.act = @current_act
+
+  if (@supercard and @supercard !=self)
+    @current_action.super_action = @supercard.current_action
+  end
+end
+
+
+
+event(:create_act_and_action_for_save,   :before=>:process_subcards, :on=>:save)   { create_act_and_action }
+event(:create_act_and_action_for_delete, :before =>:validate_delete_children, :on=>:delete) { create_act_and_action }
+
+
+event :remove_empty_act, :after=>:extend do
+  # if not @supercard and not @current_act.actions.empty?
+  #   @current_act.save
+  # end
+  @current_act.reload
+  if not @supercard and @current_act.actions.empty?
+     @current_act.delete
+     @current_act = nil
+   end
+end
+
+
+
+event :rollback_actions, :before=>:approve, :on=>:update, :when=>proc{ |c| Env and Env.params['action_ids'] and Env.params['action_ids'].class == Array} do
+  revision = { :subcards => {}}
+  rollback_actions = Env.params['action_ids'].map do |a_id|
+    Action.fetch(a_id) || nil
+  end
+  rollback_actions.each do |action|  
+    if action.card_id == id
+      revision.merge!(revision(action)) 
+    else
+      revision[:subcards].merge!(revision(action))
+    end
+  end
+  
+  Env.params['action_ids'] = nil
+  update_attributes! revision
+  rollback_actions.each do |action|
+    action.card.attachment_symlink_to action.id
+  end
+  clear_drafts
+  abort :success
+end
+
+
+
+
+
+def intrusive_family_acts args={}   # all acts with actions on self and on cards that are descendants of self and included in self
+  @intrusive_family_acts ||= begin
+    Act.find_all_with_actions_on( (included_descendant_card_ids << id), args)
+  end
+end
+
+def intrusive_acts  args={:with_drafts=>true} # all acts with actions on self and on cards included in self
+  @intrusive_acts ||= begin
+    Act.find_all_with_actions_on( (included_card_ids << id), args)
+  end
+end
+
+def current_rev_nr
+  @current_rev_nr ||= begin
+    @intrusive_acts.first.actions.last.draft ? @intrusive_acts.size - 1 : @intrusive_acts.size
+  end
+end
+
+def included_card_ids
+  Card::Reference.select(:referee_id).where( :ref_type => 'I', :referer_id=>id ).pluck('referee_id').compact.uniq
+end 
+  
+def descendant_card_ids parent_ids=[id]
+  more_ids = Card.where('left_id IN (?)', parent_ids).pluck('id')
+  
+  if !more_ids.empty? 
+    more_ids += descendant_card_ids more_ids
+  end
+  more_ids
+end
+
+def included_descendant_card_ids
+  included_card_ids & descendant_card_ids
+end
+
+format :html do
+  view :history do |args|
+    frame args.merge(:body_class=>"history-slot", :content=>true, :subheader=>_render_revision_subheader ) do
+      _render_revisions
+    end
+  end
+
+  view :revisions do |args| 
+    page = params['page'] || 1
+    count = card.intrusive_acts.size+1-(page.to_i-1)*REVISIONS_PER_PAGE
+    card.intrusive_acts.page(page).per(REVISIONS_PER_PAGE).map do |act|      
+      count -= 1
+      render_act_summary args.merge(:act=>act,:rev_nr=>count)
+    end.join
+  end
+  
+  view :revision_subheader do |args|
+    intr = card.intrusive_acts.page(params['page']).per(REVISIONS_PER_PAGE)
+    render_haml :intr=>intr do 
+      %{
+.history-header  
+  %span.slotter
+    = paginate intr, :remote=>true, :theme=>'twitter-bootstrap-3'
+  %span.history-legend{:style=>"text-align:right;"}
+    %span.glyphicon.glyphicon-plus-sign.diff-green
+    %span
+      = Card::Diff.render_added_chunk("Added")
+      |
+    %span.glyphicon.glyphicon-minus-sign.diff-red
+    %span
+      = Card::Diff.render_deleted_chunk("Deleted")
+      }
+    end
+  end
+  
+  view :act_summary do |args|
+    render_act :summary, args
+  end
+  
+  view :act_expanded do |args|
+    render_act :expanded, args
+  end
+  
+  def render_act act_view, args
+    act = (params['act_id'] and Card::Act.find(params['act_id'])) || args[:act]
+    rev_nr = params['rev_nr'] || args[:rev_nr] 
+    current_rev_nr = params['current_rev_nr'] || args[:current_rev_nr] || card.current_rev_nr
+    hide_diff = (params["hide_diff"]=="true") || args[:hide_diff]
+    wrap( args.merge(:slot_class=>"revision-#{act.id} history-slot") ) do
+      render_haml :card=>card, :act=>act, :act_view=>act_view, 
+                  :current_rev_nr=>current_rev_nr, :rev_nr=>rev_nr, 
+                  :hide_diff=> hide_diff do 
+        %{
+.act{:style=>"clear:both;"}
+  .head
+    .nr
+      = "##{rev_nr}"
+    .title
+      .actor
+        = link_to act.actor.name, card_url( act.actor.cardname.url_key )
+      .time.timeago
+        = time_ago_in_words(act.acted_at)
+        ago
+        - if act.actions.last.draft
+          |
+          %em.info
+            Autosave
+        - if current_rev_nr == rev_nr
+          |
+          %em.info
+            Current
+        - elsif act_view == :expanded
+          = rollback_link act.relevant_actions_for(card, act.actions.last.draft)
+          = show_or_hide_changes_link hide_diff, :act_id=>act.id, :act_view=>act_view, :rev_nr=>rev_nr, :current_rev_nr=>current_rev_nr 
+  .toggle
+    = fold_or_unfold_link :act_id=>act.id, :act_view=>act_view, :rev_nr=>rev_nr, :current_rev_nr=>current_rev_nr
+  
+  .action-container{:style=>("clear: left;" if act_view == :expanded)}
+    - act.relevant_actions_for(card).each do |action|
+      = send("_render_action_#{ act_view }", :action=>action )
+      }
+      end
+    end
+  end
+  
+  view :action_summary do |args|
+    render_action :summary, args
+  end
+  
+  view :action_expanded do |args|
+    render_action :expanded, args
+  end
+
+  def render_action action_view, args
+    action = args[:action] || card.last_action
+    render_haml :action => action, 
+                :action_view=>action_view, 
+                :hide_diff=>Env.params["hide_diff"]=="true" || args[:hide_diff] do
+      %{
+.action
+  .summary
+    %span.ampel   
+      %span.glyphicon.glyphicon-minus-sign{:class=>(action.red? ? 'diff-red' : 'diff-invisible')}
+      %span.glyphicon.glyphicon-plus-sign{:class=>(action.green? ? 'diff-green' : 'diff-invisible')}
+    -if action.card == card
+      = wrap_diff :name do
+        - name_changes(action, hide_diff)
+    -else
+      =  link_to path(:view=>:related, :related=>{:view=>"history",:name=>action.card.name}), :class=>'slotter name-diff', 
+                   :slotSelector=>".card-slot.card-frame", :remote=>true do
+        - name_changes(action, hide_diff)    
+    -if action.new_type?
+      = wrap_diff :type do
+        - type_changes action, hide_diff
+    -if action.new_content?
+      %span.glyphicon.glyphicon-arrow-right.arrow
+      -if action_view == :summary 
+        = wrap_diff :content do
+          - action.card.format.render_content_changes :action=>action, :diff_type=>action_view, :hide_diff=>hide_diff
+  -if action.new_content? and action_view == :expanded
+    .expanded
+      = wrap_diff :content do
+        - action.card.format.render_content_changes :action=>action, :diff_type=>action_view, :hide_diff=>hide_diff
+        }
+    end
+  end
+
+  def wrap_diff field, &block
+    content = block.call
+    if content.present?
+      %{
+         <span class="#{field}-diff">
+         #{content}
+         </span>
+      }
+    end
+  end
+  
+  def name_changes action, hide_diff=false
+    old_name = (name = action.old_values[:name] and showname(name).to_s)
+    if action.new_name?
+      new_name = showname(action.new_values[:name]).to_s
+      if hide_diff 
+        new_name
+      else
+        Card::Diff.complete(old_name,new_name)
+      end
+    else
+      old_name
+    end
+  end
+  
+  def type_changes action, hide_diff=false
+    change = hide_diff ? action.new_values[:cardtype] : action.cardtype_diff
+    "(#{change})"
+  end
+  
+
+
+  
+  view :content_changes do |args|
+    if args[:hide_diff]
+      args[:action].new_values[:content]
+    else 
+      args[:action].content_diff(args[:diff_type])
+    end
+  end
+
+  def rollback_link action_ids
+    if card.ok?(:update) 
+      "| " + link_to('Save as current', path(:action=>:update, :view=>:open, :action_ids=>action_ids,),
+        :class=>'slotter',:slotSelector=>'.card-slot.card-frame', :remote=>true, :method=>:post, :rel=>'nofollow')
+    end
+  end
+
+  def fold_or_unfold_link args
+    if (args[:act_view] == :expanded)
+      toggled_view = :act_summary
+    else
+      toggled_view = :act_expanded
+    end
+    link_to '', args.merge(:view=>toggled_view), 
+              :class=>"slotter revision-#{args[:act_id]} #{ args[:act_view]==:expanded ? "arrow-down" : "arrow-right"}", 
+              :remote=>true
+  end
+  
+  def show_or_hide_changes_link hide_diff, args
+    "| " +  view_link( (hide_diff ? "Show" : "Hide") + " changes", :act_expanded, 
+      :path_opts=>args.merge(:hide_diff=>!hide_diff), 
+      :class=>'slotter', :remote=>true )
+  end
+end
+
+def diff_args
+  {:format=>:text}
+end
+
+