wagn 1.12.7

data/mods/standard/sets/all/rss.rb

@@ -0,0 +1,66 @@
+# -*- encoding : utf-8 -*-
+
+format :rss do
+
+  view :show do |args|
+  #    render( args[:view] || :feed )
+    @xml = Builder::XmlMarkup.new
+    render_feed
+  end
+
+  # FIXME: integrate this with common XML features when it is added
+  view :feed do |args|
+    begin
+      @xml.instruct! :xml, :version => "1.0"
+      @xml.rss :version => "2.0" do
+        @xml.channel do
+          @xml.title       render_feed_title
+          @xml.description render_feed_description
+          @xml.link        render_url
+          render_feed_item_list
+        end
+      end
+    rescue Exception=>e
+      @xml.error "\n\nERROR rendering RSS: #{e.inspect}\n\n #{e.backtrace}"
+    end
+  end
+  
+  view :feed_item_list do |args|
+    items = if card.type_id == Card::SearchTypeID  #FIXME! yuck.
+      card.item_cards( search_params.merge(:default_limit => 25) )
+    else
+      [card]
+    end
+    items.each do |item|
+      @xml.item do
+        subformat(item).render_feed_item :view_changes=>(card.id==Card::RecentID)  #FIXME! yuck.
+      end
+    end
+  end
+  
+  
+  view :feed_title do |args|
+    Card.setting(:title) + " : " + card.name.gsub(/^\*/,'')
+  end
+  
+  view :feed_item do |args|
+    @xml.title card.name
+    add_name_context
+    @xml.description render((args[:view_changes] ? :change : :open_content))
+    @xml.pubDate card.revised_at.to_s(:rfc822)  #updated_at fails on virtual cards, because not all to_s's take args (just actual dates)
+    @xml.link render_url
+    @xml.guid render_url
+  end
+
+
+  view :feed_description do |args| '' end
+  view :comment_box     do |args| '' end
+  view :menu            do |args| '' end
+    
+  
+  view :open, :titled
+  view :content, :core
+  view :open_content, :core
+  view :closed, :link
+
+end

data/mods/standard/sets/all/text.rb

@@ -0,0 +1,9 @@
+# -*- encoding : utf-8 -*-
+
+format :text do
+
+  view :core do |args|
+    HTMLEntities.new.decode "#{ strip_tags( super args ) }" #need this string method to get out of html_safe mode
+  end
+
+end

data/mods/standard/sets/right/account.rb

@@ -0,0 +1 @@
+# -*- encoding : utf-8 -*-

data/mods/standard/sets/right/add_help.rb

@@ -0,0 +1 @@
+view :core, :right=>:structure

data/mods/standard/sets/right/comment.rb

@@ -0,0 +1,3 @@
+view :core,           :right=>:create
+view :editor,         :right=>:create
+view :closed_content, :right=>:create

data/mods/standard/sets/right/create.rb

@@ -0,0 +1,82 @@
+
+format do
+  view :editor do |args|
+    set_name = card.cardname.trunk_name
+    set_card = Card.fetch(set_name)
+    not_set = set_card && set_card.type_id != Card::SetID
+
+    group_options = Account.as_bot { Card.search(:type=>Card::RoleID, :sort=>'name') }
+
+    inheritable = not_set ? false : set_card.inheritable?
+    inheriting = inheritable && card.content=='_left'
+
+    item_names = inheriting ? [] : card.item_names
+
+    %{     
+      #{ form.hidden_field :content, :class=>'card-content' }
+      <div class="perm-editor">
+    
+        #{ if inheritable; %{
+          <div class="perm-inheritance perm-section">
+            #{ check_box_tag 'inherit', 'inherit', inheriting }
+            <label>
+              #{ core_inherit_content args.merge(:target=>'wagn_role') }
+              #{ content_tag( :a, :title=>"use left's #{card.cardname.tag} rule") { '?' } }
+            </label>
+          </div>
+        } end }
+    
+        <div class="perm-group perm-vals perm-section">
+          <h5>Groups</h5>
+          #{
+            group_options.map do |option|
+              checked = !!item_names.delete(option.name)
+              %{
+                <div class="group-option">
+                  #{ check_box_tag( "#{option.key}-perm-checkbox", option.name, checked, :class=>'perm-checkbox-button'  ) }
+                  <label>#{ link_to_page option.name, nil, :target=>'wagn_role' }</label>
+                </div>
+              }
+            end * "\n"
+          }
+        </div>
+      
+        <div class="perm-indiv perm-vals perm-section">
+          <h5>Individuals</h5>
+          #{ _render_list :item_list=>item_names, :extra_css_class=>'perm-indiv-ul' }
+        </div>
+                
+      </div>
+    }
+  end
+
+  view :core do |args|
+    args[:item] ||= :link
+    card.content=='_left' ? core_inherit_content(args) : _final_pointer_type_core(args)
+  end
+
+  view :closed_content do |args|
+    card.content=='_left' ? core_inherit_content(args) : _final_pointer_type_closed_content(args)
+  end
+
+  private
+
+  def core_inherit_content args={}
+    sc = args[:set_context]
+    text = if sc && sc.tag_name.key == Card[:self].key
+      begin
+        task = card.tag.codename
+        ancestor = Card[sc.trunk_name.trunk_name]
+        links = ancestor.who_can( task.to_sym ).map do |card_id|
+          link_to_page Card[card_id].name, nil, :target=>args[:target]
+        end*", "
+        "Inherit ( #{links} )"
+      rescue
+        'Inherit'
+      end
+    else
+      'Inherit from left card'
+    end
+    %{<span class="inherit-perm">#{text}</span>}
+  end
+end

data/mods/standard/sets/right/crypted_password.rb

@@ -0,0 +1,4 @@
+view :raw do |args|
+  "Private data"
+end
+view :core, :raw

data/mods/standard/sets/right/default.rb

@@ -0,0 +1,2 @@
+view :core, :right=>:structure
+view :closed_content, :right=>:structure

data/mods/standard/sets/right/delete.rb

@@ -0,0 +1,3 @@
+view :core,           :right=>:create
+view :editor,         :right=>:create
+view :closed_content, :right=>:create

data/mods/standard/sets/right/email.rb

@@ -0,0 +1,5 @@
+view :raw do |args|
+  account = Account[ card.left.id ]
+  account ? account.send('email') : ''
+end
+view :core, :raw

data/mods/standard/sets/right/help.rb

@@ -0,0 +1 @@
+view :core, :right=>:structure

data/mods/standard/sets/right/read.rb

@@ -0,0 +1,3 @@
+view :core,           :right=>:create
+view :editor,         :right=>:create
+view :closed_content, :right=>:create

data/mods/standard/sets/right/salt.rb

@@ -0,0 +1,4 @@
+view :raw do |args|
+  "Private data"
+end
+view :core, :raw

data/mods/standard/sets/right/structure.rb

@@ -0,0 +1,11 @@
+view :core do |args|
+  with_inclusion_mode :template do
+    self._final_core args
+  end
+end
+
+
+view :closed_content do |args|
+  "#{_render_type} : #{_render_raw}"
+end
+

data/mods/standard/sets/right/style.rb

@@ -0,0 +1,67 @@
+# -*- encoding : utf-8 -*-
+
+
+def self.delete_style_files
+  Account.as_bot do
+    Card.search( :right=>{:codename=>'style'}, :return=>'id' ).each do |style_file_id|
+      Card.delete_tmp_files style_file_id
+    end
+  end
+end
+
+#FIXME - the following could be unified with type/file.rb considerably
+
+# note that this was formerly accomplished as a separate File card (eg *all+*style+file).  The issue was that the permanent
+# file regularly caused problems with non-root wagns, and requiring users to re-save the *all+*style rule upon updates
+# to CSS, SCSS, and Skin cards was not popular.
+
+def style_file
+  Wagn.paths['files'].existent.first + "/tmp/#{id}/#{current_revision_id}.css"
+end
+
+def style_path
+  "#{ Wagn.config.files_web_path }/#{ name.to_name.url_key }-#{ current_revision_id }.css"
+end
+
+
+format do
+  # FIXME - this should be a read event (when we have read events)
+  view :not_found do |args|
+    if card.real?
+      compressed_css = card.compress_stylesheets
+      filename = card.style_file 
+      FileUtils.mkdir_p File.dirname(filename)  
+      File.open filename, 'w' do |f|
+        f.write compressed_css
+      end
+      self.error_status = 302
+      wagn_path card.style_path
+    else
+      _final_not_found args
+    end
+  end
+  
+end
+
+
+format :file do
+  view :core do |args|
+    if params[:explicit_file] and r = controller.response
+      r.headers["Expires"] = 1.year.from_now.httpdate
+    end
+    
+    [ card.style_file, { :filename=>"#{card.cardname.url_key}.css",
+        :x_sendfile=>true, :type=>'text/css', :disposition=>'inline' } ]
+  end
+end
+
+
+def compress_stylesheets
+  Account.as_bot do
+    format = Card::CssFormat.new self
+    Sass.compile format._render_core, :style=>:compressed
+  end
+rescue Exception=>e
+  raise Wagn::Oops, "Stylesheet Error:\n#{ e.message }"
+end
+

data/mods/standard/sets/right/update.rb

@@ -0,0 +1,3 @@
+view :core,           :right=>:create
+view :editor,         :right=>:create
+view :closed_content, :right=>:create

data/mods/standard/sets/right/when_created.rb

@@ -0,0 +1,5 @@
+view :raw do |args|
+  card.left.new_card? ? '' : card.left.created_at.strftime('%A, %B %d, %Y %I:%M %p %Z')
+end
+
+view :core, :raw

data/mods/standard/sets/right/when_last_edited.rb

@@ -0,0 +1,5 @@
+view :raw do |args|
+  card.left.new_card? ? '' : card.left.updated_at.strftime('%A, %B %d, %Y %I:%M %p %Z')
+end
+
+view :core, :raw

data/mods/standard/sets/rstar/rules.rb

@@ -0,0 +1,235 @@
+format :html do
+
+  view :closed_rule, :tags=>:unknown_ok do |args|
+    return 'not a rule' if !card.is_rule? #these are helpful for handling non-rule rstar cards until we have real rule sets
+      
+    rule_card = card.new_card? ? find_current_rule_card[0] : card
+
+    rule_content = !rule_card ? '' : begin
+      subformat(rule_card)._render_closed_content :set_context=>card.cardname.trunk_name
+    end
+
+    cells = [
+      ["rule-setting",
+        link_to( card.cardname.tag.sub(/^\*/,''), path(:view=>:open_rule),
+          :class => 'edit-rule-link slotter', :remote => true, :rel=>'nofollow' )
+      ],
+      ["rule-content",
+        %{<div class="rule-content-container">
+           <span class="closed-content content">#{rule_content}</span>
+         </div> } ],
+      ["rule-set", (rule_card ? rule_card.trunk.label : '') ],
+    ]
+
+    extra_css_class = rule_card && !rule_card.new_card? ? 'known-rule' : 'missing-rule'
+
+    %{<tr class="card-slot closed-rule">} +
+    cells.map do |css_class, content|
+      %{<td class="rule-cell #{css_class} #{extra_css_class}">#{content}</td>}
+    end.join("\n") +
+    '</tr>'
+  end
+
+
+
+  view :open_rule, :tags=>:unknown_ok do |args|
+    return 'not a rule' if !card.is_rule?
+    
+    current_rule, prototype = find_current_rule_card
+    setting_name = card.cardname.tag
+    current_rule ||= Card.new :name=> "*all+#{setting_name}" #FIXME use codename
+    set_selected = false
+
+    #~~~~~~ handle reloading due to type change
+    if params[:type_reload] && card_args=params[:card]
+      if card_args[:name] && card_args[:name].to_name.key != current_rule.key
+        current_rule = Card.new card_args
+      else
+        current_rule = current_rule.refresh
+        current_rule.assign_attributes card_args
+        current_rule.include_set_modules
+      end
+
+      set_selected = card_args[:name].to_name.left_name.to_s
+    end
+
+    edit_mode = !params[:item] && card.ok?( ( card.new_card? ? :create : :update ) )
+    
+    opts = {
+      :open_rule    => card,
+      :setting_name => setting_name,
+      :set_context  => card.cardname.trunk_name
+    }
+    rule_view = edit_mode ? :edit_rule : :show_rule
+    
+    
+    
+    if edit_mode
+      opts.merge!( {
+        :fallback_set    => false,
+        :current_set_key => (current_rule.new_card? ? nil : current_rule.cardname.trunk_name.key),
+        :set_selected    => set_selected
+      } )
+      
+      #~~~~~~~~~~ determine the set options to which the user can apply the rule.
+
+      set_options = prototype.set_names.reverse
+      first = (csk=opts[:current_set_key]) ? set_options.index{|s| s.to_name.key == csk} : 0
+      if first > 0
+        set_options[0..(first-1)].reverse.each do |set_name|
+          opts[:fallback_set] = set_name if Card.exists?("#{set_name}+#{opts[:setting_name]}")
+        end
+      end
+      last = set_options.index{|s| s.to_name.key == card.cardname.trunk_name.key} || -1
+      # note, the -1 can happen with virtual cards because the self set doesn't show up in the set_names.  FIXME!!
+      opts[:set_options] = set_options[first..last]
+
+
+      # The broadest set should always be the currently applied rule
+      # (for anything more general, they must explicitly choose to "DELETE" the current one)
+      # the narrowest rule should be the one attached to the set being viewed.  So, eg, if you're looking at the "*all plus" set, you shouldn't
+      # have the option to create rules based on arbitrary narrower sets, though narrower sets will always apply to whatever prototype we create
+    end
+
+    %{
+      
+      <tr class="card-slot open-rule #{rule_view.to_s.sub '_', '-'}">
+        <td class="rule-cell" colspan="3">
+          <div class="rule-setting">
+            #{ link_to_view setting_name.sub(/^\*/,''), :closed_rule, :class=>'close-rule-link slotter' }
+            #{ link_to_page "all rules", setting_name, :class=>'setting-link', :target=>'wagn_setting' }
+          </div>
+          
+          <div class="instruction rule-instruction">
+            #{ process_content "{{#{setting_name}+*right+*help}}" }
+          </div>
+          
+          <div class="card-body">
+            #{ subformat( current_rule )._render rule_view, opts }
+          </div>
+        </td>
+      </tr>
+    }
+
+  end
+  
+  view :show_rule, :tags=>:unknown_ok do |args|
+    return 'not a rule' if !card.is_rule?
+    
+    if !card.new_card?
+      set = card.trunk
+      args[:item] ||= :link
+      %{
+        <div class="rule-set">
+          <label>Applies to</label> #{ link_to_page set.label, set.name }:
+        </div>
+        #{ _render_core args }
+      }
+    else
+      'No Current Rule'
+    end
+  end
+
+  view :edit_rule, :tags=>:unknown_ok do |args|
+    return 'not a rule' if !card.is_rule?
+
+    setting_name    = args[:setting_name]
+    current_set_key = args[:current_set_key] || Card[:all].name  # (should have a constant for this?)
+    open_rule       = args[:open_rule]
+
+    form_for card, :url=>path(:action=>:update, :no_id=>true), :remote=>true, :html=>
+        {:class=>"card-form card-rule-form slotter" } do |form|
+
+      %{
+        #{ hidden_field_tag 'success[id]', open_rule.name }
+        #{ hidden_field_tag 'success[view]', 'open_rule' }
+        #{ hidden_field_tag 'success[item]', 'view_rule' }
+        
+
+        <div class="card-editor">
+          #{
+            fieldset 'type', type_field(
+              :href         => path(:card=>open_rule, :view=>:open_rule, :type_reload=>true),
+              :class        => 'type-field rule-type-field live-type-field',
+              'data-remote' => true
+            ), :editor=>'type'
+          }
+          
+          #{ fieldset 'content', content_field( form, args.merge(:skip_rev_id=>true) ), :editor=>'content' }
+          
+          #{
+            fieldset 'set', (
+              option_items = args[:set_options].map do |set_name|
+                checked = ( args[:set_selected] == set_name or current_set_key && args[:set_options].length==1 )
+                is_current = set_name.to_name.key == current_set_key
+                %{
+                  <li>
+                    #{ form.radio_button :name, "#{set_name}+#{setting_name}", :checked=> checked }
+                    <span class="set-label" #{'current-set-label' if is_current }>
+                      #{ link_to_page Card.fetch(set_name).label, set_name, :target=>'wagn_set' }
+                      #{'<em>(current)</em>' if is_current}
+                    </span>
+                  </li>
+                }
+              end
+              %{ <ul>#{ option_items * "\n" }</ul>}
+            ), :editor => 'set'
+          }          
+        </div>
+        
+        <div class="edit-button-area">
+          #{ 
+            if !card.new_card?
+              b_args = { :remote=>true, :class=>'rule-delete-button slotter', :type=>'button' }
+              b_args[:href] = path :action=>:delete, :success=>{ :id=>open_rule.cardname.url_key, :view=>:open_rule, :item=>:view_rule }
+              if fset = args[:fallback_set]
+                b_args['data-confirm']="Deleting will revert to #{setting_name} rule for #{Card.fetch(fset).label }"
+              end
+              %{<span class="rule-delete-section">#{ button_tag 'Delete', b_args }</span>}
+            end
+           }
+           #{ submit_tag 'Submit', :class=>'rule-submit-button' }
+           #{ button_tag 'Cancel', :class=>'rule-cancel-button slotter', :type=>'button',
+                :href=>path( :view=>( card.new_card? ? :closed_rule : :open_rule ), :card=>open_rule, :item=>:view_rule ) }
+        </div>
+      }
+    end
+  end
+
+
+  private
+
+  def find_current_rule_card
+    # self.card is a POTENTIAL rule; it quacks like a rule but may or may not exist.
+    # This generates a prototypical member of the POTENTIAL rule's set
+    # and returns that member's ACTUAL rule for the POTENTIAL rule's setting
+    set_prototype = card.trunk.prototype
+    rule_card = if card.new_card?
+      setting = card.right and set_prototype.rule_card setting.codename   
+    else
+      card
+    end 
+    [ rule_card, set_prototype ]
+  end
+
+end
+
+# I doubt that the following are actually included at present.
+
+def repair_set
+  @set_repair_attempted = true
+  if real?
+    reset_patterns
+    template # repair happens in template loading
+    include_set_modules
+  end
+end
+ 
+def method_missing method_id, *args
+  if !@set_repair_attempted and repair_set
+    send method_id, *args
+  else
+    super
+  end
+end
+