wagn 1.14.9 → 1.15.pre

data/lib/card/query/clause.rb

@@ -1,21 +0,0 @@
-
-class Card::Query::Clause
-  attr_accessor :clause
-
-  def safe_sql(txt)
-    txt = txt.to_s
-    txt.match( /[^\w\*\(\)\s\.\,]/ ) ? raise( "WQL contains disallowed characters: #{txt}" ) : txt
-  end
-
-  def quote(v)  ActiveRecord::Base.connection.quote(v)  end
-
-  def match_prep(v)
-    cxn ||= ActiveRecord::Base.connection
-    [cxn, v]
-  end
-
-  def cast_type(type)
-    cxn ||= ActiveRecord::Base.connection
-    (val = cxn.cast_types[type.to_sym]) ? val[:name] : safe_sql(type)
-  end
-end

data/lib/card/query/ref_clause.rb

@@ -1,47 +0,0 @@
-class Card::Query
-  class RefClause < Clause
-    REFERENCE_DEFINITIONS = {
-      # syntax:
-      # wql query key => [ direction, {reference_type} ]
-          # direction      = :out | :in
-          # reference_type =  'L' | 'I' | 'P' 
-
-      :refer_to => [ :out, 'L','I' ], :referred_to_by => [ :in, 'L','I' ],
-      :link_to  => [ :out, 'L' ],     :linked_to_by   => [ :in, 'L' ],
-      :include  => [ :out, 'I' ],     :included_by    => [ :in, 'I' ]
-    }
-    
-    REFERENCE_FIELDS = {
-      :out => [ :referer_id, :referee_id ],
-      :in  => [ :referee_id, :referer_id ]
-    }
-        
-    def initialize key, val, parent
-      @key, @val, @parent = key, val, parent
-    end
-
-    def to_sql *args
-      dir, *type = REFERENCE_DEFINITIONS[ @key.to_sym ]
-      field1, field2 = REFERENCE_FIELDS[ dir ]
-      cond = []
-      if type.present?
-        operator = (type.size==1 ? '=' : 'IN')
-        quoted_letters = type.map { |letter| "'#{letter}'" } * ', '
-        cond << "ref_type #{operator} (#{quoted_letters})"
-      end
-
-      sql =  %[select distinct #{field1} as ref_id from card_references]
-      if @val == '_none'
-        cond << "present = 0"
-      else
-        cardclause = CardClause.build(:return=>'id', :_parent=>@parent).merge(@val)
-        sql << %[ join #{ cardclause.to_sql } as c on #{field2} = c.id]
-      end
-      sql << %[ where #{ cond * ' and ' }] if cond.any?
-      
-      "(#{sql})"
-    end
-  end
-end
-
-

data/lib/card/query/value_clause.rb

@@ -1,65 +0,0 @@
-class Card::Query
-  class ValueClause < Clause
-    def initialize clause, cardclause
-      @cardclause = cardclause
-
-      # bare value shortcut
-      @clause = case clause
-        when ValueClause; clause.instance_variable_get('@clause')  # FIXME what a hack (what's this for?)
-        when Array;     clause
-        when String;    ['=', clause]
-        when Integer;   ['=', clause]
-        else raise("Invalid Condition Clause #{clause.inspect}")
-      end
-
-      # operator aliases
-      @clause[0] = @clause[0].to_s
-      if target = OPERATORS[@clause[0]]
-        @clause[0] = target
-      end
-
-      # check valid operator
-      raise("Invalid Operator #{@clause[0]}") unless OPERATORS.has_key?(@clause[0])
-
-      # handle IN  #FIXME -- shouldn't this handle "not in", too?
-      if @clause[0]=='in' and !@clause[1].is_a?(CardClause) and !@clause[1].is_a?(RefClause)
-        @clause = [@clause[0], @clause[1..-1]]
-      end
-    end
-
-    def op
-      @clause[0]
-    end
-
-    def sqlize(v)
-      case v
-        when CardClause, RefClause, SqlCond; v.to_sql
-        when Array;    "(" + v.flatten.collect {|x| sqlize(x)}.join(',') + ")"
-        else quote(v.to_s)
-      end
-    end
-
-    def to_sql field
-      op,v = @clause
-      #warn "to_sql(#{field}), #{op}, #{v}, #{@cardclause.inspect}"
-      v=@cardclause.selfname if v=='_self'
-      table = @cardclause.table_alias
-
-      #warn "to_sql #{field}, #{v} (#{op})"
-      field, v = case field
-        when "cond";     return "(#{sqlize(v)})"
-        when "name";     ["#{table}.key",      [v].flatten.map(&:to_name).map(&:key)]
-        when "content";  ["#{table}.db_content", v]
-        else;            ["#{table}.#{safe_sql(field)}", v]
-        end
-
-      v = v[0] if Array===v && v.length==1 && op != 'in'
-      if op=='~'
-        cxn, v = match_prep(v)
-        %{#{field} #{cxn.match(sqlize(v))}}
-      else
-        "#{field} #{op} #{sqlize(v)}"
-      end
-    end
-  end
-end

data/lib/card/reference.rb

@@ -1,62 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card::Reference < ActiveRecord::Base
-  def referencer
-    Card[referer_id]
-  end
-
-  def referencee
-    Card[referee_id]
-  end
-
-  class << self
-    
-    def delete_all_from card
-      delete_all :referer_id => card.id
-    end
-    
-    def delete_all_to card
-      where( :referee_id => card.id ).update_all :present=>0, :referee_id => nil
-    end
-    
-    def update_existing_key card, name=nil
-      key = (name || card.name).to_name.key
-      where( :referee_key => key ).update_all :present => 1, :referee_id => card.id
-    end
-
-    def update_on_rename card, newname, update_referers=false
-      if update_referers
-        # not currentlt needed because references are deleted and re-created in the process of adding new revision
-        #where( :referee_id=>card.id ).update_all :referee_key => newname.to_name.key
-      else
-        delete_all_to card
-      end
-      #Rails.logger.warn "update on rename #{card.inspect}, #{newname}, #{update_referers}"
-      update_existing_key card, newname
-    end
-
-    def update_on_delete card
-      delete_all_from card
-      delete_all_to card
-    end
-    
-    def repair_missing_referees
-      #FIXME - should treat trashed cards as not existing
-      where( Card.where( :id=>arel_table[:referee_id], :trash=>false).exists.not ).update_all :referee_id=>nil
-    end
-    
-    def delete_missing_referers
-      where( Card.where( :id=>arel_table[:referer_id], :trash=>false).exists.not ).delete_all
-    end
-    
-    def repair_all
-      delete_missing_referers
-      
-      Card.where(:trash=>false).find_each do |card|
-        Rails.logger.info "\n\n\nRepairing references for '#{card.name}' (id: #{card.id}) ... \n\n\n"
-        card.update_references 
-      end
-    end
-    
-  end
-
-end

data/lib/card/set.rb

@@ -1,367 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-class Card
-  module Set
-
-    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.
-
-    Rules take two main forms: card rules and code rules.
-
-    "Card rules" are defined in card content. These are generally configured via the web
-    interface and are thus documented at http://wagn.org/rules.
-
-    "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 mod/core/set/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/mod/mymod/set/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 but you can add arbitrary subdirectories to organize your code rules. The rule above 
-    for example could be saved in mywagn/mod/mymod/set/right/address/america/north/canada.rb.
-
-    
-    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 *format_names, &block
-      if format_names.empty?
-        format_names = [:base]
-      elsif format_names.first == :all
-        format_names = Card::Format.registered.reject {|f| Card::Format.aliases[f]}
-      end
-      format_names.each do |f|
-        define_on_format f, &block
-      end
-    end
-    
-    def define_on_format format_name=:base, &block
-      klass = Card::Format.format_class_name format_name   # 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
-
-      Card.define_callbacks event
-
-      class_eval do
-        final_method = "#{event}_without_callbacks" #should be private?
-        define_method final_method, &final
-
-        define_method event do
-          run_callbacks event do
-            Wagn.with_logging :event, :message=>event, :context=>self.name, :details=>opts do
-              send final_method
-            end
-          end
-        end
-      end
-    
-      set_event_callbacks event, opts
-    end
-
-
-    
-    #
-    # ActiveCard support: accessing plus cards as attributes
-    #
-
-
-    def card_accessor *args
-      options = args.extract_options!
-      add_traits args, options.merge( :reader=>true, :writer=>true )
-    end
-
-    def card_reader *args
-      options = args.extract_options!
-      add_traits args, options.merge( :reader=>true )
-    end
-
-    def card_writer *args
-      options = args.extract_options!
-      add_traits args, options.merge( :writer=>true )
-    end
-
-
-
-
-    # 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
-    
-      # each set file calls `extend Card::Set` when loaded
-      def extended mod
-        register_set mod
-      end
-  
-      def register_set set_module
-        if set_module.all_set?
-          modules[ :base ] << set_module
-        else
-          modules[ :nonbase ][ set_module.shortname ] ||= []
-          modules[ :nonbase ][ set_module.shortname ] << set_module
-        end      
-      end
-      
-      def write_tmp_file set_pattern, anchors, 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
-        # include_set_modules, which will look for Card::Set::Rstar, not Card::Set::Rstar::Blah
-        # This issue appears to be addressed by making the entries, in modules arrays.
-        # If yes remove this comment.
-
-        to_file = "#{Wagn.paths['tmp/set'].first}/#{set_pattern}/#{seq}-#{anchors.join '-'}.rb"
-        anchor_modules = anchors.map { |a| "module #{a.camelize};" }.join # use explicit '', not $,
-        file_content = <<EOF
-# -*- encoding : utf-8 -*-
-class Card; module Set; module #{set_pattern.camelize}; #{anchor_modules}
-extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from #{from_file} ~~~~~~~~~~~
-
-#{ File.read from_file }
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from #{from_file} ~~~~~~~~~~~
-end;end;end;#{'end;'*anchors.size}
-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
-        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?
-            klass.send :include, mod
-          end
-          if class_methods = mod.const_get_if_defined( :ClassMethods )
-            klass.send :extend, class_methods
-          end
-        end
-      end
-    
-      def clean_empty_modules
-        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
-
-
-    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.anchor_parts_count
-      parts[first..last].join '::'
-    end
-
-    def all_set?
-      name =~ /^Card::Set::All::/
-    end
-
-    private
-    
-    
-    def set_event_callbacks event, opts
-      [:before, :after, :around].each do |kind|
-        if object_method = opts.delete(kind)
-          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
-
-    def get_traits mod
-      Card::Set.traits ||= {}
-      Card::Set.traits[mod] or Card::Set.traits[mod] = {}
-    end
-
-    def add_traits args, options
-      mod = self
-  #    raise "Can't define card traits on all set" if mod == Card
-      mod_traits = get_traits mod
-    
-      new_opts = options[:type] ? {:type=>options[:type]} : {}
-      new_opts.merge!( {:content => options[:default]} ) if options[:default]
-    
-      args.each do |trait|   
-        define_trait_card trait, new_opts
-        define_trait_reader trait if options[:reader]
-        define_trait_writer trait if options[:writer]
-
-        mod_traits[trait.to_sym] = options
-      end
-    end
-  
-    def define_trait_card trait, opts
-      define_method "#{trait}_card" do
-        trait_var "@#{trait}_card" do
-          fetch :trait=>trait.to_sym, :new=>opts.clone
-        end
-      end
-    end
-  
-    def define_trait_reader trait
-      define_method trait do
-        trait_var "@#{trait}" do
-          send( "#{trait}_card" ).content
-        end
-      end
-    end
-
-    def define_trait_writer trait
-      define_method "#{trait}=" do |value|
-        card = send "#{trait}_card"
-        self.subcards ||= {}
-        self.subcards[card.name] = {:type_id => card.type_id, :content=>value }
-        instance_variable_set "@#{trait}", value
-      end
-    end
-
-  end
-end
-