smallcage 0.2.6 → 0.2.7

data/lib/smallcage/update_list.rb

@@ -1,15 +1,17 @@
 module SmallCage
-
+  #
   # Updated files list model.
-  # Do not access File system except list.yml.
+  #
+  # UpdateList doesn't access file system except list.yml.
+  #
   class UpdateList
-    attr_reader :update_count
+    attr_reader :update_count, :load_error
 
     def self.create(root_path, target_path)
       docpath = DocumentPath.new(root_path, target_path)
       uri = docpath.uri
-      uri += "/" if docpath.path.directory? && uri[-1] != ?/
-      return self.new(root_path + "_smc/tmp/list.yml", uri)
+      uri += '/' if docpath.path.directory? && uri[-1, 1] != '/'
+      new(root_path + '_smc/tmp/list.yml', uri)
     end
 
     # target_uri must be ended with / when the target is a directory.
@@ -23,21 +25,27 @@ module SmallCage
     end
 
     def load
+      @load_error = nil
       if @list_file.exist?
-        @data = YAML.load_file(@list_file)
+        begin
+          @yaml = YAML.load_file(@list_file)
+        rescue StandardError => e
+          @load_error = e
+          @yaml = {}
+        end
       else
-        @data = {}
+        @yaml = {}
       end
-      @data["version"] ||= VERSION
-      @data["list"] ||= []
+      @yaml['version'] ||= VERSION
+      @yaml['list'] ||= []
 
-      @map = {}
-      @data["list"].each do |item|
-        src = item["src"]
-        @map[src] = item
+      @src_item_map = {}
+      @yaml['list'].each do |item|
+        src = item['src']
+        @src_item_map[src] = item
         if target?(src)
           @expired_src[src] = true
-          item["dst"].each do |d|
+          item['dst'].each do |d|
             @expired_dst[d] = [true, src]
           end
         end
@@ -46,26 +54,31 @@ module SmallCage
     private :load
 
     def target?(uri)
-      return uri[0...@target_uri.length] == @target_uri
+      uri[0...@target_uri.length] == @target_uri
     end
     private :target?
 
     def save
       FileUtils.mkpath(@list_file.parent)
-      @data["version"] = VERSION
-      open(@list_file, "w") do |io|
+      @yaml['version'] = VERSION
+      open(@list_file, 'w') do |io|
         io << to_yaml
       end
     end
 
     def to_yaml
-      return @data.to_yaml
+      @yaml.to_yaml
+    end
+
+    # return src_uri => mtime hash.
+    def mtimes
+      Hash[@src_item_map.map { |k,v| [k, v['mtime'].to_i] }]
     end
 
     def mtime(srcuri)
-      item = @map[srcuri]
+      item = @src_item_map[srcuri]
       return -1 unless item
-      return item["mtime"].to_i
+      item['mtime'].to_i
     end
 
     def update(srcuri, mtime, dsturi)
@@ -75,25 +88,23 @@ module SmallCage
     end
 
     def update_list(srcuri, mtime, dsturi)
-      unless update_list_item(srcuri, mtime, dsturi)
-        add_list_item(srcuri, mtime, dsturi)
-      end
+      add_list_item(srcuri, mtime, dsturi) unless update_list_item(srcuri, mtime, dsturi)
     end
     private :update_list
 
     def update_list_item(srcuri, mtime, dsturi)
-      return false unless @map[srcuri]
-      item = @map[srcuri]
-      item["mtime"] = mtime.to_i
-      item["dst"] << dsturi unless item["dst"].include?(dsturi)
-      return true
+      return false unless @src_item_map[srcuri]
+      item = @src_item_map[srcuri]
+      item['mtime'] = mtime.to_i
+      item['dst'] << dsturi unless item['dst'].include?(dsturi)
+      true
     end
     private :update_list_item
 
     def add_list_item(srcuri, mtime, dsturi)
-      item = {"src" => srcuri, "dst" => [dsturi], "mtime" => mtime.to_i}
-      @map[srcuri] = item
-      @data["list"] << item
+      item = { 'src' => srcuri, 'dst' => [dsturi], 'mtime' => mtime.to_i }
+      @src_item_map[srcuri] = item
+      @yaml['list'] << item
     end
     private :add_list_item
 
@@ -105,21 +116,20 @@ module SmallCage
 
     def expire
       expire_src
-      result = expire_dst
-      return result
+      expire_dst
     end
 
     def expire_src
-      @expired_src.each do |srcuri,v|
+      @expired_src.each do |srcuri, v|
         mark_expired_src(srcuri)
       end
-      @data["list"] = @data["list"].select {|item| ! item["expired"] }
+      @yaml['list'] = @yaml['list'].select { |item| !item['expired'] }
     end
     private :expire_src
 
     def mark_expired_src(srcuri)
-      @map[srcuri]["expired"] = true
-      @map[srcuri]["dst"].each do |dsturi|
+      @src_item_map[srcuri]['expired'] = true
+      @src_item_map[srcuri]['dst'].each do |dsturi|
         next if @expired_dst[dsturi] && ! @expired_dst[dsturi][0]
         @expired_dst[dsturi] = [true, srcuri]
       end
@@ -131,11 +141,11 @@ module SmallCage
       @expired_dst.each do |dsturi, stat|
         next unless stat[0]
         srcuri = stat[1]
-        item = @map[srcuri]
-        item["dst"].delete(dsturi)
+        item = @src_item_map[srcuri]
+        item['dst'].delete(dsturi)
         result << dsturi
       end
-      return result
+      result
     end
     private :expire_dst
   end

data/lib/smallcage/version.rb

@@ -1,3 +1,3 @@
 module SmallCage #:nodoc:
-  VERSION = '0.2.6'
+  VERSION = '0.2.7'
 end

data/lib/smallcage.rb

@@ -28,6 +28,7 @@ require 'smallcage/runner'
 require 'smallcage/document_path'
 require 'smallcage/http_server'
 require 'smallcage/application'
+require 'smallcage/options_parser'
 require 'smallcage/update_list'
 
 SmallCage::Application.execute if __FILE__ == $0

data/spec/lib/smallcage/application_spec.rb

@@ -27,87 +27,101 @@ describe SmallCage::Application do
     }
   end
 
-  before(:each) do
-    @target = SmallCage::Application.new
-  end
+  subject { SmallCage::Application.new }
 
   it 'should parse update command' do
-    options = @target.parse_options(['update', '.'])
-    options.should eq(:path => '.', :command => :update, :quiet => false)
+    options = subject.parse_options(['update', '.'])
+    options.should eq(:path => '.', :command => :update, :quiet => false, :fast => false)
+  end
 
-    options = @target.parse_options(['up', '.'])
-    options.should eq(:path => '.', :command => :update, :quiet => false)
+  it 'should parse up command' do
+    options = subject.parse_options(['up', '.'])
+    options.should eq(:path => '.', :command => :update, :quiet => false, :fast => false)
   end
 
   it 'should parse clean command' do
-    options = @target.parse_options(['clean', '.'])
+    options = subject.parse_options(['clean', '.'])
     options.should eq(:path => '.', :command => :clean, :quiet => false)
   end
 
   it 'should parse server command' do
-    options = @target.parse_options(['server', '.'])
+    options = subject.parse_options(['server', '.'])
     options.should eq(:path => '.', :command => :server, :quiet => false, :port => 8080) # num
 
-    options = @target.parse_options(['sv', '.', '8080'])
+    options = subject.parse_options(['sv', '.', '8080'])
     options.should eq(:path => '.', :command => :server, :quiet => false, :port => 8080) # string
   end
 
   it 'should accept only number port' do
-    result = capture_result { @target.parse_options(['server', '.', 'pot']) }
+    result = capture_result { subject.parse_options(['server', '.', 'pot']) }
     result[:exit].should eq 1
     result[:stdout].should be_empty
     result[:stderr].should eq "illegal port number: pot\n"
   end
 
   it 'should not accept port 0' do
-    result = capture_result { @target.parse_options(['server', '.', '0']) }
+    result = capture_result { subject.parse_options(['server', '.', '0']) }
     result[:exit].should eq 1
     result[:stdout].should be_empty
     result[:stderr].should eq "illegal port number: 0\n"
   end
 
   it 'should parse auto command' do
-    options = @target.parse_options(['auto', '.'])
-    options.should eq(:path => '.', :command => :auto, :port => nil, :bell => false, :quiet => false)
-
-    options = @target.parse_options(['au', '.', '8080'])
-    options.should eq(:path => '.', :command => :auto, :port => 8080, :bell => false, :quiet => false)
+    options = subject.parse_options(['auto', '.'])
+    options.should eq(
+                      :path => '.',
+                      :command => :auto,
+                      :port => nil,
+                      :bell => false,
+                      :fast => false,
+                      :quiet => false
+                      )
+
+    options = subject.parse_options(['au', '.', '8080'])
+    options.should eq(
+                      :path => '.',
+                      :command => :auto,
+                      :port => 8080,
+                      :bell => false,
+                      :fast => false,
+                      :quiet => false
+                      )
   end
 
   it 'should parse import command' do
-    options = @target.parse_options(['import', 'base', '.'])
+    options = subject.parse_options(['import', 'base', '.'])
     options.should eq(:command => :import, :from => 'base', :to => '.', :quiet => false)
 
-    options = @target.parse_options(['import'])
+    options = subject.parse_options(['import'])
     options.should eq(:command => :import, :from => 'default', :to => '.', :quiet => false)
   end
 
   it 'should parse export command' do
-    options = @target.parse_options(['export', '.', 'path'])
+    options = subject.parse_options(['export', '.', 'path'])
     options.should eq(:command => :export, :path => '.',  :out => 'path', :quiet => false)
 
-    options = @target.parse_options(['export'])
+    options = subject.parse_options(['export'])
     options.should eq(:command => :export, :path => '.',  :out => nil, :quiet => false)
   end
 
   it 'should parse uri command' do
-    options = @target.parse_options(['uri', './path/to/target'])
+    options = subject.parse_options(['uri', './path/to/target'])
     options.should eq(:command => :uri, :path => './path/to/target', :quiet => false)
 
-    options = @target.parse_options(['uri'])
+    options = subject.parse_options(['uri'])
     options.should eq(:command => :uri, :path => '.', :quiet => false)
   end
 
   it 'should parse manifest command' do
-    options = @target.parse_options(['manifest', './path/to/target'])
+    options = subject.parse_options(['manifest', './path/to/target'])
     options.should eq(:command => :manifest, :path => './path/to/target', :quiet => false)
 
-    options = @target.parse_options(['manifest'])
+    options = subject.parse_options(['manifest'])
     options.should eq( :command => :manifest, :path => '.', :quiet => false )
   end
 
   it 'should exit 1 if command is empty' do
-    result = capture_result { @target.parse_options([]) }
+    result = capture_result { subject.parse_options([]) }
     result[:exit].should eq 1
     result[:stdout].should =~ /\AUsage:/
     result[:stdout].should =~ /^Subcommands are:/
@@ -115,7 +129,7 @@ describe SmallCage::Application do
   end
 
   it 'should show help' do
-    result = capture_result { @target.parse_options(['help']) }
+    result = capture_result { subject.parse_options(['help']) }
     result[:exit].should eq 0
     result[:stdout].should =~ /\AUsage:/
     result[:stdout].should =~ /^Subcommands are:/
@@ -123,7 +137,7 @@ describe SmallCage::Application do
   end
 
   it 'should show help if the arguments include --help' do
-    result = capture_result { @target.parse_options(['--help', 'update']) }
+    result = capture_result { subject.parse_options(['--help', 'update']) }
     result[:exit].should eq 0
     result[:stdout].should =~ /\AUsage:/
     result[:stdout].should =~ /^Subcommands are:/
@@ -131,28 +145,28 @@ describe SmallCage::Application do
   end
 
   it 'should show subcommand help' do
-    result = capture_result { @target.parse_options(['help', 'update']) }
+    result = capture_result { subject.parse_options(['help', 'update']) }
     result[:exit].should eq 0
     result[:stdout].should =~ /\AUsage: smc update \[path\]/
     result[:stderr].should be_empty
   end
 
   it 'should exit if the command is unknown' do
-    result = capture_result { @target.parse_options(['xxxx']) }
+    result = capture_result { subject.parse_options(['xxxx']) }
     result[:exit].should eq 1
     result[:stdout].should be_empty
     result[:stderr].should eq "no such subcommand: xxxx\n"
   end
 
   it 'should show version' do
-    result = capture_result { @target.parse_options(['--version', 'update']) }
+    result = capture_result { subject.parse_options(['--version', 'update']) }
     result[:exit].should eq 0
     result[:stdout].should =~ /\ASmallCage \d+\.\d+\.\d+ - /
     result[:stderr].should be_empty
   end
 
   it 'should exit when subcommand is empty' do
-    result = capture_result { @target.parse_options(['', '--version']) }
+    result = capture_result { subject.parse_options(['', '--version']) }
     result[:exit].should eq 1
     result[:stdout].should =~ /\AUsage:/
     result[:stdout].should =~ /^Subcommands are:/
@@ -160,49 +174,49 @@ describe SmallCage::Application do
   end
 
   it 'should ignore subcommand with --version option' do
-    result = capture_result { @target.parse_options(['help', '--version']) }
+    result = capture_result { subject.parse_options(['help', '--version']) }
     result[:exit].should eq 0
     result[:stdout].should =~ /\ASmallCage \d+\.\d+\.\d+ - /
     result[:stderr].should be_empty
   end
 
   it 'should ignore subcommand with -v option' do
-    result = capture_result { @target.parse_options(['help', '-v']) }
+    result = capture_result { subject.parse_options(['help', '-v']) }
     result[:exit].should eq 0
     result[:stdout].should =~ /\ASmallCage \d+\.\d+\.\d+ - /
     result[:stderr].should be_empty
   end
 
   it 'should ignore subcommand with --help option' do
-    result = capture_result { @target.parse_options(['update', '--help']) }
+    result = capture_result { subject.parse_options(['update', '--help']) }
     result[:exit].should eq 0
     result[:stdout].should =~ /\AUsage: smc update \[path\] \[options\]/
     result[:stderr].should be_empty
   end
 
   it 'should ignore subcommand with -h option' do
-    result = capture_result { @target.parse_options(['update', '-h']) }
+    result = capture_result { subject.parse_options(['update', '-h']) }
     result[:exit].should eq 0
     result[:stdout].should =~ /\AUsage: smc update \[path\] \[options\]/
     result[:stderr].should be_empty
   end
 
   it 'should exit with unknown main option --QQQ' do
-    result = capture_result { @target.parse_options(['--QQQ']) }
+    result = capture_result { subject.parse_options(['--QQQ']) }
     result[:exit].should eq 1
     result[:stdout].should be_empty
     result[:stderr].should eq "invalid option: --QQQ\n"
   end
 
   it 'should exit with unknown sub option --QQQ' do
-    result = capture_result { @target.parse_options(['update', '--QQQ']) }
+    result = capture_result { subject.parse_options(['update', '--QQQ']) }
     result[:exit].should eq 1
     result[:stdout].should be_empty
     result[:stderr].should eq "invalid option: --QQQ\n"
   end
 
   it 'should accept auto command --bell option' do
-    result = capture_result { @target.parse_options(['auto', '--bell']) }
+    result = capture_result { subject.parse_options(['auto', '--bell']) }
     result[:exit].should be_nil
     result[:stdout].should be_empty
     result[:stderr].should be_empty
@@ -211,12 +225,13 @@ describe SmallCage::Application do
       :port => nil,
       :path => '.',
       :bell => true,
+      :fast => false,
       :quiet => false
     )
   end
 
   it 'should set bell option false as default' do
-    result = capture_result { @target.parse_options(['auto']) }
+    result = capture_result { subject.parse_options(['auto']) }
     result[:exit].should be_nil
     result[:stdout].should be_empty
     result[:stderr].should be_empty
@@ -225,37 +240,40 @@ describe SmallCage::Application do
       :port => nil,
       :path => '.',
       :bell => false,
+      :fast => false,
       :quiet => false
     )
   end
 
   it 'should accept --quiet option' do
-    result = capture_result { @target.parse_options(['--quiet', 'update']) }
+    result = capture_result { subject.parse_options(['--quiet', 'update']) }
     result[:exit].should be_nil
     result[:stdout].should be_empty
     result[:stderr].should be_empty
     result[:result].should eq(
       :command => :update,
       :path => '.',
+      :fast => false,
       :quiet => true
     )
   end
 
   it 'should accept --quiet option after subcommand' do
-    result = capture_result { @target.parse_options(['update', '--quiet']) }
+    result = capture_result { subject.parse_options(['update', '--quiet']) }
     result[:exit].should be_nil
     result[:stdout].should be_empty
     result[:stderr].should be_empty
     result[:result].should eq(
       :command => :update,
       :path => '.',
+      :fast => false,
       :quiet => true
     )
   end
 
   it 'should accept --quiet option before and after subcommand' do
     opts = %w{--quiet auto --quiet path --bell 80}
-    result = capture_result { @target.parse_options(opts) }
+    result = capture_result { subject.parse_options(opts) }
     result[:exit].should be_nil
     result[:stdout].should be_empty
     result[:stderr].should be_empty
@@ -264,6 +282,7 @@ describe SmallCage::Application do
       :path => 'path',
       :port => 80,
       :bell => true,
+      :fast => false,
       :quiet => true
     )
   end

data/spec/lib/smallcage/commands/export_spec.rb

@@ -13,10 +13,10 @@ describe "SmallCage::Commands::Export" do
                :quiet => true }
       SmallCage::Runner.run(opts)
 
-      (outdir + "./a/test.html.smc").exist?.should_not be_true
-      (outdir + "./a/test.html").exist?.should_not be_true
-      (outdir + "./a/b/test.html").exist?.should be_true
-      (outdir + "./a/b/c/test.html").exist?.should be_true
+      (outdir + "./a/test.html.smc").exist?.should be false
+      (outdir + "./a/test.html").exist?.should be false
+      (outdir + "./a/b/test.html").exist?.should be true
+      (outdir + "./a/b/c/test.html").exist?.should be true
     ensure
       FileUtils.rm_r(outdir)
     end
@@ -31,11 +31,11 @@ describe "SmallCage::Commands::Export" do
                :quiet => true }
       SmallCage::Runner.run(opts)
 
-      (outdir + "./a/test.html.smc").exist?.should_not be_true
-      (outdir + "./a/test.html").exist?.should_not be_true
-      (outdir + "./a/b/test.html").exist?.should_not be_true
+      (outdir + "./a/test.html.smc").exist?.should be false
+      (outdir + "./a/test.html").exist?.should be false
+      (outdir + "./a/b/test.html").exist?.should be false
 
-      (outdir + "./a/b/c/test.html").exist?.should be_true
+      (outdir + "./a/b/c/test.html").exist?.should be true
     ensure
       FileUtils.rm_r(outdir)
     end

data/spec/lib/smallcage/commands/import_spec.rb

@@ -11,8 +11,8 @@ describe "SmallCage::Commands::Import" do
     opts = { :command => "import", :from => "default", :to => tmpdir.to_s, :quiet => true }
     SmallCage::Runner.run(opts)
 
-    (tmpdir + "_smc").directory?.should be_true
-    (tmpdir + "_smc/helpers/base_helper.rb").file?.should be_true
+    (tmpdir + "_smc").directory?.should be true
+    (tmpdir + "_smc/helpers/base_helper.rb").file?.should be true
 
     FileUtils.rm_r(tmpdir)
   end

data/spec/lib/smallcage/commands/manifest_spec.rb

@@ -13,7 +13,7 @@ describe SmallCage::Commands::Manifest do
   it "should create Manifest.html" do
 
     SmallCage::Runner.run(@opts.merge(:command => "manifest"))
-    @manifest_file.file?.should be_true
+    @manifest_file.file?.should be true
 
     source = @manifest_file.read
     source = source.match(%r{<ul class="files">\n(.+?)\n</ul>}m)[1].split(/\n/)

data/spec/lib/smallcage/commands/update_spec.rb

@@ -14,7 +14,7 @@ describe SmallCage::Commands::Update do
       SmallCage::Runner.run(opts)
 
       out = docroot + "a/b/c/index.html"
-      out.file?.should be_true
+      out.file?.should be true
       out.delete
 
       Dir.chdir(path) do
@@ -22,7 +22,7 @@ describe SmallCage::Commands::Update do
         SmallCage::Runner.run(opts)
       end
 
-      out.file?.should be_true
+      out.file?.should be true
       out.delete
     ensure
       SmallCage::Runner.run({:command => "clean", :path => path.to_s, :quiet => true })
@@ -38,10 +38,10 @@ describe SmallCage::Commands::Update do
       SmallCage::Runner.run(opts)
 
       out = root + "_dir"
-      out.file?.should be_false
+      out.file?.should be false
 
       out = root + "_local"
-      out.file?.should be_false
+      out.file?.should be false
     ensure
       SmallCage::Runner.run({:command => "clean", :path => root.to_s, :quiet => true })
     end
@@ -53,21 +53,21 @@ describe SmallCage::Commands::Update do
     begin
       SmallCage::Runner.run({ :command => "update", :path => root.to_s, :quiet => true })
 
-      (root + "a/index.html").file?.should be_true
-      (root + "ab/index.html").file?.should be_true
-      (root + "abc/index.html").file?.should be_true
+      (root + "a/index.html").file?.should be true
+      (root + "ab/index.html").file?.should be true
+      (root + "abc/index.html").file?.should be true
 
       SmallCage::Runner.run({ :command => "update", :path => (root + "a").to_s, :quiet => true })
 
-      (root + "a/index.html").file?.should be_true
-      (root + "ab/index.html").file?.should be_true
-      (root + "abc/index.html").file?.should be_true
+      (root + "a/index.html").file?.should be true
+      (root + "ab/index.html").file?.should be true
+      (root + "abc/index.html").file?.should be true
 
       SmallCage::Runner.run({ :command => "update", :path => (root + "ab").to_s, :quiet => true })
 
-      (root + "a/index.html").file?.should be_true
-      (root + "ab/index.html").file?.should be_true
-      (root + "abc/index.html").file?.should be_true
+      (root + "a/index.html").file?.should be true
+      (root + "ab/index.html").file?.should be true
+      (root + "abc/index.html").file?.should be true
     ensure
       SmallCage::Runner.run({:command => "clean", :path => root.to_s, :quiet => true })
     end

data/spec/lib/smallcage/document_path_spec.rb

@@ -10,7 +10,7 @@ describe SmallCage::DocumentPath do
   end
 
   it "should return smc file or not" do
-    docpath.smc?.should be_true
+    docpath.smc?.should be true
   end
 
   it "should return output file" do
@@ -45,7 +45,7 @@ describe SmallCage::DocumentPath do
       e.message.should =~ /\AIllegal path: /
       ok = true
     end
-    ok.should be_true
+    ok.should be true
 
     path    = Pathname.new(File.join(SPEC_DATA_DIR, 'htdocs'))
     ok = false
@@ -55,7 +55,7 @@ describe SmallCage::DocumentPath do
       e.message.should =~ /\AIllegal path: /
       ok = true
     end
-    ok.should be_true
+    ok.should be true
 
     path    = Pathname.new(File.join(SPEC_DATA_DIR, 'htdocs2'))
     ok = false
@@ -65,6 +65,6 @@ describe SmallCage::DocumentPath do
       e.message.should =~ /\AIllegal path: /
       ok = true
     end
-    ok.should be_true
+    ok.should be true
   end
 end

data/spec/lib/smallcage/loader_spec.rb

@@ -38,7 +38,7 @@ describe SmallCage::Loader do
     root.to_s.should =~ %r{^.+/data/htdocs1$}
 
     depth = 3
-    lambda { SmallCage::Loader.find_root(path, depth) }.should raise_error
+    lambda { SmallCage::Loader.find_root(path, depth) }.should raise_error(RuntimeError)
   end
 
   it "should load strings" do
@@ -79,7 +79,7 @@ describe SmallCage::Loader do
     dirs[1]["uri"].should == "/a/"
     dirs[2]["uri"].should == "/a/b/"
     dirs[3]["uri"].should == "/a/b/c/"
-    (dirs[3]["path"] + "index.html.smc").file?.should be_true
+    (dirs[3]["path"] + "index.html.smc").file?.should be true
 
     dirs[0]["var"].should == "xxx"
     dirs[0]["strings"][0].should == "BODYBODYBODY"
@@ -101,7 +101,7 @@ describe SmallCage::Loader do
     dirs[2]["z"].should == 999
     dirs[2]["body"].should == "dirsmc"
 
-    dirs[3]["only_local_smc"].should be_true
+    dirs[3]["only_local_smc"].should be true
     dirs[3]["arrays"][0][2].should == "smc"
     dirs[3]["body"].should == "strings"