card 0.0.1 → 1.15.pre

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

@@ -0,0 +1,198 @@
+
+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 glyphicon glyphicon-remove template-editor-close'
+  end
+  
+  view :template_editor do |args|
+    wrap args do
+      %{
+        <div class="template-editor-left">{{</div> 
+        <div class="template-editor-main">
+          #{ render_template_editor_frame args }
+        </div>
+        <div class="template-editor-right">}}</div> 
+      }
+    end
+  end
+  
+  view :template_editor_frame do |args|
+    frame :no_slot=>true, :title=>card.label, :menu_hack=>:template_closer do
+      _render_core args.merge(:unlabeled=>true)
+    end
+  end
+  
+  view :closed_content do |args|
+    ''
+  end
+  
+end
+
+
+include Card::Set::Type::SearchType
+
+def followed_by? user_id = nil
+  all_members_followed_by? user_id
+end
+
+
+def default_follow_set_card
+  self
+end
+
+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 follow_label
+  if klass = subclass_for_set
+    klass.follow_label cardname.left
+  else
+    ''
+  end
+end
+
+def follow_rule_name user=nil
+  if user
+    if user.kind_of? String
+      "#{name}+#{user}+#{Card[:follow].name}"
+    else
+      "#{name}+#{user.name}+#{Card[:follow].name}"
+    end
+  else
+    "#{name}+#{Card[:all].name}+#{Card[:follow].name}"
+  end
+end
+
+# def to_following_item_name args
+#   left_part = follow_rule_name( args[:user] )
+#   option = args[:option] || if (rule_card = Card.fetch(left_part))
+#        rule_card.content
+#      else
+#        Card[:nothing].name
+#      end
+#
+#   "#{left_part}+#{option}"
+# end
+
+def all_user_ids_with_rule_for setting_code
+  Card.all_user_ids_with_rule_for self, setting_code
+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 all_members_followed? 
+  all_members_followed_by? Auth.current_id
+end
+
+def all_members_followed_by? user_id = nil
+  if !prototype.followed_by? user_id  
+    return false
+  elsif set_followed_by? user_id
+    return true
+  else
+    broader_sets.each do |b_s|
+      if (set_card  = Card.fetch(b_s)) && set_card.set_followed_by?(user_id)
+       return true
+      end
+    end
+  end
+  return false
+end
+
+def set_followed?
+  set_followed_by? Auth.current_id
+end
+
+def set_followed_by? user_id = nil
+  return  ( user_id && (user = Card.find(user_id)) && Card.fetch(follow_rule_name(user.name)) ) || 
+          Card.fetch(follow_rule_name)
+end
+
+def broader_sets
+  prototype.set_names[1..-1]
+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

@@ -0,0 +1,144 @@
+
+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", card_path("update/~#{card.id}?approve_with_token=true"  ) )
+          links << link_to( "Approve without verification", card_path("update/~#{card.id}?approve_without_token=true") )
+        end
+        if card.ok? :delete
+          links << link_to( "Deny and delete", card_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

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

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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,72 @@
+
+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 Card.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
+
+def follow follow_name, option = '*always'
+  if (card = Card.fetch(follow_name)) && (set_card = card.default_follow_set_card)
+    if (follow_rule = Card.fetch(set_card.follow_rule_name(name), :new=>{}))
+      follow_rule.drop_item "*never"
+      follow_rule.add_item option
+      follow_rule.save!
+    end
+  end
+end
+
+

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

@@ -0,0 +1,186 @@
+# -*- 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