smallcage 0.2.6 → 0.2.7

data/lib/smallcage/loader.rb

@@ -1,10 +1,13 @@
-YAML::ENGINE.yamler = 'syck' if RUBY_VERSION >= "1.9.2"
+YAML::ENGINE.yamler = 'syck' if RUBY_VERSION >= '1.9.2'
 
 module SmallCage
+  #
+  # .smc file loader
+  #
   class Loader
-    DEFAULT_TEMPLATE = "default"
-    DIR_PROP_FILE    = "_dir.smc"
-    LOCAL_PROP_FILE  = "_local.smc"
+    DEFAULT_TEMPLATE = 'default'
+    DIR_PROP_FILE    = '_dir.smc'
+    LOCAL_PROP_FILE  = '_local.smc'
     MAX_DEPTH = 100
 
     attr_reader :root, :target, :erb_base
@@ -15,28 +18,28 @@ module SmallCage
 
       @target = target # absolute
       @root = self.class.find_root(target) # absolute
-      @templates_dir = @root + "_smc/templates"
-      @helpers_dir = @root + "_smc/helpers"
-      @filters_dir = @root + "_smc/filters"
+      @templates_dir = @root + '_smc/templates'
+      @helpers_dir = @root + '_smc/helpers'
+      @filters_dir = @root + '_smc/filters'
       @erb_base = load_erb_base
       @filters = load_filters
     end
 
     # return root dir Pathname object.
     def self.find_root(path, depth = MAX_DEPTH)
-      raise "Not found: #{path}" unless path.exist?
+      fail "Not found: #{ path }" unless path.exist?
       d = path.realpath
       d = d.parent if d.file?
       loop do
-        return d if d.join("_smc").directory?
+        return d if d.join('_smc').directory?
         break if d.root? || (depth -= 1) <= 0
         d = d.parent
       end
-      raise "Root not found: #{path}"
+      fail "Root not found: #{ path }"
     end
 
     def load(path)
-      raise "Not found: #{path}" unless path.exist?
+      fail "Not found: #{ path }" unless path.exist?
 
       docpath = DocumentPath.new(@root, path)
 
@@ -48,15 +51,15 @@ module SmallCage
     end
 
     def load_smc_file(docpath)
-      raise "Path is not smc file: #{docpath}" unless docpath.smc?
+      fail "Path is not smc file: #{ docpath }" unless docpath.smc?
 
       result = create_base_smc_object(docpath.outfile.path, docpath.path,
                                       docpath.outuri,       docpath.uri)
 
-      result["template"] = DEFAULT_TEMPLATE
-      result["dirs"]     = load_dirs(docpath.path)
+      result['template'] = DEFAULT_TEMPLATE
+      result['dirs']     = load_dirs(docpath.path)
 
-      return result.merge(load_yaml(docpath.path))
+      result.merge(load_yaml(docpath.path))
     end
     private :load_smc_file
 
@@ -64,7 +67,7 @@ module SmallCage
       path_smc = nil
       uri_smc  = nil
       uri_out  = docpath.uri
-      uri_out += "/" unless uri_out[-1] == ?/
+      uri_out += '/' unless uri_out[-1, 1] == '/'
 
       dir_prop_file   = docpath.path + DIR_PROP_FILE
       local_prop_file = docpath.path + LOCAL_PROP_FILE
@@ -79,18 +82,18 @@ module SmallCage
       result.merge!(load_yaml(dir_prop_file))   if dir_prop_file.file?
       result.merge!(load_yaml(local_prop_file)) if local_prop_file.file?
 
-      return result
+      result
     end
     private :load_dir_prop
 
     def create_base_smc_object(path_out, path_smc, uri_out, uri_smc)
       result = {}
-      result["arrays"]   = []
-      result["strings"]  = []
-      result["body"]     = nil
-      result["path"]     = DocumentPath.add_smc_method(path_out, path_smc)
-      result["uri"]      = DocumentPath.add_smc_method(uri_out,  uri_smc )
-      return result
+      result['arrays']   = []
+      result['strings']  = []
+      result['body']     = nil
+      result['path']     = DocumentPath.add_smc_method(path_out, path_smc)
+      result['uri']      = DocumentPath.add_smc_method(uri_out,  uri_smc)
+      result
     end
     private :create_base_smc_object
 
@@ -103,23 +106,23 @@ module SmallCage
         obj = YAML.load_stream(source)
         return result if obj.nil?
       rescue => e
-        raise "Can't load file: #{path} / #{e}"
+        raise "Can't load file: #{ path } / #{ e }"
       end
       obj.documents.each do |o|
         case o
         when Hash
           result.merge!(o)
         when Array
-          result["arrays"] ||= []
-          result["arrays"]  << o
+          result['arrays'] ||= []
+          result['arrays']  << o
         else
-          result["strings"] ||= []
-          result["strings"] << o.to_s
+          result['strings'] ||= []
+          result['strings'] << o.to_s
         end
       end
-      result["body"] ||= result["strings"][0] if result["strings"]
+      result['body'] ||= result['strings'][0] if result['strings']
 
-      return result
+      result
     end
     private :load_yaml
 
@@ -128,16 +131,16 @@ module SmallCage
       loop do
         path = path.parent
         result.unshift load(path)
-        break if path.join("_smc").directory?
-        raise "Root directory not found!" if path.root?
+        break if path.join('_smc').directory?
+        fail 'Root directory not found!' if path.root?
       end
-      return result
+      result
     end
 
     def template_path(name)
-      result = @templates_dir + "#{name}.rhtml"
+      result = @templates_dir + "#{ name }.rhtml"
       return nil unless result.file?
-      return result
+      result
     end
 
     def each_smc_obj
@@ -154,7 +157,7 @@ module SmallCage
       if @target.directory?
         path = Pathname.new(@target)
         Dir.chdir(@target) do
-          Dir.glob("**/*.smc").sort.each do |f|
+          Dir.glob('**/*.smc').sort.each do |f|
             yield path + f
           end
         end
@@ -167,29 +170,29 @@ module SmallCage
       if @target.directory?
         path = Pathname.new(@target)
         Dir.chdir(@target) do
-          Dir.glob("**/*").sort.each do |f|
+          Dir.glob('**/*').sort.each do |f|
             f = path + f
             next if f.directory?
             next if f.to_s =~ %r{/_smc/}
-            next if f.to_s =~ %r{\.smc$}
+            next if f.to_s =~ /\.smc$/
             yield DocumentPath.new(@root, path + f)
           end
         end
       else
         return if @target.to_s =~ %r{/_smc/}
-        return if @target.to_s =~ %r{\.smc$}
+        return if @target.to_s =~ /\.smc$/
         yield DocumentPath.new(@root, @target)
       end
     end
 
     def real_target(target)
       return target.realpath if target.directory?
-      return target.realpath if target.file? and target.to_s =~ /\.smc$/
+      return target.realpath if target.file? && target.to_s =~ /\.smc$/
 
-      tmp = Pathname.new(target.to_s + ".smc")
+      tmp = Pathname.new(target.to_s + '.smc')
       return tmp.realpath if tmp.file?
 
-      raise "Target not found: " + target.to_s
+      fail 'Target not found: ' + target.to_s
     end
     private :real_target
 
@@ -197,7 +200,7 @@ module SmallCage
       result = Class.new(ErbBase)
       class << result
         def include_helpers(anon_module, mod_names)
-          smc_module = anon_module.const_get("SmallCage")
+          smc_module = anon_module.const_get('SmallCage')
           mod_names.each do |name|
             helper_module = smc_module.const_get(name)
             include helper_module
@@ -205,43 +208,40 @@ module SmallCage
         end
       end
 
-      helpers = SmallCage::AnonymousLoader.load(@helpers_dir, %r{([^/]+_helper)\.rb\z})
+      helpers = SmallCage::AnonymousLoader.load(@helpers_dir, /([^\/]+_helper)\.rb\z/)
       result.include_helpers(helpers[:module], helpers[:names])
 
-      return result
+      result
     end
     private :load_erb_base
 
     def filters(name)
-      if @filters[name].nil?
-        return []
-      end
-      return @filters[name]
+      @filters[name].nil? ? [] : @filters[name]
     end
 
     def load_filters
       result = {}
       return {} unless @filters_dir.directory?
 
-      filter_modules = SmallCage::AnonymousLoader.load(@filters_dir, %r{([^/]+_filter)\.rb\z})
-      smc_module = filter_modules[:module].const_get("SmallCage")
+      filter_modules = SmallCage::AnonymousLoader.load(@filters_dir, /([^\/]+_filter)\.rb\z/)
+      smc_module = filter_modules[:module].const_get('SmallCage')
 
-      load_filters_config.each do |filter_type,filter_list|
+      load_filters_config.each do |filter_type, filter_list|
         result[filter_type] = []
         filter_list.to_a.each do |fc|
-          fc = { "name" => fc } if fc.is_a? String
-          filter_class = smc_module.const_get(fc["name"].camelize)
+          fc = { 'name' => fc } if fc.is_a? String
+          filter_class = smc_module.const_get(fc['name'].camelize)
           result[filter_type] << filter_class.new(fc)
         end
       end
-      return result
+      result
     end
     private :load_filters
 
     def load_filters_config
-      path = @filters_dir.join("filters.yml")
+      path = @filters_dir.join('filters.yml')
       return {} unless path.file?
-      return YAML.load(path.read()) || {}
+      YAML.load(path.read) || {}
     end
     private :load_filters_config
   end

data/lib/smallcage/misc.rb

@@ -4,7 +4,7 @@ class String
   def camelize(first_letter_in_uppercase = true)
     s = self
     if first_letter_in_uppercase
-      s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      s.gsub(/\/(.?)/) { '::' + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
     else
       s[0..0] + s.camelize[1..-1]
     end

data/lib/smallcage/options_parser.rb

@@ -0,0 +1,251 @@
+# Parse command-line arguments.
+class SmallCage::OptionsParser
+  require 'optparse'
+
+  VERSION_NOTE = "SmallCage #{SmallCage::VERSION} - a simple website generator"
+
+  def initialize(argv)
+    @argv = argv
+    @options = {}
+  end
+
+  def parse
+    @parser = create_main_parser
+    parse_main_options
+
+    @command_parsers = create_command_parsers
+    parse_command
+    parse_command_options
+
+    @options
+  end
+
+  def create_main_parser
+    parser = OptionParser.new
+    parser.banner = <<BANNER
+Usage: #{File.basename($PROGRAM_NAME)} [options] <subcommand> [subcommand-options]
+#{VERSION_NOTE}
+Subcommands are:
+    update [path]                    Build smc contents.
+    clean  [path]                    Remove files generated from *.smc source.
+    server [path] [port]             Start HTTP server.
+    auto   [path] [port]             Start auto update server.
+    import [name|uri]                Import project.
+    export [path] [outputpath]       Export project.
+    uri    [path]                    Print URIs.
+    manifest [path]                  Generate Manifest.html file.
+
+BANNER
+
+    parser.separator 'Options are:'
+    parser.on('-h', '--help', 'Show this help message.') do
+      puts parser
+      exit(true)
+    end
+    parser.on('-v', '--version', 'Show version info.') do
+      puts VERSION_NOTE
+      exit(true)
+    end
+
+    @options[:quiet] = false
+    parser.on('-q', '--quiet', 'Do not print message.') do |boolean|
+      @options[:quiet] = boolean
+    end
+
+    parser
+  end
+  private :create_main_parser
+
+  def parse_main_options
+    @parser.order!(@argv)
+  rescue OptionParser::InvalidOption => e
+    $stderr.puts e.message
+    exit(false)
+  end
+  private :parse_main_options
+
+  def create_command_parsers
+    banners = {
+      :update => <<EOT,
+smc update [path] [options]
+    path : target directory. (default:'.')
+EOT
+
+      :clean  => <<EOT,
+smc clean [path] [options]
+    path : target directory (default:'.')
+EOT
+
+      :server => <<EOT,
+smc server [path] [port] [options]
+    path : target directory (default:'.')
+    port : HTTP server port number (default:8080)
+EOT
+
+      :auto   => <<EOT,
+smc auto [path] [port] [options]
+    path : target directory (default:'.')
+    port : HTTP server port number (default:don't launch the server)
+EOT
+
+      :import => <<EOT,
+smc import [name|uri] [options]
+EOT
+
+      :export => <<EOT,
+smc export [path] [outputpath] [options]
+EOT
+
+      :help   => <<EOT,
+smc help [command]
+EOT
+
+      :uri    => <<EOT,
+smc uri [path] [options]
+EOT
+
+      :manifest => <<EOT,
+smc manifest [path] [options]
+EOT
+
+    }
+
+    parsers = {}
+    banners.each do |command, banner|
+      parsers[command] = create_default_command_parser(banner)
+    end
+
+    parsers[:update].on('--fast', 'Update only modified files.') do |boolean|
+      @options[:fast] = boolean
+    end
+
+    parsers[:auto].on('--fast', 'Update only modified files at first run.') do |boolean|
+      @options[:fast] = boolean
+    end
+
+    parsers[:auto].on('--bell', 'Ring bell after publishing files.') do |boolean|
+      @options[:bell] = boolean
+    end
+
+    parsers
+  end
+  private :create_command_parsers
+
+  def create_default_command_parser(banner)
+    parser = OptionParser.new
+    parser.banner = 'Usage: ' + banner
+    parser.separator 'Options are:'
+
+    # these options can place both before and after the subcommand.
+    parser.on('-h', '--help', 'Show this help message.') do
+      puts parser
+      exit(true)
+    end
+    parser.on('-v', '--version', 'Show version info.') do
+      puts VERSION_NOTE
+      exit(true)
+    end
+    parser.on('-q', '--quiet', 'Do not print message.') do |boolean|
+      @options[:quiet] = boolean
+    end
+
+    parser
+  end
+  private :create_default_command_parser
+
+  def parse_command
+    @options[:command] = command_sym
+
+    if @options[:command].nil?
+      puts @parser
+      exit(false)
+    end
+    parser = @command_parsers[@options[:command]]
+    if parser.nil?
+      $stderr.puts "no such subcommand: #{@options[:command]}"
+      exit(false)
+    end
+    parser.parse!(@argv)
+  rescue OptionParser::InvalidOption => e
+    $stderr.puts e.message
+    exit(false)
+  end
+  private :parse_command
+
+  # Resolve abbrev and return command name symbol.
+  def command_sym
+    commands = Hash.new { |h, k| k }
+    commands.merge!(
+      :up => :update,
+      :sv => :server,
+      :au => :auto
+    )
+
+    name = @argv.shift.to_s.strip
+    return nil if name.empty?
+    commands[name.to_sym]
+  end
+  private :command_sym
+
+  def parse_command_options
+    run_help_and_exit if @options[:command] == :help
+
+    if @options[:command] == :update
+      @options[:path] = @argv.shift
+      @options[:path] ||= '.'
+      @options[:fast] ||= false
+    elsif @options[:command] == :server
+      @options[:path] = @argv.shift
+      @options[:path] ||= '.'
+      @options[:port] = get_port_number(8080)
+    elsif @options[:command] == :auto
+      @options[:path] = @argv.shift
+      @options[:path] ||= '.'
+      @options[:port] = get_port_number(nil)
+      @options[:bell] ||= false
+      @options[:fast] ||= false
+    elsif @options[:command] == :import
+      @options[:from] = @argv.shift
+      @options[:from] ||= 'default'
+      @options[:to] = @argv.shift
+      @options[:to] ||= '.'
+    elsif @options[:command] == :export
+      @options[:path] = @argv.shift
+      @options[:path] ||= '.'
+      @options[:out] = @argv.shift
+    elsif @options[:command] == :uri
+      @options[:path] = @argv.shift
+      @options[:path] ||= '.'
+    elsif @options[:command] == :manifest
+      @options[:path] = @argv.shift
+      @options[:path] ||= '.'
+    elsif @options[:command] == :clean
+      @options[:path] = @argv.shift
+      @options[:path] ||= '.'
+    end
+  end
+  private :parse_command_options
+
+  def run_help_and_exit
+    subcmd = @argv.shift
+    if subcmd.nil?
+      puts @parser
+    else
+      puts @command_parsers[subcmd.to_sym]
+    end
+    exit true
+  end
+  private :run_help_and_exit
+
+  def get_port_number(default)
+    return default if @argv.empty?
+
+    port = @argv.shift
+    if port.to_i == 0
+      $stderr.puts "illegal port number: #{port}"
+      exit(false)
+    end
+    port.to_i
+  end
+  private :get_port_number
+end

data/lib/smallcage/renderer.rb

@@ -9,15 +9,14 @@ class SmallCage::Renderer
     path = @loader.template_path(name)
     return nil if path.nil?
     @current_template = path
-    return render_string(path.read, obj)
+    render_string(path.read, obj)
   end
 
   def render_string(str, obj)
-    erb_class = ERB.new(str, nil, '-', '@erbout').def_class(@loader.erb_base, "erb")
+    erb_class = ERB.new(str, nil, '-', '@erbout').def_class(@loader.erb_base, 'erb')
     return erb_class.new(@loader, self, obj).erb
   rescue => e
-    STDERR.puts "Can't render: #{obj["uri"]}"
+    STDERR.puts "Can't render: #{ obj['uri'] }"
     raise e
   end
-
 end

data/lib/smallcage/runner.rb

@@ -6,46 +6,46 @@ module SmallCage
 
     def initialize(opts)
       @opts = opts
-      require_command "base"
+      require_command 'base'
     end
 
     def update
-      require_command "update"
+      require_command 'update'
       SmallCage::Commands::Update.execute(@opts)
     end
 
     def clean
-      require_command "clean"
+      require_command 'clean'
       SmallCage::Commands::Clean.execute(@opts)
     end
 
     def server
-      require_command "server"
+      require_command 'server'
       SmallCage::Commands::Server.execute(@opts)
     end
 
     def auto
-      require_command "auto"
+      require_command 'auto'
       SmallCage::Commands::Auto.execute(@opts)
     end
 
     def import
-      require_command "import"
+      require_command 'import'
       SmallCage::Commands::Import.execute(@opts)
     end
 
     def manifest
-      require_command "manifest"
+      require_command 'manifest'
       SmallCage::Commands::Manifest.execute(@opts)
     end
 
     def export
-      require_command "export"
+      require_command 'export'
       SmallCage::Commands::Export.execute(@opts)
     end
 
     def uri
-      require_command "uri"
+      require_command 'uri'
       SmallCage::Commands::Uri.execute(@opts)
     end