ytools 0.1.0

data/lib/ytools/path/parser.rb

@@ -0,0 +1,135 @@
+require 'ytools/errors'
+require 'ytools/path/lexer'
+require 'ytools/path/selectors'
+
+module YTools::Path
+
+=begin
+Yaml Path Spec:
+---------------
+
+yaml_path:
+    child_selector (child_selector)* <-- '/' path_node is a root
+  | path_node (child_selector)*
+  ;
+
+child_selector:
+    '/'  path_node
+  | '//' path_node
+  ;
+
+path_node:
+    PATH_PART index?
+  | NUMBER index?
+  ;
+
+index:
+    LBRACE NUMBER RBRACE
+  ;
+
+=end
+
+  class ParseError < Exception
+    attr_reader :token
+
+    def initialize(message, token)
+      super(message)
+      @token = token
+    end
+  end
+
+  class Parser
+
+    def initialize(path)
+      @lexer = Lexer.new(path)
+      @path = path
+    end
+
+    def parse!
+      selector = nil
+
+      if @lexer.has_next?
+        selector = root_selector
+      end
+
+      while @lexer.has_next?
+        selector.chain(child_selector)
+      end
+
+      selector
+    end
+
+    private
+    def root_selector
+      if @lexer.peek.type == :path_separator
+        subselector = child_selector
+        if subselector.is_a?(ChildSelector)
+          RootSelector.new.chain(subselector)
+        else
+          subselector
+        end
+      else
+        path_node(false)
+      end
+    end
+
+    def child_selector
+      slash = @lexer.next
+
+      if slash.nil? || slash.type != :path_separator
+        raise ParseError.new("Missing a path separator '/'", slash)
+      end
+
+      if @lexer.peek.nil?
+        raise ParseError.new("Unfinished child path expression", slash)
+      end
+
+      if @lexer.peek.type == :path_separator
+        @lexer.next # Pop off the separator
+        path_node(true)
+      else
+        path_node(false)
+      end
+    end
+
+    def path_node(descendant=nil)
+      node = @lexer.next
+
+      if node.type != :number && node.type != :path_part
+        raise ParseError.new("Unexpected path node type, number or string only", node)
+      end
+
+      sel = if descendant
+              DescendantSelector.new(node.value)
+            else
+              ChildSelector.new(node.value)
+            end
+
+      if !@lexer.peek.nil? && @lexer.peek.type == :lbrace
+        sel.chain(index_selector)
+      end
+
+      sel
+    end
+
+    def index_selector
+      lbrace = @lexer.next
+
+      number = @lexer.next
+      if number.nil?
+        raise ParseError.new("Missing number in unclosed index selector", lbrace)
+      elsif number.type != :number
+        raise ParseError.new("Only numbers are allowed in indices", lbrace)
+      end
+      
+      rbrace = @lexer.next
+      if rbrace.nil?
+        raise ParseError.new("Unclosed ']' for index selector", lbrace)
+      elsif rbrace.type != :rbrace
+        raise ParseError.new("Missing ']' character for index", rbrace)
+      end
+
+      IndexSelector.new(number.value)
+    end
+  end # Parser
+end

data/lib/ytools/path/selectors.rb

@@ -0,0 +1,132 @@
+require 'ytools/errors'
+require 'ytools/yaml_object'
+
+module YTools::Path
+
+  class Selector
+    attr_reader :subselector
+    #alias :chain :<<
+
+    def chain(selector)
+      if !chained?
+        @subselector = selector
+      else
+        @subselector.chain(selector)
+      end
+      self
+    end
+
+    def chained?
+      !@subselector.nil?
+    end
+  end
+
+  class ChildSelector < Selector
+    attr_reader :child
+
+    def initialize(child)
+      @child = child
+    end
+
+    def select(yaml)
+      if yaml.yhash.has_key?(child)
+        value = yaml[child]
+        if chained?
+          subselector.select(value)
+        else
+          value
+        end
+      else
+        nil
+      end
+    end
+  end
+
+  class IndexSelector < Selector
+    attr_reader :index
+
+    def initialize(index)
+      @index = index
+    end
+
+    def select(array)
+      if array.respond_to?(:[])
+        value = array[index]
+        if chained?
+          subselector.select(value)
+        else
+          value
+        end
+      else
+        nil
+      end
+    end
+  end
+
+  class RootSelector < Selector
+    def select(yaml)
+      if yaml.is_a?(YTools::YamlObject)
+        value = yaml.yroot
+        if chained?
+          subselector.select(value)
+        else
+          value
+        end
+      else
+        nil
+      end
+    end
+  end
+
+  class DescendantSelector < Selector
+    attr_reader :match
+
+    def initialize(match)
+      @match = match
+    end
+
+    def select(yaml)
+      inner_select(yaml, [])
+    end
+
+    private
+    def inner_select(yaml, results)
+      yaml.yhash.each do |key, value|
+        if key == match
+          key_select(value, results)
+        end
+        value_select(value, results)
+      end
+      
+      if results.length == 1
+        results[0]
+      else
+        results
+      end
+    end
+
+    def key_select(value, results)
+      # Filter through the chain, if present
+      if chained?
+        nvalue = subselector.select(value)
+        if !nvalue.nil?
+          results << nvalue
+        end
+      else
+        results << value
+      end
+    end
+
+    def value_select(value, results)
+      if value.is_a?(YTools::YamlObject)
+        inner_select(value, results)
+      elsif value.is_a?(Array)
+        value.each do |v|
+          if v.is_a?(YTools::YamlObject)
+            inner_select(v, results)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ytools/templates/cli.rb

@@ -0,0 +1,108 @@
+require 'optparse'
+require 'ytools/basecli'
+require 'ytools/errors'
+require 'ytools/templates/executor'
+
+module YTools::Templates
+  class CLI < YTools::BaseCLI
+    protected
+    def parse(args)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [OPTIONS] YAML_FILES"
+        opts.separator <<EOF
+Description:
+    This tool uses an ERB template file and a set of YAML files to
+    generate a merged file.  For convenience, all of the keys in
+    hashes in regular YAML can work like methods in the ERB templates.
+    Thus, the YAML "{ 'a' : {'b' : 3 } }" could be used in an 
+    ERB template with "<%= a.b %>" instead of the more verbose hash 
+    syntax.  Indeed, the root hash values can only be accessed by
+    those method attributes, because the root YAML context object
+    is simply assumed.
+
+    It accepts multiple yaml files, and will merge their contents in the
+    order in which they are given.  Thus, files listed later, if their
+    keys conflict with ones listed earlier, override the earlier listed
+    values.  If you pass in files that don't exist, no error will be 
+    raised unless the '--strict' flag is passed.
+
+    Check out the '--examples' flag for more details.
+
+Options:
+EOF
+        opts.on('-t', '--template ERB',
+                "The ERB template file to use for generation") do |t|
+          options[:template] = t
+        end
+        opts.on('-o', '--output FILE',
+                "Write the generated output to a file instead",
+                "of STDOUT") do |o|
+          options[:output] = o
+        end
+        opts.on('-s', '--strict',
+                "Checks to make sure all of the YAML files",
+                "exist before proceeding.") do |s|
+          options[:strict] = true
+        end
+        opts.separator ""
+        
+        opts.on('-e', '--examples',
+                "Show some examples on how to use the",
+                "path syntax.") do
+          print_examples(File.dirname(__FILE__))
+        end
+        opts.on('-v', '--version',
+                "Show the version information") do |v|
+          print_version
+        end
+        opts.on('-d', '--debug',
+                "Prints out the merged yaml as a",
+                "ruby object to STDERR.") do |d|
+          options[:debug] = true
+        end
+        opts.on('-h', '--help',
+                "Show this help message.") do
+          puts opts
+          exit 0
+        end
+      end.parse!(args)
+    end
+
+    def validate(args)
+      if options[:template].nil?
+        raise YTools::ConfigurationError.new("No template file was indicated")
+      end
+
+      if !File.exists?(options[:template])
+        raise YTools::ConfigurationError.new("Unable to locate the template file: #{options[:template]}")
+      end
+
+      if options[:output] &&
+          !File.exists?(File.dirname(options[:output]))
+        raise YTools::ConfigurationError.new("The output directory doesn't exist: #{option[:output]}")
+      end
+
+      if args.length == 0
+        raise YTools::ConfigurationError.new("No YAML files were given")
+      end
+
+      if options[:strict]
+        args.each do |file|
+          if !File.exists?(file)
+            raise YTools::ConfigurationError.new("Unable to locate YAML file: #{file}")
+          end
+        end
+      end
+    end
+
+    def execute(args)
+      executor = Executor.new(options[:template], args)
+
+      if options[:debug]
+        STDERR.puts executor.yaml_object.to_s
+      end
+      
+      executor.write!(options[:output])
+    end
+  end
+end

data/lib/ytools/templates/examples.txt

@@ -0,0 +1,52 @@
+Assuming a YAML file like the following:
+
+---
+this:
+    is: 
+        - a
+        - very
+        - simple
+    yaml: file
+    but: It's
+    pretty:
+        easy: 42
+        to-read: 'right?'
+---
+
+You can then create a template to access these values:
+
+---
+You can write out <%= this.is[0] %> simple template
+<%= this.yaml %> that uses the YAML as its bound object.
+It's fairly straight forward, <%= this.pretty['to-read']%>
+---
+
+It would output:
+
+---
+You can write out a simple template
+file that uses the YAML as its bound object.
+It's fairly straight forward, right?
+---
+
+You can, of course use all of the syntax available
+in a regular ERB template so you could do something 
+like:
+
+---
+<% 0.upto(this.pretty.easy) do |i| %>
+   <% if i == 42 %>
+      The secret of the universe is <%= i %>!
+      <%= this.but %> <%= this.is[2] %> <%= this.is[3] %>
+      <%= this.pretty['to-read'] %>
+   <% end %>
+<% end %>
+---
+
+That would output:
+
+---
+The secret of the universe is 42!
+It's very simple
+right?
+---

data/lib/ytools/templates/executor.rb

@@ -0,0 +1,28 @@
+require 'erb'
+require 'ytools/yaml_object'
+require 'ytools/templates/yaml_object'
+
+module YTools::Templates
+  class Executor
+    attr_reader :template, :yaml_object
+
+    def initialize(template, files)
+      @template = template
+      @yaml_object = YTools::YamlObject.from_files(files)
+    end
+
+    def write!(outfile)
+      tcontents = nil
+      File.open(template, 'r') { |f| tcontents = f.read}
+
+      generator = ERB.new(tcontents)
+      output = generator.result(yaml_object.erb_binding)
+
+      if outfile
+        File.open(outfile, 'w') {|f| f.write(output)}
+      else
+        puts output
+      end
+    end
+  end
+end