csl 1.0.0.pre1

data/lib/csl/locale/term.rb

@@ -0,0 +1,185 @@
+module CSL
+  class Locale
+    
+    class Terms < Node
+      attr_children :term
+      
+      alias terms term
+      def_delegators :terms, :size, :length
+      
+      undef_method :[]=
+      
+      def initialize(attributes = {})
+        super(attributes)      
+        @registry, children[:term] = Hash.new { |h,k| h[k] = [] }, []
+
+        yield self if block_given?
+      end
+
+      alias each each_child
+      
+      def lookup(query)
+        terms = if Regexp === query
+          registry.keys.select { |t| t =~ query }.flatten(1)
+        else
+          registry[(Hash === query) ? query[:name] : query.to_s]
+        end
+
+        terms.detect { |t| t.matches?(query) }
+      end
+      
+      alias [] lookup
+      
+      private
+      
+      # @!attribute [r] registry
+      # @return [Hash] a private registry to map term names to the respective
+      #   term objects for quick term look-up
+      attr_reader :registry
+      
+      def added_child(term)
+        raise ValidationError, "failed to register term #{term.inspect}: name attribute missing" unless
+          term.attribute?(:name)
+          
+        registry[term[:name]].push(term)
+        term
+      end
+      
+      def deleted_child(term)
+        registry[term[:name]].delete(term)
+      end
+    end
+    
+    class Term < Node
+      attr_struct :name, :form, :gender, :'gender-form'
+      attr_children :single, :multiple
+
+      attr_accessor :text
+
+      def_delegators :attributes, :hash, :eql?, :name, :form, :gender
+
+      def gendered?
+        !attributes.gender.blank?
+      end
+    
+      def neutral?
+        !gendered?
+      end
+  
+      def textnode?
+        !text.blank?
+      end
+      
+      def singularize
+        return text if textnode?
+        children.single.to_s
+      end
+
+      alias singular singularize
+      
+      def pluralize
+        return text if textnode?
+        children.multiple.to_s
+      end      
+
+      alias plural pluralize
+
+      # Tests whether or not the Term matches the passed-in query. Tests
+      # vary slightly depending on the the query's type: if a String or
+      # Regexp is passed-in, the return value will be true if the Term's
+      # name matches the query (disregarding all other attributes); if the
+      # query is a Hash, however, the return value will only be true if
+      # all passed-in attributes
+      #
+      # @param query [Hash,Regexp,#to_s] the query
+      # @raise [ArgumentError] if the term cannot be matched using query
+      #
+      # @return [Boolean] whether or not the query matches the term
+      def match?(query)
+        case
+        when query.is_a?(Hash)
+          query.symbolize_keys.values_at(*attributes.keys) == attributes.values_at(*attributes.keys)
+        when query.is_a?(Regexp)
+          query =~ name
+        when query.respond_to?(:to_s)
+          query.to_s == name
+        else
+          raise ArgumentError, "cannot match term to query: #{query.inspect}"
+        end
+      end
+      alias matches? match?
+      
+      
+      # @!method masculine?
+      # @return [Boolean] whether or not the term is masculine
+
+      # @!method masculine!
+      # @return [self,nil] the term with the gender attribute set to
+      #   'masculine', or nil if the term was already masculine
+
+      # @!method feminine?
+      # @return [Boolean] whether or not the term is feminie
+
+      # @!method feminine!
+      # @return [self,nil] the term with the gender attribute set to
+      #   'feminine', or nil if the term was already feminine
+      %w{ masculine feminine }.each do |name|
+        define_method("#{name}?") do
+          attributes.gender.to_s == name
+        end
+        
+        define_method("#{name}!") do
+          return nil if attributes.gender.to_s == name
+          attributes.gender = name
+          self
+        end
+      end
+
+      def tags
+        if textnode?
+          ["<#{[nodename, *attribute_assignments].join(' ')}>", text, "</#{nodename}>"]
+        else
+          super
+        end
+      end
+
+      # @param options [Hash,nil] an optional configuration hash
+      #
+      # @option options [:singular,:plural] :number (:singular) whether to
+      #   return the term's singular or plural variant.
+      #
+      # @return [String] the term as a string
+      def to_s(options = nil)
+        if textnode?
+          text
+        else
+          if pluralize?(options)
+            pluralize
+          else
+            singularize
+          end
+        end
+      end
+      
+      class Single   < TextNode; end
+      class Multiple < TextNode; end
+      
+      private
+      
+      def pluralize?(options)
+        return false if options.nil?
+        
+        key = options[:number] || options['number']
+        
+        if key.is_a?(Fixnum) || key.to_s =~ /^[+-]?\d+$/
+          key.to_i > 1
+        else
+          !key.blank? && key.to_s =~ /^plural/i
+        end
+      end
+        
+    end
+       
+    TextNode.types << Term
+  end
+end

data/lib/csl/node.rb

@@ -0,0 +1,285 @@
+module CSL
+  
+  class Node
+    
+    extend Forwardable
+    
+    include Enumerable
+    include Comparable
+    
+    include Treelike
+    include PrettyPrinter
+    
+    
+    class << self
+
+      def inherited(subclass)
+        types << subclass
+        subclass.nesting.each do |klass|
+          klass.types << subclass if klass < Node
+        end
+      end
+      
+      def types
+        @types ||= Set.new
+      end
+      
+      def default_attributes
+        @default_attributes ||= {}
+      end
+      
+      def constantize(name)
+        types.detect do |t|
+          t.name.split(/::/)[-1].gsub(/([[:lower:]])([[:upper:]])/, '\1-\2').downcase == name
+        end
+      end
+      
+      # Returns a new node with the passed in name and attributes.
+      def create(name, attributes = {}, &block)
+        klass = constantize(name)
+
+        unless klass.nil?
+          klass.new(attributes, &block)
+        else
+          node = new(attributes, &block)
+          node.nodename = name
+          node
+        end
+      end
+      
+      def create_attributes(attributes)
+        if const?(:Attributes)
+          const_get(:Attributes).new(default_attributes.merge(attributes))
+        else
+          default_attributes.merge(attributes)
+        end
+      end
+
+      private
+
+      def attr_defaults(attributes)
+        @default_attributes = attributes
+      end
+
+      # Creates a new Struct for the passed-in attributes. Node instances
+      # will create an instance of this struct to manage their respective
+      # attributes.
+      #
+      # The new Struct will be available as Attributes in the current node's
+      # class scope.
+      def attr_struct(*attributes)
+        const_set(:Attributes, Struct.new(*attributes) {
+
+          # 1.8 Compatibility
+          @keys = attributes.map(&:to_sym).freeze
+          
+          class << self
+            attr_reader :keys
+          end
+                    
+          def initialize(attrs = {})
+            super(*attrs.symbolize_keys.values_at(*keys))
+          end
+
+          # @return [<Symbol>] a list of symbols representing the names/keys
+          #   of the attribute variables.
+          def keys
+            self.class.keys
+          end
+
+          def values
+            super.compact
+          end
+          
+          # def to_a
+          #   keys.zip(values_at(*keys)).reject { |k,v| v.nil? }
+          # end
+          
+          # @return [Boolean] true if all the attribute values are nil;
+          #   false otherwise.
+          def empty?
+            values.compact.empty?
+          end
+          
+          def fetch(key, default = nil)
+            value = keys.include?(key.to_sym) && send(key)
+            
+            if block_given? 
+              value || yield(key)
+            else
+              value || default
+            end
+          end
+          
+          # Merges the current with the passed-in attributes.
+          #
+          # @param other [#each_pair] the other attributes
+          # @return [self]
+          def merge(other)
+            raise ArgumentError, "failed to merge #{other.class} into Attributes" unless
+              other.respond_to?(:each_pair)
+
+            other.each_pair do |part, value|
+              writer = "#{part}="
+              send(writer, value) if !value.nil? && respond_to?(writer)
+            end
+
+            self
+          end
+
+          # @overload values_at(selector, ... )
+          #   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).
+          #
+          # @example
+          #   attributes.values_at(:family, :nick) #=> ['Matsumoto', 'Matz']
+          #
+          # @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 })
+          end
+
+        })
+      end
+
+    end
+
+
+    attr_reader :attributes
+
+    def_delegators :attributes, :[], :[]=, :values, :values_at, :length, :size
+    
+    def initialize(attributes = {})
+      @attributes = self.class.create_attributes(attributes)
+      @children = self.class.create_children
+      
+      yield self if block_given?
+    end
+    
+    # Iterates through the Node's attributes
+    def each
+      if block_given?
+        attributes.each_pair(&Proc.new)
+        self
+      else
+        to_enum
+      end
+    end
+    alias each_pair each
+
+    # Returns true if the node contains an attribute with the passed-in name;
+    # false otherwise.
+    def attribute?(name)
+      attributes.fetch(name, false)
+    end
+    
+    # Returns true if the node contains any attributes (ignores nil values);
+    # false otherwise.
+    def has_attributes?
+      !attributes.empty?
+    end
+
+    def textnode?
+      false
+    end
+    alias has_text? textnode?
+
+    def <=>(other)
+      [nodename, attributes, children] <=> [other.nodename, other.attributes, other.children]
+    rescue
+      nil
+    end
+    
+    # Returns the node' XML tags (including attribute assignments) as an
+    # array of strings.
+    def tags
+      if has_children?
+        tags = []
+        tags << "<#{[nodename, *attribute_assignments].join(' ')}>"
+        
+        tags << children.map do |node|
+          node.respond_to?(:tags) ? node.tags : [node.to_s]
+        end
+        
+        tags << "</#{nodename}>"
+        tags
+      else
+        ["<#{[nodename, *attribute_assignments].join(' ')}/>"]
+      end
+    end
+    
+    def inspect
+      "#<#{[self.class.name, *attribute_assignments].join(' ')} children=[#{children.length}]>"
+    end
+    
+    alias to_s pretty_print
+
+    
+    private
+        
+    def attribute_assignments
+      each_pair.map { |name, value|
+        value.nil? ? nil: [name, value.to_s.inspect].join('=')
+      }.compact
+    end
+    
+  end
+  
+  
+  class TextNode < Node
+    
+    has_no_children
+
+    class << self
+      undef_method :attr_children
+    end
+    
+    attr_accessor :text
+    alias to_s text
+
+    # TextNodes quack like a string.
+    # def_delegators :to_s, *String.instance_methods(false).reject do |m|
+    #   m.to_s =~ /^\W|!$|(?:^(?:hash|eql?|to_s|length|size|inspect)$)/
+    # end
+    # 
+    # String.instance_methods(false).select { |m| m.to_s =~ /!$/ }.each do |m|
+    #   define_method(m) do
+    #     content.send(m) if content.respond_to?(m)
+    #   end
+    # end
+    
+    def initialize(argument = '')
+      case
+      when argument.is_a?(Hash)
+        super
+      when argument.respond_to?(:to_s)
+        super({})
+        @text = argument.to_s
+        yield self if block_given?
+      else
+        raise ArgumentError, "failed to create text node from #{argument.inspect}"
+      end
+    end
+    
+    def textnode?
+      true
+    end
+    
+    def tags
+      tags = []
+      tags << "<#{attribute_assignments.unshift(nodename).join(' ')}>"
+      tags << text
+      tags << "</#{nodename}>"
+      tags
+    end
+    
+    def inspect
+      "#<#{[self.class.name, text.inspect, *attribute_assignments].join(' ')}>"
+    end
+    
+  end
+  
+end