card 0.0.1 → 1.15.pre

data/spec/lib/card/format_spec.rb

@@ -0,0 +1,82 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Format do
+
+  describe '#show?' do
+    let(:format) { described_class.new Card.new }
+
+    it "should respect defaults" do
+      expect(format.show_view?( :menu, :default_visibility=>:show )).to be_truthy
+      expect(format.show_view?( :menu, :default_visibility=>:hide )).to be_falsey
+      expect(format.show_view?( :menu, {}                          )).to be_truthy
+    end
+    
+    it "should respect developer default overrides" do
+      expect(format.show_view?( :menu, :optional_menu=>:show, :default_visibility=>:hide )).to be_truthy
+      expect(format.show_view?( :menu, :optional_menu=>:hide, :default_visibility=>:show )).to be_falsey
+      expect(format.show_view?( :menu, :optional_menu=>:hide                             )).to be_falsey
+    end
+    
+    it "should handle args from inclusions" do
+      expect(format.show_view?( :menu, :show=>'menu', :default_visibility=>:hide         )).to be_truthy
+      expect(format.show_view?( :menu, :hide=>'menu, paging', :default_visibility=>:show )).to be_falsey
+      expect(format.show_view?( :menu, :show=>'menu', :optional_menu=>:hide              )).to be_truthy      
+    end
+    
+    it "should handle hard developer overrides" do
+      expect(format.show_view?( :menu, :optional_menu=>:always, :hide=>'menu' )).to be_truthy
+      expect(format.show_view?( :menu, :optional_menu=>:never,  :show=>'menu' )).to be_falsey
+    end
+    
+  end
+
+  describe 'format helpers and link building' do
+    before :each do
+      # should be a way to get these defaults in these tests
+      Card::Env[:host] = '//test.host'
+      Card::Env[:protocol] = 'http:'
+    end
+
+    let(:card) { Card['Home'] }
+    let(:text_format) { card.format(:text)}
+    let(:html_format) { card.format }
+    let(:url_text1) { 'with external free link http://localhost:2020/path?cgi=foo&bar=baz' }
+    let(:url_text2) { 'with external in link syntax: [[http://brain.org/Home|extra]]' }
+    let(:url_text3) { 'with internal lik [[A]]' }
+    let(:url_text4) { 'with internal lik [[Home|display text]]' }
+    let(:url_text5) { 'external with port: http://localhost:2020/path?cgi=foo+bar=baz after '}
+
+    it "should format links" do
+      cobj = Card::Content.new url_text1, text_format
+      expect(cobj.to_s).to eq url_text1
+      cobj = Card::Content.new url_text2, text_format
+      expect(cobj.to_s).to eq url_text2
+      cobj = Card::Content.new url_text3, text_format
+      expect(cobj.to_s).to eq url_text3
+      cobj = Card::Content.new url_text4, text_format
+      expect(cobj.to_s).to eq url_text4
+      cobj = Card::Content.new url_text5, text_format
+      expect(cobj.to_s).to eq url_text5
+    end
+
+    it "should format html links" do
+      cobj = Card::Content.new url_text1, html_format
+      expect(cobj.to_s).to eq "with external free link <a class=\"external-link\" href=\"http://localhost:2020/path?cgi=foo&amp;bar=baz\">http://localhost:2020/path?cgi=foo&bar=baz</a>"
+      cobj = Card::Content.new url_text2+url_text3+url_text4, html_format
+      expect(cobj.to_s).to eq url_text2+url_text3+url_text4
+      cobj = Card::Content.new url_text5, html_format
+      expect(cobj.to_s).to eq "external with port: <a class=\"external-link\" href=\"http://localhost:2020/path?cgi=foo+bar=baz\">http://localhost:2020/path?cgi=foo+bar=baz</a> after "
+    end
+
+    it "formats page_path" do
+      expect(text_format.page_path card.cardname).to eq '/'+card.name
+      expect(html_format.page_path card.cardname).to eq '/'+card.name
+      expect(text_format.page_path card.cardname, :format => 'txt', :opt1 => 11, :opt2 => 'foo').to eq "/#{card.name}.txt?opt1=11&opt2=foo"
+    end
+
+    it "fomats full path and url" do
+      expect(text_format.card_path card.name).to eq "/#{card.name}"
+      expect(html_format.card_url card.name).to eq "http://test.host/#{card.name}"
+    end
+  end
+end

data/spec/lib/card/loader_spec.rb

@@ -0,0 +1,39 @@
+# -*- encoding : utf-8 -*-
+
+=begin
+describe Card::Loader do
+  # let(:card_double) { double "Card" }
+  # let(:pat_all_double) { proxy Card::AllSet }
+  # let(:format_double) { proxy Card::Format }
+  # let(:html_format_double) { proxy Card::HtmlFormat }
+  # it "should auto-load Card class methods from lib/card and mods" do
+  #   #xpect(Card).to receive(:load_mods)
+  #   #
+  #   card = Card[:all]
+  #   expect(card_double).to receive(:load_formats)
+  #   #expect(Card).to receive(:load_sets)
+  #   #expect(Card).to receive(:tracks).with(:any_args) # so Card still loads without core in failure testing
+  #   Card[:all]
+  #   #expect(Card.instance_method(:version)).to be
+  #   # allow(Card).to receive(:version)
+  #   # expect(Card.instance_method(:type_card)).to be
+  #   # allow(Card).to receive(:file_path_sdfs)
+  #   #expect(Card.instance_method(:file_path)).to be
+  # end
+  # it "should define Card methods from modules" do
+  #   expect(Card.instance_method(:set_modules)).to be
+  # end
+  # it "should define Formatter methods from modules" do
+  #   #expect(Card.instance_method(:render_core)).to be
+  #   expect(Card.instance_method(:_render_raw)).to be
+  #   expect(Card.instance_method(:render_core)).to be
+  #   expect(Card.instance_method(:_render_raw)).to be
+  # end
+  # it "should define Formatter methods from modules" do
+  #   expect(html_format_double.method(:render_core)).to be
+  #   expect(html_format_double.method(:_render_raw)).to be
+  #   expect(html_format_double.method(:render_core)).to be
+  #   expect(html_format_double.method(:_render_raw)).to be
+  # end
+end
+=end

data/spec/lib/card/log_spec.rb

@@ -0,0 +1,270 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Log::Request do
+  before do
+    controller = double()
+    allow(controller).to receive(:env) do
+      hash = {}
+      %w( REMOTE_ADDR REQUEST_METHOD REQUEST_URI HTTP_ACCEPT_LANGUAGE HTTP_REFERER).each do |key|
+        hash[key] = key
+      end
+      hash
+    end
+    card = double()
+    allow(card).to receive(:name) { 'cardname' }
+    allow(controller).to receive(:card) { card }
+    allow(controller).to receive(:action_name) { 'action_name' }
+    allow(controller).to receive(:params) { {'view' => 'view'} }
+    allow(controller).to receive(:status) { 'status' }
+    Card::Log::Request.write_log_entry controller
+  end
+  it 'creates csv file' do
+    expect(File.exist? Card::Log::Request.path).to be_truthy
+  end
+
+  describe 'log file' do
+    subject { File.read Card::Log::Request.path }
+
+    it { is_expected.to include 'REMOTE_ADDR' }
+    it { is_expected.to include 'REQUEST_METHOD' }
+    it { is_expected.to include 'view' }
+    it { is_expected.to include 'status' }
+    it { is_expected.to include 'cardname' }
+  end
+end
+
+
+describe Card::Log::Performance do
+  def log_method opts
+     Card::Log::Performance.load_config(:methods=>opts)
+  end
+
+  def expect_logger_to_receive_once message
+    allow(Rails.logger).to receive(:wagn).with(/((?!#{message}).)*/ )
+    expect(Rails.logger).to receive(:wagn).once.with(message)
+    with_logging { yield }
+  end
+
+
+  def expect_logger_to_receive message
+    allow(Rails.logger).to receive(:wagn)
+    Array.wrap(message).each do |msg|
+      expect(Rails.logger).to receive(:wagn).with(msg)
+    end
+    with_logging { yield }
+  end
+
+  def expect_logger_not_to_receive message
+    allow(Rails.logger).to receive(:wagn)
+    Array.wrap(message).each do |msg|
+      expect(Rails.logger).not_to receive(:wagn).with(msg)
+    end
+    with_logging { yield }
+  end
+
+  def with_logging
+    Card::Log::Performance.start :method=>'test'
+      yield
+    Card::Log::Performance.stop
+  end
+
+
+
+  it 'creates tree for nested method calls' do
+    log_method [:view]
+    expect_logger_to_receive([
+      /  \|--\([\d.]+ms\) process: c1/,
+      /    \|--\([\d.]+ms\) view\: core/,
+      /      \|--\([\d.]+ms\) view\: raw/,
+    ]) do
+      Card['c1'].format.render_core
+    end
+  end
+
+
+  describe 'logger configuration' do
+
+    it 'handles array with method name' do   # log arbitrary card method
+      log_method( [:content] )
+      expect_logger_to_receive(/content/) do
+        Card[:all].content
+      end
+    end
+
+    it 'handles instance method type' do
+      class Card
+        def test a, b
+          Rails.logger.wagn("orignal method is still alive")
+        end
+        def self.test a, b; end
+      end
+      log_method( { Card => { :instance => { :test=> { :title=>:name, :message=>2 }}}} )
+
+      expect_logger_to_receive([/still alive/,/all: magic/]) do
+        Card[:all].test "ignore this argument", "magic"
+        Card.test "you won't", "get this one"
+      end
+    end
+
+    it 'handles classes and singleton method type' do
+      log_method( { Card => { :singleton=>[:fetch] } } )
+      expect_logger_to_receive(/fetch/) do
+        Card.fetch 'A'
+      end
+    end
+
+    it 'handles different class and singleton method type' do
+      log_method( { Cardio => { :singleton=>[:gem_root] } } )
+      expect_logger_to_receive(/gem_root/) do
+        Cardio.gem_root
+      end
+    end
+
+    it 'handles method log options' do
+      log_method( {Card::Set::Type::Skin => {:item_names => {:message=>:raw_content, :title=>"skin item names"}}} )
+      expect_logger_to_receive(/skin item names/) do
+        Card['classic skin'].item_names
+        Card['*all+*read'].item_names
+      end
+    end
+
+    # it 'uses default method log options' do
+    #   log_method [:fetch]
+    #   expect_logger_to_receive( /fetch: all/ ) do
+    #     Card.fetch 'all'
+    #   end
+    # end
+
+    it 'handles procs and integers for method log options' do  # use method arguments and procs to customize log messages
+      log_method( :instance => { :name= => { :title => proc { |method_context| "change name '#{method_context.name}' to"}, :message=>1 } } )
+      expect_logger_to_receive_once(/change name 'c1' to: Alfred/) do
+        Card['c1'].name = 'Alfred'
+      end
+    end
+
+
+    describe 'special methods' do
+      # FIXME: this test fails because of the logging stuff above. Need a way to reset the Card class or use test classes in all tests
+      # it "doesn't log special methods if disabled" do
+#         log_method []
+#         expect(Rails.logger).to receive(:wagn).with(/test/).once
+#         with_logging  do
+#           Card::Auth.as_bot { Card.fetch('c1').update_attributes!(:content=>'c1') }
+#           Card.search :name=>'all'
+#           Card[:all].format.render_raw
+#         end
+#       end
+
+      it 'logs searches if enabled' do
+        log_method [:search]
+        expect_logger_to_receive( /search:/ ) do
+          Card.search :name=>'all'
+        end
+      end
+
+      it 'logs views if enabled' do
+        log_method [:view]
+        expect_logger_to_receive([/process: \*all/, /view:/ ] ) do
+          Card[:all].format.render_raw
+        end
+      end
+
+      it 'logs events if enabled' do
+        log_method [:event]
+        expect_logger_to_receive([/process: c1/, /    \|--\([\d.]+ms\) event:/] ) do
+          Card::Auth.as_bot { Card.fetch('c1').update_attributes!(:content=>'c1') }
+        end
+      end
+
+
+    end
+
+  end
+
+  describe  Card::Log::Performance::BigBrother do
+    before do
+      class TestClass
+        extend Card::Log::Performance::BigBrother
+        def inst_m; end
+        def self.sing_m; end
+      end
+    end
+
+
+    describe '#watch_singleton_method' do
+      before do
+        TestClass.watch_singleton_method :sing_m
+      end
+
+      it 'logs singleton method' do
+        expect_logger_to_receive_once(/sing_m/) do
+          TestClass.sing_m
+        end
+      end
+
+      it 'does not log instance method' do
+        expect_logger_not_to_receive(/inst_,/) do
+          TestClass.new.inst_m
+        end
+      end
+    end
+
+    describe '#watch_instance_method' do
+      before do
+        TestClass.watch_instance_method :inst_m
+      end
+
+      it 'logs instance method' do
+        expect_logger_to_receive_once(/inst_m/) do
+          TestClass.new.inst_m
+        end
+      end
+
+      it 'does not log singleton method' do
+        expect_logger_not_to_receive(/sing_m/) do
+          TestClass.sing_m
+        end
+      end
+    end
+
+
+    describe '#watch_all_singleton_methods' do
+      before do
+        TestClass.watch_all_singleton_methods
+      end
+      it 'logs singleton method' do
+        expect_logger_to_receive(/sing_m/) do
+          TestClass.sing_m
+        end
+      end
+    end
+
+    describe 'watch_all_instance_methods' do
+      before do
+        TestClass.watch_all_instance_methods
+      end
+
+      it 'logs instance method' do
+        expect_logger_to_receive(/inst_m/) do
+          TestClass.new.inst_m
+        end
+      end
+    end
+
+    describe '#watch_all_methods' do
+      before do
+        TestClass.watch_all_methods
+      end
+
+      it 'logs instance and singleton methods' do
+        expect_logger_to_receive([/inst_m/,/sing_m/]) do
+          TestClass.new.inst_m
+          TestClass.sing_m
+        end
+      end
+    end
+
+  end
+
+
+end

data/spec/lib/card/name_spec.rb

@@ -0,0 +1,279 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Name do
+
+  describe "#key" do
+    
+    it "should lowercase and underscore" do
+      expect("This Name".to_name.key).to eq("this_name")
+    end
+    
+    it "should remove spaces" do
+      expect("this    Name".to_name.key).to eq("this_name")
+    end
+
+    describe "underscores" do
+      
+      it "should be treated like spaces" do
+        expect('weird_ combo'.to_name.key).to eq('weird  combo'.to_name.key)
+      end
+      
+      it "should not impede pluralization checks" do
+        expect('Mamas_and_Papas'.to_name.key).to eq("Mamas and Papas".to_name.key)
+      end
+      
+      it "should be removed when before first word character" do
+        expect("_This Name".to_name.key).to eq("this_name")
+      end
+      
+    end
+
+    it "should singularize" do
+      expect("ethans".to_name.key).to eq("ethan")
+    end
+
+    it "should change CamelCase to snake case" do
+      expect("ThisThing".to_name.key).to eq("this_thing")
+    end
+
+    it "should handle plus cards" do
+      expect("ThisThing+Ethans".to_name.key).to eq("this_thing+ethan")
+    end
+
+    it "should retain * for star cards" do
+      expect("*right".to_name.key).to eq("*right")
+    end
+
+    it "should not singularize double s's" do
+      expect("grass".to_name.key).to eq('grass')
+    end
+
+    it "should not singularize letter 'S'" do
+      expect('S'.to_name.key).to eq('s')
+    end
+
+    it "should handle unicode characters" do
+      expect("Mañana".to_name.key).to eq('mañana')
+    end
+
+    it "should handle weird initial characters" do
+      expect('__you motha @#$'.to_name.key).to eq('you_motha')
+      expect('?!_you motha @#$'.to_name.key).to eq('you_motha')
+    end
+
+    it "should allow numbers" do
+      expect("3way".to_name.key).to eq('3way')
+    end
+
+    it "internal plurals" do
+      expect("cards hooks label foos".to_name.key).to eq('card_hook_label_foo')
+    end
+
+    it "should handle html entities" do
+      # This no longer takes off the s, is singularize broken now?
+      expect("Jean-françois Noubel".to_name.key).to eq('jean_françoi_noubel')
+    end
+  end
+
+
+
+
+
+  describe "#url_key" do
+    cardnames = ["GrassCommons.org", 'Oh you @##', "Alice's Restaurant!", "PB & J", "Mañana"].map(&:to_name)
+
+    cardnames.each do |cardname|
+      it "should have the same key as the name" do
+        k, k2 = cardname.key, cardname.url_key
+        #warn "cn tok #{cardname.inspect}, #{k.inspect}, #{k2.inspect}"
+        expect(k).to eq(k2.to_name.key)
+      end
+    end
+  end
+
+  describe "#valid" do
+    it "accepts valid names" do
+      expect("this+THAT".to_name).to be_valid
+      expect("THE*ONE*AND$!ONLY".to_name).to be_valid
+    end
+
+    it "rejects invalid names" do
+#      "Tes~sd".to_name.should_not be_valid
+      expect("TEST/DDER".to_name).not_to be_valid
+    end
+
+    it "rejects long names" do
+      card = Card.new
+      card.name="1"*256
+      expect(card).not_to be_valid
+    end 
+  end 
+
+  describe "#left_name" do
+    it "returns nil for non junction" do
+      expect("a".to_name.left_name).to eq(nil)
+    end
+
+    it "returns parent for parent" do
+      expect("a+b+c+d".to_name.left_name).to eq("a+b+c")
+    end
+  end
+
+  describe "#tag_name" do
+    it "returns last part of plus card" do
+      expect("a+b+c".to_name.tag).to eq("c")
+    end
+
+    it "returns name of simple card" do
+      expect("a".to_name.tag).to eq("a")
+    end
+  end
+
+  describe "#safe_key" do
+    it "subs pluses & stars" do
+      expect("Alpha?+*be-ta".to_name.safe_key).to eq("alpha-Xbe_tum")
+    end
+  end
+
+  describe "#replace_part" do
+    it "replaces first name part" do
+      expect('a+b'.to_name.replace_part('a','x').to_s).to eq('x+b')
+    end
+    it "replaces second name part" do
+      expect('a+b'.to_name.replace_part('b','x').to_s).to eq('a+x')
+    end
+    it "replaces two name parts" do
+      expect('a+b+c'  .to_name.replace_part('a+b', 'x'  ).to_s).to eq('x+c')
+      expect('a+b+c+d'.to_name.replace_part('a+b', 'e+f').to_s).to eq('e+f+c+d')
+    end
+    it "doesn't replace two part tag" do
+      expect('a+b+c'.to_name.replace_part('b+c','x').to_s).to eq('a+b+c')
+    end
+  end
+
+  describe "Cardnames star handling" do
+    it "recognizes star cards" do
+      expect('*a'.to_name.star?).to be_truthy
+    end
+
+    it "doesn't recognize star cards with plusses" do
+      expect('*a+*b'.to_name.star?).to be_falsey
+    end
+
+    it "recognizes rstar cards" do
+      expect('a+*a'.to_name.rstar?).to be_truthy
+    end
+
+    it "doesn't recognize star cards as rstar" do
+      expect('*a'.to_name.rstar?).to be_falsey
+    end
+
+    it "doesn't recognize non-star or star left" do
+      expect('*a+a'.to_name.rstar?).to be_falsey
+    end
+  end
+
+  describe "trait_name?" do
+    it "returns true for content codename" do
+      expect("bazoinga+*right+*structure".to_name.trait_name?(:structure)).to be_truthy
+    end
+
+    it "handles arrays" do
+      expect("bazoinga+*right+*structure".to_name.trait_name?(:structure, :default)).to be_truthy
+    end
+
+    it "returns false for non-template" do
+      expect("bazoinga+*right+nontent".to_name.trait_name?(:structure)).to be_falsey
+    end
+  end
+
+  describe "#to_absolute" do
+    it "handles _self, _whole, _" do
+      expect("_self".to_name.to_absolute("foo")).to eq("foo")
+      expect("_whole".to_name.to_absolute("foo")).to eq("foo")
+      expect("_".to_name.to_absolute("foo")).to eq("foo")
+    end
+
+    it "handles _left" do
+      expect("_left+Z".to_name.to_absolute("A+B+C")).to eq("A+B+Z")
+    end
+
+    it "handles white space" do
+      expect("_left + Z".to_name.to_absolute("A+B+C")).to eq("A+B+Z")
+    end
+
+    it "handles _right" do
+      expect("_right+bang".to_name.to_absolute("nutter+butter")).to eq("butter+bang")
+      expect("C+_right".to_name.to_absolute("B+A")).to eq("C+A")
+    end
+
+    it "handles leading +" do
+      expect("+bug".to_name.to_absolute("hum")).to eq("hum+bug")
+    end
+
+    it "handles trailing +" do
+      expect("bug+".to_name.to_absolute("tracks")).to eq("bug+tracks")
+    end
+
+    it "handles _(numbers)" do
+      expect("_1".to_name.to_absolute("A+B+C")).to eq("A")
+      expect("_1+_2".to_name.to_absolute("A+B+C")).to eq("A+B")
+      expect("_2+_3".to_name.to_absolute("A+B+C")).to eq("B+C")
+    end
+
+    it "handles _LLR etc" do
+      expect("_R".to_name.to_absolute("A+B+C+D+E")).to    eq("E")
+      expect("_L".to_name.to_absolute("A+B+C+D+E")).to    eq("A+B+C+D")
+      expect("_LR".to_name.to_absolute("A+B+C+D+E")).to   eq("D")
+      expect("_LL".to_name.to_absolute("A+B+C+D+E")).to   eq("A+B+C")
+      expect("_LLR".to_name.to_absolute("A+B+C+D+E")).to  eq("C")
+      expect("_LLL".to_name.to_absolute("A+B+C+D+E")).to  eq("A+B")
+      expect("_LLLR".to_name.to_absolute("A+B+C+D+E")).to eq("B")
+      expect("_LLLL".to_name.to_absolute("A+B+C+D+E")).to eq("A")
+    end
+
+    context "mismatched requests" do
+      it "returns _self for _left or _right on simple cards" do
+        expect("_left+Z".to_name.to_absolute("A")).to eq("A+Z")
+        expect("_right+Z".to_name.to_absolute("A")).to eq("A+Z")
+      end
+
+      it "handles bogus numbers" do
+        expect("_1".to_name.to_absolute("A")).to eq("A")
+        expect("_1+_2".to_name.to_absolute("A")).to eq("A+A")
+        expect("_2+_3".to_name.to_absolute("A")).to eq("A+A")
+      end
+
+      it "handles bogus _llr requests" do
+           expect("_R".to_name.to_absolute("A")).to eq("A")
+           expect("_L".to_name.to_absolute("A")).to eq("A")
+          expect("_LR".to_name.to_absolute("A")).to eq("A")
+          expect("_LL".to_name.to_absolute("A")).to eq("A")
+         expect("_LLR".to_name.to_absolute("A")).to eq("A")
+         expect("_LLL".to_name.to_absolute("A")).to eq("A")
+        expect("_LLLR".to_name.to_absolute("A")).to eq("A")
+        expect("_LLLL".to_name.to_absolute("A")).to eq("A")
+      end
+    end
+
+    it "does session user substitution" do
+      expect("_user".to_name.to_absolute("A")).to eq(Card::Auth.current.name)
+      Card::Auth.as_bot do
+        expect("_user".to_name.to_absolute("A")).to eq(Card::Auth.current.name)
+      end
+    end
+  end
+
+  describe "#to_show" do
+    it "ignores ignorables" do
+         expect('you+awe'.to_name.to_show('you')).to eq('+awe')
+      expect('me+you+awe'.to_name.to_show('you')).to eq('me+awe') #HMMM..... what should this do?
+      expect('me+you+awe'.to_name.to_show('me' )).to eq('+you+awe')
+      expect('me+you+awe'.to_name.to_show('me','you')).to eq('+awe')
+          expect('me+you'.to_name.to_show('me','you')).to eq('me+you')
+         expect('?a?+awe'.to_name.to_show('A')).to eq('+awe')
+            expect('+awe'.to_name.to_show()).to eq('+awe')
+    end
+  end
+
+end