hx 0.8.2 → 0.8.3

data/VERSION

@@ -1 +1 @@
-0.8.2
+0.8.3

data/lib/hx/cli.rb

@@ -42,6 +42,7 @@ Usage: hx [--config CONFIG_FILE] [upgen]
        hx [--config CONFIG_FILE] regen
        hx [--config CONFIG_FILE] post[up] SOURCE:PATH
        hx [--config CONFIG_FILE] edit[up] SOURCE:PATH
+       hx [--config CONFIG_FILE] list SOURCE:PATTERN
 
 EOS
 
@@ -128,31 +129,47 @@ def self.cmd_postup(site, entry_spec)
   cmd_upgen(site)
 end
 
-def self.parse_entry_spec(entry_spec)
+def self._parse_entry_spec(site, entry_spec)
   source_name, path = entry_spec.split(':', 2)
+  source = site.sources[source_name]
+  raise ArgumentError, "No such source #{source_name}" unless source
+  return source, path
+end
+
+def self.parse_entry_spec(site, entry_spec)
+  source, path = _parse_entry_spec(site, entry_spec)
   raise "Invalid entry specification #{entry_spec}" unless path
-  return source_name, path
+  return source, path
+end
+
+def self.parse_entry_pattern(site, entry_pattern)
+  source, pattern = _parse_entry_spec(site, entry_pattern)
+  pattern = "**" unless pattern
+  selector = Hx::Path.parse_pattern(pattern)
+  return source, selector
 end
 
 def self.cmd_edit(site, entry_spec)
-  source_name, path = parse_entry_spec(entry_spec)
-  do_edit(site, source_name, path, nil)
+  source, path = parse_entry_spec(site, entry_spec)
+  do_edit(site, source, path, nil)
 end
 
 def self.cmd_post(site, entry_spec)
-  source_name, path = parse_entry_spec(entry_spec)
+  source, path = parse_entry_spec(site, entry_spec)
   prototype = {
     'title' => Hx.make_default_title(site.options, path),
     'author' => Hx.get_default_author(site.options),
     'content' => ""
   }
-  do_edit(site, source_name, path, prototype)
+  do_edit(site, source, path, prototype)
 end
 
-def self.do_edit(site, source_name, path, prototype)
-  source = site.sources[source_name]
-  raise ArgumentError, "No such source #{source_name}" unless source
+def self.cmd_list(site, entry_spec)
+  source, selector = parse_entry_pattern(site, entry_spec)
+  source.each_entry_path(selector) { |path| puts path }
+end
 
+def self.do_edit(site, source, path, prototype)
   catch(:unchanged) do
     begin
       tempfile = Tempfile.new('hx-entry')

data/lib/hx/output/liquidtemplate.rb

@@ -74,7 +74,7 @@ class LiquidTemplate
     template_file = template_dir + "#{options[:template]}.liquid"
     @template = Liquid::Template.parse(template_file.read)
     @extension = options[:extension]
-    @mime_type = options[:mime_type]
+    @content_type = options[:content_type]
     @strip_extension_re = nil
     @strip_extension_re = /\.#{Regexp.quote(@extension)}$/ if @extension
   end
@@ -99,7 +99,7 @@ class LiquidTemplate
         'entry' => entry
       )
     end
-    output_entry['mime_type'] = @mime_type if @mime_type
+    output_entry['content_type'] = @content_type if @content_type
     if entry.has_key? 'updated'
       output_entry['created'] = output_entry['updated'] = entry['updated']
     end

data/lib/hx/path.rb

@@ -25,11 +25,6 @@ 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
@@ -49,37 +44,25 @@ end
 
 class All
   include Selector
-
-  REGEXP = Regexp.new("^.*$")
-
-  def regexp ; REGEXP ; end
   def accept?(path) ; true ; end
 end
 
 ALL = All.new
 
-class Literal
+class Pattern
   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)}$")
+  def initialize(tokens)
+    @regexp = Regexp.new("^#{tokens.map { |token|
+      case token
+      when :doublestar; '.*'
+      when :star; '[^/]*'
+      else; Regexp.quote(token)
+      end
+    }}$")
   end
 
-  def accept?(path)
-    @value == path
-  end
+  def accept?(path) ; !!(path =~ @regexp) ; end
 end
 
 def self.parse_pattern(pattern_string)
@@ -91,78 +74,35 @@ def self.parse_pattern(pattern_string)
               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
+  Pattern.new(tokens)
 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
+  Pattern.new([literal_string])
 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 self.new(*selectors)
+    if selectors.any? { |s| All === s }
+      selectors.reject! { |s| All === s }
+      case selectors.size
+      when 0; return ALL
+      when 1; return selectors.first
+      end
+    end
+    super(*selectors)
+  end
+
   def accept?(path)
     @selectors.all? { |s| s.accept? path }
   end
@@ -171,24 +111,8 @@ 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
+    @selectors.any? { |s| s.accept? path }
   end
 end
 

data/lib/hx/rack/application.rb

@@ -78,13 +78,13 @@ class Application
     end
 
     if entry
-      mime_type = entry['mime_type'] 
-      unless mime_type
+      content_type = entry['content_type'] 
+      unless content_type
         effective_path =~ /(\.[^.]+)$/
-        mime_type = ::Rack::Mime.mime_type($1 || '')
+        content_type = ::Rack::Mime.mime_type($1 || '')
       end
       content = entry['content'].to_s
-      [200, {'Content-Type' => mime_type}, [content]]
+      [200, {'Content-Type' => content_type}, [content]]
     else
       message = "#{env['SCRIPT_NAME']}#{path} not found"
       [404, {'Content-Type' => "text/plain"}, [message]]

data/spec/rack_spec.rb

@@ -30,22 +30,22 @@ describe Hx::Rack::Application do
   it "should infer content type from file extension by default" do
     cases = { "html" => "text/html",
               "jpeg" => "image/jpeg" }
-    for extension, mime_type in cases
+    for extension, content_type in cases
       path = "blah.#{extension}"
       @input.add_entry(path, "")
       response = @service.get("/#{path}", :lint => true, :fatal => true)
       response.status.to_i.should == 200
-      response['Content-Type'].should == mime_type
+      response['Content-Type'].should == content_type
     end
   end
 
   it "should allow entries to specify their mime type" do
     path = "blah.html"
-    mime_type = "junk/garbage"
-    @input.add_entry(path, "", 'mime_type' => mime_type)
+    content_type = "junk/garbage"
+    @input.add_entry(path, "", 'content_type' => content_type)
     response = @service.get("/#{path}", :lint => true, :fatal => true)
     response.status.to_i.should == 200
-    response['Content-Type'].should == mime_type
+    response['Content-Type'].should == content_type
   end
 
   it "should redirect for directories with indices" do

data/spec/selector_spec.rb

@@ -7,72 +7,27 @@ describe Hx::Path::Pattern 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")
+  it "should accept or reject literal paths" do
+    pattern = Hx::Path.literal("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
+  it "should match single path components with stars" do
+    pattern = Hx::Path.parse_pattern("foo/*")
+    pattern.should_not accept("baz/eek")
+    pattern.should accept("foo/bar")
+    pattern.should_not accept("foo/bar/baz")
+  end
 
-    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
+  it "should match multiple path components with double stars" do
+    pattern = Hx::Path.parse_pattern("foo/**")
+    pattern.should_not accept("baz/eek")
+    pattern.should accept("foo/bar")
+    pattern.should accept("foo/bar/baz")
   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) }
@@ -87,17 +42,6 @@ describe "Hx::Path::Selector disjunctions" do
     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
@@ -113,11 +57,6 @@ describe "negated Hx::Path::Selectors" 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
@@ -137,14 +76,10 @@ describe "Hx::Path::Selector conjunctions" do
     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)
+  it "should optimize use of ALL" do
+    filter = Hx::Path.parse_pattern("foo")
+    (filter & Hx::Path::ALL).should equal(filter)
+    (Hx::Path::ALL & filter).should equal(filter)
+    (Hx::Path::ALL & Hx::Path::ALL).should equal(Hx::Path::ALL)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hx
 version: !ruby/object:Gem::Version 
-  version: 0.8.2
+  version: 0.8.3
 platform: ruby
 authors: 
 - MenTaLguY
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-25 00:00:00 -04:00
+date: 2010-05-29 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency