wagn 1.14.9 → 1.15.pre

data/mod/05_standard/set/type/set.rb

@@ -1,118 +0,0 @@
-
-format :html do
-
-  view :core do |args|
-    body = card.setting_codenames_by_group.map do |group, data|
-      next if group.nil? || data.nil?
-      group_name = Card::Setting.group_names[group] || group.to_s
-      content_tag(:tr, :class=>"rule-group") do
-        (["#{group_name} Rules"]+%w{Content Set}).map do |heading|
-          content_tag(:th, :class=>'rule-heading') { heading }
-        end * "\n"
-      end +
-      raw( data.map do |setting|
-        rule_card = card.fetch(:trait=>setting, :new=>{})
-        nest rule_card, :view=>:closed_rule
-      end * "\n" )
-    end.compact * ''
-    %{
-      #{
-        unless args[:unlabeled]
-          %{ <h2 class="set-label">#{ card.label }</h2> }
-        end
-      }
-      #{ content_tag('table', :class=>'set-rules') { body } }
-    }
-  end
-
-
-  view :editor do |args|
-    'Cannot currently edit Sets' #ENGLISH
-  end
-  
-  view :template_link do |args|
-    args.delete :style
-    wrap args do
-      link = view_link args[:inc_syntax], :template_editor, :class=>'slotter' #, 'slot-include'=>include_syntax
-      "{{#{link}}}"
-    end
-  end
-  
-  view :template_closer do |args|
-    view_link '', :template_link, :class=>'slotter ui-icon ui-icon-closethick template-editor-close'
-  end
-  
-  view :template_editor do |args|
-    wrap args do
-      %{
-        <div class="template-editor-left">{{</div> 
-        <div class="template-editor-main">
-          #{
-            frame :no_slot=>true, :title=>card.label, :menu_hack=>:template_closer do
-              _render_core args.merge(:unlabeled=>true)
-            end
-          }
-        </div>
-        <div class="template-editor-right">}}</div> 
-      }
-    end
-  end
-
-  view :closed_content do |args|
-    ''
-  end
-end
-
-
-include Card::Set::Type::SearchType
-
-def inheritable?
-  return true if junction_only?
-  cardname.trunk_name.junction? and cardname.tag_name.key == Card::SelfSet.pattern.key
-end
-
-def subclass_for_set
-  set_class_key = tag.codename
-  Card.set_patterns.find do |sub|
-    cardname.tag_name.key == sub.pattern.key
-  end
-end
-
-def junction_only?()
-  if @junction_only.nil?
-    @junction_only = subclass_for_set.junction_only
-  else
-    @junction_only
-  end
-end
-
-def reset_set_patterns
-  Card.members( key ).each do |mem|
-    Card.expire mem
-  end
-end
-
-def label
-  if klass = subclass_for_set
-    klass.label cardname.left
-  else
-    ''
-  end
-end
-
-
-def setting_codenames_by_group
-  result = {}
-  Card::Setting.groups.each do |group, settings| 
-    visible_settings = settings.reject { |s| !s or !s.applies_to_cardtype(prototype.type_id) }
-    unless visible_settings.empty?
-      result[group] = visible_settings.map { |s| s.codename }
-    end
-  end
-  result
-end
-
-def prototype
-  opts = subclass_for_set.prototype_args self.cardname.trunk_name
-  Card.fetch opts[:name], :new=>opts
-end

data/mod/05_standard/set/type/signup.rb

@@ -1,144 +0,0 @@
-
-format :html do
-  
-  def default_new_args args
-    super args
-    args.merge!(
-      :optional_help => :show, #, :optional_menu=>:never
-      :buttons => button_tag( 'Submit', :disable_with=>'Submitting' ),
-      :account => card.fetch( :trait=>:account, :new=>{} ),
-      :title   => 'Sign up',
-      :hidden  => {
-        :success => (card.rule(:thanks) || '_self'),
-        'card[type_id]' => card.type_id
-      }
-    )
-    
-    if Auth.signed_in? and args[:account].confirm_ok?
-      args[:title] = 'Invite'
-      args[:buttons] = button_tag 'Send Invitation'
-      args[:hidden][:success] = '_self'
-    end
-  end
-  
-  view :new do |args|
-    #FIXME - make more use of standard new view?
-    
-    frame_and_form :create, args, 'main-success'=>"REDIRECT" do
-      [
-        _render_name_fieldset( :help=>'usually first and last name' ),
-        _optional_render( :account_fieldsets, args),
-        ( card.structure ? edit_slot : ''),
-        _optional_render( :button_fieldset, args )
-      ]
-    end
-  end
-
-
-  view :account_fieldsets do |args|
-    sub_args = { :structure => true }
-    sub_args[:no_password] = true if Auth.signed_in?
-    Auth.as_bot { subformat( args[:account] )._render :content_fieldset, sub_args }  #YUCK!!!!
-  end
-
-
-  view :core do |args|
-    headings, links = [], []
-    if !card.new_card? #necessary?
-      by_anon = card.creator_id == AnonymousID
-      headings << %(<strong>#{ card.name }</strong> #{ 'was' if !by_anon } signed up on #{ format_date card.created_at })
-      if account = card.account
-        token_action = 'Send'
-        if account.token.present?
-          headings << "A verification email has been sent #{ "to #{account.email}" if account.email_card.ok? :read }"
-          token_action = 'Resend'
-        end
-        if account.confirm_ok?
-          links << link_to( "#{token_action} verification email", wagn_path("update/~#{card.id}?approve_with_token=true"  ) )
-          links << link_to( "Approve without verification", wagn_path("update/~#{card.id}?approve_without_token=true") )
-        end
-        if card.ok? :delete
-          links << link_to( "Deny and delete", wagn_path("delete/~#{card.id}") )
-        end
-        headings << links * '' if links.any?
-      else
-        headings << "ERROR: signup card missing account"
-      end
-    end
-    %{<div class="invite-links">
-        #{ headings.map { |h| "<div>#{h}</div>"} * "\n" }
-      </div>
-      #{ process_content render_raw }    
-    }
-  end
-end
-
-event :activate_by_token, :before=>:approve, :on=>:update, :when=>proc{ |c| c.has_token? } do
-  result = account ? account.authenticate_by_token( @env_token ) : "no account associated with #{name}"
-  case result
-  when Integer
-    abort :failure, 'no field manipulation mid-activation' if subcards.present? 
-    # necessary because the rest of the action is performed as Wagn Bot
-    activate_account
-    Auth.signin id
-    Auth.as_bot
-    Env.params[:success] = ''
-  when :token_expired
-    resend_activation_token
-    abort :success
-  else
-    abort :failure, "signup activation error: #{result}" # bad token or account
-  end
-end
-
-def has_token?
-  @env_token = Env.params[:token]
-end
-
-event :activate_account do
-  subcards['+*account'] = {'+*status'=>'active'}
-  self.type_id = Card.default_accounted_type_id
-  account.send_welcome_email
-end
-
-event :approve_with_token, :on=>:update, :before=>:approve, :when=>proc {|c| Env.params[:approve_with_token] } do
-  abort :failure, 'illegal approval' unless account.confirm_ok?
-  account.reset_token
-  account.send_account_verification_email
-end
-
-event :approve_without_token, :on=>:update, :before=>:approve, :when=>proc {|c| Env.params[:approve_without_token] } do
-  abort :failure, 'illegal approval' unless account.confirm_ok?
-  activate_account
-end
-
-event :resend_activation_token do
-  account.reset_token
-  account.send_account_verification_email
-  Env.params[:success] = {
-    :id => '_self',
-    :view => 'message',
-    :message => "Sorry, this token has expired. Please check your email for a new password reset link."
-  }
-end
-
-def signed_in_as_me_without_password?
-  Auth.signed_in? && Auth.current_id==id && account.password.blank?
-end
-
-event :redirect_to_edit_password, :on=>:update, :after=>:store, :when=>proc {|c| c.signed_in_as_me_without_password? } do
-  Env.params[:success] = account.edit_password_success_args  
-end
-
-event :preprocess_account_subcards, :before=>:process_subcards, :on=>:create do
-  #FIXME: use codenames!
-  email, password = subcards.delete('+*account+*email'), subcards.delete('+*account+*password')
-  subcards['+*account'] ||={}
-  subcards['+*account']['+*email']   = email if email
-  subcards['+*account']['+*password' ]=password if password
-end
-
-event :act_as_current_for_extend_phase, :before=>:extend, :on=>:create do
-  Auth.current_id = self.id
-end
-

data/mod/05_standard/set/type/toggle.rb

@@ -1,12 +0,0 @@
-
-view :core do |args|
-  case card.raw_content.to_i
-  when 1; 'yes'
-  when 0; 'no'
-  else  ; '?'
-  end
-end
-
-view :editor do |args|
-  form.check_box :content
-end

data/mod/05_standard/set/type/uri.rb

@@ -1,11 +0,0 @@
-format do
-  include Phrase::Format
-
-  view :core do |args|
-    web_link _render_raw(args), :text=> render_title(args)
-  end
-
-  view :url_link do |args|
-    web_link _render_raw(args)
-  end
-end

data/mod/05_standard/set/type/user.rb

@@ -1,62 +0,0 @@
-
-include Basic
-
-attr_accessor :email
-
-format :html do
-
-  view :setup, :tags=>:unknown_ok, :perms=>lambda { |r| Auth.needs_setup? } do |args|
-    help_text = 'To get started, set up an account.'
-    if Wagn.config.action_mailer.perform_deliveries == false 
-      help_text += '<br>WARNING: Email delivery is turned off. Change settings in config/application.rb to send sign up notifications.'
-    end
-    args.merge!( {
-      :title=>'Welcome, Wagneer!',
-      :optional_help=>:show,
-      :optional_menu=>:never, 
-      :help_text=>help_text,
-      :buttons => button_tag( 'Set up', :disable_with=>'Setting up' ),
-      :hidden => { 
-        :success => "REDIRECT: #{ Card.path_setting '/' }",
-        'card[type_id]' => Card.default_accounted_type_id,
-        'setup'=>true
-      }
-    } )
-
-    account = card.fetch :trait=>:account, :new=>{}
-
-    Auth.as_bot do
-      frame_and_form :create, args do
-        [
-          _render_name_fieldset( :help=>'usually first and last name' ),
-          subformat(account)._render( :content_fieldset, :structure=>true ), 
-          _render_button_fieldset( args )
-        ]
-      end
-    end
-  end
-end
-
-
-event :setup_as_bot, :before=>:check_permissions, :on=>:create, :when=>proc{ |c| Card::Env.params[:setup] } do
-  abort :failure unless Auth.needs_setup? 
-  Auth.as_bot
-  # we need bot authority to set the initial administrator roles
-  # this is granted and inspected here as a separate event for 
-  # flexibility and security when configuring initial setups
-end  
-
-event :setup_first_user, :before=>:process_subcards, :on=>:create, :when=>proc{ |c| Card::Env.params[:setup] } do
-  subcards['signup alert email+*to'] = name
-  subcards['+*roles'] = { :content => Card[:administrator].name }
-  
-  email, password = subcards.delete('+*account+*email'), subcards.delete('+*account+*password')
-  subcards['+*account'] = { '+*email'=>email, '+*password'=>password }
-end
-
-event :signin_after_setup, :before=>:extend, :on=>:create, :when=>proc{ |c| Card::Env.params[:setup] } do
-  Card.cache.delete Auth::NEED_SETUP_KEY
-  Auth.signin id
-end
-
-

data/mod/05_standard/spec/chunk/include_spec.rb

@@ -1,186 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Chunk::Include, "Inclusion" do
-  include ActionView::Helpers::TextHelper
-
-  context "syntax parsing" do
-    before do
-      @class= Card::Chunk::Include
-    end
-    
-    it "should ignore invisible comments" do
-      expect(render_content("{{## now you see nothing}}")).to eq('')
-    end
-
-    it "should handle visible comments" do
-      expect(render_content("{{# now you see me}}")).to eq('<!-- # now you see me -->')
-      expect(render_content("{{# -->}}")).to eq('<!-- # --&gt; -->')
-    end
-    
-    it "should handle empty inclusions" do
-      instance = @class.new( @class.full_match( '{{ }}' ) , nil )
-      expect(instance.name).to eq('')
-      expect(instance.options[:inc_syntax]).to eq(' ')
-      instance1 = @class.new( @class.full_match( '{{|}}' ) , nil )
-      expect(instance1.name).to eq('')
-      expect(instance1.options[:inc_syntax]).to eq('|')
-      
-    end
-    
-    it "should handle no pipes" do
-      instance = @class.new( @class.full_match( '{{toy}}') , nil )
-      expect(instance.name).to eq('toy')
-      expect(instance.options[:inc_name]).to eq('toy')
-      expect(instance.options.key?(:view)).to eq(false)
-    end
-    
-    it "should strip the name" do
-      expect(@class.new( @class.full_match( '{{ toy }}') , nil ).name).to eq('toy')
-    end
-    
-    it 'should strip html tags' do
-      expect(@class.new( @class.full_match( '{{ <span>toy</span> }}') , nil ).name).to eq('toy')
-      instance = @class.new( @class.full_match( '{{ <span>toy|open</span> }}') , nil )
-      expect(instance.name).to eq('toy')
-      expect(instance.options[:view]).to eq('open')
-    end
-    
-    it "should handle single pipe" do
-      options = @class.new( @class.full_match('{{toy|view:link;hide:me}}'), nil ).options
-      expect(options[:inc_name]).to eq('toy')
-      expect(options[:view]).to eq('link')
-      expect(options[:hide]).to eq('me')
-      expect(options.key?(:items)).to eq(false)
-    end
-    
-    it "should handle multiple pipes" do
-      options = @class.new( @class.full_match('{{box|open|closed}}'), nil ).options
-      expect(options[:inc_name]).to eq('box')
-      expect(options[:view]).to eq('open')
-      expect(options[:items][:view]).to eq('closed')
-      expect(options[:items].key?(:items)).to eq(false)      
-    end
-
-    it "should handle multiple pipes with blank lists" do
-      options = @class.new( @class.full_match('{{box||closed}}'), nil ).options
-      expect(options[:inc_name]).to eq('box')
-      expect(options[:view]).to eq(nil)
-      expect(options[:items][:view]).to eq('closed')
-    end
-    
-    it "should treat :item as view of next level" do
-      options = @class.new( @class.full_match('{{toy|link;item:name}}'), nil ).options
-      expect(options[:inc_name]).to eq('toy')
-      expect(options[:view]).to eq('link')
-      expect(options[:items][:view]).to eq('name')
-    end
-  end
-
-  context "rendering" do
-
-    it "should handle absolute names" do
-      alpha = newcard 'Alpha', "Pooey"
-      beta = newcard 'Beta', "{{Alpha}}"
-      result = beta.format.render_core
-      assert_view_select result, 'div[class~="card-content"]', "Pooey"
-    end
-
-    it "should handle simple relative names" do
-      alpha = newcard 'Alpha', "{{#{Card::Name.joint}Beta}}"
-      beta = newcard 'Beta'
-      alpha_beta = Card.create :name=>"#{alpha.name}#{Card::Name.joint}Beta", :content=>"Woot"
-      assert_view_select alpha.format.render_core, 'div[class~=card-content]', "Woot"
-    end
-    
-    it "should handle complex relative names" do
-      bob_city = Card.create! :name=>'bob+city', :content=> "Sparta"
-      Card::Auth.as_bot { address_tmpl = Card.create! :name=>'address+*right+*structure', :content =>"{{_left+city}}" }
-      bob_address = Card.create! :name=>'bob+address'
-
-      r=bob_address.reload.format.render_core
-      assert_view_select r, 'div[class~=card-content]', "Sparta"
-      expect(Card.fetch("bob+address").includees.map(&:name)).to eq([bob_city.name])
-    end
-
-    it "should handle nesting" do
-      alpha = newcard 'Alpha', "{{Beta}}"
-      beta = newcard 'Beta', "{{Delta}}"
-      delta = newcard 'Delta', "Booya"
-      r= alpha .format.render_core
-      #warn "r=#{r}"
-      assert_view_select r, 'div[class~=card-content]'
-      expect(r).to match(/Booya/)
-    end
-
-    it "should handle options when nesting" do
-      Card.create! :type=>'Pointer', :name=>'Livable', :content=>'[[Earth]]'
-      Card.create! :name=>'Earth'
-      
-      expect(render_content('{{Livable|core;item:link}}')).to eq(render_content('{{Livable|core|link}}'))
-      expect(render_content('{{Livable|core;item:name}}')).to eq(render_content('{{Livable|core|name}}'))
-    end
-    
-    it "should prevent recursion" do
-      oak = Card.create! :name=>'Oak', :content=>'{{Quentin}}'
-      qnt = Card.create! :name=>'Quentin', :content=>'{{Admin}}'
-      adm = Card['Quentin']
-      adm.update_attributes :content => "{{Oak}}"
-      result = adm.format.render_core
-      expect(result).to match('too deep')
-    end
-
-    it "should handle missing cards" do
-      @a = Card.create :name=>'boo', :content=>"hey {{+there}}"
-      r=@a.format.render_core
-      assert_view_select r, 'div[data-card-name="boo+there"][class~="missing-view"]'
-    end
-
-    it "should handle structured cards" do
-      age = newcard('age')
-      template = Card['*template']
-      specialtype = Card.create :type_code=>'Cardtype', :name=>'SpecialType'
-    
-      specialtype_template = specialtype.fetch(:trait=>:type,:new=>{}).fetch(:trait=>:structure,:new=>{})
-      specialtype_template.content = "{{#{Card::Name.joint}age}}"
-      Card::Auth.as_bot { specialtype_template.save! }
-      assert_equal "{{#{Card::Name.joint}age}}", specialtype_template.format.render_raw
-    
-      wooga = Card.create! :name=>'Wooga', :type=>'SpecialType'
-      wooga_age = Card.create!( :name=>"#{wooga.name}#{Card::Name.joint}age", :content=> "39" )
-      expect(wooga_age.format.render_core).to eq("39")
-      #warn "cards #{wooga.inspect}, #{wooga_age.inspect}"
-      expect(wooga_age.includers.map(&:name)).to eq(['Wooga'])
-    end
-
-    it "should handle shading" do
-      alpha = newcard 'Alpha', "Pooey"
-      beta = newcard 'Beta', "{{Alpha|shade:off}}"
-      r=newcard('Bee', "{{Alpha|shade:off}}").format.render_core
-      assert_view_select r, 'div[style~="shade:off;"]' do
-        assert_select 'div[class~=card-content]', "Pooey"
-      end
-      r=newcard('Cee', "{{Alpha| shade: off }}").format.render_core
-      assert_view_select r, 'div[style~="shade:off;"]' do
-        assert_select 'div[class~=card-content]', "Pooey"
-      end
-      r=newcard('Dee', "{{Alpha| shade:off }}").format.render_core
-      assert_view_select r, 'div[style~="shade:off;"]' do
-        assert_select 'div[class~="card-content"]', "Pooey"
-      end
-      r=newcard('Eee', "{{Alpha| shade:on }}").format.render_core
-      assert_view_select r, 'div[style~="shade:on;"]' do
-        assert_select 'div[class~="card-content"]', "Pooey"
-      end
-    end
-
-    #FIXME - should move code and test to core_ext or some such
-    it 'Hash.new_from_semicolon_attr_list should work' do
-      expect(Hash.new_from_semicolon_attr_list("")).to eq({})
-      expect(Hash.new_from_semicolon_attr_list(nil)).to eq({})
-      expect(Hash.new_from_semicolon_attr_list("a:b;c:4"  )).to eq({:a=>'b', :c=>'4'})
-      expect(Hash.new_from_semicolon_attr_list("d:b;e:4; ")).to eq({:d=>'b', :e=>'4'})
-    end
-
-  end
-
-end