wie füllen Sie die html-Datei mit ruby-Skript

Ich historisch verwendet haben, ERB-und REXML für Dinge wie diese, da Sie sowohl Schiff mit Ruby (entfernen von gem-Abhängigkeiten). Sie können kombinieren Sie eine XML-Datei (Inhalte) mit ein .erb-Datei (für das layout) und bekommen einfach Zusammenführen. Hier ist ein Skript, das ich schrieb, für diese (die meisten von denen argument-handling und die Erweiterung REXML mit einigen convenience-Methoden):

USAGE = <<ENDUSAGE
Usage:
   rubygen source_xml [-t template_file] [-o output_file]

   -t,--template  The ERB template file to merge (default: xml_name.erb)

   -o,--output    The output file name to write  (default: template.txt)
                  If the template_file is named "somefile_XXX.yyy",
                  the output_file will default instead to "somefile.XXX"
ENDUSAGE

ARGS = {}
UNFLAGGED_ARGS = [ :source_xml ]
next_arg = UNFLAGGED_ARGS.first
ARGV.each{ |arg|
   case arg
     when '-t','--template'
       next_arg = :template_file
     when '-o','--output'
       next_arg = :output_file
     else
       if next_arg
         ARGS[next_arg] = arg
         UNFLAGGED_ARGS.delete( next_arg )
       end
       next_arg = UNFLAGGED_ARGS.first
   end
}

if !ARGS[:source_xml]
   puts USAGE
   exit
end

extension_match = /\.[^.]+$/
template_match  = /_([^._]+)\.[^.]+$/
xml_file      = ARGS[ :source_xml   ]
template_file = ARGS[ :template_file] || xml_file.sub( extension_match, '.erb' )
output_file   = ARGS[ :output_file  ] || ( ( template_file =~ template_match ) ? template_file.sub( template_match, '.\\1' ) : template_file.sub( extension_match, '.txt' ) )

require 'rexml/document'
include REXML

class REXML::Element
  # Find all descendant nodes with a specified tag name and/or attributes
  def find_all( tag_name='*', attributes_to_match={} )
    self.each_element( ".//#{REXML::Element.xpathfor(tag_name,attributes_to_match)}" ){}
  end
  # Find all child nodes with a specified tag name and/or attributes
  def kids( tag_name='*', attributes_to_match={} )
    self.each_element( "./#{REXML::Element.xpathfor(tag_name,attributes_to_match)}" ){}
  end
  def self.xpathfor( tag_name='*', attributes_to_match={} )
    out = "#{tag_name}"
    unless attributes_to_match.empty?
      out << "["
      out << attributes_to_match.map{ |key,val|
        if val == :not_empty
          "@#{key}"
        else
          "@#{key}='#{val}'"
        end
      }.join( ' and ' )
      out << "]"
    end
    out
  end

  # A hash to tag extra data onto a node during processing
  def _mydata
    @_mydata ||= {}
  end
end

start_time = Time.new
  @xmldoc = Document.new( IO.read( xml_file ), :ignore_whitespace_nodes => :all )
  @root = @xmldoc.root
  @root = @root.first if @root.is_a?( Array )
end_time = Time.new
puts "%.2fs to parse XML file (#{xml_file})" % ( end_time - start_time )

require 'erb'
File.open( output_file, 'w' ){ |o|
  start_time = Time.new
  output_code = ERB.new( IO.read( template_file ), nil, '>', 'output' ).result( binding )
  end_time = Time.new
  puts "%.2fs to run template   (#{template_file})" % ( end_time - start_time )

  start_time = Time.new
  o << output_code
}
end_time = Time.new
puts "%.2fs to write output   (#{output_file})" % ( end_time - start_time )
puts " "

Dies kann verwendet werden, in HTML oder automatisierter source code generation gleichermaßen.

Aber, in diesen Tagen würde ich befürworten mit Haml und Nokogiri (wenn Sie wollen, strukturierte XML-markup-Symbole) oder YAML (wenn Sie möchten, einfach-zu-Bearbeiten-Inhalte), da diese Ihre markup-cleaner und Ihrer Vorlage Logik einfacher.

Bearbeiten: Hier ist ein einfacher Datei Zusammenführen YAML mit Haml. Die letzten vier Zeilen alle Arbeit tun:

#!/usr/bin/env ruby
require 'yaml'; require 'haml'; require 'trollop'
EXTENSION = /\.[^.]+$/

opts = Trollop.options do
  banner "Usage:\nyamlhaml [opts] <sourcefile.yaml>"
  opt :haml,   "The Haml file to use (default: sourcefile.haml)", type:String
  opt :output, "The file to create   (default: sourcefile.html)", type:String
end
opts[:source] = ARGV.shift
Trollop.die "Please specify an input Yaml file" unless opts[:source]
Trollop.die "Could not find #{opts[:source]}"   unless File.exist?(opts[:source])

opts[:haml]   ||= opts[:source].sub( EXTENSION, '.haml' )
opts[:output] ||= opts[:source].sub( EXTENSION, '.html' )
Trollop.die "Could not find #{opts[:haml]}" unless File.exist?(opts[:haml])

@data = YAML.load(IO.read(opts[:source]))
File.open( opts[:output], 'w' ) do |output|
  output << Haml::Engine.new(IO.read(opts[:haml])).render(self)
end

Hier ein Beispiel für YAML-Datei:

title: Hello World
main: "<h1>you have 30 files in games folder</h1>"
side: "I dunno, something goes here."

...und eine Beispiel-Haml-Datei:

!!! 5
%html
  %head
    %title= @data['title']
  %body
    #main= @data['main']
    #side= @data['side']

...und schließlich der HTML-Code erzeugen:

<!DOCTYPE html>
<html>
  <head>
    <title>Hello World</title>
  </head>
  <body>
    <div id='main'><h1>you have 30 files in games folder</h1></div>
    <div id='side'>I dunno, something goes here.</div>
  </body>
</html>

Fortsetzung von @Phrogz Arbeit, die ERB-Idee ist eine tolle Idee. Ich war in der Lage, es zu benutzen, erstellen einer einfachen Rechen-Skript, das macht die Arbeit für mich. Ich finde, dass dieser Ansatz ein wenig leichter.

rakefile.rb

task :default => :generate

task :generate do

  require 'erb'

  template_file = "page.erb"
  output_file   = "page.html"

  File.open(output_file, 'w') do |o|
    puts "Processing file: #{template_file}"
    o << ERB.new( IO.read( template_file ), nil, '>', 'output' ).result( binding )
  end

end

def render(file)
  puts "Rendering file: #{file}"
  IO.read(file)
end

$game_count = 30
def game_count
  puts "Rendering game count: #{$game_count}"
  $game_count
end

page.erb

<html>
<title>html Page</title>
<body>

<div id="main">
  <h1>you have <%= game_count %> files in games folder</h1>
</div>

<div id="side">
  <%= render "side.html" %>
</div>

</body>
</html>

side.html

<ul class="side">
  <li>Side item 1</li>
  <li>Side item 2</li>
</ul>

Läuft es

$ rake
Processing file: page.erb
Rendering game count: 30
Rendering file: side.html

Neu erstellte Datei page.html

<html>
<title>html Page</title>
<body>

<div id="main">
  <h1>you have 30 files in games folder</h1>
</div>

<div id="side">
<ul class="side">
  <li>Side item 1</li>
  <li>Side item 2</li>
</ul>
</div>

</body>
</html>