wagn 1.13.0.pre1 → 1.13.0.pre2

data/lib/card/generators/set/USAGE

@@ -2,7 +2,7 @@ Description:
     Generates new set files in mods and matching specs.
 
 Example:
-    rails generate set standard type tshirt
+    wagn generate set standard type tshirt
 
     This will create:
         mods/standard/sets/type/tshirt.rb

data/lib/card/loader.rb

@@ -83,7 +83,7 @@ class Card
 
 
       def load_sets_by_pattern
-        Card.set_patterns.reverse.map(&:key).each do |set_pattern|
+        Card.set_patterns.reverse.map(&:pattern_code).each do |set_pattern|
           pattern_tmp_dir = "#{Wagn.paths['tmp/sets'].first}/#{set_pattern}"
           if rewrite_tmp_files?
             Dir.mkdir pattern_tmp_dir

data/lib/card/set.rb

@@ -1,74 +1,148 @@
 # -*- encoding : utf-8 -*-
 
-
 class Card
   module Set
 
-    mattr_accessor :includable_modules, :base_modules, :traits, :current
-    @@includable_modules, @@base_modules = {}, []
+    mattr_accessor :modules, :traits
+    @@modules = { :base=>[], :base_format=>{}, :nonbase=>{}, :nonbase_format=>{} }
     
+=begin
+    A "Set" is a group of cards to which "Rules" may be applied.  Sets can be as specific as
+    a single card, as general as all cards, or anywhere in between.
 
-    # View definitions
-    #
-    #   When you declare:
-    #     view :view_name, "<set>" do |args|
-    #
-    #   Methods are defined on the format
-    #
-    #   The external api with checks:
-    #     render(:viewname, args)
-    #
-    #   Roughly equivalent to:
-    #     render_viewname(args)
-    #
-    #   The internal call that skips the checks:
-    #     _render_viewname(args)
-    #
-    #   Each of the above ultimately calls:
-    #     _final(_set_key)_viewname(args)
+    Rules take two main forms: card rules and code rules.
 
-    #
-    # ~~~~~~~~~~  VIEW DEFINITION
-    #
+    "Card rules" are defined in card content. These are generally configured via the web
+    interface and are thus documented at http://wagn.org/rules.
 
-    def view *args, &block
-      format do view *args, &block end
+    "Code rules" can be defined in a "set file" within any "Mod" (short for both "module" and
+    "modification"). In accordance with Wagn's "MoVE" architecture, there are two main kinds of
+    code rules you can create in a set file: Views, and Events.  Events are associated with the
+    Card class, and Views are associated with a Format class.  You can also use set files to 
+    add or override Card and/or Format methods directly.  The majority of Wagn code is contained
+    in these files.
+    
+        (FIXME - define mod, add generator)
+
+    Whenever you fetch or instantiate a card, it will automatically include all the
+    set modules defined in set files associated with sets of which it is a member.  This 
+    entails both simple model methods and "events", which are special methods explored
+    in greater detail below.
+    
+    For example, say you have a Plaintext card named "Philipp+address", and you have set files
+    for the following sets:
+    
+        * all cards
+        * all Plaintext cards
+        * all cards ending in +address
+    
+    When you run this:
+    
+        mycard = Card.fetch 'Philipp+address'
+    
+    ...then mycard will include the set modules associated with each of those sets in the above
+    order.  (The order is determined by the set pattern; see lib/card/set_pattern.rb for more
+    information about set_ptterns and mods/core/sets/all/fetch.rb for more about fetching.)
+
+    Similarly, whenever a Format object is instantiated for a card, it includes all views
+    associated with BOTH (a) sets of which the card is a member and (b) the current format or 
+    its ancestors.  More on defining views below.
+
+ 
+    In order to have a set file associated with "all cards ending in +address", you could create
+    a file in mywagn/mods/mymod/sets/right/address.rb.  The recommended mechanism for doing so
+    is running `wagn generate set modname set_pattern set_anchor`. In the current example, this
+    would translate to `wagn generate set mymod right address`. Note that both the set_pattern 
+    and the set_anchor must correspond to the codename of a card in the database to function
+    correctly.
+
+    
+    When Wagn loads, it uses these files to autogenerate a tmp_file that uses this set file to
+    createa Card::Set::Right::Address module which itself is extended with Card::Set. A set file
+    is "just ruby" but is generally quite concise because Wagn uses its file location to 
+    autogenerate ruby module names and then uses Card::Set module to provide additional API.
+
+
+ View definitions
+
+   When you declare:
+     view :view_name do |args|
+       #...your code here
+     end
+
+   Methods are defined on the format
+
+   The external api with checks:
+     render(:viewname, args)
+
+
+=end
+
+    module Format
+      mattr_accessor :views
+      @@views = {}
+      
+      def view view, *args, &block
+        view = view.to_name.key.to_sym
+        views[self] ||= {}
+        view_block = views[self][view] = if block_given?
+          Card::Format.extract_class_vars view, args[0]
+          block
+        else
+          alias_block view, args
+        end
+        define_method "_view_#{ view }", view_block
+      end
+      
+      def alias_block view, args
+        opts = Hash===args[0] ? args.shift : { :view => args.shift }
+        opts[:mod]  ||= self
+        opts[:view] ||= view
+        views[ opts[:mod] ][ opts[:view] ] or fail
+      rescue
+        raise "cannot find #{ opts[:view] } view in #{ opts[:mod] }; failed to alias #{view} in #{self}"
+      end
+      
     end
 
-    def format fmt=nil, &block
-      if block_given?
-        f = Card::Format
-        format = fmt.nil? ? f : f.get_format(fmt)
-        format.class_eval &block
-      else
-        fail "block required"
+    def format format=nil, &block
+      klass = Card::Format.format_class_name format   # format class name, eg. HtmlFormat
+      mod = const_get_or_set klass do                 # called on current set module, eg Card::Set::Type::Pointer
+        m = Module.new                                # yielding set format module, eg Card::Set::Type::Pointer::HtmlFormat
+        register_set_format Card.const_get(klass), m
+        m.extend Card::Set::Format
+        m
+      end                                             
+      mod.class_eval &block
+    end
+
+    def view *args, &block
+      format do
+        view *args, &block
       end
     end
+    
 
     def event event, opts={}, &final
       opts[:on] = [:create, :update ] if opts[:on] == :save
 
-      mod = Card::Set.current[:module]
       Card.define_callbacks event
 
-      mod.class_eval do
+      class_eval do
         final_method = "#{event}_without_callbacks" #should be private?
         define_method final_method, &final
 
         define_method event do
-  #        Rails.logger.info "running #{event} for #{name}"
           run_callbacks event do
-  #          Rails.logger.info "calling event: #{event} for #{self}"
             send final_method
           end
         end
       end
     
-      set_event_callbacks event, mod, opts
+      set_event_callbacks event, opts
     end
 
 
-
     #
     # ActiveCard support: accessing plus cards as attributes
     #
@@ -88,64 +162,35 @@ class Card
       options = args.extract_options!
       add_traits args, options.merge( :writer=>true )
     end
-  
-    
-    def const_missing const
-      if const.to_s =~ /^([A-Z]\S*)ID$/ and code=$1.underscore.to_sym
-        if card_id = Codename[code]
-          const_set const, card_id
-        else
-          raise "Missing codename #{code} (#{const})"
-        end
-      else
-        super
-      end
-    end
-  
-    #
-    # Singleton methods
-    #
 
+
+
+
+    # the set loading process has two main phases:
+    
+    #  1. Definition: interpret each set file, creating/defining set and set_format modules
+    #  2. Organization: have base classes include modules associated with the "all" set, and
+    #     clean up the other modules
+       
     class << self
+
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # Definition Phase
     
-      def extended mod 
-        # document!
+      # each set file calls `extend Card::Set` when loaded
+      def extended mod
         register_set mod
       end
-    
-      def method_key opts
-        Card.set_patterns.each do |pclass|
-          if !pclass.opt_keys.map(&opts.method(:has_key?)).member? false;
-            return pclass.method_key_from_opts(opts)
-          end
-        end
-      end
-    
+  
       def register_set set_module
-        if all_set?( set_module )
-          self.current = { :module=>Card, :opts=>{} }
-          base_modules << set_module unless set_module == Card
+        if set_module.all_set?
+          modules[ :base ] << set_module
         else
-          self.current = { :module=>set_module, :opts=>opts_from_module( set_module ) }
+          modules[ :nonbase ][ set_module.shortname ] ||= []
+          modules[ :nonbase ][ set_module.shortname ] << set_module
         end      
-
-        includable_modules[ set_module.name ] = set_module unless set_module == Card
-      end
-    
-      def all_set? set_module
-        set_module == Card or set_module.name =~ /^Card::Set::All::/
       end
-
-      def opts_from_module set_module
-        if name_parts = set_module.to_s.split('::')[2..-1]
-          #FIXME - does not handle set patterns with multiple opts (eg type plus right)
-          pattern, anchor = name_parts.map { |part| part.underscore.to_sym }
-          { pattern => anchor }
-        else
-          { }
-        end
-      end
-
+      
       def write_tmp_file set_pattern, anchor, from_file, seq
         # FIXME - this does not properly handle anchorless sets
         # There are special hacks for *all, but others (like *rstar) will not be found by
@@ -166,48 +211,87 @@ EOF
         File.write to_file, file_content
         to_file
       end
+      
+      
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # Organization Phase
 
-          
+      # "base modules" are modules that are permanently included on the Card or Format class
+      # "nonbase modules" are included dynamically on singleton_classes
       def process_base_modules
-        base_modules.each do |mod|
+        process_base_module_list modules[:base], Card
+        modules[:base_format].each do |format_class, modules_list|
+          process_base_module_list modules_list, format_class
+        end
+        modules.delete :base
+        modules.delete :base_format
+      end
+      
+      def process_base_module_list list, klass
+        list.each do |mod|
           if mod.instance_methods.any?
-            Card.send :include, mod
+            klass.send :include, mod
           end
           if class_methods = mod.const_get_if_defined( :ClassMethods )
-            Card.send :extend, class_methods
+            klass.send :extend, class_methods
           end
-          includable_modules.delete mod.name
         end
-        @@base_modules = []
       end
     
       def clean_empty_modules
-        includable_modules.each do |mod_name, mod|
-          if mod.instance_methods.empty?
-            includable_modules.delete mod_name
-          end
+        clean_empty_module_from_hash modules[ :nonbase ]
+        modules[ :nonbase_format ].values.each do |hash|
+          clean_empty_module_from_hash hash
         end
       end
-    
+      
+      def clean_empty_module_from_hash hash
+        hash.each do |mod_name, modlist|
+          modlist.delete_if { |x| x.instance_methods.empty? }
+          hash.delete mod_name if modlist.empty?
+        end
+      end
+      
     end
 
 
-    private
+    def register_set_format format_class, mod
+      if self.all_set?
+        modules[ :base_format ][ format_class ] ||= []
+        modules[ :base_format ][ format_class ] << mod
+      else
+        format_hash = modules[ :nonbase_format ][ format_class ] ||= {}
+        format_hash[ shortname ] ||= []
+        format_hash[ shortname ] << mod
+      end
+    end
+
+    def shortname
+      parts = name.split '::'
+      first = 2 # shortname eliminates Card::Set
+      set_class = Card::SetPattern.find parts[first].underscore
+      
+      last = first + ( set_class.anchorless? ? 0 : 1 )
+      #FIXME - handle multi-anchor sets like type_plus_right 
+      parts[first..last].join '::'
+    end
 
+    def all_set?
+      name =~ /^Card::Set::All::/
+    end
 
-    def set_event_callbacks event, mod, opts
+    private
+    
+    
+    def set_event_callbacks event, opts
       [:before, :after, :around].each do |kind|
         if object_method = opts.delete(kind)
-          options = { :prepend => true } 
-          if mod == Card
-            options[:if] = proc { |c| c.event_applies? opts }
-          else
-            parts = mod.name.split '::'
-            set_class_key, anchor_or_placeholder = parts[-2].underscore.to_sym, parts[-1].underscore
-            set_key = Card::Set.method_key( set_class_key => anchor_or_placeholder )
-            options[:if] = proc { |c| c.method_keys.member? set_key and c.event_applies? opts }
-          end        
-          Card.class_eval { set_callback object_method, kind, event, options }
+          this_set_module = self
+          Card.class_eval do
+            set_callback object_method, kind, event, :prepend=>true, :if=> proc { |c|
+              c.singleton_class.include?( this_set_module ) and c.event_applies? opts
+            }
+          end
         end
       end
     end
@@ -218,7 +302,7 @@ EOF
     end
 
     def add_traits args, options
-      mod = Card::Set.current[:module]
+      mod = self
   #    raise "Can't define card traits on all set" if mod == Card
       mod_traits = get_traits mod
     

data/lib/card/set_pattern.rb

@@ -1,8 +1,12 @@
 class Card
   class SetPattern
-
+    
     class << self
-      attr_accessor :key, :key_id, :opt_keys, :junction_only, :method_key, :assigns_type, :anchorless
+      attr_accessor :pattern_code, :pattern_id, :junction_only, :assigns_type, :anchorless
+      
+      def find pattern_code
+        Card.set_patterns.find { |sub| sub.pattern_code == pattern_code }        
+      end
     
       def junction_only?
         !!junction_only
@@ -16,37 +20,28 @@ class Card
         super if pattern_applies? card
       end
 
-      def key_name
-        Card.fetch(self.key_id, :skip_modules=>true).cardname
+      def pattern
+        Card.fetch(self.pattern_id, :skip_modules=>true).cardname
       end
 
-      def register key, opts={}
-        if self.key_id = Card::Codename[key]
-          self.key = key
+      def register pattern_code, opts={}
+        if self.pattern_id = Card::Codename[pattern_code]
+          self.pattern_code = pattern_code
           Card.set_patterns.insert opts.delete(:index).to_i, self
-          if self.anchorless = !respond_to?( :anchor_name )
-            self.method_key = opts[:method_key] || key
-          end
-          self.opt_keys = Array.wrap( opts.delete(:opt_keys) || key.to_sym )
+          self.anchorless = !respond_to?( :anchor_name )
           opts.each { |key, val| send "#{key}=", val }
         else
-          warn "no codename for key #{key}"
+          warn "no codename for pattern_code #{pattern_code}"
         end
       end
 
-      def method_key_from_opts opts
-        method_key || ((opt_keys.map do |opt_key|
-          opts[opt_key].to_name.key.gsub('+', '-')
-        end << key) * '_' )
-      end
-
       def pattern_applies? card
         junction_only? ? card.cardname.junction? : true
       end
     
-      def write_tmp_file pattern_key, from_file, seq
-        to_file = "#{Wagn.paths['tmp/set_patterns'].first}/#{seq}-#{pattern_key}.rb"
-        klass = "Card::SetPattern::#{pattern_key.camelize}Pattern"
+      def write_tmp_file pattern_code, from_file, seq
+        to_file = "#{Wagn.paths['tmp/set_patterns'].first}/#{seq}-#{pattern_code}.rb"
+        klass = "Card::#{pattern_code.camelize}Set"
         file_content = <<EOF
 # -*- encoding : utf-8 -*-
 class #{klass} < Card::SetPattern
@@ -58,7 +53,7 @@ class #{klass} < Card::SetPattern
 
 # ~~~~~~~~~~~ below autogenerated; above pulled from #{from_file} ~~~~~~~~~~~
   end
-  register "#{pattern_key}", (options || {})
+  register "#{pattern_code}", (options || {})
 end
 
 EOF
@@ -71,93 +66,64 @@ EOF
     # Instance methods
 
     def initialize card
-    
       unless self.class.anchorless?
         @anchor_name = self.class.anchor_name(card).to_name
-
         @anchor_id = if self.class.respond_to? :anchor_id
           self.class.anchor_id card
         else
           Card.fetch_id @anchor_name
         end
       end
-
       self
     end
 
-
-    def set_module_name
-      tail = case
-        when self.class.anchorless?   ; self.class.key.camelize
-        when opt_vals.member?( nil )  ; nil
-        else "#{self.class.key.camelize}::#{opt_vals.map(&:to_s).map(&:camelize) * '::'}"
+    def module_key
+      (defined? @module_key) ? @module_key : @module_key = begin
+        if self.class.anchorless?
+          self.class.pattern_code.camelize
+        elsif anchor_codenames
+          "#{self.class.pattern_code.camelize}::#{anchor_codenames.map(&:to_s).map(&:camelize) * '::'}"
         end
-      tail && "Card::Set::#{ tail }"
-    end
-
-    def set_const
-      if set_module = self.set_module_name
-        Card::Set.includable_modules[ set_module ]
       end
-
-    rescue Exception => e
-      warn "exception set_const #{e.inspect}, #{e.backtrace*"\n"}"
     end
 
-    def get_method_key
-      if self.class.anchorless?
-        self.class.method_key
-      else
-        opts = {}
-        self.class.opt_keys.each_with_index do |key, index|
-          return nil unless opt_vals[index]
-          opts[key] = opt_vals[index]
-        end
-        self.class.method_key_from_opts opts
-      end
+    def module_list
+      module_key and Card::Set.modules[ :nonbase ][ module_key ]
     end
 
-    def opt_vals
-      if @opt_vals.nil?
-        @opt_vals = self.class.anchorless? ? [] : find_opt_vals
-      end
-      @opt_vals
+    def format_module_list klass
+      module_key and hash = Card::Set.modules[ :nonbase_format ][ klass ] and hash[ module_key ]
     end
 
-    def find_opt_vals
-      anchor_parts = if self.class.opt_keys.size > 1
-        [ @anchor_name.left, @anchor_name.right ]
-      else
-        [ @anchor_name ]
-      end
-      anchor_parts.map do |part|
+    def anchor_codenames
+      @anchor_name.parts.map do |part|
         part_id = Card.fetch_id part
-        part_id && Card::Codename[ part_id.to_i ] or return []
+        part_id && Card::Codename[ part_id.to_i ] or return nil
       end
     end
 
-    def key_name
-      @key_name ||= self.class.key_name
+    def pattern
+      @pattern ||= self.class.pattern
     end
 
     def to_s
-      self.class.anchorless? ? key_name.s : "#{@anchor_name}+#{key_name}"
+      self.class.anchorless? ? pattern.s : "#{@anchor_name}+#{pattern}"
     end
 
     def inspect
       "<#{self.class} #{to_s.to_name.inspect}>"
     end
 
-    def safe_key()
-      caps_part = self.class.key.gsub(' ','_').upcase
+    def safe_key
+      caps_part = self.class.pattern_code.gsub(' ','_').upcase
       self.class.anchorless? ? caps_part : "#{caps_part}-#{@anchor_name.safe_key}"
     end
 
     def rule_set_key
       if self.class.anchorless?
-        self.class.key
+        self.class.pattern_code
       elsif @anchor_id
-        [ @anchor_id, self.class.key ].map( &:to_s ) * '+'
+        [ @anchor_id, self.class.pattern_code ].map( &:to_s ) * '+'
       end
     end