RubyGems - card - Versions diffs - 1.91 → 1.92 - Mend

card 1.91 → 1.92

Files changed (779) hide show

@@ -1,100 +0,0 @@
-=A Developer's introduction to the Wagn/Card code base
-New folks should start here after playing with Wagn but before digging into code.
-==Intro
-===Am I in the right place?
-Yes, if:
-* <b>you're a Ruby developer</b>, or at least someone who does not fear ruby code. <b>Not a techie? {Try Wagn.org}[http://wagn.org]</b>
-* <b>you've experimented with Wagn</b> enough to know the basics (cards, types, rules, etc.) <b>No idea what a card is? {Try Wagn.org}[http://wagn.org]</b>.
-* <b>you're looking at this page from a docs site</b> (ie, NOT GitHub) so you can use our links to navigate code. <b>Links look funny? {Try rubydocs.info}[http://rubydoc.info/gems/card].</b>
-===Is Wagn an _application_ or a <i>development framework</i>?
-It's both.
-When you install and "seed" a new Wagn project, you have a working "deck" right away.  There are lots of things built in: account handling, edit histories, default layouts, CSS, etc.  In other words: you have a basic application.
-But a newly seeded Deck is just a starting point. <b>Wagn is a development framework in which you start <i>in the middle of things</i> rather than from scratch</b>.  Seeding is a bit of a headstart, and it means that designers, developers, and content creators can start working in parallel on day 1. But the seeded cards don't determine what you can build with Wagn; you can add things, you can remove things... In fact, you can build pretty much whatever you want.
-===Sets
-_Cards_ are the fundamental building blocks of Wagn, and _Sets_ are the fundamental pattern for organizing cards. Both Wagneers and Wagn developers create web systems by applying _rules_ to _sets_ of _cards_.
-If you've edited Rules through a card toolbar in any Wagn deck, you will have encountered Sets. For example, imagine you're on a User card named "Henry Tai", and you decide to edit its structure.  When you edit its rule, you will be prompted to choose the Set of cards to which the rule applies, eg:
-* Just "Henry Tai"
-* All Users
-* All Cards
-Depending on which Set you choose, the Rule in question will be applied to a specific group of cards.
-This same general pattern occurs in Wagn code: <b>code rules (methods) are organized under the Set of cards to which they apply.</b>
-===MoFoS Architecture
-Sets are central to Wagn's architecture.  Wagn is not, like Ruby on Rails, an implementation of the "MVC" (Model-View-Controller) architectural pattern.  Instead, we like to think that we're the first instance of a new pattern that we call _MoFoS_.
-MoFoS stands for "Model-Formats-Sets": One Model, viewable in many Formats, divisible into Sets.
-In Wagn, the MoFoS "one model" is, as you may have guessed, the _card_.
-You may have also noticed that you can add .html (the default), .text, .json, etc to any card's web path to receive the card's contents in a different format. This is the Format in MoFos.
-The great power of MoFoS, though, is in the Sets. Thanks to Sets, code rules (and data rules) can be as narrow or specific as desired.  These nonorthogonal groupings open up lots of exciting possibilities, and they're a big part of what makes Wagn so much fun.
-===Is Wagn Ruby on Rails?
-It's likely that many folks reading this are Ruby-on-Rails developers. They'll find lots of familiar patterns in Wagn, and they may have noticed that wagn depends upon rails gems.  We should be clear: <b>Wagn is a Rails descendant and owes a ton to the Rails community, but Wagn is not Rails</b>.
-The main difference is that while Rails' core pattern is creating new things (especially models, views, and controllers), Wagn's core pattern is subdividing exising things into new Sets.
-Wagn mod developers do create lots of views (though they're quite different from Rails views), but we never create new models or controllers.  In the Wagn gem there is one controller (CardController), one main model ({Card}), and several other models to optimize the Card model and track its history ({Card::Reference}, {Card::Act}, {Card::Action}, and {Card::Change}).
-Wagn's equivalent of creating a new model is configuring a new Set of cards. Its equivalent of creating new actions on controllers is creating new events that are conditionally triggered for a Set of cards.
-Rails development experience is definitely a plus in getting to know Wagn, but Wagn offers a new architecture, and lot of new possibilities.
-==Mods
-A Wagn Mod is a discrete piece of Wagn functionality. If you want to customize a Wagn deck in a way that can't be done on the site itself, odds are you want a mod.
-The most convenient way to add a mod is in the `mod` directory of your deck, eg:
-  /mydeck/mod/mymod
-A mod can have several different directories: <i>chunk, format, layout, set, set_pattern, spec, file, and lib</i>. Of these, the set directory is by far the most important.
-===Creating a mod with set modules
-Set modules are defined in a mod's set directory, eg:
-  /mydeck/mod/mymod/set/
-For example, if your deck has Company cards, you can extend the behavior of those cards by adding a set module like so:
-  /mydeck/mod/mymod/set/type/company.rb
-Note that "company" here does not refer to its "name", but rather its "codename" (which an administrator might add to the Company card via the RESTful web API with a url like
-  /update/Company?card[codename]=company
-Generally speaking, code should never refer to a card by name; otherwise it will break when the card is renamed.  Instead, it should use the codename, which will continue to work even if the canonical name is changed.
-The full path of a set module follows this pattern
-  [mod dir]/set/[set_pattern](/[anchor])(/[additional]).rb
-==....more coming soon!

data/lib/card/format/names.rb DELETED

@@ -1,43 +0,0 @@
-class Card
-  class Format
-    module Names
-      def initial_context_names
-        @initial_context_names ||=
-          if @context_names
-            context_names_minus_irrelevants
-          else
-            context_names_from_params
-          end
-      end
-      def context_names_minus_irrelevants
-        part_keys = @card.cardname.part_names.map(&:key)
-        @context_names.reject { |n| !part_keys.include? n.key }
-      end
-      def context_names_from_params
-        return [] unless (name_list = Card::Env.slot_opts[:name_context])
-        name_list.to_s.split(",").map(&:to_name)
-      end
-      def context_names_to_params
-        return unless @context_names
-        @context_names.join(",")
-      end
-      def add_name_context name=nil
-        name ||= card.name
-        @context_names += name.to_name.part_names
-        @context_names.uniq!
-      end
-      def showname title=nil
-        if title
-          card.cardname.title title, @context_names
-        else
-          @showname ||= card.cardname.to_show(*@context_names)
-        end
-      end
-    end
-  end
-end

data/lib/card/format/nest/view.rb DELETED

@@ -1,65 +0,0 @@
-class Card
-  class Format
-    module Nest
-      NEST_MODES = { new: :edit,
-                     closed_content: :closed,
-                     setup: :edit,
-                     edit: :edit, closed: :closed, layout: :layout,
-                     normal: :normal, template: :template }.freeze
-      # Renders views for a nests
-      module View
-        def with_nest_mode mode
-          old_mode = @mode
-          if (switch_mode = NEST_MODES[mode])
-            @mode = switch_mode
-          end
-          result = yield
-          @mode = old_mode
-          result
-        end
-        # private
-        def modal_nest_view view
-          # Note: the subformat always has the same @mode as its parent format
-          case @mode
-          when :edit then view_in_edit_mode(view)
-          when :template then :template_rule
-          when :closed then view_in_closed_mode(view)
-          else view
-          end
-        end
-        # Returns the view that the card should use
-        # if nested in edit mode
-        def view_in_edit_mode homeview
-          hide_view_in_edit_mode?(homeview) ? :blank : :edit_in_form
-        end
-        def hide_view_in_edit_mode? view
-          Card::Format.perms[view] == :none || # view never edited
-            card.structure                  || # not yet nesting structures
-            card.key.blank?                    # eg {{_self|type}} on new cards
-        end
-        # Return the view that the card should use
-        # if nested in closed mode
-        def view_in_closed_mode view
-          approved_view = Card::Format.closed[view]
-          if approved_view == true
-            view
-          elsif Card::Format.error_code[view]
-            view
-          elsif approved_view
-            approved_view
-          elsif !card.known?
-            :closed_missing
-          else
-            :closed_content
-          end
-        end
-      end
-    end
-  end
-end

data/lib/card/view/fetch.rb DELETED

@@ -1,121 +0,0 @@
-class Card
-  class View
-    # Support context-aware card view caching.
-    #
-    # View definitions can contain cache settings that guide whether and how
-    # the view should be cached.
-    module Fetch
-      # fetching can result in one of three things:
-      # - simply yielding the initial render call
-      # - storing or retrieving the render to/from the cache
-      # - creating a stub within another render
-      #   (so that the stub may be rendered later)
-      def fetch &block
-        with_fetch_logging do |cache_level|
-          case cache_level
-          when :yield       then yield
-          when :cache_yield then cache_fetch(&block)
-          when :stub        then stub
-          end
-        end
-      end
-      # Each of the following represents an accepted value for cache
-      # directives on view definitions.  eg:
-      #   view :myview, cache: :standard do ...
-      #
-      # * *always* - store independent cached view, even if that means double
-      #   caching. (eg view is inside another one already being cached)
-      # * *standard* (default) cache independently or dependently, but
-      #   don't double cache
-      # * *never* don't ever cache this view
-      def determine_cache_level
-        return :yield unless Cardio.config.view_cache
-        send "#{caching? ? 'dependent' : 'independent'}_cache_level"
-      end
-      def with_fetch_logging
-        cache_level = determine_cache_level
-        logging = false # TODO: make configurable
-        if logging
-          puts "FETCH_VIEW (#{card.name}##{requested_view})" \
-               "cache-level = #{cache_level}"
-        end
-        yield cache_level
-      end
-      # INDEPENDENT CACHING
-      # takes place on its own (not within another view being cached)
-      def independent_cache_level
-        independent_cache_ok? ? :cache_yield : :yield
-      end
-      def independent_cache_ok?
-        cache_setting != :never &&
-          foreign_live_options.empty? &&
-          clean_enough_to_cache?
-      end
-      # The following methods are shared by independent and dependent caching
-      # view-specific setting as set in view definition. (always, standard, or
-      # never)
-      def cache_setting
-        format.view_cache_setting requested_view
-      end
-      # altered view requests and altered cards are not cacheable
-      def clean_enough_to_cache?
-        requested_view == ok_view &&
-          !card.unknown? &&
-          !card.db_content_changed?
-        # FIXME: might consider other changes as disqualifying, though
-        # we should make sure not to disallow caching of virtual cards
-      end
-      # DEPENDENT CACHING
-      # handling of views rendered within another cached view.
-      def dependent_cache_level
-        level = dependent_cache_level_unvalidated
-        validate_stub if level == :stub
-        level
-      end
-      def dependent_cache_level_unvalidated
-        return :yield if ok_view == :too_deep
-        dependent_cache_ok? ? dependent_cache_setting : :stub
-      end
-      def dependent_cache_ok?
-        return false unless parent && clean_enough_to_cache?
-        return true if normalized_options[:skip_perms]
-        dependent_cacheable_permissible?
-      end
-      def dependent_cacheable_permissible?
-        case permission_task
-        when :none                  then true
-        when parent.permission_task then true
-        when Symbol                 then card.anyone_can?(permission_task)
-        else                             false
-        end
-      end
-      # task directly associated with the view in its definition via the
-      # "perms" directive
-      def permission_task
-        @permission_task ||= Card::Format.perms[requested_view] || :read
-      end
-      DEPENDENT_CACHE_LEVEL =
-        { always: :cache_yield, standard: :yield, never: :stub }.freeze
-      def dependent_cache_setting
-        level = DEPENDENT_CACHE_LEVEL[cache_setting]
-        level || raise("unknown cache setting: #{cache_setting}")
-      end
-    end
-  end
-end

data/mod/core/spec/set/all/attribute_tracking_spec.rb DELETED

@@ -1,21 +0,0 @@
-# -*- encoding : utf-8 -*-
-# describe Card::Set::All::AttributeTracking do
-#   context "new card" do
-#     before(:each) do
-#       Card::Auth.as_bot do
-#         @c = Card.new name: "New Card", content: "Great Content"
-#       end
-#     end
-#
-#     it "has updates" do
-#       described_class::Updates.should === @c.updates
-#     end
-#
-#     it "tracks changes" do
-#       @c.name.should == 'New Card'
-#       @c.name = 'Old Card'
-#       @c.name.should == 'Old Card'
-#     end
-#   end
-# end

data/spec/models/card/cardtype_spec.rb DELETED

@@ -1,189 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card
-  # REVIEW: hooks api will do this differently, probably should remove and add new tests elsewhere
-  # this is used by some type based modules on CardtypeE from type_transition
-  cattr_accessor :count
-end
-describe "Card (Cardtype)" do
-  it "does not allow cardtype remove when instances present" do
-    Card.create name: "City", type: "Cardtype"
-    city = Card.fetch("City")
-    c1 = Card.create name: "Sparta", type: "City"
-    c2 = Card.create name: "Eugene", type: "City"
-    assert_equal %w(Eugene Sparta), Card.search(type: "City").map(&:name).sort
-    assert_raises ActiveRecord::RecordInvalid do
-      city.delete!
-    end
-    # make sure it wasn't deleted / trashed
-    expect(Card["City"]).not_to be_nil
-  end
-  it "remove cardtype" do
-    Card.create! name: "County", type: "Cardtype"
-    c = Card["County"]
-    c.delete
-  end
-  it "cardtype creation and dynamic cardtype" do
-    assert Card.create(name: "BananaPudding", type: "Cardtype").type_id == Card::Codename[:cardtype]
-    assert_instance_of Card, c = Card.fetch("BananaPudding")
-    # you have to have a module to include or it's just a Basic (type_code fielde excepted)
-    cd = Card.create(type: "banana_pudding", name: "figgy")
-    assert cd.type_name == "BananaPudding"
-    assert Card.find_by_type_id(c.id)
-  end
-  describe "conversion to cardtype" do
-    before do
-      @card = Card.create!(type: "Cardtype", name: "Cookie")
-      expect(@card.type_name).to eq("Cardtype")
-    end
-    it "creates cardtype model and permission" do
-      @card.type_id = Card.fetch_id("cookie")
-      @card.save!
-      expect(@card.type_name).to eq("Cookie")
-      @card = Card["Cookie"]
-      assert_instance_of Card, @card
-      expect(@card.type_code).to eq(nil) # :cookie
-      assert_equal "Cookie", Card.create!(name: "Oreo", type: "Cookie").type_name
-    end
-  end
-  it "cardtype" do
-    Card.all.each do |card|
-      assert !card.type_card.nil?
-    end
-  end
-end
-describe Card, "created without permission" do
-  before do
-    Card::Auth.current_id = Card::AnonymousID
-  end
-  # FIXME:  this one should pass.  unfortunately when I tried to fix it it started looking like the clean solution
-  #  was to rewrite most of the permissions section as simple validations and i decided not to go down that rabbit hole.
-  #
-  # it "does not be valid" do
-  #  Card.new( name: 'foo', type: 'Cardtype').valid?.should_not be_true
-  # end
-  it "does not create a new cardtype until saved" do
-    expect do
-      Card.new(name: "foo", type: "Cardtype")
-    end.not_to change(Card, :count)
-  end
-end
-describe Card, "Normal card with descendants" do
-  before do
-    @a = Card["A"]
-  end
-  it "confirms that it has descendants" do
-    expect(@a.descendants.length).to be > 0
-  end
-  it "has its type changed" do
-    Card::Auth.as_bot do
-      @a.type_id = Card::PhraseID
-      @a.save!
-      expect(Card["A"].type_code).to eq(:phrase)
-    end
-  end
-  it "still has its descendants after changing type" do
-    Card::Auth.as_bot do
-      assert type_id = Card.fetch_id("cardtype_e")
-      @a.type_id = type_id
-      @a.save!
-      expect(Card["A"].descendants.length).to be > 0
-    end
-  end
-end
-describe Card, "New Cardtype" do
-  before do
-    Card::Auth.as_bot do
-      @ct = Card.create! name: "Animal", type: "Cardtype"
-    end
-  end
-  it "has create permissions" do
-    expect(@ct.who_can(:create)).not_to be_nil
-  end
-  it "its create permissions should be based on Basic" do
-    expect(@ct.who_can(:create)).to eq(Card["Basic"].who_can(:create))
-  end
-end
-describe Card, "Wannabe Cardtype Card" do
-  before do
-    Card::Auth.as_bot do
-      @card = Card.create! name: "convertible"
-      @card.type_id = Card::CardtypeID
-      @card.save!
-    end
-  end
-  it "changes its type to a Cardtype" do
-    expect(Card["convertible"].type_code).to eq(:cardtype)
-  end
-end
-describe Card, "Joe User" do
-  before do
-    Card::Auth.as_bot do
-      @r3 = Card["r3"]
-      Card.create name: "Cardtype F+*type+*create", type: "Pointer", content: "[[r3]]"
-    end
-    @ucard = Card::Auth.current
-    @type_names = Card::Auth.createable_types
-  end
-  it "does not have r3 permissions" do
-    expect(@ucard.fetch(new: {}, trait: :roles).item_names.member?(@r3.name)).to be_falsey
-  end
-  it "ponders creating a card of Cardtype F, but find that he lacks create permissions" do
-    expect(Card.new(type: "Cardtype F").ok?(:create)).to be_falsey
-  end
-  it "does not find Cardtype F on its list of createable cardtypes" do
-    expect(@type_names.member?("Cardtype F")).to be_falsey
-  end
-  it "finds Basic on its list of createable cardtypes" do
-    expect(@type_names.member?("Basic")).to be_truthy
-  end
-end
-describe Card, "Cardtype with Existing Cards" do
-  before do
-    @ct = Card["Cardtype F"]
-  end
-  it "has existing cards of that type" do
-    expect(Card.search(type: @ct.name)).not_to be_empty
-  end
-  it "raises an error when you try to delete it" do
-    Card::Auth.as_bot do
-      @ct.delete
-      expect(@ct.errors[:cardtype]).not_to be_empty
-    end
-  end
-end
-describe Card::Set::Type::Cardtype do
-  it "handles changing away from Cardtype" do
-    Card::Auth.as_bot do
-      ctg = Card.create! name: "CardtypeG", type: "Cardtype"
-      ctg.type_id = Card::BasicID
-      ctg.save!
-      ctg = Card["CardtypeG"]
-      expect(ctg.type_code).to eq(:basic)
-      # ctg.extension.should == nil
-    end
-  end
-end