csl 1.0.0.pre11 → 1.0.0.pre12

data/lib/csl/locale.rb

@@ -195,8 +195,10 @@ module CSL
       self
     end
 
-    def translate(query)
-      terms[query]
+    # @return [String, nil] the term's translation
+    def translate(name, options = {})
+      term = terms.lookup name, options
+      term && term.to_s(options)
     end
     alias t translate
 

data/lib/csl/locale/term.rb

@@ -21,16 +21,20 @@ module CSL
 
       alias each each_child
 
+      # @return [Term, nil] the first term that matches the query
       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) }
+        # specialize search conditions
+        conditions = options.select { |k,_| Term::Attributes.keys.include?(k.to_sym) }
+
+        term = registry[name].detect { |t| t.match?(conditions) }
+        return term unless term.nil? && conditions.delete(:'gender-form')
+
+        registry[name].detect { |t| t.match?(conditions) }
       end
       alias [] lookup
-      
+
       def ordinalize_modulo(number, divisor, options = {})
         ordinal = ordinalize(number, options)
         return unless ordinal && ordinal.match_modulo?(divisor)
@@ -39,21 +43,21 @@ module CSL
 
       def ordinalize(number, options = {})
         return unless has_ordinals?
-        
+
         if number == :default
           options[:name] = 'ordinal'
         else
           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
 
@@ -70,7 +74,7 @@ module CSL
       def has_legacy_ordinals?
         has_ordinals? && !ordinals.key?(:default)
       end
-      
+
       def drop_ordinals
         tmp = ordinals.values.flatten(1)
         ordinals.clear
@@ -113,7 +117,7 @@ module CSL
           registry[term[:name]].delete(term)
         end
       end
-      
+
     end
 
     class Term < Node
@@ -162,15 +166,23 @@ module CSL
       end
 
       def gendered?
-        not attributes.gender.blank?
+        !attributes.gender.blank?
       end
 
       def neutral?
-        not gendered?
+        !gendered?
+      end
+
+      def short?
+        attribute?(:form) && attributes.form.to_s =~ /^short$/i
+      end
+
+      def long?
+        !short?
       end
 
       def textnode?
-        not text.blank?
+        !text.blank?
       end
 
       def singularize

data/lib/csl/node.rb

@@ -183,7 +183,7 @@ module CSL
           #   Returns an array containing the attributes in self according
           #   to the given selector(s). The selectors may be either integer
           #   indices, ranges (functionality inherited from Struct) or
-          #   symbols idenifying valid keys (similar to Hash#values_at).
+          #   symbols identifying valid keys (similar to Hash#values_at).
           #
           # @example
           #   attributes.values_at(:family, :nick) #=> ['Matsumoto', 'Matz']
@@ -191,7 +191,13 @@ module CSL
           # @see Struct#values_at
           # @return [Array] the list of values
           def values_at(*arguments)
-            super(*arguments.flatten.map { |k| k.is_a?(Symbol) ? keys.index(k) : k })
+            arguments.flatten.inject([]) do |values, key|
+              if key.is_a?(Symbol)
+                values.push fetch(key)
+              else
+                values.concat super(key)
+              end
+            end
           end
 
         })

data/lib/csl/version.rb

@@ -1,3 +1,3 @@
 module CSL  
-  VERSION = '1.0.0.pre11'.freeze
+  VERSION = '1.0.0.pre12'.freeze
 end

data/spec/csl/locale/term_spec.rb

@@ -36,8 +36,41 @@ module CSL
   		    end
   		  end
 		  end
+
 		end
 
+    describe '#lookup' do
+
+		  describe "given standard English terms" do
+  		  let(:en) do
+  		    Locale::Terms.parse <<-EOS
+  	      <terms>
+            <term name="page" form="short">
+              <single>p.</single>
+              <multiple>pp.</multiple>
+            </term>
+            <term name="page">
+              <single>page</single>
+              <multiple>pages</multiple>
+            </term>
+  	      </terms>
+  	      EOS
+  		  end
+  		  
+  		  it 'returns nil if there is no matching term' do
+  		    en.lookup(:foo).should be_nil
+  		  end
+
+  		  it 'returns the first matching form by default' do
+  		    en.lookup(:page).should be_short
+  		  end
+  		  
+  		  it 'ignores irrelevant options' do
+  		    en.lookup(:page, :plural => true).should_not be_nil
+  		  end
+  		end
+
+    end
 	end
 
   describe Locale::Term do

data/spec/csl/node_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 module CSL
-	
+
 	describe Node do
 
     it { should_not be nil }
     it { should_not have_children }
     it { should_not have_attributes }
-		
+
 		describe 'given a FooBarNode with attributes :foo and :bar and a TestNode without defined attributes' do
       before(:all) do
         class FooBarNode < Node
@@ -16,15 +16,15 @@ module CSL
         class TestNode < Node
         end
       end
-      
+
       it 'creates FooBarNode::Attributes' do
         FooBarNode.const_defined?(:Attributes).should be_true
       end
-      
+
       it 'does not create TestNode::Attributes' do
         TestNode.const_defined?(:Attributes).should_not be_true
       end
-		  
+
 		  it 'TestNode attributes are a regular Hash' do
 		    TestNode.new.attributes.should be_a(Hash)
 		  end
@@ -32,21 +32,65 @@ module CSL
 		  it 'FooBarNode attributes are a Struct' do
 		    FooBarNode.new.attributes.should be_a(Struct)
 		  end
-		  
+
+		  describe '#match?' do
+		    it 'matches an empty query' do
+		      FooBarNode.new.match?({}).should be_true
+		      FooBarNode.new(:foo => 'Foo').match?({}).should be_true
+		      TestNode.new.match?({}).should be_true
+		      TestNode.new(:foo => 'Foo').match?({}).should be_true
+		    end
+
+        it 'returns true for a matching query' do
+		      FooBarNode.new(:foo => 'bar').match?(:foo => 'bar').should be_true
+		      FooBarNode.new(:bar => 'b', :foo => 'f').match?(:foo => 'f', :bar => 'b').should be_true
+        end
+
+        it 'returns false for non-matching query' do
+		      FooBarNode.new.match?(:foo => 'bar').should be_false
+		      FooBarNode.new(:foo => 'f').match?(:foo => 'f', :bar => 'b').should be_false
+        end
+
+        it 'returns false if the query contains unknown attributes' do
+		      FooBarNode.new(:foo => 'f').match?(:foo => 'f', :unknown => 'u').should be_false
+        end
+
+        it 'matches irrespective of order' do
+		      FooBarNode.new(:bar => 'b', :foo => 'f').match?(:foo => 'f', :bar => 'b').should be_true
+		      FooBarNode.new(:foo => 'f', :bar => 'b').match?(:foo => 'f', :bar => 'b').should be_true
+		      FooBarNode.new(:foo => 'f', :bar => 'b').match?(:bar => 'b', :foo => 'f').should be_true
+		      FooBarNode.new(:bar => 'b', :foo => 'f').match?(:bar => 'b', :foo => 'f').should be_true
+        end
+
+		    it 'matches an empty query with the correct node name' do
+		      FooBarNode.new.match?('foo-bar-node', {}).should be_true
+		      FooBarNode.new(:foo => 'Foo').match?('foo-bar-node', {}).should be_true
+		      TestNode.new.match?('test-node', {}).should be_true
+		      TestNode.new(:foo => 'Foo').match?('test-node', {}).should be_true
+		    end
+
+		    it 'does not match other node names' do
+		      FooBarNode.new.match?(:name, {}).should_not be_true
+		      FooBarNode.new(:foo => 'Foo').match?(:name, {}).should_not be_true
+		      TestNode.new.match?(:name, {}).should_not be_true
+		      TestNode.new(:foo => 'Foo').match?(:name, {}).should_not be_true
+		    end
+		  end
+
 		  describe '#attributes_for' do
 		    it 'returns an empty hash when there no attributes are set' do
 		      TestNode.new.attributes_for.should be_empty
 		      TestNode.new.attributes_for(:x, :y).should be_empty
-		      
+
 		      FooBarNode.new.attributes_for.should be_empty
 		      FooBarNode.new.attributes_for(:x, :y).should be_empty
 		      FooBarNode.new.attributes_for(:foo, :bar).should be_empty
 		    end
-		    
+
 		    it 'returns an empty hash when no attributes match the filter' do
 		      TestNode.new(:foo => 'foo').attributes_for.should be_empty
 		      TestNode.new(:foo => 'foo').attributes_for(:x, :y).should be_empty
-		      
+
 		      FooBarNode.new(:foo => 'foo').attributes_for.should be_empty
 		      FooBarNode.new(:foo => 'foo').attributes_for(:x, :y).should be_empty
 		    end
@@ -56,33 +100,37 @@ module CSL
 		      FooBarNode.new(:foo => 'foo', :bar => 'bar').attributes_for(:x, :foo).should == { :foo => 'foo' }
 		    end
 		  end
-		  
+
 		  describe '#formatting_options' do
 		    it 'returns an empty hash by default' do
 		      TestNode.new.formatting_options.should be_empty
 		      FooBarNode.new.formatting_options.should be_empty
 		    end
-		    
+
 		    it 'returns an empty hash if there are no formatting attributes' do
 		      TestNode.new(:foo => 'foo', :bar => 'bar').formatting_options.should be_empty
 		      FooBarNode.new(:foo => 'foo', :bar => 'bar').formatting_options.should be_empty
 		    end
-		    
+
 		    it "returns a hash of the node's formatting attributes" do
 		      TestNode.new(:foo => 'foo', :'font-style' => 'italic').formatting_options.should == { :'font-style' => 'italic' }
 		    end
 		  end
-		  
+
   		describe '#values_at' do
   		  it 'FooBarNode accepts attribute names' do
   		    FooBarNode.new(:foo => 'Foo', :bar => 'Bar').values_at(:bar, :foo).should == %w{ Bar Foo }
+  		    FooBarNode.new(:foo => 'Foo').values_at(:bar, :foo).should == [nil, 'Foo']
+  		    FooBarNode.new(:foo => 'Foo').values_at(:unknown, :foo).should == [nil, 'Foo']
   		  end
-  		  
+
   		  it 'TestNode accepts attribute names' do
   		    TestNode.new(:foo => 'Foo', :bar => 'Bar').values_at(:bar, :foo).should == %w{ Bar Foo }
+  		    TestNode.new(:foo => 'Foo').values_at(:bar, :foo).should == [nil, 'Foo']
+  		    TestNode.new(:foo => 'Foo').values_at(:unknown, :foo).should == [nil, 'Foo']
   		  end
       end
-      
+
       describe '#to_a' do
         it 'returns an empty list by default' do
           Node.new.attributes.to_a.should == []
@@ -91,7 +139,7 @@ module CSL
         it 'TestNode returns an empty list by default' do
           TestNode.new.attributes.to_a.should == []
         end
-        
+
         # it 'TestNode returns a list of all key/value pairs' do
         #   TestNode.new(:foo => 'Foo', :bar => 'Bar').attributes.to_a.map(&:last).sort.should == %w{ Bar Foo }
         # end
@@ -99,12 +147,12 @@ module CSL
         # it 'FooBarNode returns an empty list by default' do
         #   FooBarNode.new.attributes.to_a.should == []
         # end
-  		  
+
         # it 'FooBarNode returns a list of all key/value pairs' do
         #   FooBarNode.new(:foo => 'Foo', :bar => 'Bar').attributes.to_a.map(&:last).sort.should == %w{ Bar Foo }
         # end
       end
-      
+
       describe 'attributes.keys' do
         it 'returns all attribute names as symbols' do
           TestNode.new.attributes.keys.should be_empty
@@ -115,28 +163,28 @@ module CSL
 	end
 
   describe TextNode do
-    
+
     it { should_not be nil }
     it { should_not have_children }
     it { should_not have_attributes }
-    
+
     describe '.new' do
       it 'accepts a hash of attributes' do
         TextNode.new(:foo => 'bar').should have_attributes
       end
-      
+
       it 'yields itself to the optional block' do
         TextNode.new { |n| n.text = 'foo' }.text.should == 'foo'
       end
-      
+
       it 'accepts hash and yields itself to the optional block' do
         TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.to_xml.should == '<text-node foo="bar">foo</text-node>'
       end
     end
-    
+
     describe '#pretty_print' do
       TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.pretty_print.should == '<text-node foo="bar">foo</text-node>'
     end
   end
-  
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: csl
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre11
+  version: 1.0.0.pre12
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-05 00:00:00.000000000 Z
+date: 2013-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: namae
@@ -183,7 +183,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1272288240557992685
+      hash: 1070711312713509519
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: