csl 1.0.0.pre10 → 1.0.0.pre11

data/lib/csl/locale/term.rb

@@ -11,32 +11,72 @@ module CSL
 
       def initialize(attributes = {})
         super(attributes)
-        @registry, children[:term] = Hash.new { |h,k| h[k] = [] }, []
+        children[:term] = []
+
+        @registry = Term::Registry.new
+        @ordinals = Term::Registry.new
 
         yield self if block_given?
       end
 
       alias each each_child
 
-      def lookup(query)
-        query = { :name => query } unless query.is_a?(Hash)
+      def lookup(name, options = {})
+        options[:name] = name = name.to_s
+
+        term = registry[name].detect { |t| t.match?(options) }
+        return term unless term.nil? && options.delete(:'gender-form')
+  
+        registry[name].detect { |t| t.match?(options) }
+      end
+      alias [] lookup
+      
+      def ordinalize_modulo(number, divisor, options = {})
+        ordinal = ordinalize(number, options)
+        return unless ordinal && ordinal.match_modulo?(divisor)
+        ordinal
+      end
 
-        terms = if query[:name].is_a?(Regexp)
-          registry.select { |name, _| name =~ query[:name] }.flatten(1)
+      def ordinalize(number, options = {})
+        return unless has_ordinals?
+        
+        if number == :default
+          options[:name] = 'ordinal'
         else
-          registry[query[:name].to_s]
+          options[:name] = 'ordinal-%02d' % number
         end
+        
+        if options[:form].to_s =~ /^long/i
+          options.delete :form
+          options[:name][0,0] = 'long-'
+        end
+        
+        ordinal = ordinals[number].detect { |t| t.match?(options) }
+        return ordinal unless ordinal.nil? && options.delete(:'gender-form')
+        
+        ordinals[number].detect { |t| t.match?(options) }
+      end
 
-        terms.detect { |t| t.match?(query) }
+      # @return [Boolean] whether or not regular terms are registered at this node
+      def has_terms?
+        not registry.empty?
       end
-      alias [] lookup
 
-      def lookup_modulo(query, divisor)
-        term = lookup(query)
-        return if term.nil? || !term.match_modulo?(divisor)
-        term
+      # @return [Boolean] whether or not ordinal terms are registered at this node
+      def has_ordinals?
+        not ordinals.empty?
+      end
+
+      def has_legacy_ordinals?
+        has_ordinals? && !ordinals.key?(:default)
       end
       
+      def drop_ordinals
+        tmp = ordinals.values.flatten(1)
+        ordinals.clear
+        delete_children tmp
+      end
+
       private
 
       # @!attribute [r] registry
@@ -44,17 +84,36 @@ module CSL
       #   term objects for quick term look-up
       attr_reader :registry
 
+      # @!attribute [r] ordinals
+      # @return [Hash] a private registry to map ordinals to the respective
+      #   term objects for quick ordinal look-up
+      attr_reader :ordinals
+
       def added_child(term)
         raise ValidationError, "failed to register term #{term.inspect}: name attribute missing" unless
           term.attribute?(:name)
 
-        registry[term[:name]].push(term)
+        if term.ordinal?
+          store = ordinals[term.ordinal]
+        else
+          store = registry[term[:name]]
+        end
+
+        delete_children store.select { |value| term.exact_match? value }
+
+        store.push(term)
+
         term
       end
 
       def deleted_child(term)
-        registry[term[:name]].delete(term)
+        if term.ordinal?
+          ordinals[term.ordinal].delete(term)
+        else
+          registry[term[:name]].delete(term)
+        end
       end
+      
     end
 
     class Term < Node
@@ -76,7 +135,7 @@ module CSL
       #   passed-in divisor.
       def match_modulo?(divisor)
         return false unless ordinal?
-        
+
         case attributes.match
         when '2-digits'
           divisor.to_i == 100
@@ -88,24 +147,30 @@ module CSL
           true
         end
       end
-
       alias matches_modulo? match_modulo?
-      
+
       # @return [Boolean] whether or not this term is an ordinal term
       def ordinal?
-        /^ordinal(-\d\d+)?$/ === attributes.name
+        /^(long-)?ordinal(-\d\d+)?$/ === attributes.name
       end
-        
+
+      # @return [Fixnum, :default, nil]
+      def ordinal
+        return unless ordinal?
+        return :default if attributes.name == 'ordinal'
+        attributes.name[/\d+/].to_i
+      end
+
       def gendered?
-        !attributes.gender.blank?
+        not attributes.gender.blank?
       end
 
       def neutral?
-        !gendered?
+        not gendered?
       end
 
       def textnode?
-        !text.blank?
+        not text.blank?
       end
 
       def singularize
@@ -200,6 +265,11 @@ module CSL
         end
       end
 
+      class Registry < ::Hash
+        def initialize
+          super { |h,k| h[k] = [] }
+        end
+      end
     end
 
     TextNode.types << Term

data/lib/csl/node.rb

@@ -66,29 +66,44 @@ module CSL
         end
       end
 
+      def parse(data)
+        parse!(data)
+      rescue
+        nil
+      end
+
+      def parse!(data)
+        node = CSL.parse!(data, self)
+
+        raise ParseError, "root node not #{self.name}: #{node.inspect}" unless
+          node.class == self || Node.equal?(self)
+
+        node
+      end
+
       private
 
-			def has_language				
-				attr_accessor :language
-				
-				define_method :has_language? do
-					!language.nil?
-				end
-				
-				public :language, :language=, :has_language?
-				
-				alias_method :original_attribute_assignments, :attribute_assignments
-				
-				define_method :attribute_assignments do
-					if has_language?
-			  		original_attribute_assignments.unshift('xml:lang="%s"' % language)
-					else
-						original_attribute_assignments
-					end
-			  end
-			
-				private :original_attribute_assignments, :attribute_assignments
-			end
+      def has_language
+        attr_accessor :language
+
+        define_method :has_language? do
+          !language.nil?
+        end
+
+        public :language, :language=, :has_language?
+
+        alias_method :original_attribute_assignments, :attribute_assignments
+
+        define_method :attribute_assignments do
+          if has_language?
+            original_attribute_assignments.unshift('xml:lang="%s"' % language)
+          else
+            original_attribute_assignments
+          end
+        end
+
+        private :original_attribute_assignments, :attribute_assignments
+      end
 
       def attr_defaults(attributes)
         @default_attributes = attributes
@@ -120,13 +135,17 @@ module CSL
             __class__.keys
           end
 
+          def symbolize_keys
+            self
+          end
+
           def values
             super.compact
           end
 
-          # def to_a
-          #   keys.zip(values_at(*keys)).reject { |k,v| v.nil? }
-          # end
+          def to_hash
+            Hash[keys.zip(values_at(*keys)).reject { |_, v| v.nil? }]
+          end
 
           # @return [Boolean] true if all the attribute values are nil;
           #   false otherwise.
@@ -192,6 +211,23 @@ module CSL
       yield self if block_given?
     end
 
+    def initialize_copy(other)
+      super
+      @attributes = self.class.create_attributes(other.attributes)
+      @children = self.class.create_children
+      @parent, @ancestors, @descendants, @siblings, @root, @depth = nil
+    end
+
+    def deep_copy
+      copy = dup
+
+      each_child do |child|
+        copy.add_child child.deep_copy
+      end
+
+      copy
+    end
+
     # Iterates through the Node's attributes
     def each
       if block_given?
@@ -215,9 +251,9 @@ module CSL
       !attributes.empty?
     end
 
-		def has_language?
-			false
-		end
+    def has_language?
+      false
+    end
 
     def textnode?
       false
@@ -251,8 +287,13 @@ module CSL
     #
     # @see #exact_match?
     #
-    # If the optional
-    # @param name [String,Regexp] must match the nodename
+    # @example
+    #   node.match?(name, conditions)
+    #   node.match?(conditions)
+    #   node.match?(other_node)
+    #
+    # @param name [String,Regexp,Node] must match the nodename; alternatively
+    #   you can pass a node
     # @param conditions [Hash] the conditions
     #
     # @return [Boolean] whether or not the query matches the node
@@ -286,7 +327,13 @@ module CSL
     #
     # @see #match?
     #
-    # @param name [String,Regexp] must match the nodename
+    # @example
+    #   node.exact_match?(name, conditions)
+    #   node.exact_match?(conditions)
+    #   node.exact_match?(other_node)
+    #
+    # @param name [String,Regexp,Node] must match the nodename; alternatively
+    #   you can pass a node
     # @param conditions [Hash] the conditions
     #
     # @return [Boolean] whether or not the query matches the node exactly
@@ -303,20 +350,20 @@ module CSL
     end
     alias matches_exactly? exact_match?
 
-		# @option filter [Array] a list of attribute names
-		# @return [Hash] the node's attributes matching the filter
-		def attributes_for(*filter)
-			filter.flatten!
+    # @option filter [Array] a list of attribute names
+    # @return [Hash] the node's attributes matching the filter
+    def attributes_for(*filter)
+      filter.flatten!
 
-			Hash[map { |name, value|
-				!value.nil? && filter.include?(name) ? [name, value.to_s] : nil
-			}.compact]
-		end
+      Hash[map { |name, value|
+        !value.nil? && filter.include?(name) ? [name, value.to_s] : nil
+      }.compact]
+    end
 
-		# @return [Hash] the node's formatting options
-		def formatting_options
-			attributes_for Schema.attr(:formatting)
-		end
+    # @return [Hash] the node's formatting options
+    def formatting_options
+      attributes_for Schema.attr(:formatting)
+    end
 
     def <=>(other)
       [nodename, attributes, children] <=> [other.nodename, other.attributes, other.children]
@@ -349,6 +396,11 @@ module CSL
     alias to_s pretty_print
 
 
+    protected
+
+    def match_conditions
+    end
+
     private
 
     def attribute_assignments
@@ -359,6 +411,8 @@ module CSL
 
     def match_conditions_for(name, conditions)
       case name
+      when Node
+        [name.nodename, name.attributes.to_hash]
       when Hash
         conditions, name = name, nodename
       when Symbol

data/lib/csl/parser.rb

@@ -37,7 +37,7 @@ module CSL
     end
     
     def parse!(source, scope = Node)
-      root = parser[source].children.detect { |child| !comment?(child) }
+      root = parser[source].children.detect { |child| !skip?(child) }
       parse_tree root, scope
     end
 
@@ -62,8 +62,8 @@ module CSL
     end
     
     def parse_tree(node, scope = Node)
-			return nil if node.nil?
-			
+      return nil if node.nil?
+      
       root = parse_node node, scope
       scope = specialize_scope(root, scope)
       
@@ -83,23 +83,25 @@ module CSL
       end
     end
     
-		def comment?(node)
-			node.respond_to?(:comment?) && node.comment? ||
-				node.respond_to?(:node_type) && [:comment, :xmldecl].include?(node.node_type)
-		end
+    def comment?(node)
+      node.respond_to?(:comment?) && node.comment? ||
+        node.respond_to?(:node_type) &&
+        [:comment, :xmldecl, :processing_instruction, 7].include?(node.node_type)
+    end
+    alias skip? comment?
 
-		def specialize_scope(root, scope = Node)
-		  case root
-		  when Style
-		    Style
-		  when Locale
-		    Locale
-		  when Info
-		    Info
-		  else
-		    scope
-		  end
-		end
+    def specialize_scope(root, scope = Node)
+      case root
+      when Style
+        Style
+      when Locale
+        Locale
+      when Info
+        Info
+      else
+        scope
+      end
+    end
   end
   
 end

data/lib/csl/style.rb

@@ -5,7 +5,7 @@ module CSL
 
     @default = :apa
 
-    @root = File.expand_path('../../../vendor/styles', __FILE__).freeze
+    @root = '/usr/local/share/csl/styles'.freeze
 
     @extension = '.csl'.freeze
     @prefix = ''
@@ -14,15 +14,6 @@ module CSL
       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
       
       def load(input = Style.default)
         super