hx 0.7.4 → 0.8.2

data/VERSION

@@ -1 +1 @@
-0.7.4
+0.8.2

data/bin/hx

@@ -1,3 +1,4 @@
 #!/usr/bin/env ruby
-require 'hx/commandline'
-Hx::Commandline.main(*ARGV)
+require 'rubygems'
+require 'hx/cli'
+Hx::CLI.main(*ARGV)

data/lib/hx.rb

@@ -21,12 +21,12 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'rubygems'
 require 'thread'
 require 'set'
 require 'pathname'
 require 'tempfile'
 require 'yaml'
+require 'hx/path'
 
 module Hx
 
@@ -38,17 +38,18 @@ end
 class EditingNotSupportedError < RuntimeError
 end
 
+# minimal complete definition: each_entry_path + get_entry, or each_entry
 module Filter
   def edit_entry(path, prototype=nil)
     raise EditingNotSupportedError, "Editing not supported for #{path}"
   end
 
-  def each_entry_path
-    each_entry { |path, entry| yield path }
+  def each_entry_path(selector)
+    each_entry(selector) { |path, entry| yield path }
   end
 
-  def each_entry
-    each_entry_path do |path|
+  def each_entry(selector)
+    each_entry_path(selector) do |path|
       begin
         entry = get_entry(path)
       rescue NoSuchEntryError
@@ -59,8 +60,8 @@ module Filter
   end
 
   def get_entry(path)
-    each_entry do |entry_path, entry|
-      return entry if entry_path == path
+    each_entry(Path.literal(path)) do |entry_path, entry|
+      return entry
     end
     raise NoSuchEntryError, path
   end
@@ -69,7 +70,7 @@ end
 class NullInput
   include Filter
 
-  def each_entry
+  def each_entry(selector)
     self
   end
 end
@@ -79,13 +80,25 @@ NULL_INPUT = NullInput.new
 class PathSubset
   include Filter
 
+  def patterns_to_selector(patterns)
+    patterns.map { |p| Path::parse_pattern(p) }.inject { |a, b| a | b }
+  end
+  private :patterns_to_selector
+
   def initialize(input, options)
     @input = input
-    @path_filter = Predicate.new(options[:only], options[:except])
+    only = patterns_to_selector(Array(options[:only] || []))
+    except = patterns_to_selector(Array(options[:except] || []))
+    except = ~except if except
+    if only and except
+      @selector = only & except
+    else
+      @selector = only || except || Path::ALL
+    end
   end 
 
   def edit_entry(path, prototype=nil)
-    if @path_filter.accept? path
+    if @selector.accept? path
       @input.edit_entry(path, prototype) { |text| yield text }
     else
       raise EditingNotSupportedError, "Editing not supported for #{path}"
@@ -93,47 +106,20 @@ class PathSubset
     self
   end
 
-  def each_entry_path
-    @input.each_entry_path do |path|
-      yield path if @path_filter.accept? path
-    end
+  def each_entry_path(selector, &block)
+    @input.each_entry_path(@selector & selector, &block)
     self
   end
 
-  def get_entry(path)
-    raise NoSuchEntryError, path unless @path_filter.accept? path
-    @input.get_entry(path)
-  end
-end
-
-class PathSubset::Predicate
-  def initialize(accept, reject)
-    @accept_re = patterns_to_re(accept)
-    @reject_re = patterns_to_re(reject)
-  end
-
-  def accept?(path)
-    (not @accept_re or path =~ @accept_re) and
-    (not @reject_re or path !~ @reject_re)
-  end
-
-  def patterns_to_re(patterns)
-    return nil if patterns.nil? or patterns.empty?
-    patterns = Array(patterns)
-    Regexp.new("(?:#{patterns.map { |p| pattern_to_re(p) }.join("|")})")
+  def each_entry(selector, &block)
+    @input.each_entry(@selector & selector, &block)
+    self
   end
-  private :patterns_to_re
 
-  def pattern_to_re(pattern)
-    "^#{pattern.scan(/(\*\*?|[^*]+)/).map { |s,|
-      case s
-      when "**"; ".*"
-      when "*"; "[^/]*"
-      else Regexp.quote(s)
-      end
-    }}$"
+  def get_entry(path)
+    raise NoSuchEntryError, path unless @selector.accept? path
+    @input.get_entry(path)
   end
-  private :pattern_to_re
 end
 
 class Overlay
@@ -143,10 +129,10 @@ class Overlay
     @inputs = inputs
   end
 
-  def each_entry_path
+  def each_entry_path(selector)
     seen = Set[]
     @inputs.each do |input|
-      input.each_entry_path do |path|
+      input.each_entry_path(selector) do |path|
         yield path unless seen.include? path
         seen.add path
       end
@@ -197,8 +183,11 @@ class AddPath
     self
   end
 
-  def each_entry_path
-    @input.each_entry_path { |path| yield add_circumfix(path) }
+  def each_entry_path(selector)
+    @input.each_entry_path(Path::ALL) do |path|
+      path = add_circumfix(path)
+      yield path if selector.accept? path
+    end
     self
   end
 
@@ -218,10 +207,10 @@ class StripPath
     self
   end
 
-  def each_entry_path
-    @input.each_entry_path do |path|
+  def each_entry_path(selector)
+    @input.each_entry_path(Path::ALL) do |path|
       path = strip_circumfix(path)
-      yield path if path
+      yield path if path and selector.accept? path
     end
     self
   end
@@ -246,14 +235,14 @@ class Cache
     self
   end
 
-  def each_entry
+  def each_entry(selector)
     entries = nil
     @lock.synchronize do
       if @entries
         entries = @entries
       else
         entries = []
-        @input.each_entry do |path, entry|
+        @input.each_entry(Path::ALL) do |path, entry|
           @entries_by_path[path] = entry
           entries << [path, entry]
         end
@@ -261,7 +250,7 @@ class Cache
       end
     end
     entries.each do |path, entry|
-      yield path, entry.dup
+      yield path, entry.dup if selector.accept? path
     end
     self
   end
@@ -294,9 +283,9 @@ class Sort
     self
   end
 
-  def each_entry
+  def each_entry(selector)
     entries = []
-    @input.each_entry do |path, entry|
+    @input.each_entry(selector) do |path, entry|
       entries << [path, entry]
     end
     unless @key_fields.empty?
@@ -542,8 +531,8 @@ class Site
     self
   end
 
-  def each_entry_path
-    @combined_output.each_entry_path { |path| yield path }
+  def each_entry_path(selector)
+    @combined_output.each_entry_path(selector) { |path| yield path }
     self
   end
 

data/lib/hx/backend/couchdb.rb

@@ -21,7 +21,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'rubygems'
 require 'cgi'
 require 'net/http'
 require 'uri'
@@ -81,9 +80,12 @@ class CouchDB
     self
   end
 
-  def each_entry_path
+  def each_entry_path(selector)
     listing = JSON.parse(get_document('_all_docs'))
-    listing['rows'].each { |row| yield row['id'] }
+    listing['rows'].each do |row|
+      path = row['id']
+      yield path if selector.accept? path
+    end
     self
   end
 

data/lib/hx/backend/hobix.rb

@@ -21,7 +21,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'rubygems'
 require 'yaml'
 require 'hx'
 require 'hx/backend/rawfiles'
@@ -73,8 +72,8 @@ class Hobix
     self
   end
 
-  def each_entry_path
-    @source.each_entry_path { |path| yield path }
+  def each_entry_path(selector)
+    @source.each_entry_path(selector) { |path| yield path }
     self
   end
 

data/lib/hx/backend/rawfiles.rb

@@ -21,7 +21,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'rubygems'
 require 'pathname'
 require 'hx'
 
@@ -56,9 +55,11 @@ class RawFiles
     self
   end
 
-  def each_entry_path
+  def each_entry_path(selector)
     Pathname.glob(@entry_dir + '**/*') do |pathname|
-      yield pathname_to_path(pathname) if pathname.file?
+      next unless pathname.file?
+      path = pathname_to_path(pathname)
+      yield path if selector.accept? path
     end
     self
   end

data/lib/hx/{commandline.rb → cli.rb}

@@ -28,7 +28,7 @@ require 'pathname'
 require 'tempfile'
 
 module Hx
-module Commandline
+module CLI
 
 DEFAULT_CONFIG_FILENAME = "config.hx"
 
@@ -105,7 +105,7 @@ end
 
 def self.do_gen(site, update_only)
   output_dir = Hx.get_pathname(site.options, :output_dir)
-  site.each_entry do |path, entry|
+  site.each_entry(Path::ALL) do |path, entry|
     pathname = output_dir + path
     content = entry['content']
     if update_only

data/lib/hx/listing/limit.rb

@@ -21,7 +21,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'rubygems'
 require 'hx'
 
 module Hx
@@ -35,8 +34,8 @@ class Limit
     @limit = options[:limit]
   end
 
-  def each_entry
-    @input.each_entry do |path, entry|
+  def each_entry(selector)
+    @input.each_entry(selector) do |path, entry|
       if entry['items']
         trimmed_entry = entry.dup
         trimmed_entry['items'] = entry['items'][0...@limit]

data/lib/hx/listing/paginate.rb

@@ -21,7 +21,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'rubygems'
 require 'hx'
 
 module Hx
@@ -35,14 +34,14 @@ class Paginate
     @page_size = options[:page_size]
   end
 
-  def each_entry
-    @input.each_entry do |index_path, index_entry|
+  def each_entry(selector)
+    @input.each_entry(Path::ALL) do |index_path, index_entry|
       items = index_entry['items'] || []
       if items.empty?
         index_entry = index_entry.dup
         index_entry['pages'] = [index_entry]
         index_entry['page_index'] = 0
-        yield index_path, index_entry
+        yield index_path, index_entry if selector.accept? index_path
       else
         pages = []
         n_pages = (items.size + @page_size - 1) / @page_size
@@ -65,7 +64,8 @@ class Paginate
         end
         pages[-1]['entry'].delete('next_page')
         pages.each do |page|
-          yield page['path'], page['entry']
+          path = page['path']
+          yield path, page['entry'] if selector.accept? path
         end
       end
     end

data/lib/hx/listing/recursiveindex.rb

@@ -21,7 +21,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'rubygems'
 require 'hx'
 require 'hx/listing/limit'
 require 'hx/listing/paginate'
@@ -47,23 +46,31 @@ class RecursiveIndex
     @input = input
   end
 
-  def each_entry
+  def merge_updated(index, entry)
+    updated = [entry, index].map { |e| e['updated'] }.compact.max
+    index['updated'] = updated if updated
+  end
+  private :merge_updated
+
+  def each_entry(selector)
     indexes = Hash.new { |h,k| h[k] = {'items' => []} }
-    @input.each_entry do |path, entry|
+    @input.each_entry(Path::ALL) do |path, entry|
       components = path.split("/")
-      until components.empty?
-        components.pop
-        index_path = (components + ["index"]).join("/")
-        index = indexes[index_path]
-        index['items'] << {'path' => path, 'entry' => entry}
-        if entry['updated'] and
-           (not index['updated'] or entry['updated'] > index['updated'])
-          index['updated'] = entry['updated']
+      if components.last == "index"
+        index = indexes[path] = entry.merge(indexes[path])
+        merge_updated(index, entry)
+      else
+        until components.empty?
+          components.pop
+          index_path = (components + ["index"]).join("/")
+          index = indexes[index_path]
+          index['items'] << {'path' => path, 'entry' => entry}
+          merge_updated(index, entry)
         end
       end
     end
     indexes.each do |path, entry|
-      yield path, entry
+      yield path, entry if selector.accept? path
     end
     self
   end

data/lib/hx/output/liquidtemplate.rb

@@ -21,7 +21,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'rubygems'
 require 'time'
 require 'liquid'
 require 'redcloth'
@@ -72,7 +71,7 @@ class LiquidTemplate
     # same template directory for things to work right
     Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_dir)
     Liquid::Template.register_filter(TextFilters)
-    template_file = template_dir + options[:template]
+    template_file = template_dir + "#{options[:template]}.liquid"
     @template = Liquid::Template.parse(template_file.read)
     @extension = options[:extension]
     @mime_type = options[:mime_type]
@@ -80,13 +79,10 @@ class LiquidTemplate
     @strip_extension_re = /\.#{Regexp.quote(@extension)}$/ if @extension
   end
 
-  def each_entry_path
-    @input.each_entry_path do |path|
-      unless @extension.nil?
-        yield "#{path}.#{@extension}"
-      else
-        yield path
-      end
+  def each_entry_path(selector)
+    @input.each_entry_path(Path::ALL) do |path|
+      path = "#{path}.#{@extension}" unless @extension.nil?
+      yield path if selector.accept? path
     end
     self
   end

data/lib/hx/path.rb

@@ -0,0 +1,208 @@
+# hx/path - path selectors
+#
+# Copyright (c) 2009-2010 MenTaLguY <mental@rydia.net>
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+module Hx
+module Path
+
+module Selector
+  def prefix ; "" ; end
+  def suffix ; "" ; end
+  def regexp ; nil ; end
+  def remaining_suffix(prefix_consumed) ; suffix ; end
+
+  def accept?(path)
+    raise NotImplementedError, "#{self.class}#accept? not implemented"
+  end
+
+  def |(other)
+    Disjunction.new(self, other)
+  end
+
+  def &(other)
+    Conjunction.new(self, other)
+  end
+
+  def ~()
+    Negation.new(self)
+  end
+end
+
+class All
+  include Selector
+
+  REGEXP = Regexp.new("^.*$")
+
+  def regexp ; REGEXP ; end
+  def accept?(path) ; true ; end
+end
+
+ALL = All.new
+
+class Literal
+  include Selector
+
+  attr_reader :value
+  alias prefix value
+
+  def initialize(value)
+    @value = value
+    @regexp = nil
+  end
+
+  def remaining_suffix(prefix_consumed)
+    @value[prefix_consumed..-1]
+  end
+
+  def regexp
+    @regexp ||= Regexp.new("^#{Regexp.quote(@value)}$")
+  end
+
+  def accept?(path)
+    @value == path
+  end
+end
+
+def self.parse_pattern(pattern_string)
+  tokens = []
+  pattern_string.scan(/(\*\*?|[^*]+)/) do |token,|
+    tokens << case token
+              when "**"; :doublestar
+              when "*"; :star
+              else; token
+              end
+  end
+  prefix = tokens.first
+  if tokens.size == 1 and String === prefix
+    Literal.new(prefix)
+  else
+    prefix = "" unless String === prefix
+    suffix = tokens.last
+    suffix = "" unless String === suffix
+    regexp = Regexp.new("^#{tokens.map { |token|
+      case token
+      when :doublestar; '.*'
+      when :star; '[^/]*'
+      else; Regexp.quote(token)
+      end
+    }}$")
+    Pattern.new(regexp, prefix, suffix)
+  end
+end
+
+def self.literal(literal_string)
+  Literal.new(literal_string)
+end
+
+class Pattern
+  include Selector
+
+  attr_reader :prefix
+  attr_reader :suffix
+  attr_reader :regexp
+
+  def initialize(regexp, prefix, suffix)
+    @regexp = regexp
+    @prefix = prefix
+    @suffix = suffix
+  end
+
+  def accept?(path)
+    !!(@regexp.match(path))
+  end
+end
+
+module Connective
+  include Selector
+
+  attr_reader :prefix
+  attr_reader :suffix
+
+  def initialize(*selectors)
+    @selectors = selectors
+    prefixes = selectors.map { |s| s.prefix }
+    prefix_length = (prefixes.first || "").length
+    prefixes.each_cons(2) do |a, b|
+      prefix_length.downto(0) do |length|
+        prefix_length = length
+        break if a[0...length] == b[0...length]
+      end
+    end
+    @prefix = prefixes.first[0...prefix_length]
+    suffixes = selectors.map { |s| s.remaining_suffix(prefix_length) }
+    suffix_length = (suffixes.first || "").length
+    suffixes.each_cons(2) do |a, b|
+      suffix_length.downto(0) do |length|
+        suffix_length = length
+        break if a[-length..-1] == b[-length..-1]
+      end
+    end
+    @suffix = suffixes.first[-suffix_length..-1]
+  end
+end
+
+class Conjunction
+  include Connective
+
+  def accept?(path)
+    @selectors.all? { |s| s.accept? path }
+  end
+end
+
+class Disjunction
+  include Connective
+
+  attr_reader :regexp
+
+  def initialize(*selectors)
+    super
+    regexps = @selectors.map { |s| s.regexp }
+    if regexps.all?
+      @regexp = Regexp.union(*regexps)
+    else
+      @regexp = nil
+    end
+  end
+
+  def accept?(path)
+    if @regexp
+      !!@regexp.match(path)
+    else
+      @selectors.any? { |s| s.accept? path }
+    end
+  end
+end
+
+class Negation
+  include Selector
+
+  def initialize(selector)
+    @selector = selector
+  end
+
+  def accept?(path)
+    not @selector.accept?(path)
+  end
+end
+
+end
+end

data/lib/hx/rack/application.rb

@@ -21,7 +21,6 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'rubygems'
 require 'cgi'
 require 'hx'
 require 'rack/mime'

data/loc.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+# swunked from wmorgan
+(echo bin/hx ; find lib -name '*.rb' ) | xargs cat | grep -v "^ *$" | grep -v "^ *#"| grep -v "^ *end *$"| wc -l

data/spec/cache_spec.rb

@@ -12,20 +12,20 @@ describe Hx::Cache do
   end
 
   it "should return itself from each_entry" do
-    @cache.each_entry {}.should == @cache
+    @cache.each_entry(Hx::Path::ALL) {}.should == @cache
   end
 
   it "enumerates the same entries from the source" do
-    @cache.each_entry do |path, entry|
+    @cache.each_entry(Hx::Path::ALL) do |path, entry|
       entry.should == @source.get_entry(path)
     end
   end
 
   it "only reads the source once" do
-    @cache.each_entry {}
+    @cache.each_entry(Hx::Path::ALL) {}
     def @source.each_entry
       raise RuntimeError, "should not be called"
     end
-    @cache.each_entry {}
+    @cache.each_entry(Hx::Path::ALL) {}
   end
 end

data/spec/nullinput_spec.rb

@@ -8,11 +8,11 @@ describe Hx::NullInput do
   end
 
   it "should return itself from each_entry" do
-    @null_source.each_entry {}.should == @null_source
+    @null_source.each_entry(Hx::Path::ALL) {}.should == @null_source
   end
 
   it "enumerates no entry paths" do
-    @null_source.each_entry do |path, entry|
+    @null_source.each_entry(Hx::Path::ALL) do |path, entry|
       raise RuntimeError("No entries")
     end
   end

data/spec/overlay_spec.rb

@@ -14,25 +14,25 @@ describe Hx::Overlay do
   end
 
   it "should return itself from each_entry" do
-    @overlay.each_entry {}.should == @overlay
+    @overlay.each_entry(Hx::Path::ALL) {}.should == @overlay
   end
 
   it "should expose the union of paths" do
     actual_paths = []
-    @overlay.each_entry do |path, entry|
+    @overlay.each_entry(Hx::Path::ALL) do |path, entry|
       actual_paths << path
     end
     actual_paths.sort.should == %w(foo bar baz).sort
   end
 
   it "should give earlier sources precedence" do
-    @overlay.each_entry do |path, entry|
+    @overlay.each_entry(Hx::Path::ALL) do |path, entry|
       entry.should == @a.get_entry('bar') if path == 'bar'
     end
   end
 
   it "should expose entries from all sources" do
-    @overlay.each_entry do |path, entry|
+    @overlay.each_entry(Hx::Path::ALL) do |path, entry|
       entry.should == @a.get_entry('foo') if path == 'foo'
       entry.should == @b.get_entry('baz') if path == 'baz'
     end

data/spec/pathops_spec.rb

@@ -14,12 +14,12 @@ describe Hx::AddPath do
   end
 
   it "should return itself from each_entry" do
-    @add.each_entry {}.should == @add
+    @add.each_entry(Hx::Path::ALL) {}.should == @add
   end
 
   it "yields augmented paths from each_entry" do
     paths = Set[]
-    @add.each_entry do |path, entry|
+    @add.each_entry(Hx::Path::ALL) do |path, entry|
       paths.add path
     end
     paths.should == @after_paths
@@ -36,12 +36,12 @@ describe Hx::StripPath do
   end
 
   it "should return itself from each_entry" do
-    @strip.each_entry {}.should == @strip
+    @strip.each_entry(Hx::Path::ALL) {}.should == @strip
   end
 
   it "yields stripped paths from each_entry" do
     paths = Set[]
-    @strip.each_entry do |path, entry|
+    @strip.each_entry(Hx::Path::ALL) do |path, entry|
       paths.add path
     end
     paths.should == @after_paths
@@ -59,12 +59,12 @@ describe Hx::PathSubset do
   end
 
   it "returns itself from each_entry" do
-    @subset.each_entry {}.should == @subset
+    @subset.each_entry(Hx::Path::ALL) {}.should == @subset
   end
 
   it "enumerates paths according to the subset filter" do
     actual_paths = Set[]
-    @subset.each_entry do |path, entry|
+    @subset.each_entry(Hx::Path::ALL) do |path, entry|
       actual_paths.add path
     end
     actual_paths.should == Set['foo/bar', 'foo/baz']

data/spec/rack_spec.rb

@@ -3,11 +3,13 @@ require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 require 'hx'
 require 'hx/rack'
 require 'rack/mock'
+require 'rack/lint'
 
 describe Hx::Rack::Application do
   before(:each) do
     @input = FakeInput.new
     @app = Hx::Rack::Application.new(@input, {})
+    @app = Rack::Lint.new(@app)
     @service = Rack::MockRequest.new(@app)
   end
 

data/spec/selector_spec.rb

@@ -0,0 +1,150 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'hx/path'
+
+describe Hx::Path::Pattern do
+  it "should include Hx::Path::Selector" do
+    Hx::Path::Pattern.should < Hx::Path::Selector
+  end
+
+  it "should parse pattern strings" do
+    cases = [ { :pattern => "foo/**/bar",
+                :prefix => "foo/",
+                :suffix => "/bar" },
+              { :pattern => "foo/*/bar",
+                :prefix => "foo/",
+                :suffix => "/bar" },
+              { :pattern => "[blah",
+                :prefix => "[blah",
+                :suffix => "" },
+              { :pattern => "hoge*",
+                :prefix => "hoge",
+                :suffix => "" },
+              { :pattern => "*hoge",
+                :prefix => "",
+                :suffix => "hoge" } ]
+    for test_case in cases
+      pattern = Hx::Path.parse_pattern(test_case[:pattern])
+      pattern.prefix.should == test_case[:prefix]
+      pattern.suffix.should == test_case[:suffix]
+    end
+  end
+
+  it "should accept or reject paths" do
+    pattern = Hx::Path.parse_pattern("foo/bar")
+    pattern.should accept("foo/bar")
+    pattern.should_not accept("foo/baz")
+  end
+
+  it "should provide an equivalent regexp" do
+    pattern = Hx::Path.parse_pattern("foo/bar")
+    pattern.regexp.should_not be_nil
+    pattern.regexp.match("foo/bar").should_not be_nil
+    pattern.regexp.match("foo/bar/baz").should be_nil
+
+    pattern = Hx::Path.parse_pattern("foo/*/baz")
+    pattern.regexp.should_not be_nil
+    pattern.regexp.match("foo/baz").should be_nil
+    pattern.regexp.match("foo/bar/baz").should_not be_nil
+  end
+end
+
+PATHFILTER_PREFIX_CASES = [
+  { :patterns => ["foo/bar", "fudge/bear"],
+    :prefix => "f",
+    :suffix => "ar" },
+  { :patterns => ["foo/*/bar", "fudge/*/bear"],
+    :prefix => "f",
+    :suffix => "ar" },
+  { :patterns => ["foo/bar", "fudge/*/bear"],
+    :prefix => "f",
+    :suffix => "ar" },
+  { :patterns => ["bar*", "*bear"],
+    :prefix => "",
+    :suffix => "" },
+  { :patterns => ["foobarbaz", "foobar*barbaz"],
+    :prefix => "foobar",
+    :suffix => "baz" },
+  { :patterns => ["foobarbaz*", "foobar*barbaz"],
+    :prefix => "foobar",
+    :suffix => "" },
+  { :patterns => ["*foobarbaz", "foobar*barbaz"],
+    :prefix => "",
+    :suffix => "barbaz" }
+]
+
+describe "Hx::Path::Selector disjunctions" do
+  it "should be possible" do
+    filters = ["foo/bar", "abcdefg"].map { |p| Hx::Path.parse_pattern(p) }
+    filter = filters.inject { |a, b| a | b }
+    filter.should be_a_kind_of(Hx::Path::Selector)
+  end
+
+  it "should accept and reject the right paths" do
+    filters = ["foo/bar", "abcdefg"].map { |p| Hx::Path.parse_pattern(p) }
+    filter = filters.inject { |a, b| a | b }
+    filter.should accept("foo/bar")
+    filter.should accept("abcdefg")
+    filter.should_not accept("hoge")
+  end
+
+  for test_case_outer in PATHFILTER_PREFIX_CASES
+    Proc.new do |test_case|
+      it "should produce optimal prefixes and suffixes" do
+        filters = test_case[:patterns].map { |p| Hx::Path.parse_pattern(p) }
+        filter = filters.inject { |a, b| a | b }
+        filter.prefix.should == test_case[:prefix]
+        filter.suffix.should == test_case[:suffix]
+      end
+    end.call(test_case_outer)
+  end
+end
+
+describe "negated Hx::Path::Selectors" do
+  before :each do
+    @pattern = ~Hx::Path.parse_pattern("foo*bar")
+  end
+
+  it "should be possible" do
+    @pattern.should be_a_kind_of(Hx::Path::Selector)
+  end
+
+  it "should reject what they match" do
+    @pattern.should_not accept("foobar")
+    @pattern.should accept("hoge")
+  end
+
+  it "should have empty prefix and suffix" do
+    @pattern.prefix.should == ""
+    @pattern.suffix.should == ""
+  end
+end
+
+describe "Hx::Path::Selector conjunctions" do
+  it "should be possible" do
+    filters = ["foo*", "*bar"].map { |p| Hx::Path.parse_pattern(p) }
+    filter = filters.inject { |a, b| a & b }
+    filter.should be_a_kind_of(Hx::Path::Selector)
+  end
+
+  it "should accept only paths matching both filters" do
+    filters = ["foo*", "*bar"].map { |p| Hx::Path.parse_pattern(p) }
+    filter = filters.inject { |a, b| a & b }
+    filter.should accept("foobar")
+    filter.should accept("fooxbar")
+    filter.should_not accept("lemur")
+    filter.should_not accept("foobear")
+    filter.should_not accept("rebar")
+  end
+
+  for test_case_outer in PATHFILTER_PREFIX_CASES
+    Proc.new do |test_case|
+      it "should produce optimal prefixes and suffixes" do
+        filters = test_case[:patterns].map { |p| Hx::Path.parse_pattern(p) }
+        filter = filters.inject { |a, b| a & b }
+        filter.prefix.should == test_case[:prefix]
+        filter.suffix.should == test_case[:suffix]
+      end
+    end.call(test_case_outer)
+  end
+end

data/spec/site_spec.rb

@@ -60,6 +60,6 @@ describe Hx::Site do
   end
 
   it "returns itself from each_entry" do
-    @site.each_entry {}.should == @site
+    @site.each_entry(Hx::Path::ALL) {}.should == @site
   end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,10 @@ require 'hx'
 require 'ostruct'
 require 'spec'
 require 'spec/autorun'
+begin
+require 'rubygems'
+rescue LoadError
+end
 
 class FakeInput
   include Hx::Filter
@@ -18,8 +22,8 @@ class FakeInput
     @entries[path] = entry
   end
 
-  def each_entry_path
-    @entries.each_key { |path| yield path }
+  def each_entry_path(selector)
+    @entries.each_key { |path| yield path if selector.accept? path }
     self
   end
 
@@ -32,6 +36,12 @@ class FakeInput
   end
 end
 
+Spec::Matchers.define :accept do |value|
+  match do |acceptor|
+    acceptor.accept?(value)
+  end
+end
+
 Spec::Runner.configure do |config|
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hx
 version: !ruby/object:Gem::Version 
-  version: 0.7.4
+  version: 0.8.2
 platform: ruby
 authors: 
 - MenTaLguY
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-16 00:00:00 -05:00
+date: 2010-04-25 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -48,21 +48,23 @@ files:
 - lib/hx/backend/couchdb.rb
 - lib/hx/backend/hobix.rb
 - lib/hx/backend/rawfiles.rb
-- lib/hx/commandline.rb
+- lib/hx/cli.rb
 - lib/hx/listing/limit.rb
 - lib/hx/listing/paginate.rb
 - lib/hx/listing/recursiveindex.rb
 - lib/hx/output/liquidtemplate.rb
+- lib/hx/path.rb
 - lib/hx/rack.rb
 - lib/hx/rack/application.rb
+- loc.sh
 - spec/cache_spec.rb
 - spec/hx_dummy.rb
 - spec/hx_dummy2.rb
 - spec/nullinput_spec.rb
 - spec/overlay_spec.rb
-- spec/pathfilter_spec.rb
 - spec/pathops_spec.rb
 - spec/rack_spec.rb
+- spec/selector_spec.rb
 - spec/site_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
@@ -98,10 +100,10 @@ test_files:
 - spec/spec_helper.rb
 - spec/cache_spec.rb
 - spec/hx_dummy.rb
-- spec/pathfilter_spec.rb
 - spec/nullinput_spec.rb
 - spec/site_spec.rb
 - spec/hx_dummy2.rb
 - spec/rack_spec.rb
 - spec/overlay_spec.rb
 - spec/pathops_spec.rb
+- spec/selector_spec.rb

data/spec/pathfilter_spec.rb

@@ -1,45 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-require 'hx'
-
-describe Hx::PathSubset::Predicate do
-  it "accepts anything when the accept and reject patterns are nil" do
-    filter = Hx::PathSubset::Predicate.new(nil, nil)
-    filter.accept?("blah").should be_true
-  end
-
-  it "accepts only paths matching the accept pattern when it is specified" do
-    filter = Hx::PathSubset::Predicate.new("foo", nil)
-    filter.accept?("foo").should be_true
-    filter.accept?("bar").should be_false
-  end
-
-  it "accepts only paths not matching reject, when only that is specified" do
-    filter = Hx::PathSubset::Predicate.new(nil, "foo")
-    filter.accept?("foo").should be_false
-    filter.accept?("bar").should be_true
-  end
-
-  it "matches the difference of accept and reject when both are specified" do
-    filter = Hx::PathSubset::Predicate.new("foo/*", "foo/bar")
-    filter.accept?("foo/bar").should be_false
-    filter.accept?("foo/baz").should be_true
-    filter.accept?("bar").should be_false
-  end
-
-  it "shouldn't match across slashes with single star" do
-    filter = Hx::PathSubset::Predicate.new("foo/*", nil)
-    filter.accept?("bar").should be_false
-    filter.accept?("foo").should be_false
-    filter.accept?("foo/bar").should be_true
-    filter.accept?("foo/bar/baz").should be_false
-  end
-
-  it "should match across slashes with double star" do
-    filter = Hx::PathSubset::Predicate.new("foo/**", nil)
-    filter.accept?("bar").should be_false
-    filter.accept?("foo").should be_false
-    filter.accept?("foo/bar").should be_true
-    filter.accept?("foo/bar/baz").should be_true
-  end
-end