elementor 0.0.4 → 0.0.5

data/lib/core_ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def extract_options!
+    last.is_a?(Hash) ? pop : { }
+  end
+end unless [].respond_to?(:extract_options!)

data/lib/core_ext/kernel.rb

@@ -1,10 +1,16 @@
 module Kernel
-  def blank_context(ivars={}, &block)
+  def blank_context(*args, &block)
+    ivars = args.extract_options!
+    
+    args.push(/(^__)|instance_/)
+    
     klass = Class.new do
-      instance_methods.each { |m| undef_method(m) unless m =~ /^(__|instance_|meta)/ }
+      instance_methods.each do |m|
+        undef_method(m) unless args.any? { |pattern| m =~ pattern }
+      end
     end
     
-    klass.class_eval(&block)
+    klass.class_eval(&block) if block_given?
     instance = klass.new
     ivars.each { |key, value| instance.instance_variable_set("@#{key}", value) }
     instance

data/lib/core_ext/object.rb

@@ -1,8 +1,4 @@
 class Object
-  def try(sym, *args, &block)
-    respond_to?(sym) ? send(sym, *args, &block) : nil
-  end
-  
   def metaclass
     class << self; self end
   end

data/lib/elementor.rb

@@ -3,6 +3,7 @@ $LOAD_PATH << File.dirname(__FILE__) + '/elementor'
 
 require 'rubygems'
 require 'nokogiri'
+require 'array'
 require 'kernel'
 require 'object'
 require 'symbol'
@@ -11,8 +12,6 @@ require 'element_set'
 
 module Elementor
   def elements(opts={}, &block)
-    namer = Result.new(self, opts, &block)
-    namer.define_elements!
-    namer.dispatcher
+    Result.new(self, opts, &block).dispatcher
   end
 end

data/lib/elementor/element_set.rb

@@ -1,41 +1,54 @@
 module Elementor
+  # ElementSet objects wrap a Nokogiri #search result and
+  # add additional functionality such as chained filtering.
   class ElementSet < Array
     attr_accessor :result, :selector
     
+    # A simple filter for selecting only elements with content
+    # that either includes a String passed in, or matches a Regexp.
     def with_text(matcher)
-      replace(select { |item|
+      filter do |item|
         case matcher
         when Regexp then item.text =~ matcher
         when String then item.text.include?(matcher)
+        else item.text.include?(matcher.to_s)
         end
-      }) ; self
+      end
     end
     
+    alias_method :text, :with_text
+    
+    # Attribute filtering using hashes. See the specs for examples.
     def with_attrs(options={})
-      replace(select { |item|
-        options.all? { |key, value|
+      filter do |item|
+        options.all? do |key, value|
           case value
           when Regexp then item[key.to_s] =~ value
           when String then item[key.to_s] == value
+          else item[key.to_s] == value.to_s
           end
-        }
-      }) ; self
-    end
-    
-    def inspect
-      map(&:text).inspect
+        end
+      end
     end
     
+    alias_method :attrs, :with_attrs
+
     def method_missing(sym, *args, &block)
-      result.try(sym, doc, *args) || super
+      result.respond_to?(sym) ? result.send(sym, doc, *args) : super
     end
     
     def respond_to?(sym)
       result.respond_to?(sym) || super
     end
     
+    private
+    
     def doc
       result.doc.search(selector)
     end
+    
+    def filter(&block)
+      replace(select(&block)) ; return self
+    end
   end
 end

data/lib/elementor/result.rb

@@ -8,63 +8,97 @@ module Elementor
       @context = context
       @doc_ready = false
       block.call(naming_context)
+      define_elements!
     end
     
+    # Allows for the parsing of raw markup that doesn't come
+    # from the :from option.
     def parse!(markup)
       doc(markup)
     end
     
-    def naming_context
-      @naming_context ||= blank_context(:this => self) do
-        def method_missing(sym, *args)
-          @this.element_names[sym] = *args
+    # Returns a blank slate object that delegates to either an
+    # instance of Result or the original Nokogiri doc.
+    def dispatcher
+      @dispatcher ||= blank_context(:this => self) do
+        def method_missing(sym, *args, &block)
+          @this.doc_ready!
+          [@this, @this.doc].each do |context|
+            next unless context.respond_to?(sym)
+            return context.send(sym, *args, &block)
+          end
+          super # raise NoMethodError if no context can handle
         end
       end
     end
 
-    def dispatcher
-      @dispatcher ||= blank_context(:this => self) do
-        def method_missing(sym, *args, &block)
-          @this.doc_ready = true
-          @this.try(sym, *args, &block) || @this.doc.try(sym, *args, &block) || super
+    # The list of name/selector pairs you specify in the
+    # elements block.
+    def element_names
+      @element_names ||= { }
+    end
+
+    # Returns the raw Nokogiri doc once a method has been called
+    # on the dispatcher. Up until that point, returns nil.
+    def doc(markup=nil)
+      if html = markup || content
+        @doc = nil if markup
+        @doc ||= Nokogiri(html)
+      end
+    end
+    
+    # Indicates whether or not the dispatcher has received messages,
+    # meaning the content method can be called.
+    def doc_ready?
+      @doc_ready
+    end
+    
+    def doc_ready!
+      @doc_ready = true
+    end
+
+    private
+    
+    # Blank slate context for defining element names.
+    def naming_context
+      @naming_context ||= blank_context(:this => self) do
+        def method_missing(sym, *args)
+          @this.element_names[sym] = *args
         end
       end
     end
-  
+    
+    # Takes element names and defines methods that return ElementSet
+    # objects with can be chained and filtered.
     def define_elements!
       element_names.each do |name, selector|
-        meta_def(name) do |*filters|
-          set = ElementSet.new scope(filters).search(selector)
-          set.result = self
-          set.selector = selector
-          filters.empty? ? set : filters.inject(set) { |result, fn| fn[result] }
-        end
+        metaclass.class_eval(<<-END, __FILE__, __LINE__)
+          def #{name}(*filters, &block)
+            make_element_set(#{name.inspect}, #{selector.inspect}, *filters, &block)
+          end
+        END
       end
     end
     
+    def make_element_set(name, selector, *filters, &block)
+      set = ElementSet.new scope(filters).search(selector)
+      set.result = self
+      set.selector = selector
+      set = filters.empty? ? set : filters.inject(set) { |result, fn| fn[result] }
+      set = block.call(set) if block_given?
+      set
+    end
+    
+    # Enables the chaining of element selector methods to only search
+    # within the scope of a certain ElementSet.
     def scope(filters)
       scope = filters.first.is_a?(Proc) ? nil : filters.shift
       scope || doc
     end
     
-    def element_names
-      @element_names ||= { }
-    end
-    
-    def doc(markup=nil)
-      if html = markup || content
-        @doc = nil if markup
-        @doc ||= Nokogiri(html)
-      end
-    end
-    
     def content
       return unless doc_ready?
       @content ||= context.send(opts[:from] || :body)
     end
-    
-    def doc_ready?
-      @doc_ready
-    end
   end
 end

data/lib/elementor/spec.rb

@@ -7,11 +7,15 @@ module Spec
         self
       end
       
+      alias_method :text, :with_text
+      
       def with_attrs(options={})
         @args ||= []
         @args << proc { |set| set.with_attrs(options) }
         self
       end
+      
+      alias_method :attrs, :with_attrs
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: elementor
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors: 
 - Pat Nakajima
@@ -37,6 +37,7 @@ files:
 - lib/elementor/element_set.rb
 - lib/elementor/result.rb
 - lib/core_ext
+- lib/core_ext/array.rb
 - lib/core_ext/object.rb
 - lib/core_ext/kernel.rb
 - lib/core_ext/symbol.rb
@@ -62,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Prettier element traversal with Nokogiri