csl 1.0.0.pre3 → 1.0.0.pre4

data/lib/csl/style.rb

@@ -1,91 +1,147 @@
 module CSL
-  
+
   class Style < Node
     types << CSL::Info << CSL::Locale
-    
+
     @default = :apa
 
     @root = File.expand_path('../../../vendor/styles', __FILE__).freeze
-        
+
     @extension = '.csl'.freeze
     @prefix = ''
-    
+
     class << self
       include Loader
-      
+
       attr_accessor :default
 
       def parse(data)
         node = CSL.parse!(data, self)
-        
+
         raise ParseError, "root node is not a style: #{node.inspect}" unless
           node.is_a?(self)
-        
+
         node
-      end      
+      end
     end
-    
+
     attr_defaults :version => Schema.version, :xmlns => Schema.namespace
-    
+
     attr_struct :xmlns, :version, :class, :'default-locale',
       :'initialize-with-hyphen', :'page-range-format',
       :'demote-non-dropping-particle', *Schema.attr(:name, :names)
-    
+
     attr_children :'style-options', :info, :locale, :macro,
       :citation, :bibliography
-    
+
+    attr_reader :macros, :errors
+
     alias options  style_options
     alias locales  locale
-    
+
+    alias has_macros? has_macro?
+
     def_delegators :info, :self_link, :self_link=, :has_self_link?,
       :template_link, :template_link=, :has_template_link?,
       :documentation_link, :documentation_link=, :has_documentation_link?,
-			:title=, :id=
-      
+      :independent_parent_link, :independent_parent_link=,
+      :has_independent_parent_link?, :title=, :id=, :has_title?, :has_id?,
+      :published_at, :updated_at
+
     def initialize(attributes = {})
-      super(attributes, &nil)      
-      children[:locale], children[:macro] = [], []
-      
+      super(attributes, &nil)
+      children[:locale], children[:macro], @macros, @errors = [], [], {}, []
+
       yield self if block_given?
     end
 
+    # @override
+    def added_child(node)
+      delegate = :"added_#{node.nodename}"
+      send delegate, node if respond_to?(delegate, true)
+      node
+    end
+
+    # @override
+    def deleted_child(node)
+      delegate = :"deleted_#{node.nodename}"
+      send delegate, node if respond_to?(delegate, true)
+      node
+    end
+
     def validate
-      Schema.validate self
+      @errors = Schema.validate self
     end
-    
+
     def valid?
       validate.empty?
     end
-    
+
     def info
       children[:info] ||= Info.new
     end
-    
+
     alias_child :metadata, :info
-    
+
     # @return [String] the style's id
 		def id
-			return nil unless info.has_id?
+			return unless info.has_id?
 			info.id.to_s
 		end
-    
+
     # @return [String] the style's title
 		def title
-			return nil unless info.has_title?
+			return unless info.has_title?
 			info.title.to_s
 		end
-		
-		# @return [Time] timestamp for the time set in info.updated
-		def updated_at
-			return nil unless info.has_updated?
-			Time.parse(info.updated)
-		end
+
+    alias has_template? has_template_link?
+
+    # @return [Style] the style's template
+    def template
+      return unless has_template?
+      load_related_style_from template_link
+    end
+
+    alias dependent? has_independent_parent_link?
+
+    def independent?
+      !dependent?
+    end
+
+    def independent_parent
+      return unless dependent?
+      load_related_style_from independent_parent_link
+    end
 
     private
-    
+
     def preamble
       Schema.preamble.dup
-    end 
+    end
+
+    def load_related_style_from(uri)
+      # TODO try local first
+      Style.load(uri)
+    end
+    
+    def added_macro(node)
+      unless node.attribute?(:name)
+        raise ValidationError,
+          "failed to register macro #{node.inspect}: name attribute missing"
+      end
+
+      if macros.key?(node[:name])
+        raise ValidationError,
+          "failed to register macro #{node.inspect}: duplicate name"
+      end
+
+      macros[node[:name]] = node
+    end
+    
+    def deleted_macro(node)
+      macros.delete node[:name]
+    end
   end
- 
+
 end

data/lib/csl/treelike.rb

@@ -1,17 +1,17 @@
 module CSL
-  
+
   module Treelike
-    
+
     attr_accessor :parent
     attr_reader :children
     attr_writer :nodename
-    
+
 		protected :parent=
-		
+
     def self.included(base)
       base.extend(ClassMethods)
     end
-    
+
     # @return [String] the node's name.
     def nodename
       @nodename ||= self.class.name.split(/::/)[-1].gsub(/([[:lower:]])([[:upper:]])/, '\1-\2').downcase
@@ -25,12 +25,13 @@ module CSL
         enum_for :each_child
       end
     end
-        
+
     def delete_children(*nodes)
       nodes.each do |node|
         delete_child node
       end
     end
+    alias delete delete_children
     
     # Deletes child nodes that are equal to the passed-in node. Returns all
     # deleted children. If no children were deleted, returns nil. If the
@@ -38,54 +39,52 @@ module CSL
     # deleted.
     def delete_child(child)
       deleted = children.delete child
-      
+
       case
       when deleted.nil? && block_given?
         yield
       when deleted.nil?
         nil
       else
-        [*deleted].each do |node|
-          node.parent = nil
-          
-          deleted_child node
-          node.deleted_from self
-        end
-        
+        deleted.parent = nil
+
+        deleted_child deleted
+        deleted.deleted_from self
+
         deleted
       end
     rescue => e
       # TODO rollback
       raise e
     end
-    
+
     def add_children(*nodes)
       nodes.each do |node|
         add_child node
       end
       self
     end
-    
+
     def add_child(node)
       node.unlink
-      
+
       node.parent = self
       children << node
-      
+
       added_child node
       node.added_to self
-      
+
       node
     rescue => e
       # TODO rollback
       raise e
     end
-    
+
     def <<(node)
       add_child node
       self
     end
-    
+
     # Returns the first immediate child node whose nodename matches the
     # passed-in name/pattern and attribute conditions.
     #
@@ -99,7 +98,7 @@ module CSL
       end
     end
     alias > find_child
-    
+
     # Returns all immediate child nodes whose nodename matches the passed-in
     # name/pattern and attribute conditions; returns an empty array if there
     # is no match.
@@ -124,20 +123,20 @@ module CSL
 		def empty?
 			children.empty?
 		end
-    
+
     # Unlinks the node and all its children from its parent node. Returns
     # the old parent node or nil.
     def unlink
       return nil if root?
-      
+
       other = parent
       other.delete_child self
-      
+
       self.parent = nil
 
       other
     end
-    
+
     def each_sibling
       if block_given?
         unless root?
@@ -145,73 +144,73 @@ module CSL
             yield node unless node.equal?(self)
           end
         end
-        
+
         self
       else
         enum_for :each_sibling
       end
     end
-    
+
     def siblings
       @siblings = each_sibling.to_a
     end
-    
+
     # Traverses the node's sub-tree in depth-first order.
     def each_descendant
       if block_given?
         each_child do |child|
-          yield child          
+          yield child
           child.each_descendant(&Proc.new)
         end
-        
+
         self
       else
         enum_for :each_descendant
       end
     end
-    
+
     # Returns all descendants of the node. See {#descendants!}
     # for a memoized version.
     def descendants
       @descendants = each_descendant.to_a
     end
-    
+
     def each_ancestor
       if block_given?
         p = parent
-        
+
         until p.nil?
           yield p
           p = p.parent
         end
-        
+
         self
       else
         enum_for :each_ancestor
       end
     end
-    
+
     # @returns this node's ancestors as an array
     def ancestors
       @ancestors = each_ancestor.to_a
     end
-    
+
     # @return [Fixnum] the node's current depth in the tree
     def depth
       @depth = ancestors.length
     end
-    
+
     # @return [Node] the root node
     def root
       @root = root? ? self : parent.root!
     end
-    
+
     # @returns [Boolean] whether or not the node is the tree's root node
     def root?
       parent.nil?
     end
 
-		
+
     # Add memoized methods. When processing citations, styles will
 		# typically remain stable; therefore cite processors may opt
 		# to use memoized versions of the following methods. These
@@ -223,34 +222,34 @@ module CSL
         instance_variable_get(ivar) || send(name)
       end
     end
-    
+
     protected
-    
+
     # @abstract
     # Called after the node was added to another node.
     def added_to(node)
     end
-    
+
     # @abstract
     # Called when the node was deleted from an other node.
     def deleted_from(node)
     end
-    
+
     private
-    
+
     # @abstract
     # Called when the passed-in node was added to this node as a child.
     def added_child(node)
     end
-    
+
     # @abstract
     # Called when the passed-in node was deleted from this node's child nodes.
     def deleted_child(node)
     end
-    
+
 
     module ClassMethods
-      
+
       # Returns a new instance of an Array or Struct to manage the Node's
       # children. This method is called automatically by the Node's
       # constructor.
@@ -261,27 +260,27 @@ module CSL
           []
         end
       end
-      
+
 			def constantize_nodename(name)
 			  return constantize(name) if respond_to?(:constantize)
-			  
+
         klass = name.to_s.capitalize.gsub(/(\w)-(\w)/) { [$1, $2.upcase].join }
-        
+
 				if const_defined?(klass)
-				  const_get(klass)	
+				  const_get(klass)
 				else
 					nil
 				end
 			end
-			
-			
+
+
       private
-      
+
       def attr_child_names_for(name)
         reader = name.to_s.downcase.tr('-', '_')
         [name.to_sym, reader, "set_child_#{reader}", "has_#{reader}?"]
       end
-      
+
       # Creates a Struct for the passed-in child node names that will be
       # used internally by the Node to manage its children. The Struct
       # will be automatically initialized and is used similarly to the
@@ -295,7 +294,7 @@ module CSL
       # method will try to coerce the passed-in value into the correct
       # node type automatically.
       def attr_children(*names)
-        
+
         names.each do |name|
           name, reader, writer, predicate = attr_child_names_for(name)
 
@@ -312,7 +311,7 @@ module CSL
             define_method(writer) do |value|
               begin
                 klass = self.class.constantize_nodename(name)
-								
+
                 if klass
                   value = klass.new(value)
                 else
@@ -320,7 +319,7 @@ module CSL
                 	value = (value.is_a?(String) ? TextNode : Node).new(value)
                 	value.nodename = name.to_s
                 end
-                
+
               rescue => e
                 raise ArgumentError, "failed to convert #{value.inspect} to node: #{e.message}"
               end unless value.respond_to?(:nodename)
@@ -328,20 +327,20 @@ module CSL
               children << value
               value
             end
-            
+
             alias_method :"#{reader}=", writer unless method_defined?(:"#{reader}=")
           end
         end
-        
+
         const_set(:Children, Struct.new(*names) {
-          
+
           # 1.8 Compatibility
           @keys = members.map(&:to_sym).freeze
-          
+
           class << self
             attr_reader :keys
           end
-                    
+
           def initialize(attrs = {})
             super(*attrs.symbolize_keys.values_at(*keys))
           end
@@ -351,9 +350,9 @@ module CSL
           def keys
             __class__.keys
           end
-          
+
           alias original_each each
-          
+
           def count
             values.reject { |c| c.nil? || c.empty? }.length
           end
@@ -373,11 +372,11 @@ module CSL
               to_enum
             end
           end
-          
+
           def empty?
             all?(&:nil?)
           end
-          
+
           # Adds the node as a child node. Raises ValidationError if none
           # of the Struct members matches the node's name. If there is
           # already a node set with this node name, the node will be pushed
@@ -386,7 +385,7 @@ module CSL
             unless node.respond_to?(:nodename) && keys.include?(node.nodename.to_sym)
               raise ValidationError, "not allowed to add #{node.inspect} to #{inspect}"
             end
-            
+
             current = self[node.nodename]
             case current
             when Array
@@ -396,19 +395,19 @@ module CSL
             else
               self[node.nodename] = [current, node]
             end
-            
+
             self
           end
-          
+
           alias << push
-          
+
           # Delete items from self that are equal to node. If any items are
           # found, returns the deleted items. If the items is not found,
           # returns nil. If the optional code block is given, returns the
           # result og block if the item is not found.
           def delete(node)
             return nil unless node.respond_to?(:nodename)
-            
+
             deleted = resolve(node.nodename)
             if deleted.kind_of?(Array)
               deleted = deleted.delete(node)
@@ -419,30 +418,30 @@ module CSL
                 deleted = nil
               end
             end
-            
+
             if deleted.nil? && block_given?
               yield
             else
               deleted
             end
           end
-          
+
           def fetch(name, default = nil)
-            if block_given? 
+            if block_given?
               resolve(name) || yield(key)
             else
               resolve(name) || default
             end
           end
-          
+
           private
-          
+
           def resolve(nodename)
             keys.include?(nodename.to_sym) && send(nodename)
           end
         })
       end
-      
+
       def alias_child(new_name, old_name)
         attr_child_names_for(new_name).zip(attr_child_names_for(old_name)).each do |nn, on|
           alias_method nn, on if method_defined?(on)
@@ -450,7 +449,7 @@ module CSL
       end
 
       # Turns the node into a leaf-node.
-      def has_no_children   
+      def has_no_children
         undef_method :add_child
         undef_method :added_child
         undef_method :add_children
@@ -459,9 +458,9 @@ module CSL
         undef_method :delete_child
         undef_method :deleted_child
         undef_method :delete_children
-        
+
         private :children
-        
+
         define_method(:has_children?) do
           false
         end
@@ -471,8 +470,8 @@ module CSL
         end
 
       end
-            
+
     end
-        
+
   end
 end